ai 5.0.0-alpha.6 → 5.0.0-alpha.8

package/dist/index.mjs

@@ -449,21 +449,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
-import {
-  parseJsonEventStream
-} from "@ai-sdk/provider-utils";
+// src/ui/call-completion-api.ts
+import { parseJsonEventStream } from "@ai-sdk/provider-utils";
 
 // src/ui-message-stream/ui-message-stream-parts.ts
 import { z } from "zod";
@@ -569,6 +556,138 @@ 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: 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
+import {
+  generateId as generateIdFunc
+} from "@ai-sdk/provider-utils";
+
 // src/ui/process-ui-message-stream.ts
 import {
   validateTypes
@@ -944,14 +1063,6 @@ async function parsePartialJson(jsonText) {
   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(
@@ -964,9 +1075,7 @@ function createStreamingUIMessageState({
   lastMessage,
   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 ? lastMessage : {
     id: newMessageId,
     metadata: {},
@@ -977,8 +1086,7 @@ function createStreamingUIMessageState({
     message,
     activeTextPart: void 0,
     activeReasoningPart: void 0,
-    partialToolCalls: {},
-    step
+    partialToolCalls: {}
   };
 }
 function processUIMessageStream({
@@ -1076,13 +1184,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
@@ -1098,7 +1204,6 @@ function processUIMessageStream({
               );
               updateToolInvocationPart(part.toolCallId, {
                 state: "partial-call",
-                step: partialToolCall.step,
                 toolCallId: part.toolCallId,
                 toolName: partialToolCall.toolName,
                 args: partialArgs
@@ -1109,7 +1214,6 @@ function processUIMessageStream({
             case "tool-call": {
               updateToolInvocationPart(part.toolCallId, {
                 state: "call",
-                step: state.step,
                 toolCallId: part.toolCallId,
                 toolName: part.toolName,
                 args: part.args
@@ -1122,7 +1226,6 @@ function processUIMessageStream({
                 if (result != null) {
                   updateToolInvocationPart(part.toolCallId, {
                     state: "result",
-                    step: state.step,
                     toolCallId: part.toolCallId,
                     toolName: part.toolName,
                     args: part.args,
@@ -1161,7 +1264,6 @@ function processUIMessageStream({
               break;
             }
             case "finish-step": {
-              state.step += 1;
               state.activeTextPart = void 0;
               state.activeReasoningPart = void 0;
               await updateMessageMetadata(part.metadata);
@@ -1224,408 +1326,64 @@ 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.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;
-async function fetchUIMessageStream({
-  api,
-  body,
-  credentials,
-  headers,
-  abortController,
-  fetch: fetch2 = getOriginalFetch(),
-  requestType = "generate"
-}) {
-  var _a17, _b, _c;
-  const response = requestType === "resume" ? await fetch2(`${api}?chatId=${body.chatId}`, {
-    method: "GET",
-    headers: {
-      "Content-Type": "application/json",
-      ...headers
-    },
-    signal: (_a17 = abortController == null ? void 0 : abortController()) == null ? void 0 : _a17.signal,
-    credentials
-  }) : await fetch2(api, {
-    method: "POST",
-    body: JSON.stringify(body),
-    headers: {
-      "Content-Type": "application/json",
-      ...headers
-    },
-    signal: (_b = abortController == null ? void 0 : abortController()) == null ? void 0 : _b.signal,
-    credentials
-  });
-  if (!response.ok) {
-    throw new Error(
-      (_c = await response.text()) != null ? _c : "Failed to fetch the chat response."
+// src/ui/chat-store.ts
+var ChatStore = class {
+  constructor({
+    chats = {},
+    generateId: generateId3,
+    transport,
+    maxSteps = 1,
+    messageMetadataSchema,
+    dataPartSchemas,
+    createChat
+  }) {
+    this.createChat = createChat;
+    this.chats = new Map(
+      Object.entries(chats).map(([id, chat]) => [
+        id,
+        this.createChat({ messages: chat.messages })
+      ])
     );
+    this.maxSteps = maxSteps;
+    this.transport = transport;
+    this.subscribers = /* @__PURE__ */ new Set();
+    this.generateId = generateId3 != null ? generateId3 : generateIdFunc;
+    this.messageMetadataSchema = messageMetadataSchema;
+    this.dataPartSchemas = dataPartSchemas;
   }
-  if (!response.body) {
-    throw new Error("The response body is empty.");
-  }
-  return parseJsonEventStream({
-    stream: response.body,
-    schema: uiMessageStreamPartSchema
-  }).pipeThrough(
-    new TransformStream({
-      async transform(part, controller) {
-        if (!part.success) {
-          throw part.error;
-        }
-        controller.enqueue(part.value);
-      }
-    })
-  );
-}
-async function fetchTextStream({
-  api,
-  body,
-  credentials,
-  headers,
-  abortController,
-  fetch: fetch2 = getOriginalFetch(),
-  requestType = "generate"
-}) {
-  var _a17, _b, _c;
-  const response = requestType === "resume" ? await fetch2(`${api}?chatId=${body.chatId}`, {
-    method: "GET",
-    headers: {
-      "Content-Type": "application/json",
-      ...headers
-    },
-    signal: (_a17 = abortController == null ? void 0 : abortController()) == null ? void 0 : _a17.signal,
-    credentials
-  }) : await fetch2(api, {
-    method: "POST",
-    body: JSON.stringify(body),
-    headers: {
-      "Content-Type": "application/json",
-      ...headers
-    },
-    signal: (_b = abortController == null ? void 0 : abortController()) == null ? void 0 : _b.signal,
-    credentials
-  });
-  if (!response.ok) {
-    throw new Error(
-      (_c = await response.text()) != null ? _c : "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())
-  });
-}
-async function consumeUIMessageStream({
-  stream,
-  onUpdate,
-  onFinish,
-  onToolCall,
-  generateId: generateId3,
-  lastMessage,
-  messageMetadataSchema
-}) {
-  const state = createStreamingUIMessageState({
-    lastMessage: lastMessage ? structuredClone(lastMessage) : void 0,
-    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 = streamProtocol === "text" ? await fetchTextStream({
-    api,
-    body,
-    credentials,
-    headers,
-    abortController,
-    fetch: fetch2,
-    requestType
-  }) : await fetchUIMessageStream({
-    api,
-    body,
-    credentials,
-    headers,
-    abortController,
-    fetch: fetch2,
-    requestType
-  });
-  await consumeUIMessageStream({
-    stream,
-    onUpdate,
-    onFinish,
-    onToolCall,
-    generateId: generateId3,
-    lastMessage,
-    messageMetadataSchema
-  });
-}
-
-// src/ui/call-completion-api.ts
-import { parseJsonEventStream as parseJsonEventStream2 } from "@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);
-  }
-}
-
-// 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;
-    });
-    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: parseJsonEventStream2({
-            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
-import {
-  generateId as generateIdFunc
-} from "@ai-sdk/provider-utils";
-
-// src/ui/should-resubmit-messages.ts
-function shouldResubmitMessages({
-  originalMaxToolInvocationStep,
-  originalMessageCount,
-  maxSteps,
-  messages
-}) {
-  var _a17;
-  const lastMessage = messages[messages.length - 1];
-  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 || 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) < maxSteps
-  );
-}
-function isAssistantMessageWithCompletedToolCalls(message) {
-  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/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;
-  }
-  invocationPart.toolInvocation = {
-    ...invocationPart.toolInvocation,
-    state: "result",
-    result
-  };
-}
-
-// src/ui/chat-store.ts
-var ChatStore = class {
-  constructor({
-    chats = {},
-    generateId: generateId3,
-    transport,
-    maxSteps = 1,
-    messageMetadataSchema,
-    dataPartSchemas,
-    createChat
-  }) {
-    this.createChat = createChat;
-    this.chats = new Map(
-      Object.entries(chats).map(([id, chat]) => [
-        id,
-        this.createChat({ messages: chat.messages })
-      ])
-    );
-    this.maxSteps = maxSteps;
-    this.transport = transport;
-    this.subscribers = /* @__PURE__ */ new Set();
-    this.generateId = generateId3 != null ? generateId3 : generateIdFunc;
-    this.messageMetadataSchema = messageMetadataSchema;
-    this.dataPartSchemas = dataPartSchemas;
-  }
-  hasChat(id) {
-    return this.chats.has(id);
+  hasChat(id) {
+    return this.chats.has(id);
   }
   addChat(id, messages) {
     this.chats.set(id, this.createChat({ messages }));
@@ -1637,14 +1395,14 @@ var ChatStore = class {
     return this.chats.size;
   }
   getStatus(id) {
-    return this.getChatState(id).status;
+    return this.getChat(id).status;
   }
   setStatus({
     id,
     status,
     error
   }) {
-    const state = this.getChatState(id);
+    const state = this.getChat(id);
     if (state.status === status)
       return;
     state.setStatus(status);
@@ -1652,13 +1410,13 @@ var ChatStore = class {
     this.emit({ type: "chat-status-changed", chatId: id, error });
   }
   getError(id) {
-    return this.getChatState(id).error;
+    return this.getChat(id).error;
   }
   getMessages(id) {
-    return this.getChatState(id).messages;
+    return this.getChat(id).messages;
   }
   getLastMessage(id) {
-    const chat = this.getChatState(id);
+    const chat = this.getChat(id);
     return chat.messages[chat.messages.length - 1];
   }
   subscribe(subscriber) {
@@ -1669,11 +1427,11 @@ var ChatStore = class {
     id,
     messages
   }) {
-    this.getChatState(id).setMessages(messages);
+    this.getChat(id).setMessages(messages);
     this.emit({ type: "chat-messages-changed", chatId: id });
   }
   removeAssistantResponse(id) {
-    const chat = this.getChatState(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");
@@ -1694,8 +1452,8 @@ var ChatStore = class {
     onFinish
   }) {
     var _a17;
-    const state = this.getChatState(chatId);
-    state.pushMessage({ ...message, id: (_a17 = message.id) != null ? _a17 : this.generateId() });
+    const chat = this.getChat(chatId);
+    chat.pushMessage({ ...message, id: (_a17 = message.id) != null ? _a17 : this.generateId() });
     this.emit({
       type: "chat-messages-changed",
       chatId
@@ -1718,7 +1476,7 @@ var ChatStore = class {
     onToolCall,
     onFinish
   }) {
-    const chat = this.getChatState(chatId);
+    const chat = this.getChat(chatId);
     if (chat.messages[chat.messages.length - 1].role === "assistant") {
       chat.popMessage();
       this.emit({
@@ -1762,7 +1520,7 @@ var ChatStore = class {
     toolCallId,
     result
   }) {
-    const chat = this.getChatState(chatId);
+    const chat = this.getChat(chatId);
     chat.jobExecutor.run(async () => {
       updateToolCallResult({
         messages: chat.messages,
@@ -1787,7 +1545,7 @@ var ChatStore = class {
   }
   async stopStream({ chatId }) {
     var _a17;
-    const chat = this.getChatState(chatId);
+    const chat = this.getChat(chatId);
     if (chat.status !== "streaming" && chat.status !== "submitted")
       return;
     if ((_a17 = chat.activeResponse) == null ? void 0 : _a17.abortController) {
@@ -1800,7 +1558,7 @@ var ChatStore = class {
       subscriber.onChatChanged(event);
     }
   }
-  getChatState(id) {
+  getChat(id) {
     if (!this.hasChat(id)) {
       this.addChat(id, []);
     }
@@ -1815,17 +1573,18 @@ var ChatStore = class {
     onToolCall,
     onFinish
   }) {
-    const chat = this.getChatState(chatId);
+    const chat = this.getChat(chatId);
     this.setStatus({ id: chatId, status: "submitted", error: void 0 });
     const messageCount = chat.messages.length;
-    const maxStep = extractMaxToolInvocationStep(
-      getToolInvocations(chat.messages[chat.messages.length - 1])
-    );
+    const lastMessage = chat.messages[chat.messages.length - 1];
+    const maxStep = lastMessage.parts.filter(
+      (part) => part.type === "step-start"
+    ).length;
     try {
-      const lastMessage = chat.messages[chat.messages.length - 1];
+      const lastMessage2 = chat.messages[chat.messages.length - 1];
       const activeResponse = {
         state: createStreamingUIMessageState({
-          lastMessage: chat.snapshot ? chat.snapshot(lastMessage) : lastMessage,
+          lastMessage: chat.snapshot ? chat.snapshot(lastMessage2) : lastMessage2,
           newMessageId: this.generateId()
         }),
         abortController: new AbortController()
@@ -1907,106 +1666,24 @@ var ChatStore = class {
     }
   }
 };
-
-// src/ui/chat-transport.ts
-var DefaultChatTransport = class {
-  constructor({
-    api,
-    credentials,
-    headers,
-    body,
-    fetch: fetch2,
-    prepareRequestBody
-  }) {
-    this.api = api;
-    this.credentials = credentials;
-    this.headers = headers;
-    this.body = body;
-    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
-      },
-      credentials: this.credentials,
-      abortController: () => abortController,
-      fetch: this.fetch,
-      requestType
-    });
-  }
-};
-var TextStreamChatTransport = class {
-  constructor({
-    api,
-    credentials,
-    headers,
-    body,
-    fetch: fetch2,
-    prepareRequestBody
-  }) {
-    this.api = api;
-    this.credentials = credentials;
-    this.headers = headers;
-    this.body = body;
-    this.fetch = fetch2;
-    this.prepareRequestBody = prepareRequestBody;
-  }
-  submitMessages({
-    chatId,
-    messages,
-    abortController,
-    body,
-    headers,
-    requestType
-  }) {
-    var _a17, _b;
-    return fetchTextStream({
-      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
-      },
-      credentials: this.credentials,
-      abortController: () => abortController,
-      fetch: this.fetch,
-      requestType
-    });
+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-file-list-to-file-ui-parts.ts
 async function convertFileListToFileUIParts(files) {
@@ -2040,7 +1717,7 @@ async function convertFileListToFileUIParts(files) {
 
 // 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) {
@@ -2071,6 +1748,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) {
@@ -2145,33 +1825,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;
               }
             }
@@ -2190,14 +1857,121 @@ function convertToModelMessages(messages, options) {
       }
     }
   }
-  return modelMessages;
-}
-var convertToCoreMessages = convertToModelMessages;
+  return modelMessages;
+}
+var convertToCoreMessages = convertToModelMessages;
+
+// src/ui/default-chat-store-options.ts
+import {
+  generateId as generateIdFunc2
+} from "@ai-sdk/provider-utils";
+
+// src/ui/default-chat-transport.ts
+import {
+  parseJsonEventStream as parseJsonEventStream2
+} from "@ai-sdk/provider-utils";
+var getOriginalFetch2 = () => fetch;
+async function fetchUIMessageStream({
+  api,
+  body,
+  credentials,
+  headers,
+  abortController,
+  fetch: fetch2 = getOriginalFetch2(),
+  requestType = "generate"
+}) {
+  var _a17, _b, _c;
+  const response = requestType === "resume" ? await fetch2(`${api}?chatId=${body.chatId}`, {
+    method: "GET",
+    headers: {
+      "Content-Type": "application/json",
+      ...headers
+    },
+    signal: (_a17 = abortController == null ? void 0 : abortController()) == null ? void 0 : _a17.signal,
+    credentials
+  }) : await fetch2(api, {
+    method: "POST",
+    body: JSON.stringify(body),
+    headers: {
+      "Content-Type": "application/json",
+      ...headers
+    },
+    signal: (_b = abortController == null ? void 0 : abortController()) == null ? void 0 : _b.signal,
+    credentials
+  });
+  if (!response.ok) {
+    throw new Error(
+      (_c = await response.text()) != null ? _c : "Failed to fetch the chat response."
+    );
+  }
+  if (!response.body) {
+    throw new Error("The response body is empty.");
+  }
+  return parseJsonEventStream2({
+    stream: response.body,
+    schema: uiMessageStreamPartSchema
+  }).pipeThrough(
+    new TransformStream({
+      async transform(part, controller) {
+        if (!part.success) {
+          throw part.error;
+        }
+        controller.enqueue(part.value);
+      }
+    })
+  );
+}
+var DefaultChatTransport = class {
+  constructor({
+    api,
+    credentials,
+    headers,
+    body,
+    fetch: fetch2,
+    prepareRequestBody
+  }) {
+    this.api = api;
+    this.credentials = credentials;
+    this.headers = headers;
+    this.body = body;
+    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
+      },
+      credentials: this.credentials,
+      abortController: () => abortController,
+      fetch: this.fetch,
+      requestType
+    });
+  }
+};
 
 // src/ui/default-chat-store-options.ts
-import {
-  generateId as generateIdFunc2
-} from "@ai-sdk/provider-utils";
 function defaultChatStoreOptions({
   api = "/api/chat",
   fetch: fetch2,
@@ -2228,6 +2002,119 @@ function defaultChatStoreOptions({
   });
 }
 
+// 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,
+  body,
+  credentials,
+  headers,
+  abortController,
+  fetch: fetch2 = getOriginalFetch3(),
+  requestType = "generate"
+}) {
+  var _a17, _b, _c;
+  const response = requestType === "resume" ? await fetch2(`${api}?chatId=${body.chatId}`, {
+    method: "GET",
+    headers: {
+      "Content-Type": "application/json",
+      ...headers
+    },
+    signal: (_a17 = abortController == null ? void 0 : abortController()) == null ? void 0 : _a17.signal,
+    credentials
+  }) : await fetch2(api, {
+    method: "POST",
+    body: JSON.stringify(body),
+    headers: {
+      "Content-Type": "application/json",
+      ...headers
+    },
+    signal: (_b = abortController == null ? void 0 : abortController()) == null ? void 0 : _b.signal,
+    credentials
+  });
+  if (!response.ok) {
+    throw new Error(
+      (_c = await response.text()) != null ? _c : "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,
+    prepareRequestBody
+  }) {
+    this.api = api;
+    this.credentials = credentials;
+    this.headers = headers;
+    this.body = body;
+    this.fetch = fetch2;
+    this.prepareRequestBody = prepareRequestBody;
+  }
+  submitMessages({
+    chatId,
+    messages,
+    abortController,
+    body,
+    headers,
+    requestType
+  }) {
+    var _a17, _b;
+    return fetchTextStream({
+      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
+      },
+      credentials: this.credentials,
+      abortController: () => abortController,
+      fetch: this.fetch,
+      requestType
+    });
+  }
+};
+
 // src/ui-message-stream/handle-ui-message-stream-finish.ts
 function handleUIMessageStreamFinish({
   newMessageId,
@@ -3855,6 +3742,19 @@ function prepareCallSettings({
   };
 }
 
+// core/prompt/resolve-language-model.ts
+import { gateway } from "@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 : gateway).languageModel(model);
+}
+
 // core/prompt/standardize-prompt.ts
 import { InvalidPromptError as InvalidPromptError2 } from "@ai-sdk/provider";
 import { safeValidateTypes } from "@ai-sdk/provider-utils";
@@ -4046,6 +3946,23 @@ async function standardizePrompt(prompt) {
   };
 }
 
+// core/prompt/wrap-gateway-error.ts
+import {
+  GatewayAuthenticationError,
+  GatewayModelNotFoundError
+} from "@ai-sdk/gateway";
+import { AISDKError as AISDKError18 } from "@ai-sdk/provider";
+function wrapGatewayError(error) {
+  if (GatewayAuthenticationError.isInstance(error) || GatewayModelNotFoundError.isInstance(error)) {
+    return new AISDKError18({
+      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(
@@ -4462,12 +4379,6 @@ function validateObjectGenerationInput({
   }
 }
 
-// core/prompt/resolve-language-model.ts
-import { gateway } from "@ai-sdk/gateway";
-function resolveLanguageModel(model) {
-  return typeof model === "string" ? gateway.languageModel(model) : model;
-}
-
 // core/generate-object/generate-object.ts
 var originalGenerateId = createIdGenerator({ prefix: "aiobj", size: 24 });
 async function generateObject(options) {
@@ -4517,208 +4428,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: () => 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
-            }
+  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 safeParseJSON2({ 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 safeParseJSON2({ 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) && (JSONParseError2.isInstance(error.cause) || TypeValidationError3.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) && (JSONParseError2.isInstance(error.cause) || TypeValidationError3.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) {
@@ -4742,7 +4657,9 @@ var DefaultGenerateObjectResult = class {
 };
 
 // core/generate-object/stream-object.ts
-import { createIdGenerator as createIdGenerator2 } from "@ai-sdk/provider-utils";
+import {
+  createIdGenerator as createIdGenerator2
+} from "@ai-sdk/provider-utils";
 
 // src/util/create-resolvable-promise.ts
 function createResolvablePromise() {
@@ -4899,7 +4816,9 @@ function streamObject(options) {
     headers,
     experimental_telemetry: telemetry,
     providerOptions,
-    onError,
+    onError = ({ error }) => {
+      console.error(error);
+    },
     onFinish,
     _internal: {
       generateId: generateId3 = originalGenerateId2,
@@ -4992,7 +4911,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) });
         }
       }
     });
@@ -5392,8 +5311,8 @@ var DefaultStreamObjectResult = class {
 };
 
 // src/error/no-speech-generated-error.ts
-import { AISDKError as AISDKError18 } from "@ai-sdk/provider";
-var NoSpeechGeneratedError = class extends AISDKError18 {
+import { AISDKError as AISDKError19 } from "@ai-sdk/provider";
+var NoSpeechGeneratedError = class extends AISDKError19 {
   constructor(options) {
     super({
       name: "AI_NoSpeechGeneratedError",
@@ -5833,239 +5752,243 @@ async function generateText({
     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, _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 };
-              }
-            });
+  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: (_e = currentModelResponse.request) != null ? _e : {},
-          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 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 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,
@@ -6602,7 +6525,9 @@ function streamText({
   experimental_repairToolCall: repairToolCall,
   experimental_transform: transform,
   onChunk,
-  onError,
+  onError = ({ error }) => {
+    console.error(error);
+  },
   onFinish,
   onStepFinish,
   _internal: {
@@ -6741,7 +6666,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];
@@ -7397,7 +7322,7 @@ var DefaultStreamTextResult = class {
   } = {}) {
     const lastMessage = originalMessages[originalMessages.length - 1];
     const isContinuation = (lastMessage == null ? void 0 : lastMessage.role) === "assistant";
-    const messageId = isContinuation ? lastMessage.id : newMessageId != null ? newMessageId : this.generateId();
+    const messageId = isContinuation ? lastMessage.id : newMessageId;
     const baseStream = this.fullStream.pipeThrough(
       new TransformStream({
         transform: async (part, controller) => {
@@ -7533,7 +7458,7 @@ var DefaultStreamTextResult = class {
     );
     return handleUIMessageStreamFinish({
       stream: baseStream,
-      newMessageId: messageId,
+      newMessageId: messageId != null ? messageId : this.generateId(),
       originalMessages,
       onFinish
     });
@@ -7879,7 +7804,7 @@ function customProvider({
 var experimental_customProvider = customProvider;
 
 // core/registry/no-such-provider-error.ts
-import { AISDKError as AISDKError19, NoSuchModelError as NoSuchModelError3 } from "@ai-sdk/provider";
+import { AISDKError as AISDKError20, NoSuchModelError as NoSuchModelError3 } from "@ai-sdk/provider";
 var name16 = "AI_NoSuchProviderError";
 var marker16 = `vercel.ai.error.${name16}`;
 var symbol16 = Symbol.for(marker16);
@@ -7898,7 +7823,7 @@ var NoSuchProviderError = class extends NoSuchModelError3 {
     this.availableProviders = availableProviders;
   }
   static isInstance(error) {
-    return AISDKError19.hasMarker(error, marker16);
+    return AISDKError20.hasMarker(error, marker16);
   }
 };
 _a16 = symbol16;
@@ -8555,8 +8480,8 @@ var MCPClient = class {
 };
 
 // src/error/no-transcript-generated-error.ts
-import { AISDKError as AISDKError20 } from "@ai-sdk/provider";
-var NoTranscriptGeneratedError = class extends AISDKError20 {
+import { AISDKError as AISDKError21 } from "@ai-sdk/provider";
+var NoTranscriptGeneratedError = class extends AISDKError21 {
   constructor(options) {
     super({
       name: "AI_NoTranscriptGeneratedError",
@@ -8624,6 +8549,7 @@ export {
   DefaultChatTransport,
   DownloadError,
   EmptyResponseBodyError,
+  GLOBAL_DEFAULT_PROVIDER,
   InvalidArgumentError,
   InvalidDataContentError,
   InvalidMessageRoleError,
@@ -8651,10 +8577,8 @@ export {
   ToolExecutionError,
   TypeValidationError,
   UnsupportedFunctionalityError,
-  appendClientMessage,
   asSchema5 as asSchema,
   assistantModelMessageSchema,
-  callChatApi,
   callCompletionApi,
   convertFileListToFileUIParts,
   convertToCoreMessages,
@@ -8681,7 +8605,6 @@ export {
   generateImage as experimental_generateImage,
   generateSpeech as experimental_generateSpeech,
   transcribe as experimental_transcribe,
-  extractMaxToolInvocationStep,
   extractReasoningMiddleware,
   generateId2 as generateId,
   generateObject,
@@ -8689,14 +8612,12 @@ export {
   getTextFromDataUrl,
   getToolInvocations,
   hasToolCall,
-  isAssistantMessageWithCompletedToolCalls,
   isDeepEqualData,
   jsonSchema2 as jsonSchema,
   modelMessageSchema,
   parsePartialJson,
   pipeTextStreamToResponse,
   pipeUIMessageStreamToResponse,
-  shouldResubmitMessages,
   simulateReadableStream,
   simulateStreamingMiddleware,
   smoothStream,
@@ -8706,7 +8627,6 @@ export {
   systemModelMessageSchema,
   tool,
   toolModelMessageSchema,
-  updateToolCallResult,
   userModelMessageSchema,
   wrapLanguageModel
 };