ai 5.0.0-alpha.1 → 5.0.0-alpha.11

package/dist/index.js

@@ -22,10 +22,11 @@ var src_exports = {};
 __export(src_exports, {
   AISDKError: () => import_provider16.AISDKError,
   APICallError: () => import_provider16.APICallError,
-  ChatStore: () => ChatStore,
+  AbstractChat: () => AbstractChat,
   DefaultChatTransport: () => DefaultChatTransport,
   DownloadError: () => DownloadError,
   EmptyResponseBodyError: () => import_provider16.EmptyResponseBodyError,
+  GLOBAL_DEFAULT_PROVIDER: () => GLOBAL_DEFAULT_PROVIDER,
   InvalidArgumentError: () => InvalidArgumentError,
   InvalidDataContentError: () => InvalidDataContentError,
   InvalidMessageRoleError: () => InvalidMessageRoleError,
@@ -47,14 +48,14 @@ __export(src_exports, {
   NoSuchToolError: () => NoSuchToolError,
   Output: () => output_exports,
   RetryError: () => RetryError,
+  SerialJobExecutor: () => SerialJobExecutor,
+  TextStreamChatTransport: () => TextStreamChatTransport,
   ToolCallRepairError: () => ToolCallRepairError,
   ToolExecutionError: () => ToolExecutionError,
   TypeValidationError: () => import_provider16.TypeValidationError,
   UnsupportedFunctionalityError: () => import_provider16.UnsupportedFunctionalityError,
-  appendClientMessage: () => appendClientMessage,
-  asSchema: () => import_provider_utils26.asSchema,
+  asSchema: () => import_provider_utils25.asSchema,
   assistantModelMessageSchema: () => assistantModelMessageSchema,
-  callChatApi: () => callChatApi,
   callCompletionApi: () => callCompletionApi,
   convertFileListToFileUIParts: () => convertFileListToFileUIParts,
   convertToCoreMessages: () => convertToCoreMessages,
@@ -65,13 +66,12 @@ __export(src_exports, {
   coreToolMessageSchema: () => coreToolMessageSchema,
   coreUserMessageSchema: () => coreUserMessageSchema,
   cosineSimilarity: () => cosineSimilarity,
-  createIdGenerator: () => import_provider_utils26.createIdGenerator,
+  createIdGenerator: () => import_provider_utils25.createIdGenerator,
   createProviderRegistry: () => createProviderRegistry,
   createTextStreamResponse: () => createTextStreamResponse,
   createUIMessageStream: () => createUIMessageStream,
   createUIMessageStreamResponse: () => createUIMessageStreamResponse,
   customProvider: () => customProvider,
-  defaultChatStore: () => defaultChatStore,
   defaultSettingsMiddleware: () => defaultSettingsMiddleware,
   embed: () => embed,
   embedMany: () => embedMany,
@@ -81,37 +81,33 @@ __export(src_exports, {
   experimental_generateImage: () => generateImage,
   experimental_generateSpeech: () => generateSpeech,
   experimental_transcribe: () => transcribe,
-  extractMaxToolInvocationStep: () => extractMaxToolInvocationStep,
   extractReasoningMiddleware: () => extractReasoningMiddleware,
-  generateId: () => import_provider_utils26.generateId,
+  generateId: () => import_provider_utils25.generateId,
   generateObject: () => generateObject,
   generateText: () => generateText,
   getTextFromDataUrl: () => getTextFromDataUrl,
   getToolInvocations: () => getToolInvocations,
   hasToolCall: () => hasToolCall,
-  isAssistantMessageWithCompletedToolCalls: () => isAssistantMessageWithCompletedToolCalls,
   isDeepEqualData: () => isDeepEqualData,
-  jsonSchema: () => import_provider_utils26.jsonSchema,
-  maxSteps: () => maxSteps,
+  jsonSchema: () => import_provider_utils25.jsonSchema,
   modelMessageSchema: () => modelMessageSchema,
   parsePartialJson: () => parsePartialJson,
   pipeTextStreamToResponse: () => pipeTextStreamToResponse,
   pipeUIMessageStreamToResponse: () => pipeUIMessageStreamToResponse,
-  shouldResubmitMessages: () => shouldResubmitMessages,
   simulateReadableStream: () => simulateReadableStream,
   simulateStreamingMiddleware: () => simulateStreamingMiddleware,
   smoothStream: () => smoothStream,
+  stepCountIs: () => stepCountIs,
   streamObject: () => streamObject,
   streamText: () => streamText,
   systemModelMessageSchema: () => systemModelMessageSchema,
   tool: () => tool,
   toolModelMessageSchema: () => toolModelMessageSchema,
-  updateToolCallResult: () => updateToolCallResult,
   userModelMessageSchema: () => userModelMessageSchema,
   wrapLanguageModel: () => wrapLanguageModel
 });
 module.exports = __toCommonJS(src_exports);
-var import_provider_utils26 = require("@ai-sdk/provider-utils");
+var import_provider_utils25 = require("@ai-sdk/provider-utils");
 
 // src/error/index.ts
 var import_provider16 = require("@ai-sdk/provider");
@@ -538,19 +534,8 @@ function pipeTextStreamToResponse({
   });
 }
 
-// src/ui/append-client-message.ts
-function appendClientMessage({
-  messages,
-  message
-}) {
-  return [
-    ...messages.length > 0 && messages[messages.length - 1].id === message.id ? messages.slice(0, -1) : messages,
-    message
-  ];
-}
-
-// src/ui/call-chat-api.ts
-var import_provider_utils3 = require("@ai-sdk/provider-utils");
+// src/ui/call-completion-api.ts
+var import_provider_utils = require("@ai-sdk/provider-utils");
 
 // src/ui-message-stream/ui-message-stream-parts.ts
 var import_zod = require("zod");
@@ -591,14 +576,22 @@ var uiMessageStreamPartSchema = import_zod.z.union([
     providerMetadata: import_zod.z.record(import_zod.z.any()).optional()
   }),
   import_zod.z.object({
-    type: import_zod.z.literal("source"),
-    sourceType: import_zod.z.literal("url"),
-    id: import_zod.z.string(),
+    type: import_zod.z.literal("source-url"),
+    sourceId: import_zod.z.string(),
     url: import_zod.z.string(),
     title: import_zod.z.string().optional(),
     providerMetadata: import_zod.z.any().optional()
     // Use z.any() for generic metadata
   }),
+  import_zod.z.object({
+    type: import_zod.z.literal("source-document"),
+    sourceId: import_zod.z.string(),
+    mediaType: import_zod.z.string(),
+    title: import_zod.z.string(),
+    filename: import_zod.z.string().optional(),
+    providerMetadata: import_zod.z.any().optional()
+    // Use z.any() for generic metadata
+  }),
   import_zod.z.object({
     type: import_zod.z.literal("file"),
     url: import_zod.z.string(),
@@ -657,8 +650,170 @@ async function consumeStream({
   }
 }
 
+// src/ui/process-text-stream.ts
+async function processTextStream({
+  stream,
+  onTextPart
+}) {
+  const reader = stream.pipeThrough(new TextDecoderStream()).getReader();
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) {
+      break;
+    }
+    await onTextPart(value);
+  }
+}
+
+// src/ui/call-completion-api.ts
+var getOriginalFetch = () => fetch;
+async function callCompletionApi({
+  api,
+  prompt,
+  credentials,
+  headers,
+  body,
+  streamProtocol = "data",
+  setCompletion,
+  setLoading,
+  setError,
+  setAbortController,
+  onFinish,
+  onError,
+  fetch: fetch2 = getOriginalFetch()
+}) {
+  var _a17;
+  try {
+    setLoading(true);
+    setError(void 0);
+    const abortController = new AbortController();
+    setAbortController(abortController);
+    setCompletion("");
+    const response = await fetch2(api, {
+      method: "POST",
+      body: JSON.stringify({
+        prompt,
+        ...body
+      }),
+      credentials,
+      headers: {
+        "Content-Type": "application/json",
+        ...headers
+      },
+      signal: abortController.signal
+    }).catch((err) => {
+      throw err;
+    });
+    if (!response.ok) {
+      throw new Error(
+        (_a17 = await response.text()) != null ? _a17 : "Failed to fetch the chat response."
+      );
+    }
+    if (!response.body) {
+      throw new Error("The response body is empty.");
+    }
+    let result = "";
+    switch (streamProtocol) {
+      case "text": {
+        await processTextStream({
+          stream: response.body,
+          onTextPart: (chunk) => {
+            result += chunk;
+            setCompletion(result);
+          }
+        });
+        break;
+      }
+      case "data": {
+        await consumeStream({
+          stream: (0, import_provider_utils.parseJsonEventStream)({
+            stream: response.body,
+            schema: uiMessageStreamPartSchema
+          }).pipeThrough(
+            new TransformStream({
+              async transform(part) {
+                if (!part.success) {
+                  throw part.error;
+                }
+                const streamPart = part.value;
+                if (streamPart.type === "text") {
+                  result += streamPart.text;
+                  setCompletion(result);
+                } else if (streamPart.type === "error") {
+                  throw new Error(streamPart.errorText);
+                }
+              }
+            })
+          ),
+          onError: (error) => {
+            throw error;
+          }
+        });
+        break;
+      }
+      default: {
+        const exhaustiveCheck = streamProtocol;
+        throw new Error(`Unknown stream protocol: ${exhaustiveCheck}`);
+      }
+    }
+    if (onFinish) {
+      onFinish(prompt, result);
+    }
+    setAbortController(null);
+    return result;
+  } catch (err) {
+    if (err.name === "AbortError") {
+      setAbortController(null);
+      return null;
+    }
+    if (err instanceof Error) {
+      if (onError) {
+        onError(err);
+      }
+    }
+    setError(err);
+  } finally {
+    setLoading(false);
+  }
+}
+
+// src/ui/chat.ts
+var import_provider_utils5 = require("@ai-sdk/provider-utils");
+
+// src/util/serial-job-executor.ts
+var SerialJobExecutor = class {
+  constructor() {
+    this.queue = [];
+    this.isProcessing = false;
+  }
+  async processQueue() {
+    if (this.isProcessing) {
+      return;
+    }
+    this.isProcessing = true;
+    while (this.queue.length > 0) {
+      await this.queue[0]();
+      this.queue.shift();
+    }
+    this.isProcessing = false;
+  }
+  async run(job) {
+    return new Promise((resolve, reject) => {
+      this.queue.push(async () => {
+        try {
+          await job();
+          resolve();
+        } catch (error) {
+          reject(error);
+        }
+      });
+      void this.processQueue();
+    });
+  }
+};
+
 // src/ui/process-ui-message-stream.ts
-var import_provider_utils2 = require("@ai-sdk/provider-utils");
+var import_provider_utils3 = require("@ai-sdk/provider-utils");
 
 // src/util/merge-objects.ts
 function mergeObjects(base, overrides) {
@@ -694,7 +849,7 @@ function mergeObjects(base, overrides) {
 }
 
 // src/util/parse-partial-json.ts
-var import_provider_utils = require("@ai-sdk/provider-utils");
+var import_provider_utils2 = require("@ai-sdk/provider-utils");
 
 // src/util/fix-json.ts
 function fixJson(input) {
@@ -1019,25 +1174,17 @@ async function parsePartialJson(jsonText) {
   if (jsonText === void 0) {
     return { value: void 0, state: "undefined-input" };
   }
-  let result = await (0, import_provider_utils.safeParseJSON)({ text: jsonText });
+  let result = await (0, import_provider_utils2.safeParseJSON)({ text: jsonText });
   if (result.success) {
     return { value: result.value, state: "successful-parse" };
   }
-  result = await (0, import_provider_utils.safeParseJSON)({ text: fixJson(jsonText) });
+  result = await (0, import_provider_utils2.safeParseJSON)({ text: fixJson(jsonText) });
   if (result.success) {
     return { value: result.value, state: "repaired-parse" };
   }
   return { value: void 0, state: "failed-parse" };
 }
 
-// src/ui/extract-max-tool-invocation-step.ts
-function extractMaxToolInvocationStep(toolInvocations) {
-  return toolInvocations == null ? void 0 : toolInvocations.reduce((max, toolInvocation) => {
-    var _a17;
-    return Math.max(max, (_a17 = toolInvocation.step) != null ? _a17 : 0);
-  }, 0);
-}
-
 // src/ui/get-tool-invocations.ts
 function getToolInvocations(message) {
   return message.parts.filter(
@@ -1048,12 +1195,10 @@ function getToolInvocations(message) {
 // src/ui/process-ui-message-stream.ts
 function createStreamingUIMessageState({
   lastMessage,
-  newMessageId = "no-id"
+  newMessageId = ""
 } = {}) {
-  var _a17;
   const isContinuation = (lastMessage == null ? void 0 : lastMessage.role) === "assistant";
-  const step = isContinuation ? 1 + ((_a17 = extractMaxToolInvocationStep(getToolInvocations(lastMessage))) != null ? _a17 : 0) : 0;
-  const message = isContinuation ? structuredClone(lastMessage) : {
+  const message = isContinuation ? lastMessage : {
     id: newMessageId,
     metadata: {},
     role: "assistant",
@@ -1063,8 +1208,7 @@ function createStreamingUIMessageState({
     message,
     activeTextPart: void 0,
     activeReasoningPart: void 0,
-    partialToolCalls: {},
-    step
+    partialToolCalls: {}
   };
 }
 function processUIMessageStream({
@@ -1095,7 +1239,7 @@ function processUIMessageStream({
             if (metadata != null) {
               const mergedMetadata = state.message.metadata != null ? mergeObjects(state.message.metadata, metadata) : metadata;
               if (messageMetadataSchema != null) {
-                await (0, import_provider_utils2.validateTypes)({
+                await (0, import_provider_utils3.validateTypes)({
                   value: mergedMetadata,
                   schema: messageMetadataSchema
                 });
@@ -1147,16 +1291,25 @@ function processUIMessageStream({
               write();
               break;
             }
-            case "source": {
+            case "source-url": {
               state.message.parts.push({
-                type: "source",
-                source: {
-                  sourceType: "url",
-                  id: part.id,
-                  url: part.url,
-                  title: part.title,
-                  providerMetadata: part.providerMetadata
-                }
+                type: "source-url",
+                sourceId: part.sourceId,
+                url: part.url,
+                title: part.title,
+                providerMetadata: part.providerMetadata
+              });
+              write();
+              break;
+            }
+            case "source-document": {
+              state.message.parts.push({
+                type: "source-document",
+                sourceId: part.sourceId,
+                mediaType: part.mediaType,
+                title: part.title,
+                filename: part.filename,
+                providerMetadata: part.providerMetadata
               });
               write();
               break;
@@ -1165,13 +1318,11 @@ function processUIMessageStream({
               const toolInvocations = getToolInvocations(state.message);
               state.partialToolCalls[part.toolCallId] = {
                 text: "",
-                step: state.step,
                 toolName: part.toolName,
                 index: toolInvocations.length
               };
               updateToolInvocationPart(part.toolCallId, {
                 state: "partial-call",
-                step: state.step,
                 toolCallId: part.toolCallId,
                 toolName: part.toolName,
                 args: void 0
@@ -1187,7 +1338,6 @@ function processUIMessageStream({
               );
               updateToolInvocationPart(part.toolCallId, {
                 state: "partial-call",
-                step: partialToolCall.step,
                 toolCallId: part.toolCallId,
                 toolName: partialToolCall.toolName,
                 args: partialArgs
@@ -1198,7 +1348,6 @@ function processUIMessageStream({
             case "tool-call": {
               updateToolInvocationPart(part.toolCallId, {
                 state: "call",
-                step: state.step,
                 toolCallId: part.toolCallId,
                 toolName: part.toolName,
                 args: part.args
@@ -1211,7 +1360,6 @@ function processUIMessageStream({
                 if (result != null) {
                   updateToolInvocationPart(part.toolCallId, {
                     state: "result",
-                    step: state.step,
                     toolCallId: part.toolCallId,
                     toolName: part.toolName,
                     args: part.args,
@@ -1250,7 +1398,6 @@ function processUIMessageStream({
               break;
             }
             case "finish-step": {
-              state.step += 1;
               state.activeTextPart = void 0;
               state.activeReasoningPart = void 0;
               await updateMessageMetadata(part.metadata);
@@ -1292,14 +1439,7 @@ function processUIMessageStream({
                   (partArg) => part.type === partArg.type && part.id === partArg.id
                 ) : void 0;
                 if (existingPart != null) {
-                  if (isObject(existingPart.data) && isObject(part.data)) {
-                    existingPart.value = mergeObjects(
-                      existingPart.data,
-                      part.data
-                    );
-                  } else {
-                    existingPart.data = part.data;
-                  }
+                  existingPart.data = isObject(existingPart.data) && isObject(part.data) ? mergeObjects(existingPart.data, part.data) : part.data;
                 } else {
                   state.message.parts.push(part);
                 }
@@ -1320,47 +1460,60 @@ function isObject(value) {
   return typeof value === "object" && value !== null;
 }
 
-// src/ui/transform-text-to-ui-message-stream.ts
-function transformTextToUiMessageStream({
-  stream
+// src/ui/should-resubmit-messages.ts
+function shouldResubmitMessages({
+  originalMaxToolInvocationStep,
+  originalMessageCount,
+  maxSteps,
+  messages
 }) {
-  return stream.pipeThrough(
-    new TransformStream({
-      start(controller) {
-        controller.enqueue({ type: "start" });
-        controller.enqueue({ type: "start-step" });
-      },
-      async transform(part, controller) {
-        controller.enqueue({ type: "text", text: part });
-      },
-      async flush(controller) {
-        controller.enqueue({ type: "finish-step" });
-        controller.enqueue({ type: "finish" });
-      }
-    })
+  const lastMessage = messages[messages.length - 1];
+  const lastMessageStepStartCount = lastMessage.parts.filter(
+    (part) => part.type === "step-start"
+  ).length;
+  return (
+    // check if the feature is enabled:
+    maxSteps > 1 && // ensure there is a last message:
+    lastMessage != null && // ensure we actually have new steps (to prevent infinite loops in case of errors):
+    (messages.length > originalMessageCount || lastMessageStepStartCount !== originalMaxToolInvocationStep) && // check that next step is possible:
+    isAssistantMessageWithCompletedToolCalls(lastMessage) && // limit the number of automatic steps:
+    lastMessageStepStartCount < maxSteps
   );
 }
+function isAssistantMessageWithCompletedToolCalls(message) {
+  if (!message) {
+    return false;
+  }
+  if (message.role !== "assistant") {
+    return false;
+  }
+  const lastStepStartIndex = message.parts.reduce((lastIndex, part, index) => {
+    return part.type === "step-start" ? index : lastIndex;
+  }, -1);
+  const lastStepToolInvocations = message.parts.slice(lastStepStartIndex + 1).filter((part) => part.type === "tool-invocation");
+  return lastStepToolInvocations.length > 0 && lastStepToolInvocations.every((part) => "result" in part.toolInvocation);
+}
 
-// src/ui/call-chat-api.ts
-var getOriginalFetch = () => fetch;
+// src/ui/default-chat-transport.ts
+var import_provider_utils4 = require("@ai-sdk/provider-utils");
+var getOriginalFetch2 = () => fetch;
 async function fetchUIMessageStream({
   api,
   body,
-  streamProtocol = "ui-message",
   credentials,
   headers,
-  abortController,
-  fetch: fetch2 = getOriginalFetch(),
+  abortSignal,
+  fetch: fetch2 = getOriginalFetch2(),
   requestType = "generate"
 }) {
-  var _a17, _b, _c;
-  const response = requestType === "resume" ? await fetch2(`${api}?chatId=${body.chatId}`, {
+  var _a17;
+  const response = requestType === "resume" ? await fetch2(`${api}?id=${body.id}`, {
     method: "GET",
     headers: {
       "Content-Type": "application/json",
       ...headers
     },
-    signal: (_a17 = abortController == null ? void 0 : abortController()) == null ? void 0 : _a17.signal,
+    signal: abortSignal,
     credentials
   }) : await fetch2(api, {
     method: "POST",
@@ -1369,20 +1522,18 @@ async function fetchUIMessageStream({
       "Content-Type": "application/json",
       ...headers
     },
-    signal: (_b = abortController == null ? void 0 : abortController()) == null ? void 0 : _b.signal,
+    signal: abortSignal,
     credentials
   });
   if (!response.ok) {
     throw new Error(
-      (_c = await response.text()) != null ? _c : "Failed to fetch the chat response."
+      (_a17 = await response.text()) != null ? _a17 : "Failed to fetch the chat response."
     );
   }
   if (!response.body) {
     throw new Error("The response body is empty.");
   }
-  return streamProtocol === "text" ? transformTextToUiMessageStream({
-    stream: response.body.pipeThrough(new TextDecoderStream())
-  }) : (0, import_provider_utils3.parseJsonEventStream)({
+  return (0, import_provider_utils4.parseJsonEventStream)({
     stream: response.body,
     schema: uiMessageStreamPartSchema
   }).pipeThrough(
@@ -1396,552 +1547,291 @@ async function fetchUIMessageStream({
     })
   );
 }
-async function consumeUIMessageStream({
-  stream,
-  onUpdate,
-  onFinish,
-  onToolCall,
-  generateId: generateId3,
-  lastMessage,
-  messageMetadataSchema
-}) {
-  const state = createStreamingUIMessageState({
-    lastMessage,
-    newMessageId: generateId3()
-  });
-  const runUpdateMessageJob = async (job) => {
-    await job({
-      state,
-      write: () => {
-        onUpdate({ message: state.message });
-      }
-    });
-  };
-  await consumeStream({
-    stream: processUIMessageStream({
-      stream,
-      onToolCall,
-      messageMetadataSchema,
-      runUpdateMessageJob
-    }),
-    onError: (error) => {
-      throw error;
-    }
-  });
-  onFinish == null ? void 0 : onFinish({ message: state.message });
-}
-async function callChatApi({
-  api,
-  body,
-  streamProtocol = "ui-message",
-  credentials,
-  headers,
-  abortController,
-  onUpdate,
-  onFinish,
-  onToolCall,
-  generateId: generateId3,
-  fetch: fetch2 = getOriginalFetch(),
-  lastMessage,
-  requestType = "generate",
-  messageMetadataSchema
-}) {
-  const stream = await fetchUIMessageStream({
-    api,
-    body,
-    streamProtocol,
+var DefaultChatTransport = class {
+  constructor({
+    api = "/api/chat",
     credentials,
     headers,
-    abortController,
+    body,
     fetch: fetch2,
-    requestType
-  });
-  await consumeUIMessageStream({
-    stream,
-    onUpdate,
-    onFinish,
-    onToolCall,
-    generateId: generateId3,
-    lastMessage,
-    messageMetadataSchema
-  });
-}
-
-// src/ui/call-completion-api.ts
-var import_provider_utils4 = require("@ai-sdk/provider-utils");
-
-// src/ui/process-text-stream.ts
-async function processTextStream({
-  stream,
-  onTextPart
-}) {
-  const reader = stream.pipeThrough(new TextDecoderStream()).getReader();
-  while (true) {
-    const { done, value } = await reader.read();
-    if (done) {
-      break;
-    }
-    await onTextPart(value);
+    prepareRequest
+  } = {}) {
+    this.api = api;
+    this.credentials = credentials;
+    this.headers = headers;
+    this.body = body;
+    this.fetch = fetch2;
+    this.prepareRequest = prepareRequest;
   }
-}
-
-// src/ui/call-completion-api.ts
-var getOriginalFetch2 = () => fetch;
-async function callCompletionApi({
-  api,
-  prompt,
-  credentials,
-  headers,
-  body,
-  streamProtocol = "data",
-  setCompletion,
-  setLoading,
-  setError,
-  setAbortController,
-  onFinish,
-  onError,
-  fetch: fetch2 = getOriginalFetch2()
-}) {
-  var _a17;
-  try {
-    setLoading(true);
-    setError(void 0);
-    const abortController = new AbortController();
-    setAbortController(abortController);
-    setCompletion("");
-    const response = await fetch2(api, {
-      method: "POST",
-      body: JSON.stringify({
-        prompt,
-        ...body
-      }),
-      credentials,
-      headers: {
-        "Content-Type": "application/json",
-        ...headers
-      },
-      signal: abortController.signal
-    }).catch((err) => {
-      throw err;
+  submitMessages({
+    chatId,
+    messages,
+    abortSignal,
+    metadata,
+    headers,
+    body,
+    requestType
+  }) {
+    var _a17, _b;
+    const preparedRequest = (_a17 = this.prepareRequest) == null ? void 0 : _a17.call(this, {
+      id: chatId,
+      messages,
+      body: { ...this.body, ...body },
+      headers: { ...this.headers, ...headers },
+      credentials: this.credentials,
+      requestMetadata: metadata
     });
-    if (!response.ok) {
-      throw new Error(
-        (_a17 = await response.text()) != null ? _a17 : "Failed to fetch the chat response."
-      );
-    }
-    if (!response.body) {
-      throw new Error("The response body is empty.");
-    }
-    let result = "";
-    switch (streamProtocol) {
-      case "text": {
-        await processTextStream({
-          stream: response.body,
-          onTextPart: (chunk) => {
-            result += chunk;
-            setCompletion(result);
-          }
-        });
-        break;
-      }
-      case "data": {
-        await consumeStream({
-          stream: (0, import_provider_utils4.parseJsonEventStream)({
-            stream: response.body,
-            schema: uiMessageStreamPartSchema
-          }).pipeThrough(
-            new TransformStream({
-              async transform(part) {
-                if (!part.success) {
-                  throw part.error;
-                }
-                const streamPart = part.value;
-                if (streamPart.type === "text") {
-                  result += streamPart.text;
-                  setCompletion(result);
-                } else if (streamPart.type === "error") {
-                  throw new Error(streamPart.errorText);
-                }
-              }
-            })
-          ),
-          onError: (error) => {
-            throw error;
-          }
-        });
-        break;
-      }
-      default: {
-        const exhaustiveCheck = streamProtocol;
-        throw new Error(`Unknown stream protocol: ${exhaustiveCheck}`);
-      }
-    }
-    if (onFinish) {
-      onFinish(prompt, result);
-    }
-    setAbortController(null);
-    return result;
-  } catch (err) {
-    if (err.name === "AbortError") {
-      setAbortController(null);
-      return null;
-    }
-    if (err instanceof Error) {
-      if (onError) {
-        onError(err);
-      }
-    }
-    setError(err);
-  } finally {
-    setLoading(false);
-  }
-}
-
-// src/ui/chat-store.ts
-var import_provider_utils5 = require("@ai-sdk/provider-utils");
-
-// src/util/serial-job-executor.ts
-var SerialJobExecutor = class {
-  constructor() {
-    this.queue = [];
-    this.isProcessing = false;
-  }
-  async processQueue() {
-    if (this.isProcessing) {
-      return;
-    }
-    this.isProcessing = true;
-    while (this.queue.length > 0) {
-      await this.queue[0]();
-      this.queue.shift();
-    }
-    this.isProcessing = false;
-  }
-  async run(job) {
-    return new Promise((resolve, reject) => {
-      this.queue.push(async () => {
-        try {
-          await job();
-          resolve();
-        } catch (error) {
-          reject(error);
-        }
-      });
-      void this.processQueue();
+    return fetchUIMessageStream({
+      api: this.api,
+      body: (preparedRequest == null ? void 0 : preparedRequest.body) !== void 0 ? preparedRequest.body : { ...this.body, ...body, id: chatId, messages },
+      headers: (preparedRequest == null ? void 0 : preparedRequest.headers) !== void 0 ? preparedRequest.headers : { ...this.headers, ...headers },
+      credentials: (_b = preparedRequest == null ? void 0 : preparedRequest.credentials) != null ? _b : this.credentials,
+      abortSignal,
+      fetch: this.fetch,
+      requestType
     });
   }
 };
 
-// src/ui/should-resubmit-messages.ts
-function shouldResubmitMessages({
-  originalMaxToolInvocationStep,
-  originalMessageCount,
-  maxSteps: maxSteps2,
-  messages
-}) {
-  var _a17;
-  const lastMessage = messages[messages.length - 1];
-  return (
-    // check if the feature is enabled:
-    maxSteps2 > 1 && // ensure there is a last message:
-    lastMessage != null && // ensure we actually have new steps (to prevent infinite loops in case of errors):
-    (messages.length > originalMessageCount || extractMaxToolInvocationStep(getToolInvocations(lastMessage)) !== originalMaxToolInvocationStep) && // check that next step is possible:
-    isAssistantMessageWithCompletedToolCalls(lastMessage) && // limit the number of automatic steps:
-    ((_a17 = extractMaxToolInvocationStep(getToolInvocations(lastMessage))) != null ? _a17 : 0) < maxSteps2
-  );
-}
-function isAssistantMessageWithCompletedToolCalls(message) {
-  if (message.role !== "assistant") {
-    return false;
+// src/ui/convert-file-list-to-file-ui-parts.ts
+async function convertFileListToFileUIParts(files) {
+  if (files == null) {
+    return [];
   }
-  const lastStepStartIndex = message.parts.reduce((lastIndex, part, index) => {
-    return part.type === "step-start" ? index : lastIndex;
-  }, -1);
-  const lastStepToolInvocations = message.parts.slice(lastStepStartIndex + 1).filter((part) => part.type === "tool-invocation");
-  return lastStepToolInvocations.length > 0 && lastStepToolInvocations.every((part) => "result" in part.toolInvocation);
-}
-
-// src/ui/update-tool-call-result.ts
-function updateToolCallResult({
-  messages,
-  toolCallId,
-  toolResult: result
-}) {
-  const lastMessage = messages[messages.length - 1];
-  const invocationPart = lastMessage.parts.find(
-    (part) => part.type === "tool-invocation" && part.toolInvocation.toolCallId === toolCallId
-  );
-  if (invocationPart == null) {
-    return;
+  if (!globalThis.FileList || !(files instanceof globalThis.FileList)) {
+    throw new Error("FileList is not supported in the current environment");
   }
-  invocationPart.toolInvocation = {
-    ...invocationPart.toolInvocation,
-    state: "result",
-    result
-  };
+  return Promise.all(
+    Array.from(files).map(async (file) => {
+      const { name: name17, type } = file;
+      const dataUrl = await new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onload = (readerEvent) => {
+          var _a17;
+          resolve((_a17 = readerEvent.target) == null ? void 0 : _a17.result);
+        };
+        reader.onerror = (error) => reject(error);
+        reader.readAsDataURL(file);
+      });
+      return {
+        type: "file",
+        mediaType: type,
+        filename: name17,
+        url: dataUrl
+      };
+    })
+  );
 }
 
-// src/ui/chat-store.ts
-var ChatStore = class {
+// src/ui/chat.ts
+var AbstractChat = class {
   constructor({
-    chats = {},
-    generateId: generateId3,
-    transport,
-    maxSteps: maxSteps2 = 1,
+    generateId: generateId3 = import_provider_utils5.generateId,
+    id = generateId3(),
+    transport = new DefaultChatTransport(),
+    maxSteps = 1,
     messageMetadataSchema,
-    dataPartSchemas
+    dataPartSchemas,
+    state,
+    onError,
+    onToolCall,
+    onFinish
   }) {
-    this.chats = new Map(
-      Object.entries(chats).map(([id, state]) => [
-        id,
-        {
-          messages: [...state.messages],
-          status: "ready",
-          activeResponse: void 0,
-          error: void 0,
-          jobExecutor: new SerialJobExecutor()
+    this.subscribers = /* @__PURE__ */ new Set();
+    this.activeResponse = void 0;
+    this.jobExecutor = new SerialJobExecutor();
+    this.removeAssistantResponse = () => {
+      const lastMessage = this.state.messages[this.state.messages.length - 1];
+      if (lastMessage == null) {
+        throw new Error("Cannot remove assistant response from empty chat");
+      }
+      if (lastMessage.role !== "assistant") {
+        throw new Error("Last message is not an assistant message");
+      }
+      this.state.popMessage();
+      this.emit({ type: "messages-changed" });
+    };
+    /**
+     * Append a user message to the chat list. This triggers the API call to fetch
+     * the assistant's response.
+     */
+    this.sendMessage = async (message, options = {}) => {
+      var _a17, _b;
+      let uiMessage;
+      if ("text" in message || "files" in message) {
+        const fileParts = Array.isArray(message.files) ? message.files : await convertFileListToFileUIParts(message.files);
+        uiMessage = {
+          parts: [
+            ...fileParts,
+            ..."text" in message && message.text != null ? [{ type: "text", text: message.text }] : []
+          ]
+        };
+      } else {
+        uiMessage = message;
+      }
+      this.state.pushMessage({
+        ...uiMessage,
+        id: (_a17 = uiMessage.id) != null ? _a17 : this.generateId(),
+        role: (_b = uiMessage.role) != null ? _b : "user"
+      });
+      this.emit({ type: "messages-changed" });
+      await this.triggerRequest({ requestType: "generate", ...options });
+    };
+    /**
+     * Regenerate the last assistant message.
+     */
+    this.reload = async (options = {}) => {
+      if (this.lastMessage === void 0) {
+        return;
+      }
+      if (this.lastMessage.role === "assistant") {
+        this.state.popMessage();
+        this.emit({ type: "messages-changed" });
+      }
+      await this.triggerRequest({ requestType: "generate", ...options });
+    };
+    /**
+     * Resume an ongoing chat generation stream. This does not resume an aborted generation.
+     */
+    this.experimental_resume = async (options = {}) => {
+      await this.triggerRequest({ requestType: "resume", ...options });
+    };
+    this.addToolResult = async ({
+      toolCallId,
+      result
+    }) => {
+      this.jobExecutor.run(async () => {
+        updateToolCallResult({
+          messages: this.state.messages,
+          toolCallId,
+          toolResult: result
+        });
+        this.messages = this.state.messages;
+        if (this.status === "submitted" || this.status === "streaming") {
+          return;
         }
-      ])
-    );
-    this.maxSteps = maxSteps2;
+        const lastMessage = this.lastMessage;
+        if (isAssistantMessageWithCompletedToolCalls(lastMessage)) {
+          this.triggerRequest({
+            requestType: "generate"
+          });
+        }
+      });
+    };
+    /**
+     * Abort the current request immediately, keep the generated tokens if any.
+     */
+    this.stop = async () => {
+      var _a17;
+      if (this.status !== "streaming" && this.status !== "submitted")
+        return;
+      if ((_a17 = this.activeResponse) == null ? void 0 : _a17.abortController) {
+        this.activeResponse.abortController.abort();
+        this.activeResponse.abortController = void 0;
+      }
+    };
+    this.id = id;
+    this.maxSteps = maxSteps;
     this.transport = transport;
-    this.subscribers = /* @__PURE__ */ new Set();
-    this.generateId = generateId3 != null ? generateId3 : import_provider_utils5.generateId;
+    this.generateId = generateId3;
     this.messageMetadataSchema = messageMetadataSchema;
     this.dataPartSchemas = dataPartSchemas;
+    this.state = state;
+    this.onError = onError;
+    this.onToolCall = onToolCall;
+    this.onFinish = onFinish;
   }
-  hasChat(id) {
-    return this.chats.has(id);
-  }
-  addChat(id, messages) {
-    this.chats.set(id, {
-      messages,
-      status: "ready",
-      jobExecutor: new SerialJobExecutor()
-    });
-  }
-  getChats() {
-    return Array.from(this.chats.entries());
-  }
-  get chatCount() {
-    return this.chats.size;
-  }
-  getStatus(id) {
-    return this.getChat(id).status;
+  /**
+   * Hook status:
+   *
+   * - `submitted`: The message has been sent to the API and we're awaiting the start of the response stream.
+   * - `streaming`: The response is actively streaming in from the API, receiving chunks of data.
+   * - `ready`: The full response has been received and processed; a new user message can be submitted.
+   * - `error`: An error occurred during the API request, preventing successful completion.
+   */
+  get status() {
+    return this.state.status;
   }
   setStatus({
-    id,
     status,
     error
   }) {
-    const chat = this.getChat(id);
-    if (chat.status === status)
+    if (this.status === status)
       return;
-    chat.status = status;
-    chat.error = error;
-    this.emit({ type: "chat-status-changed", chatId: id, error });
+    this.state.status = status;
+    this.state.error = error;
+    this.emit({ type: "status-changed" });
   }
-  getError(id) {
-    return this.getChat(id).error;
+  get error() {
+    return this.state.error;
   }
-  getMessages(id) {
-    return this.getChat(id).messages;
+  get messages() {
+    return this.state.messages;
   }
-  getLastMessage(id) {
-    const chat = this.getChat(id);
-    return chat.messages[chat.messages.length - 1];
+  get lastMessage() {
+    return this.state.messages[this.state.messages.length - 1];
   }
   subscribe(subscriber) {
     this.subscribers.add(subscriber);
     return () => this.subscribers.delete(subscriber);
   }
-  setMessages({
-    id,
-    messages
-  }) {
-    this.getChat(id).messages = [...messages];
-    this.emit({ type: "chat-messages-changed", chatId: id });
-  }
-  removeAssistantResponse(id) {
-    const chat = this.getChat(id);
-    const lastMessage = chat.messages[chat.messages.length - 1];
-    if (lastMessage == null) {
-      throw new Error("Cannot remove assistant response from empty chat");
-    }
-    if (lastMessage.role !== "assistant") {
-      throw new Error("Last message is not an assistant message");
-    }
-    this.setMessages({ id, messages: chat.messages.slice(0, -1) });
-  }
-  async submitMessage({
-    chatId,
-    message,
-    headers,
-    body,
-    onError,
-    onToolCall,
-    onFinish
-  }) {
-    var _a17;
-    const chat = this.getChat(chatId);
-    const currentMessages = chat.messages;
-    await this.triggerRequest({
-      chatId,
-      messages: currentMessages.concat({
-        ...message,
-        id: (_a17 = message.id) != null ? _a17 : this.generateId()
-      }),
-      headers,
-      body,
-      requestType: "generate",
-      onError,
-      onToolCall,
-      onFinish
-    });
-  }
-  async resubmitLastUserMessage({
-    chatId,
-    headers,
-    body,
-    onError,
-    onToolCall,
-    onFinish
-  }) {
-    const messages = this.getChat(chatId).messages;
-    const messagesToSubmit = messages[messages.length - 1].role === "assistant" ? messages.slice(0, -1) : messages;
-    if (messagesToSubmit.length === 0) {
-      return;
-    }
-    return this.triggerRequest({
-      chatId,
-      requestType: "generate",
-      messages: messagesToSubmit,
-      headers,
-      body,
-      onError,
-      onToolCall,
-      onFinish
-    });
-  }
-  async resumeStream({
-    chatId,
-    headers,
-    body,
-    onError,
-    onToolCall,
-    onFinish
-  }) {
-    const chat = this.getChat(chatId);
-    const currentMessages = chat.messages;
-    return this.triggerRequest({
-      chatId,
-      messages: currentMessages,
-      requestType: "resume",
-      headers,
-      body,
-      onError,
-      onToolCall,
-      onFinish
-    });
-  }
-  async addToolResult({
-    chatId,
-    toolCallId,
-    result
-  }) {
-    const chat = this.getChat(chatId);
-    chat.jobExecutor.run(async () => {
-      const currentMessages = chat.messages;
-      updateToolCallResult({
-        messages: currentMessages,
-        toolCallId,
-        toolResult: result
-      });
-      this.setMessages({ id: chatId, messages: currentMessages });
-      if (chat.status === "submitted" || chat.status === "streaming") {
-        return;
-      }
-      const lastMessage = currentMessages[currentMessages.length - 1];
-      if (isAssistantMessageWithCompletedToolCalls(lastMessage)) {
-        await this.triggerRequest({
-          messages: currentMessages,
-          requestType: "generate",
-          chatId
-        });
-      }
-    });
-  }
-  async stopStream({ chatId }) {
-    var _a17;
-    const chat = this.getChat(chatId);
-    if (chat.status !== "streaming" && chat.status !== "submitted")
-      return;
-    if ((_a17 = chat.activeResponse) == null ? void 0 : _a17.abortController) {
-      chat.activeResponse.abortController.abort();
-      chat.activeResponse.abortController = void 0;
-    }
+  set messages(messages) {
+    this.state.messages = messages;
+    this.emit({ type: "messages-changed" });
   }
   emit(event) {
     for (const subscriber of this.subscribers) {
-      subscriber.onChatChanged(event);
-    }
-  }
-  getChat(id) {
-    if (!this.hasChat(id)) {
-      throw new Error(`chat '${id}' not found`);
+      subscriber.onChange(event);
     }
-    return this.chats.get(id);
   }
   async triggerRequest({
-    chatId,
-    messages: chatMessages,
     requestType,
+    metadata,
     headers,
-    body,
-    onError,
-    onToolCall,
-    onFinish
+    body
   }) {
-    const self = this;
-    const chat = this.getChat(chatId);
-    this.setMessages({ id: chatId, messages: chatMessages });
-    this.setStatus({ id: chatId, status: "submitted", error: void 0 });
-    const messageCount = chatMessages.length;
-    const maxStep = extractMaxToolInvocationStep(
-      getToolInvocations(chatMessages[chatMessages.length - 1])
-    );
+    var _a17, _b;
+    this.setStatus({ status: "submitted", error: void 0 });
+    const messageCount = this.state.messages.length;
+    const lastMessage = this.lastMessage;
+    const maxStep = (_a17 = lastMessage == null ? void 0 : lastMessage.parts.filter((part) => part.type === "step-start").length) != null ? _a17 : 0;
     try {
       const activeResponse = {
         state: createStreamingUIMessageState({
-          lastMessage: chatMessages[chatMessages.length - 1],
-          newMessageId: self.generateId()
+          lastMessage: this.state.snapshot(lastMessage),
+          newMessageId: this.generateId()
         }),
         abortController: new AbortController()
       };
-      chat.activeResponse = activeResponse;
-      const stream = await self.transport.submitMessages({
-        chatId,
-        messages: chatMessages,
-        body,
+      this.activeResponse = activeResponse;
+      const stream = await this.transport.submitMessages({
+        chatId: this.id,
+        messages: this.state.messages,
+        abortSignal: activeResponse.abortController.signal,
+        metadata,
         headers,
-        abortController: activeResponse.abortController,
+        body,
         requestType
       });
       const runUpdateMessageJob = (job) => (
         // serialize the job execution to avoid race conditions:
-        chat.jobExecutor.run(
+        this.jobExecutor.run(
           () => job({
             state: activeResponse.state,
             write: () => {
-              self.setStatus({ id: chatId, status: "streaming" });
-              const replaceLastMessage = activeResponse.state.message.id === chatMessages[chatMessages.length - 1].id;
-              const newMessages = [
-                ...replaceLastMessage ? chatMessages.slice(0, chatMessages.length - 1) : chatMessages,
-                activeResponse.state.message
-              ];
-              self.setMessages({
-                id: chatId,
-                messages: newMessages
+              var _a18;
+              this.setStatus({ status: "streaming" });
+              const replaceLastMessage = activeResponse.state.message.id === ((_a18 = this.lastMessage) == null ? void 0 : _a18.id);
+              if (replaceLastMessage) {
+                this.state.replaceMessage(
+                  this.state.messages.length - 1,
+                  activeResponse.state.message
+                );
+              } else {
+                this.state.pushMessage(activeResponse.state.message);
+              }
+              this.emit({
+                type: "messages-changed"
               });
             }
           })
@@ -1950,137 +1840,67 @@ var ChatStore = class {
       await consumeStream({
         stream: processUIMessageStream({
           stream,
-          onToolCall,
-          messageMetadataSchema: self.messageMetadataSchema,
-          dataPartSchemas: self.dataPartSchemas,
+          onToolCall: this.onToolCall,
+          messageMetadataSchema: this.messageMetadataSchema,
+          dataPartSchemas: this.dataPartSchemas,
           runUpdateMessageJob
         }),
         onError: (error) => {
           throw error;
         }
       });
-      onFinish == null ? void 0 : onFinish({ message: activeResponse.state.message });
-      this.setStatus({ id: chatId, status: "ready" });
+      (_b = this.onFinish) == null ? void 0 : _b.call(this, { message: activeResponse.state.message });
+      this.setStatus({ status: "ready" });
     } catch (err) {
+      console.error(err);
       if (err.name === "AbortError") {
-        this.setStatus({ id: chatId, status: "ready" });
+        this.setStatus({ status: "ready" });
         return null;
       }
-      if (onError && err instanceof Error) {
-        onError(err);
+      if (this.onError && err instanceof Error) {
+        this.onError(err);
       }
-      this.setStatus({ id: chatId, status: "error", error: err });
+      this.setStatus({ status: "error", error: err });
     } finally {
-      chat.activeResponse = void 0;
+      this.activeResponse = void 0;
     }
-    const currentMessages = self.getMessages(chatId);
     if (shouldResubmitMessages({
       originalMaxToolInvocationStep: maxStep,
       originalMessageCount: messageCount,
-      maxSteps: self.maxSteps,
-      messages: currentMessages
+      maxSteps: this.maxSteps,
+      messages: this.state.messages
     })) {
-      await self.triggerRequest({
-        chatId,
+      await this.triggerRequest({
         requestType,
-        onError,
-        onToolCall,
-        onFinish,
+        metadata,
         headers,
-        body,
-        messages: currentMessages
+        body
       });
     }
   }
 };
-
-// src/ui/chat-transport.ts
-var DefaultChatTransport = class {
-  constructor({
-    api,
-    credentials,
-    headers,
-    body,
-    streamProtocol,
-    fetch: fetch2,
-    prepareRequestBody
-  }) {
-    this.api = api;
-    this.credentials = credentials;
-    this.headers = headers;
-    this.body = body;
-    this.streamProtocol = streamProtocol;
-    this.fetch = fetch2;
-    this.prepareRequestBody = prepareRequestBody;
-  }
-  submitMessages({
-    chatId,
-    messages,
-    abortController,
-    body,
-    headers,
-    requestType
-  }) {
-    var _a17, _b;
-    return fetchUIMessageStream({
-      api: this.api,
-      headers: {
-        ...this.headers,
-        ...headers
-      },
-      body: (_b = (_a17 = this.prepareRequestBody) == null ? void 0 : _a17.call(this, {
-        chatId,
-        messages,
-        ...this.body,
-        ...body
-      })) != null ? _b : {
-        chatId,
-        messages,
-        ...this.body,
-        ...body
-      },
-      streamProtocol: this.streamProtocol,
-      credentials: this.credentials,
-      abortController: () => abortController,
-      fetch: this.fetch,
-      requestType
-    });
-  }
-};
-
-// src/ui/convert-file-list-to-file-ui-parts.ts
-async function convertFileListToFileUIParts(files) {
-  if (files == null) {
-    return [];
-  }
-  if (!globalThis.FileList || !(files instanceof globalThis.FileList)) {
-    throw new Error("FileList is not supported in the current environment");
-  }
-  return Promise.all(
-    Array.from(files).map(async (file) => {
-      const { name: name17, type } = file;
-      const dataUrl = await new Promise((resolve, reject) => {
-        const reader = new FileReader();
-        reader.onload = (readerEvent) => {
-          var _a17;
-          resolve((_a17 = readerEvent.target) == null ? void 0 : _a17.result);
-        };
-        reader.onerror = (error) => reject(error);
-        reader.readAsDataURL(file);
-      });
-      return {
-        type: "file",
-        mediaType: type,
-        filename: name17,
-        url: dataUrl
-      };
-    })
+function updateToolCallResult({
+  messages,
+  toolCallId,
+  toolResult: result
+}) {
+  const lastMessage = messages[messages.length - 1];
+  const invocationPart = lastMessage.parts.find(
+    (part) => part.type === "tool-invocation" && part.toolInvocation.toolCallId === toolCallId
   );
+  if (invocationPart == null) {
+    return;
+  }
+  invocationPart.toolInvocation = {
+    ...invocationPart.toolInvocation,
+    state: "result",
+    result
+  };
 }
 
 // src/ui/convert-to-model-messages.ts
 function convertToModelMessages(messages, options) {
-  var _a17, _b;
+  var _a17;
   const tools = (_a17 = options == null ? void 0 : options.tools) != null ? _a17 : {};
   const modelMessages = [];
   for (const message of messages) {
@@ -2111,6 +1931,9 @@ function convertToModelMessages(messages, options) {
       case "assistant": {
         if (message.parts != null) {
           let processBlock2 = function() {
+            if (block.length === 0) {
+              return;
+            }
             const content = [];
             for (const part of block) {
               switch (part.type) {
@@ -2185,33 +2008,20 @@ function convertToModelMessages(messages, options) {
               });
             }
             block = [];
-            blockHasToolInvocations = false;
-            currentStep++;
           };
           var processBlock = processBlock2;
-          let currentStep = 0;
-          let blockHasToolInvocations = false;
           let block = [];
           for (const part of message.parts) {
             switch (part.type) {
-              case "text": {
-                if (blockHasToolInvocations) {
-                  processBlock2();
-                }
-                block.push(part);
-                break;
-              }
+              case "text":
+              case "reasoning":
               case "file":
-              case "reasoning": {
+              case "tool-invocation": {
                 block.push(part);
                 break;
               }
-              case "tool-invocation": {
-                if (((_b = part.toolInvocation.step) != null ? _b : 0) !== currentStep) {
-                  processBlock2();
-                }
-                block.push(part);
-                blockHasToolInvocations = true;
+              case "step-start": {
+                processBlock2();
                 break;
               }
             }
@@ -2234,45 +2044,166 @@ function convertToModelMessages(messages, options) {
 }
 var convertToCoreMessages = convertToModelMessages;
 
-// src/ui/default-chat-store.ts
-var import_provider_utils6 = require("@ai-sdk/provider-utils");
-function defaultChatStore({
+// src/ui/transform-text-to-ui-message-stream.ts
+function transformTextToUiMessageStream({
+  stream
+}) {
+  return stream.pipeThrough(
+    new TransformStream({
+      start(controller) {
+        controller.enqueue({ type: "start" });
+        controller.enqueue({ type: "start-step" });
+      },
+      async transform(part, controller) {
+        controller.enqueue({ type: "text", text: part });
+      },
+      async flush(controller) {
+        controller.enqueue({ type: "finish-step" });
+        controller.enqueue({ type: "finish" });
+      }
+    })
+  );
+}
+
+// src/ui/text-stream-chat-transport.ts
+var getOriginalFetch3 = () => fetch;
+async function fetchTextStream({
   api,
-  fetch: fetch2,
-  streamProtocol = "ui-message",
+  body,
   credentials,
   headers,
-  body,
-  prepareRequestBody,
-  generateId: generateId3 = import_provider_utils6.generateId,
-  dataPartSchemas,
-  messageMetadataSchema,
-  maxSteps: maxSteps2 = 1,
-  chats
+  abortSignal,
+  fetch: fetch2 = getOriginalFetch3(),
+  requestType = "generate"
 }) {
-  return new ChatStore({
-    transport: new DefaultChatTransport({
-      api,
-      fetch: fetch2,
-      streamProtocol,
-      credentials,
-      headers,
-      body,
-      prepareRequestBody
-    }),
-    generateId: generateId3,
-    messageMetadataSchema,
-    dataPartSchemas,
-    maxSteps: maxSteps2,
-    chats
+  var _a17;
+  const response = requestType === "resume" ? await fetch2(`${api}?chatId=${body.chatId}`, {
+    method: "GET",
+    headers: {
+      "Content-Type": "application/json",
+      ...headers
+    },
+    signal: abortSignal,
+    credentials
+  }) : await fetch2(api, {
+    method: "POST",
+    body: JSON.stringify(body),
+    headers: {
+      "Content-Type": "application/json",
+      ...headers
+    },
+    signal: abortSignal,
+    credentials
+  });
+  if (!response.ok) {
+    throw new Error(
+      (_a17 = await response.text()) != null ? _a17 : "Failed to fetch the chat response."
+    );
+  }
+  if (!response.body) {
+    throw new Error("The response body is empty.");
+  }
+  return transformTextToUiMessageStream({
+    stream: response.body.pipeThrough(new TextDecoderStream())
+  });
+}
+var TextStreamChatTransport = class {
+  constructor({
+    api,
+    credentials,
+    headers,
+    body,
+    fetch: fetch2,
+    prepareRequest
+  }) {
+    this.api = api;
+    this.credentials = credentials;
+    this.headers = headers;
+    this.body = body;
+    this.fetch = fetch2;
+    this.prepareRequest = prepareRequest;
+  }
+  submitMessages({
+    chatId,
+    messages,
+    abortSignal,
+    metadata,
+    headers,
+    body,
+    requestType
+  }) {
+    var _a17, _b;
+    const preparedRequest = (_a17 = this.prepareRequest) == null ? void 0 : _a17.call(this, {
+      id: chatId,
+      messages,
+      body: { ...this.body, ...body },
+      headers: { ...this.headers, ...headers },
+      credentials: this.credentials,
+      requestMetadata: metadata
+    });
+    return fetchTextStream({
+      api: this.api,
+      body: (preparedRequest == null ? void 0 : preparedRequest.body) !== void 0 ? preparedRequest.body : { ...this.body, ...body },
+      headers: (preparedRequest == null ? void 0 : preparedRequest.headers) !== void 0 ? preparedRequest.headers : { ...this.headers, ...headers },
+      credentials: (_b = preparedRequest == null ? void 0 : preparedRequest.credentials) != null ? _b : this.credentials,
+      abortSignal,
+      fetch: this.fetch,
+      requestType
+    });
+  }
+};
+
+// src/ui-message-stream/handle-ui-message-stream-finish.ts
+function handleUIMessageStreamFinish({
+  newMessageId,
+  originalMessages = [],
+  onFinish,
+  stream
+}) {
+  if (onFinish == null) {
+    return stream;
+  }
+  const lastMessage = originalMessages[originalMessages.length - 1];
+  const isContinuation = (lastMessage == null ? void 0 : lastMessage.role) === "assistant";
+  const messageId = isContinuation ? lastMessage.id : newMessageId;
+  const state = createStreamingUIMessageState({
+    lastMessage: structuredClone(lastMessage),
+    newMessageId: messageId
   });
+  const runUpdateMessageJob = async (job) => {
+    await job({ state, write: () => {
+    } });
+  };
+  return processUIMessageStream({
+    stream,
+    runUpdateMessageJob
+  }).pipeThrough(
+    new TransformStream({
+      transform(chunk, controller) {
+        controller.enqueue(chunk);
+      },
+      flush() {
+        const isContinuation2 = state.message.id === (lastMessage == null ? void 0 : lastMessage.id);
+        onFinish({
+          isContinuation: isContinuation2,
+          responseMessage: state.message,
+          messages: [
+            ...isContinuation2 ? originalMessages.slice(0, -1) : originalMessages,
+            state.message
+          ]
+        });
+      }
+    })
+  );
 }
 
 // src/ui-message-stream/create-ui-message-stream.ts
 function createUIMessageStream({
   execute,
-  onError = () => "An error occurred."
+  onError = () => "An error occurred.",
   // mask error messages for safety by default
+  originalMessages,
+  onFinish
 }) {
   let controller;
   const ongoingStreamPromises = [];
@@ -2289,25 +2220,27 @@ function createUIMessageStream({
   }
   try {
     const result = execute({
-      write(part) {
-        safeEnqueue(part);
-      },
-      merge(streamArg) {
-        ongoingStreamPromises.push(
-          (async () => {
-            const reader = streamArg.getReader();
-            while (true) {
-              const { done, value } = await reader.read();
-              if (done)
-                break;
-              safeEnqueue(value);
-            }
-          })().catch((error) => {
-            safeEnqueue({ type: "error", errorText: onError(error) });
-          })
-        );
-      },
-      onError
+      writer: {
+        write(part) {
+          safeEnqueue(part);
+        },
+        merge(streamArg) {
+          ongoingStreamPromises.push(
+            (async () => {
+              const reader = streamArg.getReader();
+              while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                  break;
+                safeEnqueue(value);
+              }
+            })().catch((error) => {
+              safeEnqueue({ type: "error", errorText: onError(error) });
+            })
+          );
+        },
+        onError
+      }
     });
     if (result) {
       ongoingStreamPromises.push(
@@ -2331,7 +2264,12 @@ function createUIMessageStream({
     } catch (error) {
     }
   });
-  return stream;
+  return handleUIMessageStreamFinish({
+    stream,
+    newMessageId: "",
+    originalMessages,
+    onFinish
+  });
 }
 
 // src/ui-message-stream/ui-message-stream-headers.ts
@@ -2396,6 +2334,32 @@ function pipeUIMessageStreamToResponse({
   });
 }
 
+// src/util/cosine-similarity.ts
+function cosineSimilarity(vector1, vector2) {
+  if (vector1.length !== vector2.length) {
+    throw new InvalidArgumentError({
+      parameter: "vector1,vector2",
+      value: { vector1Length: vector1.length, vector2Length: vector2.length },
+      message: `Vectors must have the same length`
+    });
+  }
+  const n = vector1.length;
+  if (n === 0) {
+    return 0;
+  }
+  let magnitudeSquared1 = 0;
+  let magnitudeSquared2 = 0;
+  let dotProduct = 0;
+  for (let i = 0; i < n; i++) {
+    const value1 = vector1[i];
+    const value2 = vector2[i];
+    magnitudeSquared1 += value1 * value1;
+    magnitudeSquared2 += value2 * value2;
+    dotProduct += value1 * value2;
+  }
+  return magnitudeSquared1 === 0 || magnitudeSquared2 === 0 ? 0 : dotProduct / (Math.sqrt(magnitudeSquared1) * Math.sqrt(magnitudeSquared2));
+}
+
 // src/util/data-url.ts
 function getTextFromDataUrl(dataUrl) {
   const [header, base64Content] = dataUrl.split(",");
@@ -2445,34 +2409,8 @@ function isDeepEqualData(obj1, obj2) {
   return true;
 }
 
-// src/util/cosine-similarity.ts
-function cosineSimilarity(vector1, vector2) {
-  if (vector1.length !== vector2.length) {
-    throw new InvalidArgumentError({
-      parameter: "vector1,vector2",
-      value: { vector1Length: vector1.length, vector2Length: vector2.length },
-      message: `Vectors must have the same length`
-    });
-  }
-  const n = vector1.length;
-  if (n === 0) {
-    return 0;
-  }
-  let magnitudeSquared1 = 0;
-  let magnitudeSquared2 = 0;
-  let dotProduct = 0;
-  for (let i = 0; i < n; i++) {
-    const value1 = vector1[i];
-    const value2 = vector2[i];
-    magnitudeSquared1 += value1 * value1;
-    magnitudeSquared2 += value2 * value2;
-    dotProduct += value1 * value2;
-  }
-  return magnitudeSquared1 === 0 || magnitudeSquared2 === 0 ? 0 : dotProduct / (Math.sqrt(magnitudeSquared1) * Math.sqrt(magnitudeSquared2));
-}
-
 // src/util/simulate-readable-stream.ts
-var import_provider_utils7 = require("@ai-sdk/provider-utils");
+var import_provider_utils6 = require("@ai-sdk/provider-utils");
 function simulateReadableStream({
   chunks,
   initialDelayInMs = 0,
@@ -2480,7 +2418,7 @@ function simulateReadableStream({
   _internal
 }) {
   var _a17;
-  const delay2 = (_a17 = _internal == null ? void 0 : _internal.delay) != null ? _a17 : import_provider_utils7.delay;
+  const delay2 = (_a17 = _internal == null ? void 0 : _internal.delay) != null ? _a17 : import_provider_utils6.delay;
   let index = 0;
   return new ReadableStream({
     async pull(controller) {
@@ -2496,7 +2434,7 @@ function simulateReadableStream({
 
 // src/util/retry-with-exponential-backoff.ts
 var import_provider17 = require("@ai-sdk/provider");
-var import_provider_utils8 = require("@ai-sdk/provider-utils");
+var import_provider_utils7 = require("@ai-sdk/provider-utils");
 var retryWithExponentialBackoff = ({
   maxRetries = 2,
   initialDelayInMs = 2e3,
@@ -2514,13 +2452,13 @@ async function _retryWithExponentialBackoff(f, {
   try {
     return await f();
   } catch (error) {
-    if ((0, import_provider_utils8.isAbortError)(error)) {
+    if ((0, import_provider_utils7.isAbortError)(error)) {
       throw error;
     }
     if (maxRetries === 0) {
       throw error;
     }
-    const errorMessage = (0, import_provider_utils8.getErrorMessage)(error);
+    const errorMessage = (0, import_provider_utils7.getErrorMessage)(error);
     const newErrors = [...errors, error];
     const tryNumber = newErrors.length;
     if (tryNumber > maxRetries) {
@@ -2531,7 +2469,7 @@ async function _retryWithExponentialBackoff(f, {
       });
     }
     if (error instanceof Error && import_provider17.APICallError.isInstance(error) && error.isRetryable === true && tryNumber <= maxRetries) {
-      await (0, import_provider_utils8.delay)(delayInMs);
+      await (0, import_provider_utils7.delay)(delayInMs);
       return _retryWithExponentialBackoff(
         f,
         { maxRetries, delayInMs: backoffFactor * delayInMs, backoffFactor },
@@ -3090,7 +3028,7 @@ var DefaultEmbedManyResult = class {
 };
 
 // src/util/detect-media-type.ts
-var import_provider_utils9 = require("@ai-sdk/provider-utils");
+var import_provider_utils8 = require("@ai-sdk/provider-utils");
 var imageMediaTypeSignatures = [
   {
     mediaType: "image/gif",
@@ -3197,7 +3135,7 @@ var audioMediaTypeSignatures = [
   }
 ];
 var stripID3 = (data) => {
-  const bytes = typeof data === "string" ? (0, import_provider_utils9.convertBase64ToUint8Array)(data) : data;
+  const bytes = typeof data === "string" ? (0, import_provider_utils8.convertBase64ToUint8Array)(data) : data;
   const id3Size = (bytes[6] & 127) << 21 | (bytes[7] & 127) << 14 | (bytes[8] & 127) << 7 | bytes[9] & 127;
   return bytes.slice(id3Size + 10);
 };
@@ -3223,7 +3161,7 @@ function detectMediaType({
 }
 
 // core/generate-text/generated-file.ts
-var import_provider_utils10 = require("@ai-sdk/provider-utils");
+var import_provider_utils9 = require("@ai-sdk/provider-utils");
 var DefaultGeneratedFile = class {
   constructor({
     data,
@@ -3237,14 +3175,14 @@ var DefaultGeneratedFile = class {
   // lazy conversion with caching to avoid unnecessary conversion overhead:
   get base64() {
     if (this.base64Data == null) {
-      this.base64Data = (0, import_provider_utils10.convertUint8ArrayToBase64)(this.uint8ArrayData);
+      this.base64Data = (0, import_provider_utils9.convertUint8ArrayToBase64)(this.uint8ArrayData);
     }
     return this.base64Data;
   }
   // lazy conversion with caching to avoid unnecessary conversion overhead:
   get uint8Array() {
     if (this.uint8ArrayData == null) {
-      this.uint8ArrayData = (0, import_provider_utils10.convertBase64ToUint8Array)(this.base64Data);
+      this.uint8ArrayData = (0, import_provider_utils9.convertBase64ToUint8Array)(this.base64Data);
     }
     return this.uint8ArrayData;
   }
@@ -3359,8 +3297,8 @@ async function invokeModelMaxImagesPerCall(model) {
 }
 
 // core/generate-object/generate-object.ts
-var import_provider21 = require("@ai-sdk/provider");
-var import_provider_utils15 = require("@ai-sdk/provider-utils");
+var import_provider22 = require("@ai-sdk/provider");
+var import_provider_utils14 = require("@ai-sdk/provider-utils");
 
 // core/generate-text/extract-content-text.ts
 function extractContentText(content) {
@@ -3374,7 +3312,7 @@ function extractContentText(content) {
 }
 
 // core/prompt/convert-to-language-model-prompt.ts
-var import_provider_utils12 = require("@ai-sdk/provider-utils");
+var import_provider_utils11 = require("@ai-sdk/provider-utils");
 
 // src/util/download.ts
 async function download({ url }) {
@@ -3403,7 +3341,7 @@ async function download({ url }) {
 
 // core/prompt/data-content.ts
 var import_provider18 = require("@ai-sdk/provider");
-var import_provider_utils11 = require("@ai-sdk/provider-utils");
+var import_provider_utils10 = require("@ai-sdk/provider-utils");
 var import_zod2 = require("zod");
 
 // core/prompt/split-data-url.ts
@@ -3463,13 +3401,22 @@ function convertToLanguageModelV2DataContent(content) {
   }
   return { data: content, mediaType: void 0 };
 }
+function convertDataContentToBase64String(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  if (content instanceof ArrayBuffer) {
+    return (0, import_provider_utils10.convertUint8ArrayToBase64)(new Uint8Array(content));
+  }
+  return (0, import_provider_utils10.convertUint8ArrayToBase64)(content);
+}
 function convertDataContentToUint8Array(content) {
   if (content instanceof Uint8Array) {
     return content;
   }
   if (typeof content === "string") {
     try {
-      return (0, import_provider_utils11.convertBase64ToUint8Array)(content);
+      return (0, import_provider_utils10.convertBase64ToUint8Array)(content);
     } catch (error) {
       throw new InvalidDataContentError({
         message: "Invalid data content. Content string is not a base64-encoded media.",
@@ -3620,7 +3567,7 @@ async function downloadAssets(messages, downloadImplementation, supportedUrls) {
     }
     return { mediaType, data };
   }).filter(
-    (part) => part.data instanceof URL && part.mediaType != null && !(0, import_provider_utils12.isUrlSupported)({
+    (part) => part.data instanceof URL && part.mediaType != null && !(0, import_provider_utils11.isUrlSupported)({
       url: part.data.toString(),
       mediaType: part.mediaType,
       supportedUrls
@@ -3789,9 +3736,22 @@ function prepareCallSettings({
   };
 }
 
+// core/prompt/resolve-language-model.ts
+var import_gateway = require("@ai-sdk/gateway");
+var GLOBAL_DEFAULT_PROVIDER = Symbol(
+  "vercel.ai.global.defaultProvider"
+);
+function resolveLanguageModel(model) {
+  if (typeof model !== "string") {
+    return model;
+  }
+  const globalProvider = globalThis[GLOBAL_DEFAULT_PROVIDER];
+  return (globalProvider != null ? globalProvider : import_gateway.gateway).languageModel(model);
+}
+
 // core/prompt/standardize-prompt.ts
 var import_provider19 = require("@ai-sdk/provider");
-var import_provider_utils13 = require("@ai-sdk/provider-utils");
+var import_provider_utils12 = require("@ai-sdk/provider-utils");
 var import_zod8 = require("zod");
 
 // core/prompt/message.ts
@@ -3963,7 +3923,7 @@ async function standardizePrompt(prompt) {
       message: "messages must not be empty"
     });
   }
-  const validationResult = await (0, import_provider_utils13.safeValidateTypes)({
+  const validationResult = await (0, import_provider_utils12.safeValidateTypes)({
     value: messages,
     schema: import_zod8.z.array(modelMessageSchema)
   });
@@ -3980,9 +3940,38 @@ async function standardizePrompt(prompt) {
   };
 }
 
-// core/generate-object/output-strategy.ts
+// core/prompt/wrap-gateway-error.ts
+var import_gateway2 = require("@ai-sdk/gateway");
 var import_provider20 = require("@ai-sdk/provider");
-var import_provider_utils14 = require("@ai-sdk/provider-utils");
+function wrapGatewayError(error) {
+  if (import_gateway2.GatewayAuthenticationError.isInstance(error) || import_gateway2.GatewayModelNotFoundError.isInstance(error)) {
+    return new import_provider20.AISDKError({
+      name: "GatewayError",
+      message: "Vercel AI Gateway access failed. If you want to use AI SDK providers directly, use the providers, e.g. @ai-sdk/openai, or register a different global default provider.",
+      cause: error
+    });
+  }
+  return error;
+}
+
+// core/telemetry/stringify-for-telemetry.ts
+function stringifyForTelemetry(prompt) {
+  return JSON.stringify(
+    prompt.map((message) => ({
+      ...message,
+      content: typeof message.content === "string" ? message.content : message.content.map(
+        (part) => part.type === "file" ? {
+          ...part,
+          data: part.data instanceof Uint8Array ? convertDataContentToBase64String(part.data) : part.data
+        } : part
+      )
+    }))
+  );
+}
+
+// core/generate-object/output-strategy.ts
+var import_provider21 = require("@ai-sdk/provider");
+var import_provider_utils13 = require("@ai-sdk/provider-utils");
 
 // src/util/async-iterable-stream.ts
 function createAsyncIterableStream(source) {
@@ -4019,7 +4008,7 @@ var noSchemaOutputStrategy = {
     } : { success: true, value };
   },
   createElementStream() {
-    throw new import_provider20.UnsupportedFunctionalityError({
+    throw new import_provider21.UnsupportedFunctionalityError({
       functionality: "element streams in no-schema mode"
     });
   }
@@ -4038,10 +4027,10 @@ var objectOutputStrategy = (schema) => ({
     };
   },
   async validateFinalResult(value) {
-    return (0, import_provider_utils14.safeValidateTypes)({ value, schema });
+    return (0, import_provider_utils13.safeValidateTypes)({ value, schema });
   },
   createElementStream() {
-    throw new import_provider20.UnsupportedFunctionalityError({
+    throw new import_provider21.UnsupportedFunctionalityError({
       functionality: "element streams in object mode"
     });
   }
@@ -4069,10 +4058,10 @@ var arrayOutputStrategy = (schema) => {
       isFinalDelta
     }) {
       var _a17;
-      if (!(0, import_provider20.isJSONObject)(value) || !(0, import_provider20.isJSONArray)(value.elements)) {
+      if (!(0, import_provider21.isJSONObject)(value) || !(0, import_provider21.isJSONArray)(value.elements)) {
         return {
           success: false,
-          error: new import_provider20.TypeValidationError({
+          error: new import_provider21.TypeValidationError({
             value,
             cause: "value must be an object that contains an array of elements"
           })
@@ -4082,7 +4071,7 @@ var arrayOutputStrategy = (schema) => {
       const resultArray = [];
       for (let i = 0; i < inputArray.length; i++) {
         const element = inputArray[i];
-        const result = await (0, import_provider_utils14.safeValidateTypes)({ value: element, schema });
+        const result = await (0, import_provider_utils13.safeValidateTypes)({ value: element, schema });
         if (i === inputArray.length - 1 && !isFinalDelta) {
           continue;
         }
@@ -4112,10 +4101,10 @@ var arrayOutputStrategy = (schema) => {
       };
     },
     async validateFinalResult(value) {
-      if (!(0, import_provider20.isJSONObject)(value) || !(0, import_provider20.isJSONArray)(value.elements)) {
+      if (!(0, import_provider21.isJSONObject)(value) || !(0, import_provider21.isJSONArray)(value.elements)) {
         return {
           success: false,
-          error: new import_provider20.TypeValidationError({
+          error: new import_provider21.TypeValidationError({
             value,
             cause: "value must be an object that contains an array of elements"
           })
@@ -4123,7 +4112,7 @@ var arrayOutputStrategy = (schema) => {
       }
       const inputArray = value.elements;
       for (const element of inputArray) {
-        const result = await (0, import_provider_utils14.safeValidateTypes)({ value: element, schema });
+        const result = await (0, import_provider_utils13.safeValidateTypes)({ value: element, schema });
         if (!result.success) {
           return result;
         }
@@ -4178,10 +4167,10 @@ var enumOutputStrategy = (enumValues) => {
       additionalProperties: false
     },
     async validateFinalResult(value) {
-      if (!(0, import_provider20.isJSONObject)(value) || typeof value.result !== "string") {
+      if (!(0, import_provider21.isJSONObject)(value) || typeof value.result !== "string") {
         return {
           success: false,
-          error: new import_provider20.TypeValidationError({
+          error: new import_provider21.TypeValidationError({
             value,
             cause: 'value must be an object that contains a string in the "result" property.'
           })
@@ -4190,17 +4179,17 @@ var enumOutputStrategy = (enumValues) => {
       const result = value.result;
       return enumValues.includes(result) ? { success: true, value: result } : {
         success: false,
-        error: new import_provider20.TypeValidationError({
+        error: new import_provider21.TypeValidationError({
           value,
           cause: "value must be a string in the enum"
         })
       };
     },
     async validatePartialResult({ value, textDelta }) {
-      if (!(0, import_provider20.isJSONObject)(value) || typeof value.result !== "string") {
+      if (!(0, import_provider21.isJSONObject)(value) || typeof value.result !== "string") {
         return {
           success: false,
-          error: new import_provider20.TypeValidationError({
+          error: new import_provider21.TypeValidationError({
             value,
             cause: 'value must be an object that contains a string in the "result" property.'
           })
@@ -4213,7 +4202,7 @@ var enumOutputStrategy = (enumValues) => {
       if (value.result.length === 0 || possibleEnumValues.length === 0) {
         return {
           success: false,
-          error: new import_provider20.TypeValidationError({
+          error: new import_provider21.TypeValidationError({
             value,
             cause: "value must be a string in the enum"
           })
@@ -4228,7 +4217,7 @@ var enumOutputStrategy = (enumValues) => {
       };
     },
     createElementStream() {
-      throw new import_provider20.UnsupportedFunctionalityError({
+      throw new import_provider21.UnsupportedFunctionalityError({
         functionality: "element streams in enum mode"
       });
     }
@@ -4241,9 +4230,9 @@ function getOutputStrategy({
 }) {
   switch (output) {
     case "object":
-      return objectOutputStrategy((0, import_provider_utils14.asSchema)(schema));
+      return objectOutputStrategy((0, import_provider_utils13.asSchema)(schema));
     case "array":
-      return arrayOutputStrategy((0, import_provider_utils14.asSchema)(schema));
+      return arrayOutputStrategy((0, import_provider_utils13.asSchema)(schema));
     case "enum":
       return enumOutputStrategy(enumValues);
     case "no-schema":
@@ -4374,10 +4363,10 @@ function validateObjectGenerationInput({
 }
 
 // core/generate-object/generate-object.ts
-var originalGenerateId = (0, import_provider_utils15.createIdGenerator)({ prefix: "aiobj", size: 24 });
+var originalGenerateId = (0, import_provider_utils14.createIdGenerator)({ prefix: "aiobj", size: 24 });
 async function generateObject(options) {
   const {
-    model,
+    model: modelArg,
     output = "object",
     system,
     prompt,
@@ -4394,6 +4383,7 @@ async function generateObject(options) {
     } = {},
     ...settings
   } = options;
+  const model = resolveLanguageModel(modelArg);
   const enumValues = "enum" in options ? options.enum : void 0;
   const {
     schema: inputSchema,
@@ -4421,208 +4411,212 @@ async function generateObject(options) {
     settings: { ...callSettings, maxRetries }
   });
   const tracer = getTracer(telemetry);
-  return recordSpan({
-    name: "ai.generateObject",
-    attributes: selectTelemetryAttributes({
-      telemetry,
-      attributes: {
-        ...assembleOperationName({
-          operationId: "ai.generateObject",
-          telemetry
-        }),
-        ...baseTelemetryAttributes,
-        // specific settings that only make sense on the outer level:
-        "ai.prompt": {
-          input: () => JSON.stringify({ system, prompt, messages })
-        },
-        "ai.schema": outputStrategy.jsonSchema != null ? { input: () => JSON.stringify(outputStrategy.jsonSchema) } : void 0,
-        "ai.schema.name": schemaName,
-        "ai.schema.description": schemaDescription,
-        "ai.settings.output": outputStrategy.type
-      }
-    }),
-    tracer,
-    fn: async (span) => {
-      var _a17;
-      let result;
-      let finishReason;
-      let usage;
-      let warnings;
-      let response;
-      let request;
-      let resultProviderMetadata;
-      const standardizedPrompt = await standardizePrompt({
-        system,
-        prompt,
-        messages
-      });
-      const promptMessages = await convertToLanguageModelPrompt({
-        prompt: standardizedPrompt,
-        supportedUrls: await model.supportedUrls
-      });
-      const generateResult = await retry(
-        () => recordSpan({
-          name: "ai.generateObject.doGenerate",
-          attributes: selectTelemetryAttributes({
-            telemetry,
-            attributes: {
-              ...assembleOperationName({
-                operationId: "ai.generateObject.doGenerate",
-                telemetry
-              }),
-              ...baseTelemetryAttributes,
-              "ai.prompt.messages": {
-                input: () => JSON.stringify(promptMessages)
-              },
-              // standardized gen-ai llm span attributes:
-              "gen_ai.system": model.provider,
-              "gen_ai.request.model": model.modelId,
-              "gen_ai.request.frequency_penalty": callSettings.frequencyPenalty,
-              "gen_ai.request.max_tokens": callSettings.maxOutputTokens,
-              "gen_ai.request.presence_penalty": callSettings.presencePenalty,
-              "gen_ai.request.temperature": callSettings.temperature,
-              "gen_ai.request.top_k": callSettings.topK,
-              "gen_ai.request.top_p": callSettings.topP
-            }
+  try {
+    return await recordSpan({
+      name: "ai.generateObject",
+      attributes: selectTelemetryAttributes({
+        telemetry,
+        attributes: {
+          ...assembleOperationName({
+            operationId: "ai.generateObject",
+            telemetry
           }),
-          tracer,
-          fn: async (span2) => {
-            var _a18, _b, _c, _d, _e, _f, _g, _h;
-            const result2 = await model.doGenerate({
-              responseFormat: {
-                type: "json",
-                schema: outputStrategy.jsonSchema,
-                name: schemaName,
-                description: schemaDescription
-              },
-              ...prepareCallSettings(settings),
-              prompt: promptMessages,
-              providerOptions,
-              abortSignal,
-              headers
-            });
-            const responseData = {
-              id: (_b = (_a18 = result2.response) == null ? void 0 : _a18.id) != null ? _b : generateId3(),
-              timestamp: (_d = (_c = result2.response) == null ? void 0 : _c.timestamp) != null ? _d : currentDate(),
-              modelId: (_f = (_e = result2.response) == null ? void 0 : _e.modelId) != null ? _f : model.modelId,
-              headers: (_g = result2.response) == null ? void 0 : _g.headers,
-              body: (_h = result2.response) == null ? void 0 : _h.body
-            };
-            const text2 = extractContentText(result2.content);
-            if (text2 === void 0) {
-              throw new NoObjectGeneratedError({
-                message: "No object generated: the model did not return a response.",
-                response: responseData,
-                usage: result2.usage,
-                finishReason: result2.finishReason
+          ...baseTelemetryAttributes,
+          // specific settings that only make sense on the outer level:
+          "ai.prompt": {
+            input: () => JSON.stringify({ system, prompt, messages })
+          },
+          "ai.schema": outputStrategy.jsonSchema != null ? { input: () => JSON.stringify(outputStrategy.jsonSchema) } : void 0,
+          "ai.schema.name": schemaName,
+          "ai.schema.description": schemaDescription,
+          "ai.settings.output": outputStrategy.type
+        }
+      }),
+      tracer,
+      fn: async (span) => {
+        var _a17;
+        let result;
+        let finishReason;
+        let usage;
+        let warnings;
+        let response;
+        let request;
+        let resultProviderMetadata;
+        const standardizedPrompt = await standardizePrompt({
+          system,
+          prompt,
+          messages
+        });
+        const promptMessages = await convertToLanguageModelPrompt({
+          prompt: standardizedPrompt,
+          supportedUrls: await model.supportedUrls
+        });
+        const generateResult = await retry(
+          () => recordSpan({
+            name: "ai.generateObject.doGenerate",
+            attributes: selectTelemetryAttributes({
+              telemetry,
+              attributes: {
+                ...assembleOperationName({
+                  operationId: "ai.generateObject.doGenerate",
+                  telemetry
+                }),
+                ...baseTelemetryAttributes,
+                "ai.prompt.messages": {
+                  input: () => stringifyForTelemetry(promptMessages)
+                },
+                // standardized gen-ai llm span attributes:
+                "gen_ai.system": model.provider,
+                "gen_ai.request.model": model.modelId,
+                "gen_ai.request.frequency_penalty": callSettings.frequencyPenalty,
+                "gen_ai.request.max_tokens": callSettings.maxOutputTokens,
+                "gen_ai.request.presence_penalty": callSettings.presencePenalty,
+                "gen_ai.request.temperature": callSettings.temperature,
+                "gen_ai.request.top_k": callSettings.topK,
+                "gen_ai.request.top_p": callSettings.topP
+              }
+            }),
+            tracer,
+            fn: async (span2) => {
+              var _a18, _b, _c, _d, _e, _f, _g, _h;
+              const result2 = await model.doGenerate({
+                responseFormat: {
+                  type: "json",
+                  schema: outputStrategy.jsonSchema,
+                  name: schemaName,
+                  description: schemaDescription
+                },
+                ...prepareCallSettings(settings),
+                prompt: promptMessages,
+                providerOptions,
+                abortSignal,
+                headers
               });
+              const responseData = {
+                id: (_b = (_a18 = result2.response) == null ? void 0 : _a18.id) != null ? _b : generateId3(),
+                timestamp: (_d = (_c = result2.response) == null ? void 0 : _c.timestamp) != null ? _d : currentDate(),
+                modelId: (_f = (_e = result2.response) == null ? void 0 : _e.modelId) != null ? _f : model.modelId,
+                headers: (_g = result2.response) == null ? void 0 : _g.headers,
+                body: (_h = result2.response) == null ? void 0 : _h.body
+              };
+              const text2 = extractContentText(result2.content);
+              if (text2 === void 0) {
+                throw new NoObjectGeneratedError({
+                  message: "No object generated: the model did not return a response.",
+                  response: responseData,
+                  usage: result2.usage,
+                  finishReason: result2.finishReason
+                });
+              }
+              span2.setAttributes(
+                selectTelemetryAttributes({
+                  telemetry,
+                  attributes: {
+                    "ai.response.finishReason": result2.finishReason,
+                    "ai.response.object": { output: () => text2 },
+                    "ai.response.id": responseData.id,
+                    "ai.response.model": responseData.modelId,
+                    "ai.response.timestamp": responseData.timestamp.toISOString(),
+                    // TODO rename telemetry attributes to inputTokens and outputTokens
+                    "ai.usage.promptTokens": result2.usage.inputTokens,
+                    "ai.usage.completionTokens": result2.usage.outputTokens,
+                    // standardized gen-ai llm span attributes:
+                    "gen_ai.response.finish_reasons": [result2.finishReason],
+                    "gen_ai.response.id": responseData.id,
+                    "gen_ai.response.model": responseData.modelId,
+                    "gen_ai.usage.input_tokens": result2.usage.inputTokens,
+                    "gen_ai.usage.output_tokens": result2.usage.outputTokens
+                  }
+                })
+              );
+              return { ...result2, objectText: text2, responseData };
             }
-            span2.setAttributes(
-              selectTelemetryAttributes({
-                telemetry,
-                attributes: {
-                  "ai.response.finishReason": result2.finishReason,
-                  "ai.response.object": { output: () => text2 },
-                  "ai.response.id": responseData.id,
-                  "ai.response.model": responseData.modelId,
-                  "ai.response.timestamp": responseData.timestamp.toISOString(),
-                  // TODO rename telemetry attributes to inputTokens and outputTokens
-                  "ai.usage.promptTokens": result2.usage.inputTokens,
-                  "ai.usage.completionTokens": result2.usage.outputTokens,
-                  // standardized gen-ai llm span attributes:
-                  "gen_ai.response.finish_reasons": [result2.finishReason],
-                  "gen_ai.response.id": responseData.id,
-                  "gen_ai.response.model": responseData.modelId,
-                  "gen_ai.usage.input_tokens": result2.usage.inputTokens,
-                  "gen_ai.usage.output_tokens": result2.usage.outputTokens
-                }
-              })
-            );
-            return { ...result2, objectText: text2, responseData };
+          })
+        );
+        result = generateResult.objectText;
+        finishReason = generateResult.finishReason;
+        usage = generateResult.usage;
+        warnings = generateResult.warnings;
+        resultProviderMetadata = generateResult.providerMetadata;
+        request = (_a17 = generateResult.request) != null ? _a17 : {};
+        response = generateResult.responseData;
+        async function processResult(result2) {
+          const parseResult = await (0, import_provider_utils14.safeParseJSON)({ text: result2 });
+          if (!parseResult.success) {
+            throw new NoObjectGeneratedError({
+              message: "No object generated: could not parse the response.",
+              cause: parseResult.error,
+              text: result2,
+              response,
+              usage,
+              finishReason
+            });
           }
-        })
-      );
-      result = generateResult.objectText;
-      finishReason = generateResult.finishReason;
-      usage = generateResult.usage;
-      warnings = generateResult.warnings;
-      resultProviderMetadata = generateResult.providerMetadata;
-      request = (_a17 = generateResult.request) != null ? _a17 : {};
-      response = generateResult.responseData;
-      async function processResult(result2) {
-        const parseResult = await (0, import_provider_utils15.safeParseJSON)({ text: result2 });
-        if (!parseResult.success) {
-          throw new NoObjectGeneratedError({
-            message: "No object generated: could not parse the response.",
-            cause: parseResult.error,
-            text: result2,
-            response,
-            usage,
-            finishReason
-          });
-        }
-        const validationResult = await outputStrategy.validateFinalResult(
-          parseResult.value,
-          {
-            text: result2,
-            response,
-            usage
+          const validationResult = await outputStrategy.validateFinalResult(
+            parseResult.value,
+            {
+              text: result2,
+              response,
+              usage
+            }
+          );
+          if (!validationResult.success) {
+            throw new NoObjectGeneratedError({
+              message: "No object generated: response did not match schema.",
+              cause: validationResult.error,
+              text: result2,
+              response,
+              usage,
+              finishReason
+            });
           }
-        );
-        if (!validationResult.success) {
-          throw new NoObjectGeneratedError({
-            message: "No object generated: response did not match schema.",
-            cause: validationResult.error,
-            text: result2,
-            response,
-            usage,
-            finishReason
-          });
+          return validationResult.value;
         }
-        return validationResult.value;
-      }
-      let object2;
-      try {
-        object2 = await processResult(result);
-      } catch (error) {
-        if (repairText != null && NoObjectGeneratedError.isInstance(error) && (import_provider21.JSONParseError.isInstance(error.cause) || import_provider21.TypeValidationError.isInstance(error.cause))) {
-          const repairedText = await repairText({
-            text: result,
-            error: error.cause
-          });
-          if (repairedText === null) {
+        let object2;
+        try {
+          object2 = await processResult(result);
+        } catch (error) {
+          if (repairText != null && NoObjectGeneratedError.isInstance(error) && (import_provider22.JSONParseError.isInstance(error.cause) || import_provider22.TypeValidationError.isInstance(error.cause))) {
+            const repairedText = await repairText({
+              text: result,
+              error: error.cause
+            });
+            if (repairedText === null) {
+              throw error;
+            }
+            object2 = await processResult(repairedText);
+          } else {
             throw error;
           }
-          object2 = await processResult(repairedText);
-        } else {
-          throw error;
         }
+        span.setAttributes(
+          selectTelemetryAttributes({
+            telemetry,
+            attributes: {
+              "ai.response.finishReason": finishReason,
+              "ai.response.object": {
+                output: () => JSON.stringify(object2)
+              },
+              // TODO rename telemetry attributes to inputTokens and outputTokens
+              "ai.usage.promptTokens": usage.inputTokens,
+              "ai.usage.completionTokens": usage.outputTokens
+            }
+          })
+        );
+        return new DefaultGenerateObjectResult({
+          object: object2,
+          finishReason,
+          usage,
+          warnings,
+          request,
+          response,
+          providerMetadata: resultProviderMetadata
+        });
       }
-      span.setAttributes(
-        selectTelemetryAttributes({
-          telemetry,
-          attributes: {
-            "ai.response.finishReason": finishReason,
-            "ai.response.object": {
-              output: () => JSON.stringify(object2)
-            },
-            // TODO rename telemetry attributes to inputTokens and outputTokens
-            "ai.usage.promptTokens": usage.inputTokens,
-            "ai.usage.completionTokens": usage.outputTokens
-          }
-        })
-      );
-      return new DefaultGenerateObjectResult({
-        object: object2,
-        finishReason,
-        usage,
-        warnings,
-        request,
-        response,
-        providerMetadata: resultProviderMetadata
-      });
-    }
-  });
+    });
+  } catch (error) {
+    throw wrapGatewayError(error);
+  }
 }
 var DefaultGenerateObjectResult = class {
   constructor(options) {
@@ -4646,7 +4640,7 @@ var DefaultGenerateObjectResult = class {
 };
 
 // core/generate-object/stream-object.ts
-var import_provider_utils16 = require("@ai-sdk/provider-utils");
+var import_provider_utils15 = require("@ai-sdk/provider-utils");
 
 // src/util/create-resolvable-promise.ts
 function createResolvablePromise() {
@@ -4752,11 +4746,11 @@ var DelayedPromise = class {
     this._resolve = void 0;
     this._reject = void 0;
   }
-  get value() {
-    if (this.promise) {
-      return this.promise;
+  get promise() {
+    if (this._promise) {
+      return this._promise;
     }
-    this.promise = new Promise((resolve, reject) => {
+    this._promise = new Promise((resolve, reject) => {
       if (this.status.type === "resolved") {
         resolve(this.status.value);
       } else if (this.status.type === "rejected") {
@@ -4765,19 +4759,19 @@ var DelayedPromise = class {
       this._resolve = resolve;
       this._reject = reject;
     });
-    return this.promise;
+    return this._promise;
   }
   resolve(value) {
     var _a17;
     this.status = { type: "resolved", value };
-    if (this.promise) {
+    if (this._promise) {
       (_a17 = this._resolve) == null ? void 0 : _a17.call(this, value);
     }
   }
   reject(error) {
     var _a17;
     this.status = { type: "rejected", error };
-    if (this.promise) {
+    if (this._promise) {
       (_a17 = this._reject) == null ? void 0 : _a17.call(this, error);
     }
   }
@@ -4790,7 +4784,7 @@ function now() {
 }
 
 // core/generate-object/stream-object.ts
-var originalGenerateId2 = (0, import_provider_utils16.createIdGenerator)({ prefix: "aiobj", size: 24 });
+var originalGenerateId2 = (0, import_provider_utils15.createIdGenerator)({ prefix: "aiobj", size: 24 });
 function streamObject(options) {
   const {
     model,
@@ -4803,7 +4797,9 @@ function streamObject(options) {
     headers,
     experimental_telemetry: telemetry,
     providerOptions,
-    onError,
+    onError = ({ error }) => {
+      console.error(error);
+    },
     onFinish,
     _internal: {
       generateId: generateId3 = originalGenerateId2,
@@ -4853,7 +4849,7 @@ function streamObject(options) {
 }
 var DefaultStreamObjectResult = class {
   constructor({
-    model,
+    model: modelArg,
     headers,
     telemetry,
     settings,
@@ -4872,12 +4868,13 @@ var DefaultStreamObjectResult = class {
     currentDate,
     now: now2
   }) {
-    this.objectPromise = new DelayedPromise();
-    this.usagePromise = new DelayedPromise();
-    this.providerMetadataPromise = new DelayedPromise();
-    this.warningsPromise = new DelayedPromise();
-    this.requestPromise = new DelayedPromise();
-    this.responsePromise = new DelayedPromise();
+    this._object = new DelayedPromise();
+    this._usage = new DelayedPromise();
+    this._providerMetadata = new DelayedPromise();
+    this._warnings = new DelayedPromise();
+    this._request = new DelayedPromise();
+    this._response = new DelayedPromise();
+    const model = resolveLanguageModel(modelArg);
     const { maxRetries, retry } = prepareRetries({
       maxRetries: maxRetriesArg
     });
@@ -4895,7 +4892,7 @@ var DefaultStreamObjectResult = class {
       transform(chunk, controller) {
         controller.enqueue(chunk);
         if (chunk.type === "error") {
-          onError == null ? void 0 : onError({ error: chunk.error });
+          onError({ error: wrapGatewayError(chunk.error) });
         }
       }
     });
@@ -4974,7 +4971,7 @@ var DefaultStreamObjectResult = class {
                 }),
                 ...baseTelemetryAttributes,
                 "ai.prompt.messages": {
-                  input: () => JSON.stringify(callOptions.prompt)
+                  input: () => stringifyForTelemetry(callOptions.prompt)
                 },
                 // standardized gen-ai llm span attributes:
                 "gen_ai.system": model.provider,
@@ -4996,7 +4993,7 @@ var DefaultStreamObjectResult = class {
             })
           })
         );
-        self.requestPromise.resolve(request != null ? request : {});
+        self._request.resolve(request != null ? request : {});
         let warnings;
         let usage = {
           inputTokens: void 0,
@@ -5089,9 +5086,9 @@ var DefaultStreamObjectResult = class {
                     usage,
                     response: fullResponse
                   });
-                  self.usagePromise.resolve(usage);
-                  self.providerMetadataPromise.resolve(providerMetadata);
-                  self.responsePromise.resolve({
+                  self._usage.resolve(usage);
+                  self._providerMetadata.resolve(providerMetadata);
+                  self._response.resolve({
                     ...fullResponse,
                     headers: response == null ? void 0 : response.headers
                   });
@@ -5105,7 +5102,7 @@ var DefaultStreamObjectResult = class {
                   );
                   if (validationResult.success) {
                     object2 = validationResult.value;
-                    self.objectPromise.resolve(object2);
+                    self._object.resolve(object2);
                   } else {
                     error = new NoObjectGeneratedError({
                       message: "No object generated: response did not match schema.",
@@ -5115,7 +5112,7 @@ var DefaultStreamObjectResult = class {
                       usage,
                       finishReason
                     });
-                    self.objectPromise.reject(error);
+                    self._object.reject(error);
                   }
                   break;
                 }
@@ -5210,22 +5207,22 @@ var DefaultStreamObjectResult = class {
     this.outputStrategy = outputStrategy;
   }
   get object() {
-    return this.objectPromise.value;
+    return this._object.promise;
   }
   get usage() {
-    return this.usagePromise.value;
+    return this._usage.promise;
   }
   get providerMetadata() {
-    return this.providerMetadataPromise.value;
+    return this._providerMetadata.promise;
   }
   get warnings() {
-    return this.warningsPromise.value;
+    return this._warnings.promise;
   }
   get request() {
-    return this.requestPromise.value;
+    return this._request.promise;
   }
   get response() {
-    return this.responsePromise.value;
+    return this._response.promise;
   }
   get partialObjectStream() {
     return createAsyncIterableStream(
@@ -5295,8 +5292,8 @@ var DefaultStreamObjectResult = class {
 };
 
 // src/error/no-speech-generated-error.ts
-var import_provider22 = require("@ai-sdk/provider");
-var NoSpeechGeneratedError = class extends import_provider22.AISDKError {
+var import_provider23 = require("@ai-sdk/provider");
+var NoSpeechGeneratedError = class extends import_provider23.AISDKError {
   constructor(options) {
     super({
       name: "AI_NoSpeechGeneratedError",
@@ -5385,10 +5382,15 @@ var DefaultSpeechResult = class {
 };
 
 // core/generate-text/generate-text.ts
-var import_provider_utils19 = require("@ai-sdk/provider-utils");
+var import_provider_utils18 = require("@ai-sdk/provider-utils");
+
+// src/util/as-array.ts
+function asArray(value) {
+  return value === void 0 ? [] : Array.isArray(value) ? value : [value];
+}
 
 // core/prompt/prepare-tools-and-tool-choice.ts
-var import_provider_utils17 = require("@ai-sdk/provider-utils");
+var import_provider_utils16 = require("@ai-sdk/provider-utils");
 
 // src/util/is-non-empty-object.ts
 function isNonEmptyObject(object2) {
@@ -5420,7 +5422,7 @@ function prepareToolsAndToolChoice({
             type: "function",
             name: name17,
             description: tool2.description,
-            parameters: (0, import_provider_utils17.asSchema)(tool2.parameters).jsonSchema
+            parameters: (0, import_provider_utils16.asSchema)(tool2.parameters).jsonSchema
           };
         case "provider-defined":
           return {
@@ -5490,7 +5492,7 @@ function asContent({
 }
 
 // core/generate-text/parse-tool-call.ts
-var import_provider_utils18 = require("@ai-sdk/provider-utils");
+var import_provider_utils17 = require("@ai-sdk/provider-utils");
 async function parseToolCall({
   toolCall,
   tools,
@@ -5514,7 +5516,7 @@ async function parseToolCall({
         tools,
         parameterSchema: ({ toolName }) => {
           const { parameters } = tools[toolName];
-          return (0, import_provider_utils18.asSchema)(parameters).jsonSchema;
+          return (0, import_provider_utils17.asSchema)(parameters).jsonSchema;
         },
         system,
         messages,
@@ -5544,8 +5546,8 @@ async function doParseToolCall({
       availableTools: Object.keys(tools)
     });
   }
-  const schema = (0, import_provider_utils18.asSchema)(tool2.parameters);
-  const parseResult = toolCall.args.trim() === "" ? await (0, import_provider_utils18.safeValidateTypes)({ value: {}, schema }) : await (0, import_provider_utils18.safeParseJSON)({ text: toolCall.args, schema });
+  const schema = (0, import_provider_utils17.asSchema)(tool2.parameters);
+  const parseResult = toolCall.args.trim() === "" ? await (0, import_provider_utils17.safeValidateTypes)({ value: {}, schema }) : await (0, import_provider_utils17.safeParseJSON)({ text: toolCall.args, schema });
   if (parseResult.success === false) {
     throw new InvalidToolArgumentsError({
       toolName,
@@ -5604,8 +5606,8 @@ var DefaultStepResult = class {
 };
 
 // core/generate-text/stop-condition.ts
-function maxSteps(maxSteps2) {
-  return ({ steps }) => steps.length >= maxSteps2;
+function stepCountIs(stepCount) {
+  return ({ steps }) => steps.length === stepCount;
 }
 function hasToolCall(toolName) {
   return ({ steps }) => {
@@ -5615,6 +5617,12 @@ function hasToolCall(toolName) {
     )) != null ? _c : false;
   };
 }
+async function isStopConditionMet({
+  stopConditions,
+  steps
+}) {
+  return (await Promise.all(stopConditions.map((condition) => condition({ steps })))).some((result) => result);
+}
 
 // core/generate-text/to-response-messages.ts
 function toResponseMessages({
@@ -5654,300 +5662,310 @@ function toResponseMessages({
       type: "tool-result",
       toolCallId: toolResult.toolCallId,
       toolName: toolResult.toolName,
-      result: tool2.experimental_toToolResultContent(toolResult.result),
-      experimental_content: tool2.experimental_toToolResultContent(
-        toolResult.result
-      )
-    } : {
-      type: "tool-result",
-      toolCallId: toolResult.toolCallId,
-      toolName: toolResult.toolName,
-      result: toolResult.result
-    };
-  });
-  if (toolResultContent.length > 0) {
-    responseMessages.push({
-      role: "tool",
-      content: toolResultContent
-    });
-  }
-  return responseMessages;
-}
-
-// core/generate-text/generate-text.ts
-var originalGenerateId3 = (0, import_provider_utils19.createIdGenerator)({
-  prefix: "aitxt",
-  size: 24
-});
-async function generateText({
-  model,
-  tools,
-  toolChoice,
-  system,
-  prompt,
-  messages,
-  maxRetries: maxRetriesArg,
-  abortSignal,
-  headers,
-  continueUntil = maxSteps(1),
-  experimental_output: output,
-  experimental_telemetry: telemetry,
-  providerOptions,
-  experimental_activeTools: activeTools,
-  experimental_prepareStep: prepareStep,
-  experimental_repairToolCall: repairToolCall,
-  _internal: {
-    generateId: generateId3 = originalGenerateId3,
-    currentDate = () => /* @__PURE__ */ new Date()
-  } = {},
-  onStepFinish,
-  ...settings
-}) {
-  const { maxRetries, retry } = prepareRetries({ maxRetries: maxRetriesArg });
-  const callSettings = prepareCallSettings(settings);
-  const baseTelemetryAttributes = getBaseTelemetryAttributes({
-    model,
-    telemetry,
-    headers,
-    settings: { ...callSettings, maxRetries }
-  });
-  const initialPrompt = await standardizePrompt({
-    system,
-    prompt,
-    messages
-  });
-  const tracer = getTracer(telemetry);
-  return recordSpan({
-    name: "ai.generateText",
-    attributes: selectTelemetryAttributes({
-      telemetry,
-      attributes: {
-        ...assembleOperationName({
-          operationId: "ai.generateText",
-          telemetry
-        }),
-        ...baseTelemetryAttributes,
-        // model:
-        "ai.model.provider": model.provider,
-        "ai.model.id": model.modelId,
-        // specific settings that only make sense on the outer level:
-        "ai.prompt": {
-          input: () => JSON.stringify({ system, prompt, messages })
-        }
-      }
-    }),
-    tracer,
-    fn: async (span) => {
-      var _a17, _b, _c, _d;
-      const callSettings2 = prepareCallSettings(settings);
-      let currentModelResponse;
-      let currentToolCalls = [];
-      let currentToolResults = [];
-      const responseMessages = [];
-      const steps = [];
-      do {
-        const stepInputMessages = [
-          ...initialPrompt.messages,
-          ...responseMessages
-        ];
-        const prepareStepResult = await (prepareStep == null ? void 0 : prepareStep({
-          model,
-          steps,
-          stepNumber: steps.length
-        }));
-        const promptMessages = await convertToLanguageModelPrompt({
-          prompt: {
-            system: initialPrompt.system,
-            messages: stepInputMessages
-          },
-          supportedUrls: await model.supportedUrls
-        });
-        const stepModel = (_a17 = prepareStepResult == null ? void 0 : prepareStepResult.model) != null ? _a17 : model;
-        const { toolChoice: stepToolChoice, tools: stepTools } = prepareToolsAndToolChoice({
-          tools,
-          toolChoice: (_b = prepareStepResult == null ? void 0 : prepareStepResult.toolChoice) != null ? _b : toolChoice,
-          activeTools: (_c = prepareStepResult == null ? void 0 : prepareStepResult.experimental_activeTools) != null ? _c : activeTools
-        });
-        currentModelResponse = await retry(
-          () => {
-            var _a18;
-            return recordSpan({
-              name: "ai.generateText.doGenerate",
-              attributes: selectTelemetryAttributes({
-                telemetry,
-                attributes: {
-                  ...assembleOperationName({
-                    operationId: "ai.generateText.doGenerate",
-                    telemetry
-                  }),
-                  ...baseTelemetryAttributes,
-                  // model:
-                  "ai.model.provider": stepModel.provider,
-                  "ai.model.id": stepModel.modelId,
-                  // prompt:
-                  "ai.prompt.messages": {
-                    input: () => JSON.stringify(promptMessages)
-                  },
-                  "ai.prompt.tools": {
-                    // convert the language model level tools:
-                    input: () => stepTools == null ? void 0 : stepTools.map((tool2) => JSON.stringify(tool2))
-                  },
-                  "ai.prompt.toolChoice": {
-                    input: () => stepToolChoice != null ? JSON.stringify(stepToolChoice) : void 0
-                  },
-                  // standardized gen-ai llm span attributes:
-                  "gen_ai.system": stepModel.provider,
-                  "gen_ai.request.model": stepModel.modelId,
-                  "gen_ai.request.frequency_penalty": settings.frequencyPenalty,
-                  "gen_ai.request.max_tokens": settings.maxOutputTokens,
-                  "gen_ai.request.presence_penalty": settings.presencePenalty,
-                  "gen_ai.request.stop_sequences": settings.stopSequences,
-                  "gen_ai.request.temperature": (_a18 = settings.temperature) != null ? _a18 : void 0,
-                  "gen_ai.request.top_k": settings.topK,
-                  "gen_ai.request.top_p": settings.topP
-                }
-              }),
-              tracer,
-              fn: async (span2) => {
-                var _a19, _b2, _c2, _d2, _e, _f, _g, _h;
-                const result = await stepModel.doGenerate({
-                  ...callSettings2,
-                  tools: stepTools,
-                  toolChoice: stepToolChoice,
-                  responseFormat: output == null ? void 0 : output.responseFormat,
-                  prompt: promptMessages,
-                  providerOptions,
-                  abortSignal,
-                  headers
-                });
-                const responseData = {
-                  id: (_b2 = (_a19 = result.response) == null ? void 0 : _a19.id) != null ? _b2 : generateId3(),
-                  timestamp: (_d2 = (_c2 = result.response) == null ? void 0 : _c2.timestamp) != null ? _d2 : currentDate(),
-                  modelId: (_f = (_e = result.response) == null ? void 0 : _e.modelId) != null ? _f : stepModel.modelId,
-                  headers: (_g = result.response) == null ? void 0 : _g.headers,
-                  body: (_h = result.response) == null ? void 0 : _h.body
-                };
-                span2.setAttributes(
-                  selectTelemetryAttributes({
-                    telemetry,
-                    attributes: {
-                      "ai.response.finishReason": result.finishReason,
-                      "ai.response.text": {
-                        output: () => extractContentText(result.content)
-                      },
-                      "ai.response.toolCalls": {
-                        output: () => {
-                          const toolCalls = asToolCalls(result.content);
-                          return toolCalls == null ? void 0 : JSON.stringify(toolCalls);
-                        }
-                      },
-                      "ai.response.id": responseData.id,
-                      "ai.response.model": responseData.modelId,
-                      "ai.response.timestamp": responseData.timestamp.toISOString(),
-                      // TODO rename telemetry attributes to inputTokens and outputTokens
-                      "ai.usage.promptTokens": result.usage.inputTokens,
-                      "ai.usage.completionTokens": result.usage.outputTokens,
-                      // standardized gen-ai llm span attributes:
-                      "gen_ai.response.finish_reasons": [result.finishReason],
-                      "gen_ai.response.id": responseData.id,
-                      "gen_ai.response.model": responseData.modelId,
-                      "gen_ai.usage.input_tokens": result.usage.inputTokens,
-                      "gen_ai.usage.output_tokens": result.usage.outputTokens
-                    }
-                  })
-                );
-                return { ...result, response: responseData };
-              }
-            });
+      result: tool2.experimental_toToolResultContent(toolResult.result),
+      experimental_content: tool2.experimental_toToolResultContent(
+        toolResult.result
+      )
+    } : {
+      type: "tool-result",
+      toolCallId: toolResult.toolCallId,
+      toolName: toolResult.toolName,
+      result: toolResult.result
+    };
+  });
+  if (toolResultContent.length > 0) {
+    responseMessages.push({
+      role: "tool",
+      content: toolResultContent
+    });
+  }
+  return responseMessages;
+}
+
+// core/generate-text/generate-text.ts
+var originalGenerateId3 = (0, import_provider_utils18.createIdGenerator)({
+  prefix: "aitxt",
+  size: 24
+});
+async function generateText({
+  model: modelArg,
+  tools,
+  toolChoice,
+  system,
+  prompt,
+  messages,
+  maxRetries: maxRetriesArg,
+  abortSignal,
+  headers,
+  stopWhen = stepCountIs(1),
+  experimental_output: output,
+  experimental_telemetry: telemetry,
+  providerOptions,
+  experimental_activeTools,
+  activeTools = experimental_activeTools,
+  experimental_prepareStep,
+  prepareStep = experimental_prepareStep,
+  experimental_repairToolCall: repairToolCall,
+  _internal: {
+    generateId: generateId3 = originalGenerateId3,
+    currentDate = () => /* @__PURE__ */ new Date()
+  } = {},
+  onStepFinish,
+  ...settings
+}) {
+  const model = resolveLanguageModel(modelArg);
+  const stopConditions = asArray(stopWhen);
+  const { maxRetries, retry } = prepareRetries({ maxRetries: maxRetriesArg });
+  const callSettings = prepareCallSettings(settings);
+  const baseTelemetryAttributes = getBaseTelemetryAttributes({
+    model,
+    telemetry,
+    headers,
+    settings: { ...callSettings, maxRetries }
+  });
+  const initialPrompt = await standardizePrompt({
+    system,
+    prompt,
+    messages
+  });
+  const tracer = getTracer(telemetry);
+  try {
+    return await recordSpan({
+      name: "ai.generateText",
+      attributes: selectTelemetryAttributes({
+        telemetry,
+        attributes: {
+          ...assembleOperationName({
+            operationId: "ai.generateText",
+            telemetry
+          }),
+          ...baseTelemetryAttributes,
+          // model:
+          "ai.model.provider": model.provider,
+          "ai.model.id": model.modelId,
+          // specific settings that only make sense on the outer level:
+          "ai.prompt": {
+            input: () => JSON.stringify({ system, prompt, messages })
           }
-        );
-        currentToolCalls = await Promise.all(
-          currentModelResponse.content.filter(
-            (part) => part.type === "tool-call"
-          ).map(
-            (toolCall) => parseToolCall({
-              toolCall,
-              tools,
-              repairToolCall,
-              system,
+        }
+      }),
+      tracer,
+      fn: async (span) => {
+        var _a17, _b, _c, _d, _e;
+        const callSettings2 = prepareCallSettings(settings);
+        let currentModelResponse;
+        let currentToolCalls = [];
+        let currentToolResults = [];
+        const responseMessages = [];
+        const steps = [];
+        do {
+          const stepInputMessages = [
+            ...initialPrompt.messages,
+            ...responseMessages
+          ];
+          const prepareStepResult = await (prepareStep == null ? void 0 : prepareStep({
+            model,
+            steps,
+            stepNumber: steps.length
+          }));
+          const promptMessages = await convertToLanguageModelPrompt({
+            prompt: {
+              system: (_a17 = prepareStepResult == null ? void 0 : prepareStepResult.system) != null ? _a17 : initialPrompt.system,
               messages: stepInputMessages
+            },
+            supportedUrls: await model.supportedUrls
+          });
+          const stepModel = resolveLanguageModel(
+            (_b = prepareStepResult == null ? void 0 : prepareStepResult.model) != null ? _b : model
+          );
+          const { toolChoice: stepToolChoice, tools: stepTools } = prepareToolsAndToolChoice({
+            tools,
+            toolChoice: (_c = prepareStepResult == null ? void 0 : prepareStepResult.toolChoice) != null ? _c : toolChoice,
+            activeTools: (_d = prepareStepResult == null ? void 0 : prepareStepResult.activeTools) != null ? _d : activeTools
+          });
+          currentModelResponse = await retry(
+            () => {
+              var _a18;
+              return recordSpan({
+                name: "ai.generateText.doGenerate",
+                attributes: selectTelemetryAttributes({
+                  telemetry,
+                  attributes: {
+                    ...assembleOperationName({
+                      operationId: "ai.generateText.doGenerate",
+                      telemetry
+                    }),
+                    ...baseTelemetryAttributes,
+                    // model:
+                    "ai.model.provider": stepModel.provider,
+                    "ai.model.id": stepModel.modelId,
+                    // prompt:
+                    "ai.prompt.messages": {
+                      input: () => stringifyForTelemetry(promptMessages)
+                    },
+                    "ai.prompt.tools": {
+                      // convert the language model level tools:
+                      input: () => stepTools == null ? void 0 : stepTools.map((tool2) => JSON.stringify(tool2))
+                    },
+                    "ai.prompt.toolChoice": {
+                      input: () => stepToolChoice != null ? JSON.stringify(stepToolChoice) : void 0
+                    },
+                    // standardized gen-ai llm span attributes:
+                    "gen_ai.system": stepModel.provider,
+                    "gen_ai.request.model": stepModel.modelId,
+                    "gen_ai.request.frequency_penalty": settings.frequencyPenalty,
+                    "gen_ai.request.max_tokens": settings.maxOutputTokens,
+                    "gen_ai.request.presence_penalty": settings.presencePenalty,
+                    "gen_ai.request.stop_sequences": settings.stopSequences,
+                    "gen_ai.request.temperature": (_a18 = settings.temperature) != null ? _a18 : void 0,
+                    "gen_ai.request.top_k": settings.topK,
+                    "gen_ai.request.top_p": settings.topP
+                  }
+                }),
+                tracer,
+                fn: async (span2) => {
+                  var _a19, _b2, _c2, _d2, _e2, _f, _g, _h;
+                  const result = await stepModel.doGenerate({
+                    ...callSettings2,
+                    tools: stepTools,
+                    toolChoice: stepToolChoice,
+                    responseFormat: output == null ? void 0 : output.responseFormat,
+                    prompt: promptMessages,
+                    providerOptions,
+                    abortSignal,
+                    headers
+                  });
+                  const responseData = {
+                    id: (_b2 = (_a19 = result.response) == null ? void 0 : _a19.id) != null ? _b2 : generateId3(),
+                    timestamp: (_d2 = (_c2 = result.response) == null ? void 0 : _c2.timestamp) != null ? _d2 : currentDate(),
+                    modelId: (_f = (_e2 = result.response) == null ? void 0 : _e2.modelId) != null ? _f : stepModel.modelId,
+                    headers: (_g = result.response) == null ? void 0 : _g.headers,
+                    body: (_h = result.response) == null ? void 0 : _h.body
+                  };
+                  span2.setAttributes(
+                    selectTelemetryAttributes({
+                      telemetry,
+                      attributes: {
+                        "ai.response.finishReason": result.finishReason,
+                        "ai.response.text": {
+                          output: () => extractContentText(result.content)
+                        },
+                        "ai.response.toolCalls": {
+                          output: () => {
+                            const toolCalls = asToolCalls(result.content);
+                            return toolCalls == null ? void 0 : JSON.stringify(toolCalls);
+                          }
+                        },
+                        "ai.response.id": responseData.id,
+                        "ai.response.model": responseData.modelId,
+                        "ai.response.timestamp": responseData.timestamp.toISOString(),
+                        // TODO rename telemetry attributes to inputTokens and outputTokens
+                        "ai.usage.promptTokens": result.usage.inputTokens,
+                        "ai.usage.completionTokens": result.usage.outputTokens,
+                        // standardized gen-ai llm span attributes:
+                        "gen_ai.response.finish_reasons": [result.finishReason],
+                        "gen_ai.response.id": responseData.id,
+                        "gen_ai.response.model": responseData.modelId,
+                        "gen_ai.usage.input_tokens": result.usage.inputTokens,
+                        "gen_ai.usage.output_tokens": result.usage.outputTokens
+                      }
+                    })
+                  );
+                  return { ...result, response: responseData };
+                }
+              });
+            }
+          );
+          currentToolCalls = await Promise.all(
+            currentModelResponse.content.filter(
+              (part) => part.type === "tool-call"
+            ).map(
+              (toolCall) => parseToolCall({
+                toolCall,
+                tools,
+                repairToolCall,
+                system,
+                messages: stepInputMessages
+              })
+            )
+          );
+          currentToolResults = tools == null ? [] : await executeTools({
+            toolCalls: currentToolCalls,
+            tools,
+            tracer,
+            telemetry,
+            messages: stepInputMessages,
+            abortSignal
+          });
+          const stepContent = asContent({
+            content: currentModelResponse.content,
+            toolCalls: currentToolCalls,
+            toolResults: currentToolResults
+          });
+          responseMessages.push(
+            ...toResponseMessages({
+              content: stepContent,
+              tools: tools != null ? tools : {}
             })
-          )
-        );
-        currentToolResults = tools == null ? [] : await executeTools({
-          toolCalls: currentToolCalls,
-          tools,
-          tracer,
-          telemetry,
-          messages: stepInputMessages,
-          abortSignal
-        });
-        const stepContent = asContent({
-          content: currentModelResponse.content,
-          toolCalls: currentToolCalls,
-          toolResults: currentToolResults
-        });
-        responseMessages.push(
-          ...toResponseMessages({
+          );
+          const currentStepResult = new DefaultStepResult({
             content: stepContent,
-            tools: tools != null ? tools : {}
+            finishReason: currentModelResponse.finishReason,
+            usage: currentModelResponse.usage,
+            warnings: currentModelResponse.warnings,
+            providerMetadata: currentModelResponse.providerMetadata,
+            request: (_e = currentModelResponse.request) != null ? _e : {},
+            response: {
+              ...currentModelResponse.response,
+              // deep clone msgs to avoid mutating past messages in multi-step:
+              messages: structuredClone(responseMessages)
+            }
+          });
+          steps.push(currentStepResult);
+          await (onStepFinish == null ? void 0 : onStepFinish(currentStepResult));
+        } while (
+          // there are tool calls:
+          currentToolCalls.length > 0 && // all current tool calls have results:
+          currentToolResults.length === currentToolCalls.length && // continue until a stop condition is met:
+          !await isStopConditionMet({ stopConditions, steps })
+        );
+        span.setAttributes(
+          selectTelemetryAttributes({
+            telemetry,
+            attributes: {
+              "ai.response.finishReason": currentModelResponse.finishReason,
+              "ai.response.text": {
+                output: () => extractContentText(currentModelResponse.content)
+              },
+              "ai.response.toolCalls": {
+                output: () => {
+                  const toolCalls = asToolCalls(currentModelResponse.content);
+                  return toolCalls == null ? void 0 : JSON.stringify(toolCalls);
+                }
+              },
+              // TODO rename telemetry attributes to inputTokens and outputTokens
+              "ai.usage.promptTokens": currentModelResponse.usage.inputTokens,
+              "ai.usage.completionTokens": currentModelResponse.usage.outputTokens
+            }
           })
         );
-        const currentStepResult = new DefaultStepResult({
-          content: stepContent,
-          finishReason: currentModelResponse.finishReason,
-          usage: currentModelResponse.usage,
-          warnings: currentModelResponse.warnings,
-          providerMetadata: currentModelResponse.providerMetadata,
-          request: (_d = currentModelResponse.request) != null ? _d : {},
-          response: {
-            ...currentModelResponse.response,
-            // deep clone msgs to avoid mutating past messages in multi-step:
-            messages: structuredClone(responseMessages)
-          }
+        const lastStep = steps[steps.length - 1];
+        return new DefaultGenerateTextResult({
+          steps,
+          resolvedOutput: await (output == null ? void 0 : output.parseOutput(
+            { text: lastStep.text },
+            {
+              response: lastStep.response,
+              usage: lastStep.usage,
+              finishReason: lastStep.finishReason
+            }
+          ))
         });
-        steps.push(currentStepResult);
-        await (onStepFinish == null ? void 0 : onStepFinish(currentStepResult));
-      } while (
-        // there are tool calls:
-        currentToolCalls.length > 0 && // all current tool calls have results:
-        currentToolResults.length === currentToolCalls.length && // continue until the stop condition is met:
-        !await continueUntil({ steps })
-      );
-      span.setAttributes(
-        selectTelemetryAttributes({
-          telemetry,
-          attributes: {
-            "ai.response.finishReason": currentModelResponse.finishReason,
-            "ai.response.text": {
-              output: () => extractContentText(currentModelResponse.content)
-            },
-            "ai.response.toolCalls": {
-              output: () => {
-                const toolCalls = asToolCalls(currentModelResponse.content);
-                return toolCalls == null ? void 0 : JSON.stringify(toolCalls);
-              }
-            },
-            // TODO rename telemetry attributes to inputTokens and outputTokens
-            "ai.usage.promptTokens": currentModelResponse.usage.inputTokens,
-            "ai.usage.completionTokens": currentModelResponse.usage.outputTokens
-          }
-        })
-      );
-      const lastStep = steps[steps.length - 1];
-      return new DefaultGenerateTextResult({
-        steps,
-        resolvedOutput: await (output == null ? void 0 : output.parseOutput(
-          { text: lastStep.text },
-          {
-            response: lastStep.response,
-            usage: lastStep.usage,
-            finishReason: lastStep.finishReason
-          }
-        ))
-      });
-    }
-  });
+      }
+    });
+  } catch (error) {
+    throw wrapGatewayError(error);
+  }
 }
 async function executeTools({
   toolCalls,
@@ -5960,6 +5978,14 @@ async function executeTools({
   const toolResults = await Promise.all(
     toolCalls.map(async ({ toolCallId, toolName, args }) => {
       const tool2 = tools[toolName];
+      if ((tool2 == null ? void 0 : tool2.onArgsAvailable) != null) {
+        await tool2.onArgsAvailable({
+          args,
+          toolCallId,
+          messages,
+          abortSignal
+        });
+      }
       if ((tool2 == null ? void 0 : tool2.execute) == null) {
         return void 0;
       }
@@ -6116,7 +6142,7 @@ __export(output_exports, {
   object: () => object,
   text: () => text
 });
-var import_provider_utils20 = require("@ai-sdk/provider-utils");
+var import_provider_utils19 = require("@ai-sdk/provider-utils");
 var text = () => ({
   type: "text",
   responseFormat: { type: "text" },
@@ -6130,7 +6156,7 @@ var text = () => ({
 var object = ({
   schema: inputSchema
 }) => {
-  const schema = (0, import_provider_utils20.asSchema)(inputSchema);
+  const schema = (0, import_provider_utils19.asSchema)(inputSchema);
   return {
     type: "object",
     responseFormat: {
@@ -6156,7 +6182,7 @@ var object = ({
       }
     },
     async parseOutput({ text: text2 }, context) {
-      const parseResult = await (0, import_provider_utils20.safeParseJSON)({ text: text2 });
+      const parseResult = await (0, import_provider_utils19.safeParseJSON)({ text: text2 });
       if (!parseResult.success) {
         throw new NoObjectGeneratedError({
           message: "No object generated: could not parse the response.",
@@ -6167,7 +6193,7 @@ var object = ({
           finishReason: context.finishReason
         });
       }
-      const validationResult = await (0, import_provider_utils20.safeValidateTypes)({
+      const validationResult = await (0, import_provider_utils19.safeValidateTypes)({
         value: parseResult.value,
         schema
       });
@@ -6187,8 +6213,8 @@ var object = ({
 };
 
 // core/generate-text/smooth-stream.ts
-var import_provider_utils21 = require("@ai-sdk/provider-utils");
-var import_provider23 = require("@ai-sdk/provider");
+var import_provider_utils20 = require("@ai-sdk/provider-utils");
+var import_provider24 = require("@ai-sdk/provider");
 var CHUNKING_REGEXPS = {
   word: /\S+\s+/m,
   line: /\n+/m
@@ -6196,7 +6222,7 @@ var CHUNKING_REGEXPS = {
 function smoothStream({
   delayInMs = 10,
   chunking = "word",
-  _internal: { delay: delay2 = import_provider_utils21.delay } = {}
+  _internal: { delay: delay2 = import_provider_utils20.delay } = {}
 } = {}) {
   let detectChunk;
   if (typeof chunking === "function") {
@@ -6218,7 +6244,7 @@ function smoothStream({
   } else {
     const chunkingRegex = typeof chunking === "string" ? CHUNKING_REGEXPS[chunking] : chunking;
     if (chunkingRegex == null) {
-      throw new import_provider23.InvalidArgumentError({
+      throw new import_provider24.InvalidArgumentError({
         argument: "chunking",
         message: `Chunking must be "word" or "line" or a RegExp. Received: ${chunking}`
       });
@@ -6256,15 +6282,10 @@ function smoothStream({
 }
 
 // core/generate-text/stream-text.ts
-var import_provider_utils23 = require("@ai-sdk/provider-utils");
-
-// src/util/as-array.ts
-function asArray(value) {
-  return value === void 0 ? [] : Array.isArray(value) ? value : [value];
-}
+var import_provider_utils22 = require("@ai-sdk/provider-utils");
 
 // core/generate-text/run-tools-transformation.ts
-var import_provider_utils22 = require("@ai-sdk/provider-utils");
+var import_provider_utils21 = require("@ai-sdk/provider-utils");
 function runToolsTransformation({
   tools,
   generatorStream,
@@ -6349,8 +6370,16 @@ function runToolsTransformation({
             });
             controller.enqueue(toolCall);
             const tool2 = tools[toolCall.toolName];
+            if (tool2.onArgsAvailable != null) {
+              await tool2.onArgsAvailable({
+                args: toolCall.args,
+                toolCallId: toolCall.toolCallId,
+                messages,
+                abortSignal
+              });
+            }
             if (tool2.execute != null) {
-              const toolExecutionId = (0, import_provider_utils22.generateId)();
+              const toolExecutionId = (0, import_provider_utils21.generateId)();
               outstandingToolResults.add(toolExecutionId);
               recordSpan({
                 name: "ai.toolCall",
@@ -6459,7 +6488,7 @@ function runToolsTransformation({
 }
 
 // core/generate-text/stream-text.ts
-var originalGenerateId4 = (0, import_provider_utils23.createIdGenerator)({
+var originalGenerateId4 = (0, import_provider_utils22.createIdGenerator)({
   prefix: "aitxt",
   size: 24
 });
@@ -6473,17 +6502,21 @@ function streamText({
   maxRetries,
   abortSignal,
   headers,
-  maxSteps: maxSteps2 = 1,
+  stopWhen = stepCountIs(1),
   experimental_output: output,
   experimental_telemetry: telemetry,
+  prepareStep,
   providerOptions,
   experimental_toolCallStreaming = false,
   toolCallStreaming = experimental_toolCallStreaming,
-  experimental_activeTools: activeTools,
+  experimental_activeTools,
+  activeTools = experimental_activeTools,
   experimental_repairToolCall: repairToolCall,
   experimental_transform: transform,
   onChunk,
-  onError,
+  onError = ({ error }) => {
+    console.error(error);
+  },
   onFinish,
   onStepFinish,
   _internal: {
@@ -6494,7 +6527,7 @@ function streamText({
   ...settings
 }) {
   return new DefaultStreamTextResult({
-    model,
+    model: resolveLanguageModel(model),
     telemetry,
     headers,
     settings,
@@ -6509,9 +6542,10 @@ function streamText({
     transforms: asArray(transform),
     activeTools,
     repairToolCall,
-    maxSteps: maxSteps2,
+    stopConditions: asArray(stopWhen),
     output,
     providerOptions,
+    prepareStep,
     onChunk,
     onError,
     onFinish,
@@ -6586,9 +6620,10 @@ var DefaultStreamTextResult = class {
     transforms,
     activeTools,
     repairToolCall,
-    maxSteps: maxSteps2,
+    stopConditions,
     output,
     providerOptions,
+    prepareStep,
     now: now2,
     currentDate,
     generateId: generateId3,
@@ -6597,18 +6632,12 @@ var DefaultStreamTextResult = class {
     onFinish,
     onStepFinish
   }) {
-    this.totalUsagePromise = new DelayedPromise();
-    this.finishReasonPromise = new DelayedPromise();
-    this.stepsPromise = new DelayedPromise();
-    if (maxSteps2 < 1) {
-      throw new InvalidArgumentError({
-        parameter: "maxSteps",
-        value: maxSteps2,
-        message: "maxSteps must be at least 1"
-      });
-    }
+    this._totalUsage = new DelayedPromise();
+    this._finishReason = new DelayedPromise();
+    this._steps = new DelayedPromise();
     this.output = output;
     this.generateId = generateId3;
+    let stepFinish;
     let activeReasoningPart = void 0;
     let recordedContent = [];
     const recordedResponseMessages = [];
@@ -6626,7 +6655,7 @@ var DefaultStreamTextResult = class {
           await (onChunk == null ? void 0 : onChunk({ chunk: part }));
         }
         if (part.type === "error") {
-          await (onError == null ? void 0 : onError({ error: part.error }));
+          await onError({ error: wrapGatewayError(part.error) });
         }
         if (part.type === "text") {
           const latestContent = recordedContent[recordedContent.length - 1];
@@ -6690,6 +6719,7 @@ var DefaultStreamTextResult = class {
           recordedContent = [];
           activeReasoningPart = void 0;
           recordedResponseMessages.push(...stepMessages);
+          stepFinish.resolve();
         }
         if (part.type === "finish") {
           recordedTotalUsage = part.totalUsage;
@@ -6707,9 +6737,9 @@ var DefaultStreamTextResult = class {
             outputTokens: void 0,
             totalTokens: void 0
           };
-          self.finishReasonPromise.resolve(finishReason);
-          self.totalUsagePromise.resolve(totalUsage);
-          self.stepsPromise.resolve(recordedSteps);
+          self._finishReason.resolve(finishReason);
+          self._totalUsage.resolve(totalUsage);
+          self._steps.resolve(recordedSteps);
           const finalStep = recordedSteps[recordedSteps.length - 1];
           await (onFinish == null ? void 0 : onFinish({
             finishReason,
@@ -6800,8 +6830,7 @@ var DefaultStreamTextResult = class {
           // specific settings that only make sense on the outer level:
           "ai.prompt": {
             input: () => JSON.stringify({ system, prompt, messages })
-          },
-          "ai.settings.maxSteps": maxSteps2
+          }
         }
       }),
       tracer,
@@ -6813,6 +6842,8 @@ var DefaultStreamTextResult = class {
           responseMessages,
           usage
         }) {
+          var _a17, _b, _c, _d;
+          stepFinish = new DelayedPromise();
           const initialPrompt = await standardizePrompt({
             system,
             prompt,
@@ -6822,16 +6853,26 @@ var DefaultStreamTextResult = class {
             ...initialPrompt.messages,
             ...responseMessages
           ];
+          const prepareStepResult = await (prepareStep == null ? void 0 : prepareStep({
+            model,
+            steps: recordedSteps,
+            stepNumber: recordedSteps.length
+          }));
           const promptMessages = await convertToLanguageModelPrompt({
             prompt: {
-              system: initialPrompt.system,
+              system: (_a17 = prepareStepResult == null ? void 0 : prepareStepResult.system) != null ? _a17 : initialPrompt.system,
               messages: stepInputMessages
             },
             supportedUrls: await model.supportedUrls
           });
-          const toolsAndToolChoice = {
-            ...prepareToolsAndToolChoice({ tools, toolChoice, activeTools })
-          };
+          const stepModel = resolveLanguageModel(
+            (_b = prepareStepResult == null ? void 0 : prepareStepResult.model) != null ? _b : model
+          );
+          const { toolChoice: stepToolChoice, tools: stepTools } = prepareToolsAndToolChoice({
+            tools,
+            toolChoice: (_c = prepareStepResult == null ? void 0 : prepareStepResult.toolChoice) != null ? _c : toolChoice,
+            activeTools: (_d = prepareStepResult == null ? void 0 : prepareStepResult.activeTools) != null ? _d : activeTools
+          });
           const {
             result: { stream: stream2, response, request },
             doStreamSpan,
@@ -6847,24 +6888,23 @@ var DefaultStreamTextResult = class {
                     telemetry
                   }),
                   ...baseTelemetryAttributes,
+                  // model:
+                  "ai.model.provider": stepModel.provider,
+                  "ai.model.id": stepModel.modelId,
+                  // prompt:
                   "ai.prompt.messages": {
-                    input: () => JSON.stringify(promptMessages)
+                    input: () => stringifyForTelemetry(promptMessages)
                   },
                   "ai.prompt.tools": {
                     // convert the language model level tools:
-                    input: () => {
-                      var _a17;
-                      return (_a17 = toolsAndToolChoice.tools) == null ? void 0 : _a17.map(
-                        (tool2) => JSON.stringify(tool2)
-                      );
-                    }
+                    input: () => stepTools == null ? void 0 : stepTools.map((tool2) => JSON.stringify(tool2))
                   },
                   "ai.prompt.toolChoice": {
-                    input: () => toolsAndToolChoice.toolChoice != null ? JSON.stringify(toolsAndToolChoice.toolChoice) : void 0
+                    input: () => stepToolChoice != null ? JSON.stringify(stepToolChoice) : void 0
                   },
                   // standardized gen-ai llm span attributes:
-                  "gen_ai.system": model.provider,
-                  "gen_ai.request.model": model.modelId,
+                  "gen_ai.system": stepModel.provider,
+                  "gen_ai.request.model": stepModel.modelId,
                   "gen_ai.request.frequency_penalty": callSettings.frequencyPenalty,
                   "gen_ai.request.max_tokens": callSettings.maxOutputTokens,
                   "gen_ai.request.presence_penalty": callSettings.presencePenalty,
@@ -6881,9 +6921,10 @@ var DefaultStreamTextResult = class {
                   startTimestampMs: now2(),
                   // get before the call
                   doStreamSpan: doStreamSpan2,
-                  result: await model.doStream({
+                  result: await stepModel.doStream({
                     ...callSettings,
-                    ...toolsAndToolChoice,
+                    tools: stepTools,
+                    toolChoice: stepToolChoice,
                     responseFormat: output == null ? void 0 : output.responseFormat,
                     prompt: promptMessages,
                     providerOptions,
@@ -6894,7 +6935,7 @@ var DefaultStreamTextResult = class {
               }
             })
           );
-          const transformedStream = runToolsTransformation({
+          const streamWithToolResults = runToolsTransformation({
             tools,
             generatorStream: stream2,
             toolCallStreaming,
@@ -6933,10 +6974,10 @@ var DefaultStreamTextResult = class {
             stepText += chunk.text;
           }
           self.addStream(
-            transformedStream.pipeThrough(
+            streamWithToolResults.pipeThrough(
               new TransformStream({
                 async transform(chunk, controller) {
-                  var _a17, _b, _c, _d;
+                  var _a18, _b2, _c2, _d2;
                   if (chunk.type === "stream-start") {
                     warnings = chunk.warnings;
                     return;
@@ -6999,9 +7040,9 @@ var DefaultStreamTextResult = class {
                     }
                     case "response-metadata": {
                       stepResponse = {
-                        id: (_a17 = chunk.id) != null ? _a17 : stepResponse.id,
-                        timestamp: (_b = chunk.timestamp) != null ? _b : stepResponse.timestamp,
-                        modelId: (_c = chunk.modelId) != null ? _c : stepResponse.modelId
+                        id: (_a18 = chunk.id) != null ? _a18 : stepResponse.id,
+                        timestamp: (_b2 = chunk.timestamp) != null ? _b2 : stepResponse.timestamp,
+                        modelId: (_c2 = chunk.modelId) != null ? _c2 : stepResponse.modelId
                       };
                       break;
                     }
@@ -7013,7 +7054,7 @@ var DefaultStreamTextResult = class {
                       doStreamSpan.addEvent("ai.stream.finish");
                       doStreamSpan.setAttributes({
                         "ai.response.msToFinish": msToFinish,
-                        "ai.response.avgOutputTokensPerSecond": 1e3 * ((_d = stepUsage.outputTokens) != null ? _d : 0) / msToFinish
+                        "ai.response.avgOutputTokensPerSecond": 1e3 * ((_d2 = stepUsage.outputTokens) != null ? _d2 : 0) / msToFinish
                       });
                       break;
                     }
@@ -7027,8 +7068,28 @@ var DefaultStreamTextResult = class {
                       controller.enqueue(chunk);
                       break;
                     }
-                    case "tool-call-streaming-start":
+                    case "tool-call-streaming-start": {
+                      const tool2 = tools == null ? void 0 : tools[chunk.toolName];
+                      if ((tool2 == null ? void 0 : tool2.onArgsStreamingStart) != null) {
+                        await tool2.onArgsStreamingStart({
+                          toolCallId: chunk.toolCallId,
+                          messages: stepInputMessages,
+                          abortSignal
+                        });
+                      }
+                      controller.enqueue(chunk);
+                      break;
+                    }
                     case "tool-call-delta": {
+                      const tool2 = tools == null ? void 0 : tools[chunk.toolName];
+                      if ((tool2 == null ? void 0 : tool2.onArgsStreamingDelta) != null) {
+                        await tool2.onArgsStreamingDelta({
+                          argsTextDelta: chunk.argsTextDelta,
+                          toolCallId: chunk.toolCallId,
+                          messages: stepInputMessages,
+                          abortSignal
+                        });
+                      }
                       controller.enqueue(chunk);
                       break;
                     }
@@ -7088,9 +7149,13 @@ var DefaultStreamTextResult = class {
                     }
                   });
                   const combinedUsage = addLanguageModelUsage(usage, stepUsage);
-                  if (currentStep + 1 < maxSteps2 && // there are tool calls:
-                  stepToolCalls.length > 0 && // all current tool calls have results:
-                  stepToolResults.length === stepToolCalls.length) {
+                  await stepFinish.promise;
+                  if (stepToolCalls.length > 0 && // all current tool calls have results:
+                  stepToolResults.length === stepToolCalls.length && // continue until a stop condition is met:
+                  !await isStopConditionMet({
+                    stopConditions,
+                    steps: recordedSteps
+                  })) {
                     responseMessages.push(
                       ...toResponseMessages({
                         content: stepContent,
@@ -7138,7 +7203,7 @@ var DefaultStreamTextResult = class {
     });
   }
   get steps() {
-    return this.stepsPromise.value;
+    return this._steps.promise;
   }
   get finalStep() {
     return this.steps.then((steps) => steps[steps.length - 1]);
@@ -7183,10 +7248,10 @@ var DefaultStreamTextResult = class {
     return this.finalStep.then((step) => step.response);
   }
   get totalUsage() {
-    return this.totalUsagePromise.value;
+    return this._totalUsage.promise;
   }
   get finishReason() {
-    return this.finishReasonPromise.value;
+    return this._finishReason.promise;
   }
   /**
   Split out a new stream from the original stream.
@@ -7259,8 +7324,8 @@ var DefaultStreamTextResult = class {
     messageMetadata,
     sendReasoning = false,
     sendSources = false,
-    experimental_sendStart = true,
-    experimental_sendFinish = true,
+    sendStart = true,
+    sendFinish = true,
     onError = () => "An error occurred."
     // mask error messages for safety by default
   } = {}) {
@@ -7304,16 +7369,25 @@ var DefaultStreamTextResult = class {
               break;
             }
             case "source": {
-              if (sendSources) {
+              if (sendSources && part.sourceType === "url") {
                 controller.enqueue({
-                  type: "source",
-                  sourceType: part.sourceType,
-                  id: part.id,
+                  type: "source-url",
+                  sourceId: part.id,
                   url: part.url,
                   title: part.title,
                   providerMetadata: part.providerMetadata
                 });
               }
+              if (sendSources && part.sourceType === "document") {
+                controller.enqueue({
+                  type: "source-document",
+                  sourceId: part.id,
+                  mediaType: part.mediaType,
+                  title: part.title,
+                  filename: part.filename,
+                  providerMetadata: part.providerMetadata
+                });
+              }
               break;
             }
             case "tool-call-streaming-start": {
@@ -7373,7 +7447,7 @@ var DefaultStreamTextResult = class {
               break;
             }
             case "start": {
-              if (experimental_sendStart) {
+              if (sendStart) {
                 const metadata = messageMetadata == null ? void 0 : messageMetadata({ part });
                 controller.enqueue({
                   type: "start",
@@ -7384,7 +7458,7 @@ var DefaultStreamTextResult = class {
               break;
             }
             case "finish": {
-              if (experimental_sendFinish) {
+              if (sendFinish) {
                 const metadata = messageMetadata == null ? void 0 : messageMetadata({ part });
                 controller.enqueue({
                   type: "finish",
@@ -7401,38 +7475,12 @@ var DefaultStreamTextResult = class {
         }
       })
     );
-    if (onFinish == null) {
-      return baseStream;
-    }
-    const state = createStreamingUIMessageState({
-      lastMessage,
-      newMessageId: messageId != null ? messageId : this.generateId()
-    });
-    const runUpdateMessageJob = async (job) => {
-      await job({ state, write: () => {
-      } });
-    };
-    return processUIMessageStream({
+    return handleUIMessageStreamFinish({
       stream: baseStream,
-      runUpdateMessageJob
-    }).pipeThrough(
-      new TransformStream({
-        transform(chunk, controller) {
-          controller.enqueue(chunk);
-        },
-        flush() {
-          const isContinuation2 = state.message.id === (lastMessage == null ? void 0 : lastMessage.id);
-          onFinish({
-            isContinuation: isContinuation2,
-            responseMessage: state.message,
-            messages: [
-              ...isContinuation2 ? originalMessages.slice(0, -1) : originalMessages,
-              state.message
-            ]
-          });
-        }
-      })
-    );
+      newMessageId: messageId != null ? messageId : this.generateId(),
+      originalMessages,
+      onFinish
+    });
   }
   pipeUIMessageStreamToResponse(response, {
     newMessageId,
@@ -7441,8 +7489,8 @@ var DefaultStreamTextResult = class {
     messageMetadata,
     sendReasoning,
     sendSources,
-    experimental_sendFinish,
-    experimental_sendStart,
+    sendFinish,
+    sendStart,
     onError,
     ...init
   } = {}) {
@@ -7455,8 +7503,8 @@ var DefaultStreamTextResult = class {
         messageMetadata,
         sendReasoning,
         sendSources,
-        experimental_sendFinish,
-        experimental_sendStart,
+        sendFinish,
+        sendStart,
         onError
       }),
       ...init
@@ -7476,8 +7524,8 @@ var DefaultStreamTextResult = class {
     messageMetadata,
     sendReasoning,
     sendSources,
-    experimental_sendFinish,
-    experimental_sendStart,
+    sendFinish,
+    sendStart,
     onError,
     ...init
   } = {}) {
@@ -7489,8 +7537,8 @@ var DefaultStreamTextResult = class {
         messageMetadata,
         sendReasoning,
         sendSources,
-        experimental_sendFinish,
-        experimental_sendStart,
+        sendFinish,
+        sendStart,
         onError
       }),
       ...init
@@ -7733,7 +7781,7 @@ var doWrap = ({
 };
 
 // core/registry/custom-provider.ts
-var import_provider24 = require("@ai-sdk/provider");
+var import_provider25 = require("@ai-sdk/provider");
 function customProvider({
   languageModels,
   textEmbeddingModels,
@@ -7748,7 +7796,7 @@ function customProvider({
       if (fallbackProvider) {
         return fallbackProvider.languageModel(modelId);
       }
-      throw new import_provider24.NoSuchModelError({ modelId, modelType: "languageModel" });
+      throw new import_provider25.NoSuchModelError({ modelId, modelType: "languageModel" });
     },
     textEmbeddingModel(modelId) {
       if (textEmbeddingModels != null && modelId in textEmbeddingModels) {
@@ -7757,7 +7805,7 @@ function customProvider({
       if (fallbackProvider) {
         return fallbackProvider.textEmbeddingModel(modelId);
       }
-      throw new import_provider24.NoSuchModelError({ modelId, modelType: "textEmbeddingModel" });
+      throw new import_provider25.NoSuchModelError({ modelId, modelType: "textEmbeddingModel" });
     },
     imageModel(modelId) {
       if (imageModels != null && modelId in imageModels) {
@@ -7766,19 +7814,19 @@ function customProvider({
       if (fallbackProvider == null ? void 0 : fallbackProvider.imageModel) {
         return fallbackProvider.imageModel(modelId);
       }
-      throw new import_provider24.NoSuchModelError({ modelId, modelType: "imageModel" });
+      throw new import_provider25.NoSuchModelError({ modelId, modelType: "imageModel" });
     }
   };
 }
 var experimental_customProvider = customProvider;
 
 // core/registry/no-such-provider-error.ts
-var import_provider25 = require("@ai-sdk/provider");
+var import_provider26 = require("@ai-sdk/provider");
 var name16 = "AI_NoSuchProviderError";
 var marker16 = `vercel.ai.error.${name16}`;
 var symbol16 = Symbol.for(marker16);
 var _a16;
-var NoSuchProviderError = class extends import_provider25.NoSuchModelError {
+var NoSuchProviderError = class extends import_provider26.NoSuchModelError {
   constructor({
     modelId,
     modelType,
@@ -7792,13 +7840,13 @@ var NoSuchProviderError = class extends import_provider25.NoSuchModelError {
     this.availableProviders = availableProviders;
   }
   static isInstance(error) {
-    return import_provider25.AISDKError.hasMarker(error, marker16);
+    return import_provider26.AISDKError.hasMarker(error, marker16);
   }
 };
 _a16 = symbol16;
 
 // core/registry/provider-registry.ts
-var import_provider26 = require("@ai-sdk/provider");
+var import_provider27 = require("@ai-sdk/provider");
 function createProviderRegistry(providers, {
   separator = ":"
 } = {}) {
@@ -7837,7 +7885,7 @@ var DefaultProviderRegistry = class {
   splitId(id, modelType) {
     const index = id.indexOf(this.separator);
     if (index === -1) {
-      throw new import_provider26.NoSuchModelError({
+      throw new import_provider27.NoSuchModelError({
         modelId: id,
         modelType,
         message: `Invalid ${modelType} id for registry: ${id} (must be in the format "providerId${this.separator}modelId")`
@@ -7850,7 +7898,7 @@ var DefaultProviderRegistry = class {
     const [providerId, modelId] = this.splitId(id, "languageModel");
     const model = (_b = (_a17 = this.getProvider(providerId)).languageModel) == null ? void 0 : _b.call(_a17, modelId);
     if (model == null) {
-      throw new import_provider26.NoSuchModelError({ modelId: id, modelType: "languageModel" });
+      throw new import_provider27.NoSuchModelError({ modelId: id, modelType: "languageModel" });
     }
     return model;
   }
@@ -7860,7 +7908,7 @@ var DefaultProviderRegistry = class {
     const provider = this.getProvider(providerId);
     const model = (_a17 = provider.textEmbeddingModel) == null ? void 0 : _a17.call(provider, modelId);
     if (model == null) {
-      throw new import_provider26.NoSuchModelError({
+      throw new import_provider27.NoSuchModelError({
         modelId: id,
         modelType: "textEmbeddingModel"
       });
@@ -7873,14 +7921,14 @@ var DefaultProviderRegistry = class {
     const provider = this.getProvider(providerId);
     const model = (_a17 = provider.imageModel) == null ? void 0 : _a17.call(provider, modelId);
     if (model == null) {
-      throw new import_provider26.NoSuchModelError({ modelId: id, modelType: "imageModel" });
+      throw new import_provider27.NoSuchModelError({ modelId: id, modelType: "imageModel" });
     }
     return model;
   }
 };
 
 // core/tool/mcp/mcp-client.ts
-var import_provider_utils25 = require("@ai-sdk/provider-utils");
+var import_provider_utils24 = require("@ai-sdk/provider-utils");
 
 // core/tool/tool.ts
 function tool(tool2) {
@@ -7888,7 +7936,7 @@ function tool(tool2) {
 }
 
 // core/tool/mcp/mcp-sse-transport.ts
-var import_provider_utils24 = require("@ai-sdk/provider-utils");
+var import_provider_utils23 = require("@ai-sdk/provider-utils");
 
 // core/tool/mcp/json-rpc-message.ts
 var import_zod10 = require("zod");
@@ -8059,7 +8107,7 @@ var SseMCPTransport = class {
             (_b = this.onerror) == null ? void 0 : _b.call(this, error);
             return reject(error);
           }
-          const stream = response.body.pipeThrough(new TextDecoderStream()).pipeThrough((0, import_provider_utils24.createEventSourceParserStream)());
+          const stream = response.body.pipeThrough(new TextDecoderStream()).pipeThrough((0, import_provider_utils23.createEventSourceParserStream)());
           const reader = stream.getReader();
           const processEvents = async () => {
             var _a18, _b2, _c2;
@@ -8383,7 +8431,7 @@ var MCPClient = class {
         if (schemas !== "automatic" && !(name17 in schemas)) {
           continue;
         }
-        const parameters = schemas === "automatic" ? (0, import_provider_utils25.jsonSchema)({
+        const parameters = schemas === "automatic" ? (0, import_provider_utils24.jsonSchema)({
           ...inputSchema,
           properties: (_a17 = inputSchema.properties) != null ? _a17 : {},
           additionalProperties: false
@@ -8447,8 +8495,8 @@ var MCPClient = class {
 };
 
 // src/error/no-transcript-generated-error.ts
-var import_provider27 = require("@ai-sdk/provider");
-var NoTranscriptGeneratedError = class extends import_provider27.AISDKError {
+var import_provider28 = require("@ai-sdk/provider");
+var NoTranscriptGeneratedError = class extends import_provider28.AISDKError {
   constructor(options) {
     super({
       name: "AI_NoTranscriptGeneratedError",
@@ -8513,10 +8561,11 @@ var DefaultTranscriptionResult = class {
 0 && (module.exports = {
   AISDKError,
   APICallError,
-  ChatStore,
+  AbstractChat,
   DefaultChatTransport,
   DownloadError,
   EmptyResponseBodyError,
+  GLOBAL_DEFAULT_PROVIDER,
   InvalidArgumentError,
   InvalidDataContentError,
   InvalidMessageRoleError,
@@ -8538,14 +8587,14 @@ var DefaultTranscriptionResult = class {
   NoSuchToolError,
   Output,
   RetryError,
+  SerialJobExecutor,
+  TextStreamChatTransport,
   ToolCallRepairError,
   ToolExecutionError,
   TypeValidationError,
   UnsupportedFunctionalityError,
-  appendClientMessage,
   asSchema,
   assistantModelMessageSchema,
-  callChatApi,
   callCompletionApi,
   convertFileListToFileUIParts,
   convertToCoreMessages,
@@ -8562,7 +8611,6 @@ var DefaultTranscriptionResult = class {
   createUIMessageStream,
   createUIMessageStreamResponse,
   customProvider,
-  defaultChatStore,
   defaultSettingsMiddleware,
   embed,
   embedMany,
@@ -8572,7 +8620,6 @@ var DefaultTranscriptionResult = class {
   experimental_generateImage,
   experimental_generateSpeech,
   experimental_transcribe,
-  extractMaxToolInvocationStep,
   extractReasoningMiddleware,
   generateId,
   generateObject,
@@ -8580,24 +8627,21 @@ var DefaultTranscriptionResult = class {
   getTextFromDataUrl,
   getToolInvocations,
   hasToolCall,
-  isAssistantMessageWithCompletedToolCalls,
   isDeepEqualData,
   jsonSchema,
-  maxSteps,
   modelMessageSchema,
   parsePartialJson,
   pipeTextStreamToResponse,
   pipeUIMessageStreamToResponse,
-  shouldResubmitMessages,
   simulateReadableStream,
   simulateStreamingMiddleware,
   smoothStream,
+  stepCountIs,
   streamObject,
   streamText,
   systemModelMessageSchema,
   tool,
   toolModelMessageSchema,
-  updateToolCallResult,
   userModelMessageSchema,
   wrapLanguageModel
 });