ai 5.0.0-canary.22 → 5.0.0-canary.24

package/dist/index.mjs

@@ -467,102 +467,84 @@ import {
 
 // src/ui-message-stream/ui-message-stream-parts.ts
 import { z } from "zod";
-var toolCallSchema = z.object({
-  toolCallId: z.string(),
-  toolName: z.string(),
-  args: z.unknown()
-});
-var toolResultValueSchema = z.object({
-  toolCallId: z.string(),
-  result: z.unknown(),
-  providerMetadata: z.any().optional()
-});
-var sourceSchema = z.object({
-  type: z.literal("source"),
-  sourceType: z.literal("url"),
-  id: z.string(),
-  url: z.string(),
-  title: z.string().optional(),
-  providerMetadata: z.any().optional()
-  // Use z.any() for generic metadata
-});
-var uiMessageStreamPartSchema = z.discriminatedUnion("type", [
+var uiMessageStreamPartSchema = z.union([
   z.object({
     type: z.literal("text"),
-    value: z.string()
+    text: z.string()
   }),
   z.object({
     type: z.literal("error"),
-    value: z.string()
+    errorText: z.string()
   }),
   z.object({
-    type: z.literal("tool-call"),
-    value: toolCallSchema
+    type: z.literal("tool-call-streaming-start"),
+    toolCallId: z.string(),
+    toolName: z.string()
   }),
   z.object({
-    type: z.literal("tool-result"),
-    value: toolResultValueSchema
+    type: z.literal("tool-call-delta"),
+    toolCallId: z.string(),
+    argsTextDelta: z.string()
   }),
   z.object({
-    type: z.literal("tool-call-streaming-start"),
-    value: z.object({ toolCallId: z.string(), toolName: z.string() })
+    type: z.literal("tool-call"),
+    toolCallId: z.string(),
+    toolName: z.string(),
+    args: z.unknown()
   }),
   z.object({
-    type: z.literal("tool-call-delta"),
-    value: z.object({ toolCallId: z.string(), argsTextDelta: z.string() })
+    type: z.literal("tool-result"),
+    toolCallId: z.string(),
+    result: z.unknown(),
+    providerMetadata: z.any().optional()
   }),
   z.object({
     type: z.literal("reasoning"),
-    value: z.object({
-      text: z.string(),
-      providerMetadata: z.record(z.any()).optional()
-    })
+    text: z.string(),
+    providerMetadata: z.record(z.any()).optional()
   }),
   z.object({
     type: z.literal("source"),
-    value: sourceSchema
+    sourceType: z.literal("url"),
+    id: z.string(),
+    url: z.string(),
+    title: z.string().optional(),
+    providerMetadata: z.any().optional()
+    // Use z.any() for generic metadata
   }),
   z.object({
     type: z.literal("file"),
-    value: z.object({
-      url: z.string(),
-      mediaType: z.string()
-    })
+    url: z.string(),
+    mediaType: z.string()
+  }),
+  z.object({
+    type: z.string().startsWith("data-"),
+    id: z.string().optional(),
+    data: z.unknown()
   }),
   z.object({
     type: z.literal("metadata"),
-    value: z.object({
-      metadata: z.unknown()
-    })
+    value: z.object({ metadata: z.unknown() })
   }),
   z.object({
     type: z.literal("start-step"),
-    value: z.object({
-      metadata: z.unknown()
-    })
+    metadata: z.unknown().optional()
   }),
   z.object({
     type: z.literal("finish-step"),
-    value: z.object({
-      metadata: z.unknown()
-    })
+    metadata: z.unknown().optional()
   }),
   z.object({
     type: z.literal("start"),
-    value: z.object({
-      messageId: z.string().optional(),
-      metadata: z.unknown()
-    })
+    messageId: z.string().optional(),
+    metadata: z.unknown().optional()
   }),
   z.object({
     type: z.literal("finish"),
-    value: z.object({
-      metadata: z.unknown()
-    })
+    metadata: z.unknown().optional()
   }),
   z.object({
-    type: z.literal("reasoning-part-finish"),
-    value: z.null()
+    type: z.literal("reasoning-part-finish")
   })
 ]);
 
@@ -974,303 +956,305 @@ function getToolInvocations(message) {
 }
 
 // src/ui/process-ui-message-stream.ts
-function processUIMessageStream({
-  stream,
-  onUpdate,
-  onToolCall,
-  onFinish,
+function createStreamingUIMessageState({
   lastMessage,
-  newMessageId,
-  messageMetadataSchema
-}) {
+  newMessageId = "no-id"
+} = {}) {
   var _a17;
   const isContinuation = (lastMessage == null ? void 0 : lastMessage.role) === "assistant";
-  let step = isContinuation ? 1 + ((_a17 = extractMaxToolInvocationStep(getToolInvocations(lastMessage))) != null ? _a17 : 0) : 0;
+  const step = isContinuation ? 1 + ((_a17 = extractMaxToolInvocationStep(getToolInvocations(lastMessage))) != null ? _a17 : 0) : 0;
   const message = isContinuation ? structuredClone(lastMessage) : {
     id: newMessageId,
     metadata: {},
     role: "assistant",
     parts: []
   };
-  let currentTextPart = void 0;
-  let currentReasoningPart = void 0;
-  function updateToolInvocationPart(toolCallId, invocation) {
-    const part = message.parts.find(
-      (part2) => part2.type === "tool-invocation" && part2.toolInvocation.toolCallId === toolCallId
-    );
-    if (part != null) {
-      part.toolInvocation = invocation;
-    } else {
-      message.parts.push({
-        type: "tool-invocation",
-        toolInvocation: invocation
-      });
-    }
-  }
-  const partialToolCalls = {};
-  async function updateMessageMetadata(metadata) {
-    if (metadata != null) {
-      const mergedMetadata = message.metadata != null ? mergeObjects(message.metadata, metadata) : metadata;
-      if (messageMetadataSchema != null) {
-        await validateTypes({
-          value: mergedMetadata,
-          schema: messageMetadataSchema
-        });
-      }
-      message.metadata = mergedMetadata;
-    }
-  }
+  return {
+    message,
+    activeTextPart: void 0,
+    activeReasoningPart: void 0,
+    partialToolCalls: {},
+    step
+  };
+}
+function processUIMessageStream({
+  stream,
+  onToolCall,
+  messageMetadataSchema,
+  runUpdateMessageJob
+}) {
   return stream.pipeThrough(
     new TransformStream({
-      async transform(chunk, controller) {
-        const { type, value } = chunk;
-        switch (type) {
-          case "text": {
-            if (currentTextPart == null) {
-              currentTextPart = {
-                type: "text",
-                text: value
-              };
-              message.parts.push(currentTextPart);
+      async transform(part, controller) {
+        await runUpdateMessageJob(async ({ state, write }) => {
+          function updateToolInvocationPart(toolCallId, invocation) {
+            const part2 = state.message.parts.find(
+              (part3) => part3.type === "tool-invocation" && part3.toolInvocation.toolCallId === toolCallId
+            );
+            if (part2 != null) {
+              part2.toolInvocation = invocation;
             } else {
-              currentTextPart.text += value;
+              state.message.parts.push({
+                type: "tool-invocation",
+                toolInvocation: invocation
+              });
             }
-            onUpdate == null ? void 0 : onUpdate({ message });
-            break;
           }
-          case "reasoning": {
-            if (currentReasoningPart == null) {
-              currentReasoningPart = {
-                type: "reasoning",
-                text: value.text,
-                providerMetadata: value.providerMetadata
-              };
-              message.parts.push(currentReasoningPart);
-            } else {
-              currentReasoningPart.text += value.text;
-              currentReasoningPart.providerMetadata = value.providerMetadata;
+          async function updateMessageMetadata(metadata) {
+            if (metadata != null) {
+              const mergedMetadata = state.message.metadata != null ? mergeObjects(state.message.metadata, metadata) : metadata;
+              if (messageMetadataSchema != null) {
+                await validateTypes({
+                  value: mergedMetadata,
+                  schema: messageMetadataSchema
+                });
+              }
+              state.message.metadata = mergedMetadata;
             }
-            onUpdate == null ? void 0 : onUpdate({ message });
-            break;
           }
-          case "reasoning-part-finish": {
-            if (currentReasoningPart != null) {
-              currentReasoningPart = void 0;
+          switch (part.type) {
+            case "text": {
+              if (state.activeTextPart == null) {
+                state.activeTextPart = {
+                  type: "text",
+                  text: part.text
+                };
+                state.message.parts.push(state.activeTextPart);
+              } else {
+                state.activeTextPart.text += part.text;
+              }
+              write();
+              break;
             }
-            break;
-          }
-          case "file": {
-            message.parts.push({
-              type: "file",
-              mediaType: value.mediaType,
-              url: value.url
-            });
-            onUpdate == null ? void 0 : onUpdate({ message });
-            break;
-          }
-          case "source": {
-            message.parts.push({
-              type: "source",
-              source: value
-            });
-            onUpdate == null ? void 0 : onUpdate({ message });
-            break;
-          }
-          case "tool-call-streaming-start": {
-            const toolInvocations = getToolInvocations(message);
-            partialToolCalls[value.toolCallId] = {
-              text: "",
-              step,
-              toolName: value.toolName,
-              index: toolInvocations.length
-            };
-            updateToolInvocationPart(value.toolCallId, {
-              state: "partial-call",
-              step,
-              toolCallId: value.toolCallId,
-              toolName: value.toolName,
-              args: void 0
-            });
-            onUpdate == null ? void 0 : onUpdate({ message });
-            break;
-          }
-          case "tool-call-delta": {
-            const partialToolCall = partialToolCalls[value.toolCallId];
-            partialToolCall.text += value.argsTextDelta;
-            const { value: partialArgs } = await parsePartialJson(
-              partialToolCall.text
-            );
-            updateToolInvocationPart(value.toolCallId, {
-              state: "partial-call",
-              step: partialToolCall.step,
-              toolCallId: value.toolCallId,
-              toolName: partialToolCall.toolName,
-              args: partialArgs
-            });
-            onUpdate == null ? void 0 : onUpdate({ message });
-            break;
-          }
-          case "tool-call": {
-            const call = { args: value.args, ...value };
-            updateToolInvocationPart(value.toolCallId, {
-              state: "call",
-              step,
-              ...call
-            });
-            onUpdate == null ? void 0 : onUpdate({ message });
-            if (onToolCall) {
-              const result = await onToolCall({
-                toolCall: call
+            case "reasoning": {
+              if (state.activeReasoningPart == null) {
+                state.activeReasoningPart = {
+                  type: "reasoning",
+                  text: part.text,
+                  providerMetadata: part.providerMetadata
+                };
+                state.message.parts.push(state.activeReasoningPart);
+              } else {
+                state.activeReasoningPart.text += part.text;
+                state.activeReasoningPart.providerMetadata = part.providerMetadata;
+              }
+              write();
+              break;
+            }
+            case "reasoning-part-finish": {
+              if (state.activeReasoningPart != null) {
+                state.activeReasoningPart = void 0;
+              }
+              break;
+            }
+            case "file": {
+              state.message.parts.push({
+                type: "file",
+                mediaType: part.mediaType,
+                url: part.url
+              });
+              write();
+              break;
+            }
+            case "source": {
+              state.message.parts.push({
+                type: "source",
+                source: {
+                  sourceType: "url",
+                  id: part.id,
+                  url: part.url,
+                  title: part.title,
+                  providerMetadata: part.providerMetadata
+                }
               });
-              if (result != null) {
-                updateToolInvocationPart(value.toolCallId, {
-                  state: "result",
-                  step,
-                  ...call,
-                  result
+              write();
+              break;
+            }
+            case "tool-call-streaming-start": {
+              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
+              });
+              write();
+              break;
+            }
+            case "tool-call-delta": {
+              const partialToolCall = state.partialToolCalls[part.toolCallId];
+              partialToolCall.text += part.argsTextDelta;
+              const { value: partialArgs } = await parsePartialJson(
+                partialToolCall.text
+              );
+              updateToolInvocationPart(part.toolCallId, {
+                state: "partial-call",
+                step: partialToolCall.step,
+                toolCallId: part.toolCallId,
+                toolName: partialToolCall.toolName,
+                args: partialArgs
+              });
+              write();
+              break;
+            }
+            case "tool-call": {
+              updateToolInvocationPart(part.toolCallId, {
+                state: "call",
+                step: state.step,
+                toolCallId: part.toolCallId,
+                toolName: part.toolName,
+                args: part.args
+              });
+              write();
+              if (onToolCall) {
+                const result = await onToolCall({
+                  toolCall: part
                 });
-                onUpdate == null ? void 0 : onUpdate({ message });
+                if (result != null) {
+                  updateToolInvocationPart(part.toolCallId, {
+                    state: "result",
+                    step: state.step,
+                    toolCallId: part.toolCallId,
+                    toolName: part.toolName,
+                    args: part.args,
+                    result
+                  });
+                  write();
+                }
               }
+              break;
             }
-            break;
-          }
-          case "tool-result": {
-            const toolInvocations = getToolInvocations(message);
-            if (toolInvocations == null) {
-              throw new Error("tool_result must be preceded by a tool_call");
-            }
-            const toolInvocationIndex = toolInvocations.findIndex(
-              (invocation) => invocation.toolCallId === value.toolCallId
-            );
-            if (toolInvocationIndex === -1) {
-              throw new Error(
-                "tool_result must be preceded by a tool_call with the same toolCallId"
+            case "tool-result": {
+              const toolInvocations = getToolInvocations(state.message);
+              if (toolInvocations == null) {
+                throw new Error("tool_result must be preceded by a tool_call");
+              }
+              const toolInvocationIndex = toolInvocations.findIndex(
+                (invocation) => invocation.toolCallId === part.toolCallId
               );
+              if (toolInvocationIndex === -1) {
+                throw new Error(
+                  "tool_result must be preceded by a tool_call with the same toolCallId"
+                );
+              }
+              updateToolInvocationPart(part.toolCallId, {
+                ...toolInvocations[toolInvocationIndex],
+                state: "result",
+                result: part.result
+              });
+              write();
+              break;
             }
-            const result = { result: value.result, ...value };
-            updateToolInvocationPart(value.toolCallId, {
-              ...toolInvocations[toolInvocationIndex],
-              state: "result",
-              ...result
-            });
-            onUpdate == null ? void 0 : onUpdate({ message });
-            break;
-          }
-          case "start-step": {
-            message.parts.push({ type: "step-start" });
-            await updateMessageMetadata(value.metadata);
-            onUpdate == null ? void 0 : onUpdate({ message });
-            break;
-          }
-          case "finish-step": {
-            step += 1;
-            currentTextPart = void 0;
-            currentReasoningPart = void 0;
-            await updateMessageMetadata(value.metadata);
-            if (value.metadata != null) {
-              onUpdate == null ? void 0 : onUpdate({ message });
+            case "start-step": {
+              state.message.parts.push({ type: "step-start" });
+              await updateMessageMetadata(part.metadata);
+              write();
+              break;
             }
-            break;
-          }
-          case "start": {
-            if (value.messageId != null) {
-              message.id = value.messageId;
+            case "finish-step": {
+              state.step += 1;
+              state.activeTextPart = void 0;
+              state.activeReasoningPart = void 0;
+              await updateMessageMetadata(part.metadata);
+              if (part.metadata != null) {
+                write();
+              }
+              break;
+            }
+            case "start": {
+              if (part.messageId != null) {
+                state.message.id = part.messageId;
+              }
+              await updateMessageMetadata(part.metadata);
+              if (part.messageId != null || part.metadata != null) {
+                write();
+              }
+              break;
             }
-            await updateMessageMetadata(value.metadata);
-            if (value.messageId != null || value.metadata != null) {
-              onUpdate == null ? void 0 : onUpdate({ message });
+            case "finish": {
+              await updateMessageMetadata(part.metadata);
+              if (part.metadata != null) {
+                write();
+              }
+              break;
             }
-            break;
-          }
-          case "finish": {
-            await updateMessageMetadata(value.metadata);
-            if (value.metadata != null) {
-              onUpdate == null ? void 0 : onUpdate({ message });
+            case "metadata": {
+              await updateMessageMetadata(part.metadata);
+              if (part.metadata != null) {
+                write();
+              }
+              break;
             }
-            break;
-          }
-          case "metadata": {
-            await updateMessageMetadata(value.metadata);
-            if (value.metadata != null) {
-              onUpdate == null ? void 0 : onUpdate({ message });
+            case "error": {
+              throw new Error(part.errorText);
+            }
+            default: {
+              if (part.type.startsWith("data-")) {
+                const existingPart = part.id != null ? state.message.parts.find(
+                  (partArg) => part.type === partArg.type && part.id === partArg.id
+                ) : void 0;
+                if (existingPart != null) {
+                  existingPart.value = mergeObjects(
+                    existingPart.data,
+                    part.data
+                  );
+                } else {
+                  state.message.parts.push({
+                    type: part.type,
+                    id: part.id,
+                    value: part.data
+                  });
+                }
+                write();
+              }
             }
-            break;
-          }
-          case "error": {
-            throw new Error(value);
-          }
-          default: {
-            const _exhaustiveCheck = type;
-            throw new Error(`Unhandled stream part: ${_exhaustiveCheck}`);
           }
-        }
-        controller.enqueue(chunk);
-      },
-      flush() {
-        onFinish == null ? void 0 : onFinish({ message });
+          controller.enqueue(part);
+        });
       }
     })
   );
 }
 
-// src/ui/process-chat-text-response.ts
-import { generateId as generateIdFunction } 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/process-chat-text-response.ts
-async function processChatTextResponse({
-  stream,
-  update,
-  onFinish,
-  generateId: generateId3 = generateIdFunction
+// src/ui/transform-text-to-ui-message-stream.ts
+function transformTextToUiMessageStream({
+  stream
 }) {
-  const textPart = { type: "text", text: "" };
-  const resultMessage = {
-    id: generateId3(),
-    role: "assistant",
-    parts: [textPart]
-  };
-  await processTextStream({
-    stream,
-    onTextPart: (chunk) => {
-      textPart.text += chunk;
-      update({ message: { ...resultMessage } });
-    }
-  });
-  onFinish == null ? void 0 : onFinish({ message: resultMessage });
+  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/call-chat-api.ts
 var getOriginalFetch = () => fetch;
-async function callChatApi({
+async function fetchUIMessageStream({
   api,
   body,
   streamProtocol = "ui-message",
   credentials,
   headers,
   abortController,
-  onUpdate,
-  onFinish,
-  onToolCall,
-  generateId: generateId3,
   fetch: fetch2 = getOriginalFetch(),
-  lastMessage,
-  requestType = "generate",
-  messageMetadataSchema
+  requestType = "generate"
 }) {
   var _a17, _b, _c;
   const response = requestType === "resume" ? await fetch2(`${api}?chatId=${body.id}`, {
@@ -1299,177 +1283,674 @@ async function callChatApi({
   if (!response.body) {
     throw new Error("The response body is empty.");
   }
-  switch (streamProtocol) {
-    case "text": {
-      await processChatTextResponse({
-        stream: response.body,
-        update: onUpdate,
-        onFinish,
-        generateId: generateId3
-      });
-      return;
+  return streamProtocol === "text" ? transformTextToUiMessageStream({
+    stream: response.body.pipeThrough(new TextDecoderStream())
+  }) : 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 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;
     }
-    case "ui-message": {
+  });
+  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,
+    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/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/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;
+  }
+  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,
+    messageMetadataSchema,
+    transport,
+    maxSteps: maxSteps2 = 1
+  }) {
+    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.maxSteps = maxSteps2;
+    this.transport = transport;
+    this.subscribers = /* @__PURE__ */ new Set();
+    this.generateId = generateId3 != null ? generateId3 : generateIdFunc;
+    this.messageMetadataSchema = messageMetadataSchema;
+  }
+  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;
+  }
+  setStatus({
+    id,
+    status,
+    error
+  }) {
+    const chat = this.getChat(id);
+    if (chat.status === status)
+      return;
+    chat.status = status;
+    chat.error = error;
+    this.emit({ type: "chat-status-changed", chatId: id, error });
+  }
+  getError(id) {
+    return this.getChat(id).error;
+  }
+  getMessages(id) {
+    return this.getChat(id).messages;
+  }
+  getLastMessage(id) {
+    const chat = this.getChat(id);
+    return chat.messages[chat.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;
+    }
+  }
+  emit(event) {
+    for (const subscriber of this.subscribers) {
+      subscriber.onChatChanged(event);
+    }
+  }
+  getChat(id) {
+    if (!this.hasChat(id)) {
+      throw new Error(`chat '${id}' not found`);
+    }
+    return this.chats.get(id);
+  }
+  async triggerRequest({
+    chatId,
+    messages: chatMessages,
+    requestType,
+    headers,
+    body,
+    onError,
+    onToolCall,
+    onFinish
+  }) {
+    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])
+    );
+    try {
+      const activeResponse = {
+        state: createStreamingUIMessageState({
+          lastMessage: chatMessages[chatMessages.length - 1],
+          newMessageId: self.generateId()
+        }),
+        abortController: new AbortController()
+      };
+      chat.activeResponse = activeResponse;
+      const stream = await self.transport.submitMessages({
+        chatId,
+        messages: chatMessages,
+        body,
+        headers,
+        abortController: activeResponse.abortController,
+        requestType
+      });
+      const runUpdateMessageJob = (job) => (
+        // serialize the job execution to avoid race conditions:
+        chat.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
+              });
+            }
+          })
+        )
+      );
       await consumeStream({
         stream: processUIMessageStream({
-          stream: parseJsonEventStream({
-            stream: response.body,
-            schema: uiMessageStreamPartSchema
-          }).pipeThrough(
-            new TransformStream({
-              async transform(part, controller) {
-                if (!part.success) {
-                  throw part.error;
-                }
-                controller.enqueue(part.value);
-              }
-            })
-          ),
-          onUpdate({ message }) {
-            const copiedMessage = {
-              // deep copy the message to ensure that deep changes (msg attachments) are updated
-              // with SolidJS. SolidJS uses referential integration of sub-objects to detect changes.
-              ...structuredClone(message),
-              // add a revision id to ensure that the message is updated with SWR. SWR uses a
-              // hashing approach by default to detect changes, but it only works for shallow
-              // changes. This is why we need to add a revision id to ensure that the message
-              // is updated with SWR (without it, the changes get stuck in SWR and are not
-              // forwarded to rendering):
-              revisionId: generateId3()
-            };
-            onUpdate({ message: copiedMessage });
-          },
-          lastMessage,
+          stream,
           onToolCall,
-          onFinish,
-          newMessageId: generateId3(),
-          messageMetadataSchema
+          messageMetadataSchema: self.messageMetadataSchema,
+          runUpdateMessageJob
         }),
         onError: (error) => {
           throw error;
         }
       });
-      return;
-    }
-    default: {
-      const exhaustiveCheck = streamProtocol;
-      throw new Error(`Unknown stream protocol: ${exhaustiveCheck}`);
+      onFinish == null ? void 0 : onFinish({ message: activeResponse.state.message });
+      this.setStatus({ id: chatId, status: "ready" });
+    } catch (err) {
+      if (err.name === "AbortError") {
+        this.setStatus({ id: chatId, status: "ready" });
+        return null;
+      }
+      if (onError && err instanceof Error) {
+        onError(err);
+      }
+      this.setStatus({ id: chatId, status: "error", error: err });
+    } finally {
+      chat.activeResponse = void 0;
+    }
+    const currentMessages = self.getMessages(chatId);
+    if (shouldResubmitMessages({
+      originalMaxToolInvocationStep: maxStep,
+      originalMessageCount: messageCount,
+      maxSteps: self.maxSteps,
+      messages: currentMessages
+    })) {
+      await self.triggerRequest({
+        chatId,
+        requestType,
+        onError,
+        onToolCall,
+        onFinish,
+        headers,
+        body,
+        messages: currentMessages
+      });
     }
   }
-}
+};
 
-// src/ui/call-completion-api.ts
-import { parseJsonEventStream as parseJsonEventStream2 } from "@ai-sdk/provider-utils";
-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,
+// 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: {
-        "Content-Type": "application/json",
+        ...this.headers,
         ...headers
       },
-      signal: abortController.signal
-    }).catch((err) => {
-      throw err;
+      body: (_b = (_a17 = this.prepareRequestBody) == null ? void 0 : _a17.call(this, {
+        id: chatId,
+        // TODO change to chatId
+        messages,
+        ...this.body,
+        ...body
+      })) != null ? _b : {
+        id: chatId,
+        // TODO change to chatId
+        messages,
+        ...this.body,
+        ...body
+      },
+      streamProtocol: this.streamProtocol,
+      credentials: this.credentials,
+      abortController: () => abortController,
+      fetch: this.fetch,
+      requestType
     });
-    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 { type, value } = part.value;
-                if (type === "text") {
-                  result += value;
-                  setCompletion(result);
-                } else if (type === "error") {
-                  throw new Error(value);
-                }
-              }
-            })
-          ),
-          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/convert-file-list-to-file-ui-parts.ts
 async function convertFileListToFileUIParts(files) {
@@ -1657,53 +2138,38 @@ function convertToModelMessages(messages, options) {
 }
 var convertToCoreMessages = convertToModelMessages;
 
-// 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
+// src/ui/default-chat-store.ts
+import {
+  generateId as generateIdFunc2
+} from "@ai-sdk/provider-utils";
+function defaultChatStore({
+  api,
+  fetch: fetch2,
+  streamProtocol = "ui-message",
+  credentials,
+  headers,
+  body,
+  prepareRequestBody,
+  generateId: generateId3 = generateIdFunc2,
+  messageMetadataSchema,
+  maxSteps: maxSteps2 = 1,
+  chats
 }) {
-  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
-  };
+  return new ChatStore({
+    transport: new DefaultChatTransport({
+      api,
+      fetch: fetch2,
+      streamProtocol,
+      credentials,
+      headers,
+      body,
+      prepareRequestBody
+    }),
+    generateId: generateId3,
+    messageMetadataSchema,
+    maxSteps: maxSteps2,
+    chats
+  });
 }
 
 // src/ui-message-stream/create-ui-message-stream.ts
@@ -1741,7 +2207,7 @@ function createUIMessageStream({
               safeEnqueue(value);
             }
           })().catch((error) => {
-            safeEnqueue({ type: "error", value: onError(error) });
+            safeEnqueue({ type: "error", errorText: onError(error) });
           })
         );
       },
@@ -1750,12 +2216,12 @@ function createUIMessageStream({
     if (result) {
       ongoingStreamPromises.push(
         result.catch((error) => {
-          safeEnqueue({ type: "error", value: onError(error) });
+          safeEnqueue({ type: "error", errorText: onError(error) });
         })
       );
     }
   } catch (error) {
-    safeEnqueue({ type: "error", value: onError(error) });
+    safeEnqueue({ type: "error", errorText: onError(error) });
   }
   const waitForStreams = new Promise(async (resolve) => {
     while (ongoingStreamPromises.length > 0) {
@@ -3411,7 +3877,7 @@ async function standardizePrompt(prompt) {
   if (!validationResult.success) {
     throw new InvalidPromptError2({
       prompt,
-      message: "messages must be an array of ModelMessage",
+      message: "The messages must be a ModelMessage[]. If you have passed a UIMessage[], you can use convertToModelMessages to convert them.",
       cause: validationResult.error
     });
   }
@@ -5056,6 +5522,19 @@ var DefaultStepResult = class {
   }
 };
 
+// core/generate-text/stop-condition.ts
+function maxSteps(maxSteps2) {
+  return ({ steps }) => steps.length >= maxSteps2;
+}
+function hasToolCall(toolName) {
+  return ({ steps }) => {
+    var _a17, _b, _c;
+    return (_c = (_b = (_a17 = steps[steps.length - 1]) == null ? void 0 : _a17.toolCalls) == null ? void 0 : _b.some(
+      (toolCall) => toolCall.toolName === toolName
+    )) != null ? _c : false;
+  };
+}
+
 // core/generate-text/to-response-messages.ts
 function toResponseMessages({
   content: inputContent,
@@ -5129,7 +5608,7 @@ async function generateText({
   maxRetries: maxRetriesArg,
   abortSignal,
   headers,
-  maxSteps = 1,
+  continueUntil = maxSteps(1),
   experimental_output: output,
   experimental_telemetry: telemetry,
   providerOptions,
@@ -5143,13 +5622,6 @@ async function generateText({
   onStepFinish,
   ...settings
 }) {
-  if (maxSteps < 1) {
-    throw new InvalidArgumentError({
-      parameter: "maxSteps",
-      value: maxSteps,
-      message: "maxSteps must be at least 1"
-    });
-  }
   const { maxRetries, retry } = prepareRetries({ maxRetries: maxRetriesArg });
   const callSettings = prepareCallSettings(settings);
   const baseTelemetryAttributes = getBaseTelemetryAttributes({
@@ -5180,8 +5652,7 @@ async function generateText({
         // specific settings that only make sense on the outer level:
         "ai.prompt": {
           input: () => JSON.stringify({ system, prompt, messages })
-        },
-        "ai.settings.maxSteps": maxSteps
+        }
       }
     }),
     tracer,
@@ -5191,7 +5662,6 @@ async function generateText({
       let currentModelResponse;
       let currentToolCalls = [];
       let currentToolResults = [];
-      let stepCount = 0;
       const responseMessages = [];
       const steps = [];
       do {
@@ -5202,8 +5672,7 @@ async function generateText({
         const prepareStepResult = await (prepareStep == null ? void 0 : prepareStep({
           model,
           steps,
-          maxSteps,
-          stepNumber: stepCount
+          stepNumber: steps.length
         }));
         const promptMessages = await convertToLanguageModelPrompt({
           prompt: {
@@ -5358,9 +5827,12 @@ async function generateText({
         });
         steps.push(currentStepResult);
         await (onStepFinish == null ? void 0 : onStepFinish(currentStepResult));
-      } while (++stepCount < maxSteps && // there are tool calls:
-      currentToolCalls.length > 0 && // all current tool calls have results:
-      currentToolResults.length === currentToolCalls.length);
+      } 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,
@@ -5924,7 +6396,7 @@ function streamText({
   maxRetries,
   abortSignal,
   headers,
-  maxSteps = 1,
+  maxSteps: maxSteps2 = 1,
   experimental_output: output,
   experimental_telemetry: telemetry,
   providerOptions,
@@ -5960,7 +6432,7 @@ function streamText({
     transforms: asArray(transform),
     activeTools,
     repairToolCall,
-    maxSteps,
+    maxSteps: maxSteps2,
     output,
     providerOptions,
     onChunk,
@@ -6037,7 +6509,7 @@ var DefaultStreamTextResult = class {
     transforms,
     activeTools,
     repairToolCall,
-    maxSteps,
+    maxSteps: maxSteps2,
     output,
     providerOptions,
     now: now2,
@@ -6051,10 +6523,10 @@ var DefaultStreamTextResult = class {
     this.totalUsagePromise = new DelayedPromise();
     this.finishReasonPromise = new DelayedPromise();
     this.stepsPromise = new DelayedPromise();
-    if (maxSteps < 1) {
+    if (maxSteps2 < 1) {
       throw new InvalidArgumentError({
         parameter: "maxSteps",
-        value: maxSteps,
+        value: maxSteps2,
         message: "maxSteps must be at least 1"
       });
     }
@@ -6211,6 +6683,13 @@ var DefaultStreamTextResult = class {
     this.addStream = stitchableStream.addStream;
     this.closeStream = stitchableStream.close;
     let stream = stitchableStream.stream;
+    stream = stream.pipeThrough(
+      new TransformStream({
+        start(controller) {
+          controller.enqueue({ type: "start" });
+        }
+      })
+    );
     for (const transform of transforms) {
       stream = stream.pipeThrough(
         transform({
@@ -6245,7 +6724,7 @@ var DefaultStreamTextResult = class {
           "ai.prompt": {
             input: () => JSON.stringify({ system, prompt, messages })
           },
-          "ai.settings.maxSteps": maxSteps
+          "ai.settings.maxSteps": maxSteps2
         }
       }),
       tracer,
@@ -6383,7 +6862,6 @@ var DefaultStreamTextResult = class {
                   var _a17, _b, _c, _d;
                   if (chunk.type === "stream-start") {
                     warnings = chunk.warnings;
-                    controller.enqueue({ type: "start" });
                     return;
                   }
                   if (stepFirstChunk) {
@@ -6533,7 +7011,7 @@ var DefaultStreamTextResult = class {
                     }
                   });
                   const combinedUsage = addLanguageModelUsage(usage, stepUsage);
-                  if (currentStep + 1 < maxSteps && // there are tool calls:
+                  if (currentStep + 1 < maxSteps2 && // there are tool calls:
                   stepToolCalls.length > 0 && // all current tool calls have results:
                   stepToolResults.length === stepToolCalls.length) {
                     responseMessages.push(
@@ -6718,125 +7196,122 @@ var DefaultStreamTextResult = class {
           const partType = part.type;
           switch (partType) {
             case "text": {
-              controller.enqueue({ type: "text", value: part.text });
+              controller.enqueue({
+                type: "text",
+                text: part.text
+              });
               break;
             }
             case "reasoning": {
               if (sendReasoning) {
-                controller.enqueue({ type: "reasoning", value: part });
+                controller.enqueue({
+                  type: "reasoning",
+                  text: part.text,
+                  providerMetadata: part.providerMetadata
+                });
               }
               break;
             }
             case "reasoning-part-finish": {
               if (sendReasoning) {
-                controller.enqueue({
-                  type: "reasoning-part-finish",
-                  value: null
-                });
+                controller.enqueue({ type: "reasoning-part-finish" });
               }
               break;
             }
             case "file": {
               controller.enqueue({
                 type: "file",
-                value: {
-                  mediaType: part.file.mediaType,
-                  url: `data:${part.file.mediaType};base64,${part.file.base64}`
-                }
+                mediaType: part.file.mediaType,
+                url: `data:${part.file.mediaType};base64,${part.file.base64}`
               });
               break;
             }
             case "source": {
               if (sendSources) {
-                controller.enqueue({ type: "source", value: part });
+                controller.enqueue({
+                  type: "source",
+                  sourceType: part.sourceType,
+                  id: part.id,
+                  url: part.url,
+                  title: part.title,
+                  providerMetadata: part.providerMetadata
+                });
               }
               break;
             }
             case "tool-call-streaming-start": {
               controller.enqueue({
                 type: "tool-call-streaming-start",
-                value: {
-                  toolCallId: part.toolCallId,
-                  toolName: part.toolName
-                }
+                toolCallId: part.toolCallId,
+                toolName: part.toolName
               });
               break;
             }
             case "tool-call-delta": {
               controller.enqueue({
                 type: "tool-call-delta",
-                value: {
-                  toolCallId: part.toolCallId,
-                  argsTextDelta: part.argsTextDelta
-                }
+                toolCallId: part.toolCallId,
+                argsTextDelta: part.argsTextDelta
               });
               break;
             }
             case "tool-call": {
               controller.enqueue({
                 type: "tool-call",
-                value: {
-                  toolCallId: part.toolCallId,
-                  toolName: part.toolName,
-                  args: part.args
-                }
+                toolCallId: part.toolCallId,
+                toolName: part.toolName,
+                args: part.args
               });
               break;
             }
             case "tool-result": {
               controller.enqueue({
                 type: "tool-result",
-                value: {
-                  toolCallId: part.toolCallId,
-                  result: part.result
-                }
+                toolCallId: part.toolCallId,
+                result: part.result
               });
               break;
             }
             case "error": {
               controller.enqueue({
                 type: "error",
-                value: onError(part.error)
+                errorText: onError(part.error)
               });
               break;
             }
             case "start-step": {
+              const metadata = messageMetadata == null ? void 0 : messageMetadata({ part });
               controller.enqueue({
                 type: "start-step",
-                value: {
-                  metadata: messageMetadata == null ? void 0 : messageMetadata({ part })
-                }
+                metadata
               });
               break;
             }
             case "finish-step": {
+              const metadata = messageMetadata == null ? void 0 : messageMetadata({ part });
               controller.enqueue({
                 type: "finish-step",
-                value: {
-                  metadata: messageMetadata == null ? void 0 : messageMetadata({ part })
-                }
+                metadata
               });
               break;
             }
             case "start": {
               if (experimental_sendStart) {
+                const metadata = messageMetadata == null ? void 0 : messageMetadata({ part });
                 controller.enqueue({
                   type: "start",
-                  value: {
-                    messageId,
-                    metadata: messageMetadata == null ? void 0 : messageMetadata({ part })
-                  }
+                  messageId,
+                  metadata
                 });
               }
               break;
             }
             case "finish": {
               if (experimental_sendFinish) {
+                const metadata = messageMetadata == null ? void 0 : messageMetadata({ part });
                 controller.enqueue({
                   type: "finish",
-                  value: {
-                    metadata: messageMetadata == null ? void 0 : messageMetadata({ part })
-                  }
+                  metadata
                 });
               }
               break;
@@ -6849,22 +7324,38 @@ var DefaultStreamTextResult = class {
         }
       })
     );
-    return onFinish == null ? baseStream : processUIMessageStream({
-      stream: baseStream,
+    if (onFinish == null) {
+      return baseStream;
+    }
+    const state = createStreamingUIMessageState({
       lastMessage,
-      newMessageId: messageId != null ? messageId : this.generateId(),
-      onFinish: ({ message }) => {
-        const isContinuation2 = message.id === (lastMessage == null ? void 0 : lastMessage.id);
-        onFinish({
-          isContinuation: isContinuation2,
-          responseMessage: message,
-          messages: [
-            ...isContinuation2 ? originalMessages.slice(0, -1) : originalMessages,
-            message
-          ]
-        });
-      }
+      newMessageId: messageId != null ? messageId : this.generateId()
     });
+    const runUpdateMessageJob = async (job) => {
+      await job({ state, write: () => {
+      } });
+    };
+    return processUIMessageStream({
+      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
+            ]
+          });
+        }
+      })
+    );
   }
   pipeUIMessageStreamToResponse(response, {
     newMessageId,
@@ -7944,6 +8435,8 @@ var DefaultTranscriptionResult = class {
 export {
   AISDKError16 as AISDKError,
   APICallError,
+  ChatStore,
+  DefaultChatTransport,
   DownloadError,
   EmptyResponseBodyError,
   InvalidArgumentError,
@@ -7991,6 +8484,7 @@ export {
   createUIMessageStream,
   createUIMessageStreamResponse,
   customProvider,
+  defaultChatStore,
   defaultSettingsMiddleware,
   embed,
   embedMany,
@@ -8007,14 +8501,15 @@ export {
   generateText,
   getTextFromDataUrl,
   getToolInvocations,
+  hasToolCall,
   isAssistantMessageWithCompletedToolCalls,
   isDeepEqualData,
   jsonSchema2 as jsonSchema,
+  maxSteps,
   modelMessageSchema,
   parsePartialJson,
   pipeTextStreamToResponse,
   pipeUIMessageStreamToResponse,
-  processTextStream,
   shouldResubmitMessages,
   simulateReadableStream,
   simulateStreamingMiddleware,