ai 5.0.0-canary.21 → 5.0.0-canary.23

package/dist/index.js

@@ -22,6 +22,8 @@ var src_exports = {};
 __export(src_exports, {
   AISDKError: () => import_provider16.AISDKError,
   APICallError: () => import_provider16.APICallError,
+  ChatStore: () => ChatStore,
+  DefaultChatTransport: () => DefaultChatTransport,
   DownloadError: () => DownloadError,
   EmptyResponseBodyError: () => import_provider16.EmptyResponseBodyError,
   InvalidArgumentError: () => InvalidArgumentError,
@@ -50,7 +52,7 @@ __export(src_exports, {
   TypeValidationError: () => import_provider16.TypeValidationError,
   UnsupportedFunctionalityError: () => import_provider16.UnsupportedFunctionalityError,
   appendClientMessage: () => appendClientMessage,
-  asSchema: () => import_provider_utils25.asSchema,
+  asSchema: () => import_provider_utils26.asSchema,
   assistantModelMessageSchema: () => assistantModelMessageSchema,
   callChatApi: () => callChatApi,
   callCompletionApi: () => callCompletionApi,
@@ -63,12 +65,13 @@ __export(src_exports, {
   coreToolMessageSchema: () => coreToolMessageSchema,
   coreUserMessageSchema: () => coreUserMessageSchema,
   cosineSimilarity: () => cosineSimilarity,
-  createDataStream: () => createDataStream,
-  createDataStreamResponse: () => createDataStreamResponse,
-  createIdGenerator: () => import_provider_utils25.createIdGenerator,
+  createIdGenerator: () => import_provider_utils26.createIdGenerator,
   createProviderRegistry: () => createProviderRegistry,
   createTextStreamResponse: () => createTextStreamResponse,
+  createUIMessageStream: () => createUIMessageStream,
+  createUIMessageStreamResponse: () => createUIMessageStreamResponse,
   customProvider: () => customProvider,
+  defaultChatStore: () => defaultChatStore,
   defaultSettingsMiddleware: () => defaultSettingsMiddleware,
   embed: () => embed,
   embedMany: () => embedMany,
@@ -80,19 +83,18 @@ __export(src_exports, {
   experimental_transcribe: () => transcribe,
   extractMaxToolInvocationStep: () => extractMaxToolInvocationStep,
   extractReasoningMiddleware: () => extractReasoningMiddleware,
-  generateId: () => import_provider_utils25.generateId,
+  generateId: () => import_provider_utils26.generateId,
   generateObject: () => generateObject,
   generateText: () => generateText,
   getTextFromDataUrl: () => getTextFromDataUrl,
   getToolInvocations: () => getToolInvocations,
   isAssistantMessageWithCompletedToolCalls: () => isAssistantMessageWithCompletedToolCalls,
   isDeepEqualData: () => isDeepEqualData,
-  jsonSchema: () => import_provider_utils25.jsonSchema,
+  jsonSchema: () => import_provider_utils26.jsonSchema,
   modelMessageSchema: () => modelMessageSchema,
   parsePartialJson: () => parsePartialJson,
-  pipeDataStreamToResponse: () => pipeDataStreamToResponse,
   pipeTextStreamToResponse: () => pipeTextStreamToResponse,
-  processTextStream: () => processTextStream,
+  pipeUIMessageStreamToResponse: () => pipeUIMessageStreamToResponse,
   shouldResubmitMessages: () => shouldResubmitMessages,
   simulateReadableStream: () => simulateReadableStream,
   simulateStreamingMiddleware: () => simulateStreamingMiddleware,
@@ -107,173 +109,7 @@ __export(src_exports, {
   wrapLanguageModel: () => wrapLanguageModel
 });
 module.exports = __toCommonJS(src_exports);
-var import_provider_utils25 = require("@ai-sdk/provider-utils");
-
-// src/data-stream/create-data-stream.ts
-function createDataStream({
-  execute,
-  onError = () => "An error occurred."
-  // mask error messages for safety by default
-}) {
-  let controller;
-  const ongoingStreamPromises = [];
-  const stream = new ReadableStream({
-    start(controllerArg) {
-      controller = controllerArg;
-    }
-  });
-  function safeEnqueue(data) {
-    try {
-      controller.enqueue(data);
-    } catch (error) {
-    }
-  }
-  try {
-    const result = execute({
-      write(part) {
-        safeEnqueue(part);
-      },
-      merge(streamArg) {
-        ongoingStreamPromises.push(
-          (async () => {
-            const reader = streamArg.getReader();
-            while (true) {
-              const { done, value } = await reader.read();
-              if (done)
-                break;
-              safeEnqueue(value);
-            }
-          })().catch((error) => {
-            safeEnqueue({ type: "error", value: onError(error) });
-          })
-        );
-      },
-      onError
-    });
-    if (result) {
-      ongoingStreamPromises.push(
-        result.catch((error) => {
-          safeEnqueue({ type: "error", value: onError(error) });
-        })
-      );
-    }
-  } catch (error) {
-    safeEnqueue({ type: "error", value: onError(error) });
-  }
-  const waitForStreams = new Promise(async (resolve) => {
-    while (ongoingStreamPromises.length > 0) {
-      await ongoingStreamPromises.shift();
-    }
-    resolve();
-  });
-  waitForStreams.finally(() => {
-    try {
-      controller.close();
-    } catch (error) {
-    }
-  });
-  return stream;
-}
-
-// src/util/prepare-headers.ts
-function prepareHeaders(headers, defaultHeaders) {
-  const responseHeaders = new Headers(headers != null ? headers : {});
-  for (const [key, value] of Object.entries(defaultHeaders)) {
-    if (!responseHeaders.has(key)) {
-      responseHeaders.set(key, value);
-    }
-  }
-  return responseHeaders;
-}
-
-// src/data-stream/data-stream-headers.ts
-var dataStreamHeaders = {
-  "content-type": "text/event-stream",
-  "cache-control": "no-cache",
-  connection: "keep-alive",
-  "x-vercel-ai-data-stream": "v2",
-  "x-accel-buffering": "no"
-  // disable nginx buffering
-};
-
-// src/data-stream/json-to-sse-transform-stream.ts
-var JsonToSseTransformStream = class extends TransformStream {
-  constructor() {
-    super({
-      transform(part, controller) {
-        controller.enqueue(`data: ${JSON.stringify(part)}
-
-`);
-      },
-      flush(controller) {
-        controller.enqueue("data: [DONE]\n\n");
-      }
-    });
-  }
-};
-
-// src/data-stream/create-data-stream-response.ts
-function createDataStreamResponse({
-  status,
-  statusText,
-  headers,
-  dataStream
-}) {
-  return new Response(
-    dataStream.pipeThrough(new JsonToSseTransformStream()).pipeThrough(new TextEncoderStream()),
-    {
-      status,
-      statusText,
-      headers: prepareHeaders(headers, dataStreamHeaders)
-    }
-  );
-}
-
-// src/util/write-to-server-response.ts
-function writeToServerResponse({
-  response,
-  status,
-  statusText,
-  headers,
-  stream
-}) {
-  response.writeHead(status != null ? status : 200, statusText, headers);
-  const reader = stream.getReader();
-  const read = async () => {
-    try {
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done)
-          break;
-        response.write(value);
-      }
-    } catch (error) {
-      throw error;
-    } finally {
-      response.end();
-    }
-  };
-  read();
-}
-
-// src/data-stream/pipe-data-stream-to-response.ts
-function pipeDataStreamToResponse({
-  response,
-  status,
-  statusText,
-  headers,
-  dataStream
-}) {
-  writeToServerResponse({
-    response,
-    status,
-    statusText,
-    headers: Object.fromEntries(
-      prepareHeaders(headers, dataStreamHeaders).entries()
-    ),
-    stream: dataStream.pipeThrough(new JsonToSseTransformStream()).pipeThrough(new TextEncoderStream())
-  });
-}
+var import_provider_utils26 = require("@ai-sdk/provider-utils");
 
 // src/error/index.ts
 var import_provider16 = require("@ai-sdk/provider");
@@ -625,6 +461,17 @@ var RetryError = class extends import_provider15.AISDKError {
 };
 _a15 = symbol15;
 
+// src/util/prepare-headers.ts
+function prepareHeaders(headers, defaultHeaders) {
+  const responseHeaders = new Headers(headers != null ? headers : {});
+  for (const [key, value] of Object.entries(defaultHeaders)) {
+    if (!responseHeaders.has(key)) {
+      responseHeaders.set(key, value);
+    }
+  }
+  return responseHeaders;
+}
+
 // src/text-stream/create-text-stream-response.ts
 function createTextStreamResponse({
   status,
@@ -641,6 +488,33 @@ function createTextStreamResponse({
   });
 }
 
+// src/util/write-to-server-response.ts
+function writeToServerResponse({
+  response,
+  status,
+  statusText,
+  headers,
+  stream
+}) {
+  response.writeHead(status != null ? status : 200, statusText, headers);
+  const reader = stream.getReader();
+  const read = async () => {
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+          break;
+        response.write(value);
+      }
+    } catch (error) {
+      throw error;
+    } finally {
+      response.end();
+    }
+  };
+  read();
+}
+
 // src/text-stream/pipe-text-stream-to-response.ts
 function pipeTextStreamToResponse({
   response,
@@ -674,9 +548,9 @@ function appendClientMessage({
 }
 
 // src/ui/call-chat-api.ts
-var import_provider_utils4 = require("@ai-sdk/provider-utils");
+var import_provider_utils3 = require("@ai-sdk/provider-utils");
 
-// src/data-stream/data-stream-parts.ts
+// src/ui-message-stream/ui-message-stream-parts.ts
 var import_zod = require("zod");
 var toolCallSchema = import_zod.z.object({
   toolCallId: import_zod.z.string(),
@@ -697,7 +571,7 @@ var sourceSchema = import_zod.z.object({
   providerMetadata: import_zod.z.any().optional()
   // Use z.any() for generic metadata
 });
-var dataStreamPartSchema = import_zod.z.discriminatedUnion("type", [
+var uiMessageStreamPartSchema = import_zod.z.discriminatedUnion("type", [
   import_zod.z.object({
     type: import_zod.z.literal("text"),
     value: import_zod.z.string()
@@ -796,7 +670,7 @@ async function consumeStream({
   }
 }
 
-// src/ui/process-chat-response.ts
+// src/ui/process-ui-message-stream.ts
 var import_provider_utils2 = require("@ai-sdk/provider-utils");
 
 // src/util/merge-objects.ts
@@ -1184,305 +1058,283 @@ function getToolInvocations(message) {
   ).map((part) => part.toolInvocation);
 }
 
-// src/ui/process-chat-response.ts
-function processChatResponse({
-  stream,
-  onUpdate,
-  onToolCall,
-  onFinish,
+// src/ui/process-ui-message-stream.ts
+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 (0, import_provider_utils2.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);
-            } else {
-              currentTextPart.text += value;
-            }
-            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);
+        await runUpdateMessageJob(async ({ state, write }) => {
+          function updateToolInvocationPart(toolCallId, invocation) {
+            const part = state.message.parts.find(
+              (part2) => part2.type === "tool-invocation" && part2.toolInvocation.toolCallId === toolCallId
+            );
+            if (part != null) {
+              part.toolInvocation = invocation;
             } else {
-              currentReasoningPart.text += value.text;
-              currentReasoningPart.providerMetadata = value.providerMetadata;
-            }
-            onUpdate == null ? void 0 : onUpdate({ message });
-            break;
-          }
-          case "reasoning-part-finish": {
-            if (currentReasoningPart != null) {
-              currentReasoningPart = void 0;
+              state.message.parts.push({
+                type: "tool-invocation",
+                toolInvocation: invocation
+              });
             }
-            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
-              });
-              if (result != null) {
-                updateToolInvocationPart(value.toolCallId, {
-                  state: "result",
-                  step,
-                  ...call,
-                  result
+          async function updateMessageMetadata(metadata) {
+            if (metadata != null) {
+              const mergedMetadata = state.message.metadata != null ? mergeObjects(state.message.metadata, metadata) : metadata;
+              if (messageMetadataSchema != null) {
+                await (0, import_provider_utils2.validateTypes)({
+                  value: mergedMetadata,
+                  schema: messageMetadataSchema
                 });
-                onUpdate == null ? void 0 : onUpdate({ message });
               }
+              state.message.metadata = mergedMetadata;
             }
-            break;
           }
-          case "tool-result": {
-            const toolInvocations = getToolInvocations(message);
-            if (toolInvocations == null) {
-              throw new Error("tool_result must be preceded by a tool_call");
+          const { type, value } = chunk;
+          switch (type) {
+            case "text": {
+              if (state.activeTextPart == null) {
+                state.activeTextPart = {
+                  type: "text",
+                  text: value
+                };
+                state.message.parts.push(state.activeTextPart);
+              } else {
+                state.activeTextPart.text += value;
+              }
+              write();
+              break;
             }
-            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 "reasoning": {
+              if (state.activeReasoningPart == null) {
+                state.activeReasoningPart = {
+                  type: "reasoning",
+                  text: value.text,
+                  providerMetadata: value.providerMetadata
+                };
+                state.message.parts.push(state.activeReasoningPart);
+              } else {
+                state.activeReasoningPart.text += value.text;
+                state.activeReasoningPart.providerMetadata = value.providerMetadata;
+              }
+              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 "reasoning-part-finish": {
+              if (state.activeReasoningPart != null) {
+                state.activeReasoningPart = void 0;
+              }
+              break;
             }
-            break;
-          }
-          case "start": {
-            if (value.messageId != null) {
-              message.id = value.messageId;
+            case "file": {
+              state.message.parts.push({
+                type: "file",
+                mediaType: value.mediaType,
+                url: value.url
+              });
+              write();
+              break;
             }
-            await updateMessageMetadata(value.metadata);
-            if (value.messageId != null || value.metadata != null) {
-              onUpdate == null ? void 0 : onUpdate({ message });
+            case "source": {
+              state.message.parts.push({
+                type: "source",
+                source: value
+              });
+              write();
+              break;
             }
-            break;
-          }
-          case "finish": {
-            await updateMessageMetadata(value.metadata);
-            if (value.metadata != null) {
-              onUpdate == null ? void 0 : onUpdate({ message });
+            case "tool-call-streaming-start": {
+              const toolInvocations = getToolInvocations(state.message);
+              state.partialToolCalls[value.toolCallId] = {
+                text: "",
+                step: state.step,
+                toolName: value.toolName,
+                index: toolInvocations.length
+              };
+              updateToolInvocationPart(value.toolCallId, {
+                state: "partial-call",
+                step: state.step,
+                toolCallId: value.toolCallId,
+                toolName: value.toolName,
+                args: void 0
+              });
+              write();
+              break;
             }
-            break;
-          }
-          case "metadata": {
-            await updateMessageMetadata(value.metadata);
-            if (value.metadata != null) {
-              onUpdate == null ? void 0 : onUpdate({ message });
+            case "tool-call-delta": {
+              const partialToolCall = state.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
+              });
+              write();
+              break;
+            }
+            case "tool-call": {
+              const call = { args: value.args, ...value };
+              updateToolInvocationPart(value.toolCallId, {
+                state: "call",
+                step: state.step,
+                ...call
+              });
+              write();
+              if (onToolCall) {
+                const result = await onToolCall({
+                  toolCall: call
+                });
+                if (result != null) {
+                  updateToolInvocationPart(value.toolCallId, {
+                    state: "result",
+                    step: state.step,
+                    ...call,
+                    result
+                  });
+                  write();
+                }
+              }
+              break;
+            }
+            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 === value.toolCallId
+              );
+              if (toolInvocationIndex === -1) {
+                throw new Error(
+                  "tool_result must be preceded by a tool_call with the same toolCallId"
+                );
+              }
+              const result = { result: value.result, ...value };
+              updateToolInvocationPart(value.toolCallId, {
+                ...toolInvocations[toolInvocationIndex],
+                state: "result",
+                ...result
+              });
+              write();
+              break;
+            }
+            case "start-step": {
+              state.message.parts.push({ type: "step-start" });
+              await updateMessageMetadata(value.metadata);
+              write();
+              break;
+            }
+            case "finish-step": {
+              state.step += 1;
+              state.activeTextPart = void 0;
+              state.activeReasoningPart = void 0;
+              await updateMessageMetadata(value.metadata);
+              if (value.metadata != null) {
+                write();
+              }
+              break;
+            }
+            case "start": {
+              if (value.messageId != null) {
+                state.message.id = value.messageId;
+              }
+              await updateMessageMetadata(value.metadata);
+              if (value.messageId != null || value.metadata != null) {
+                write();
+              }
+              break;
+            }
+            case "finish": {
+              await updateMessageMetadata(value.metadata);
+              if (value.metadata != null) {
+                write();
+              }
+              break;
+            }
+            case "metadata": {
+              await updateMessageMetadata(value.metadata);
+              if (value.metadata != null) {
+                write();
+              }
+              break;
+            }
+            case "error": {
+              throw new Error(value);
+            }
+            default: {
+              const _exhaustiveCheck = type;
+              throw new Error(`Unhandled stream part: ${_exhaustiveCheck}`);
             }
-            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(chunk);
+        });
       }
     })
   );
 }
 
-// src/ui/process-chat-text-response.ts
-var import_provider_utils3 = require("@ai-sdk/provider-utils");
-
-// src/ui/process-text-stream.ts
-async function processTextStream({
-  stream,
-  onTextPart
-}) {
-  const reader = stream.pipeThrough(new TextDecoderStream()).getReader();
-  while (true) {
-    const { done, value } = await reader.read();
-    if (done) {
-      break;
-    }
-    await onTextPart(value);
-  }
-}
-
-// src/ui/process-chat-text-response.ts
-async function processChatTextResponse({
-  stream,
-  update,
-  onFinish,
-  generateId: generateId3 = import_provider_utils3.generateId
+// 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", value: {} });
+        controller.enqueue({ type: "start-step", value: {} });
+      },
+      async transform(part, controller) {
+        controller.enqueue({ type: "text", value: part });
+      },
+      async flush(controller) {
+        controller.enqueue({ type: "finish-step", value: {} });
+        controller.enqueue({ type: "finish", value: {} });
+      }
+    })
+  );
 }
 
 // src/ui/call-chat-api.ts
 var getOriginalFetch = () => fetch;
-async function callChatApi({
+async function fetchUIMessageStream({
   api,
   body,
-  streamProtocol = "data",
+  streamProtocol = "ui-message",
   credentials,
   headers,
   abortController,
-  onResponse,
-  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}`, {
@@ -1503,9 +1355,6 @@ async function callChatApi({
     signal: (_b = abortController == null ? void 0 : abortController()) == null ? void 0 : _b.signal,
     credentials
   });
-  if (onResponse != null) {
-    await onResponse(response);
-  }
   if (!response.ok) {
     throw new Error(
       (_c = await response.text()) != null ? _c : "Failed to fetch the chat response."
@@ -1514,67 +1363,112 @@ 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;
-    }
-    case "data": {
-      await consumeStream({
-        stream: processChatResponse({
-          stream: (0, import_provider_utils4.parseJsonEventStream)({
-            stream: response.body,
-            schema: dataStreamPartSchema
-          }).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,
-          onToolCall,
-          onFinish,
-          newMessageId: generateId3(),
-          messageMetadataSchema
-        }),
-        onError: (error) => {
-          throw error;
+  return streamProtocol === "text" ? transformTextToUiMessageStream({
+    stream: response.body.pipeThrough(new TextDecoderStream())
+  }) : (0, import_provider_utils3.parseJsonEventStream)({
+    stream: response.body,
+    schema: uiMessageStreamPartSchema
+  }).pipeThrough(
+    new TransformStream({
+      async transform(part, controller) {
+        if (!part.success) {
+          throw part.error;
         }
-      });
-      return;
+        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;
     }
-    default: {
-      const exhaustiveCheck = streamProtocol;
-      throw new Error(`Unknown stream protocol: ${exhaustiveCheck}`);
+  });
+  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
+var import_provider_utils4 = require("@ai-sdk/provider-utils");
+
+// src/ui/process-text-stream.ts
+async function processTextStream({
+  stream,
+  onTextPart
+}) {
+  const reader = stream.pipeThrough(new TextDecoderStream()).getReader();
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) {
+      break;
     }
+    await onTextPart(value);
   }
 }
 
 // src/ui/call-completion-api.ts
-var import_provider_utils5 = require("@ai-sdk/provider-utils");
 var getOriginalFetch2 = () => fetch;
 async function callCompletionApi({
   api,
@@ -1587,7 +1481,6 @@ async function callCompletionApi({
   setLoading,
   setError,
   setAbortController,
-  onResponse,
   onFinish,
   onError,
   fetch: fetch2 = getOriginalFetch2()
@@ -1614,13 +1507,6 @@ async function callCompletionApi({
     }).catch((err) => {
       throw err;
     });
-    if (onResponse) {
-      try {
-        await onResponse(response);
-      } catch (err) {
-        throw err;
-      }
-    }
     if (!response.ok) {
       throw new Error(
         (_a17 = await response.text()) != null ? _a17 : "Failed to fetch the chat response."
@@ -1643,9 +1529,9 @@ async function callCompletionApi({
       }
       case "data": {
         await consumeStream({
-          stream: (0, import_provider_utils5.parseJsonEventStream)({
+          stream: (0, import_provider_utils4.parseJsonEventStream)({
             stream: response.body,
-            schema: dataStreamPartSchema
+            schema: uiMessageStreamPartSchema
           }).pipeThrough(
             new TransformStream({
               async transform(part) {
@@ -1672,27 +1558,484 @@ async function callCompletionApi({
         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) {
+    }
+    if (onFinish) {
+      onFinish(prompt, result);
+    }
+    setAbortController(null);
+    return result;
+  } catch (err) {
+    if (err.name === "AbortError") {
+      setAbortController(null);
+      return null;
+    }
+    if (err instanceof Error) {
+      if (onError) {
+        onError(err);
+      }
+    }
+    setError(err);
+  } finally {
+    setLoading(false);
+  }
+}
+
+// src/ui/chat-store.ts
+var import_provider_utils5 = require("@ai-sdk/provider-utils");
+
+// src/util/serial-job-executor.ts
+var SerialJobExecutor = class {
+  constructor() {
+    this.queue = [];
+    this.isProcessing = false;
+  }
+  async processQueue() {
+    if (this.isProcessing) {
+      return;
+    }
+    this.isProcessing = true;
+    while (this.queue.length > 0) {
+      await this.queue[0]();
+      this.queue.shift();
+    }
+    this.isProcessing = false;
+  }
+  async run(job) {
+    return new Promise((resolve, reject) => {
+      this.queue.push(async () => {
+        try {
+          await job();
+          resolve();
+        } catch (error) {
+          reject(error);
+        }
+      });
+      void this.processQueue();
+    });
+  }
+};
+
+// 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,
+    messageMetadataSchema,
+    transport,
+    maxSteps = 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 = maxSteps;
+    this.transport = transport;
+    this.subscribers = /* @__PURE__ */ new Set();
+    this.generateId = generateId3 != null ? generateId3 : import_provider_utils5.generateId;
+    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 });
+  }
+  appendMessage({
+    id,
+    message
+  }) {
+    const chat = this.getChat(id);
+    chat.messages = [...chat.messages, { ...message }];
+    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.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,
+          onToolCall,
+          messageMetadataSchema: self.messageMetadataSchema,
+          runUpdateMessageJob
+        }),
+        onError: (error) => {
+          throw error;
+        }
+      });
+      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
+      });
     }
-    setError(err);
-  } finally {
-    setLoading(false);
   }
-}
+};
+
+// src/ui/chat-transport.ts
+var DefaultChatTransport = class {
+  constructor({
+    api,
+    credentials,
+    headers,
+    body,
+    streamProtocol,
+    fetch: fetch2,
+    prepareRequestBody
+  }) {
+    this.api = api;
+    this.credentials = credentials;
+    this.headers = headers;
+    this.body = body;
+    this.streamProtocol = streamProtocol;
+    this.fetch = fetch2;
+    this.prepareRequestBody = prepareRequestBody;
+  }
+  submitMessages({
+    chatId,
+    messages,
+    abortController,
+    body,
+    headers,
+    requestType
+  }) {
+    var _a17, _b;
+    return fetchUIMessageStream({
+      api: this.api,
+      headers: {
+        ...this.headers,
+        ...headers
+      },
+      body: (_b = (_a17 = this.prepareRequestBody) == null ? void 0 : _a17.call(this, {
+        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
+    });
+  }
+};
 
 // src/ui/convert-file-list-to-file-ui-parts.ts
 async function convertFileListToFileUIParts(files) {
@@ -1880,53 +2223,164 @@ function convertToModelMessages(messages, options) {
 }
 var convertToCoreMessages = convertToModelMessages;
 
-// src/ui/should-resubmit-messages.ts
-function shouldResubmitMessages({
-  originalMaxToolInvocationStep,
-  originalMessageCount,
-  maxSteps,
-  messages
+// src/ui/default-chat-store.ts
+var import_provider_utils6 = require("@ai-sdk/provider-utils");
+function defaultChatStore({
+  api,
+  fetch: fetch2,
+  streamProtocol = "ui-message",
+  credentials,
+  headers,
+  body,
+  prepareRequestBody,
+  generateId: generateId3 = import_provider_utils6.generateId,
+  messageMetadataSchema,
+  maxSteps = 1,
+  chats
 }) {
-  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
-  );
+  return new ChatStore({
+    transport: new DefaultChatTransport({
+      api,
+      fetch: fetch2,
+      streamProtocol,
+      credentials,
+      headers,
+      body,
+      prepareRequestBody
+    }),
+    generateId: generateId3,
+    messageMetadataSchema,
+    maxSteps,
+    chats
+  });
 }
-function isAssistantMessageWithCompletedToolCalls(message) {
-  if (message.role !== "assistant") {
-    return false;
+
+// src/ui-message-stream/create-ui-message-stream.ts
+function createUIMessageStream({
+  execute,
+  onError = () => "An error occurred."
+  // mask error messages for safety by default
+}) {
+  let controller;
+  const ongoingStreamPromises = [];
+  const stream = new ReadableStream({
+    start(controllerArg) {
+      controller = controllerArg;
+    }
+  });
+  function safeEnqueue(data) {
+    try {
+      controller.enqueue(data);
+    } catch (error) {
+    }
   }
-  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);
+  try {
+    const result = execute({
+      write(part) {
+        safeEnqueue(part);
+      },
+      merge(streamArg) {
+        ongoingStreamPromises.push(
+          (async () => {
+            const reader = streamArg.getReader();
+            while (true) {
+              const { done, value } = await reader.read();
+              if (done)
+                break;
+              safeEnqueue(value);
+            }
+          })().catch((error) => {
+            safeEnqueue({ type: "error", value: onError(error) });
+          })
+        );
+      },
+      onError
+    });
+    if (result) {
+      ongoingStreamPromises.push(
+        result.catch((error) => {
+          safeEnqueue({ type: "error", value: onError(error) });
+        })
+      );
+    }
+  } catch (error) {
+    safeEnqueue({ type: "error", value: onError(error) });
+  }
+  const waitForStreams = new Promise(async (resolve) => {
+    while (ongoingStreamPromises.length > 0) {
+      await ongoingStreamPromises.shift();
+    }
+    resolve();
+  });
+  waitForStreams.finally(() => {
+    try {
+      controller.close();
+    } catch (error) {
+    }
+  });
+  return stream;
 }
 
-// src/ui/update-tool-call-result.ts
-function updateToolCallResult({
-  messages,
-  toolCallId,
-  toolResult: result
+// src/ui-message-stream/ui-message-stream-headers.ts
+var uiMessageStreamHeaders = {
+  "content-type": "text/event-stream",
+  "cache-control": "no-cache",
+  connection: "keep-alive",
+  "x-vercel-ai-ui-message-stream": "v1",
+  "x-accel-buffering": "no"
+  // disable nginx buffering
+};
+
+// src/ui-message-stream/json-to-sse-transform-stream.ts
+var JsonToSseTransformStream = class extends TransformStream {
+  constructor() {
+    super({
+      transform(part, controller) {
+        controller.enqueue(`data: ${JSON.stringify(part)}
+
+`);
+      },
+      flush(controller) {
+        controller.enqueue("data: [DONE]\n\n");
+      }
+    });
+  }
+};
+
+// src/ui-message-stream/create-ui-message-stream-response.ts
+function createUIMessageStreamResponse({
+  status,
+  statusText,
+  headers,
+  stream
 }) {
-  const lastMessage = messages[messages.length - 1];
-  const invocationPart = lastMessage.parts.find(
-    (part) => part.type === "tool-invocation" && part.toolInvocation.toolCallId === toolCallId
+  return new Response(
+    stream.pipeThrough(new JsonToSseTransformStream()).pipeThrough(new TextEncoderStream()),
+    {
+      status,
+      statusText,
+      headers: prepareHeaders(headers, uiMessageStreamHeaders)
+    }
   );
-  if (invocationPart == null) {
-    return;
-  }
-  invocationPart.toolInvocation = {
-    ...invocationPart.toolInvocation,
-    state: "result",
-    result
-  };
+}
+
+// src/ui-message-stream/pipe-ui-message-stream-to-response.ts
+function pipeUIMessageStreamToResponse({
+  response,
+  status,
+  statusText,
+  headers,
+  stream
+}) {
+  writeToServerResponse({
+    response,
+    status,
+    statusText,
+    headers: Object.fromEntries(
+      prepareHeaders(headers, uiMessageStreamHeaders).entries()
+    ),
+    stream: stream.pipeThrough(new JsonToSseTransformStream()).pipeThrough(new TextEncoderStream())
+  });
 }
 
 // src/util/data-url.ts
@@ -2005,7 +2459,7 @@ function cosineSimilarity(vector1, vector2) {
 }
 
 // src/util/simulate-readable-stream.ts
-var import_provider_utils6 = require("@ai-sdk/provider-utils");
+var import_provider_utils7 = require("@ai-sdk/provider-utils");
 function simulateReadableStream({
   chunks,
   initialDelayInMs = 0,
@@ -2013,7 +2467,7 @@ function simulateReadableStream({
   _internal
 }) {
   var _a17;
-  const delay2 = (_a17 = _internal == null ? void 0 : _internal.delay) != null ? _a17 : import_provider_utils6.delay;
+  const delay2 = (_a17 = _internal == null ? void 0 : _internal.delay) != null ? _a17 : import_provider_utils7.delay;
   let index = 0;
   return new ReadableStream({
     async pull(controller) {
@@ -2029,7 +2483,7 @@ function simulateReadableStream({
 
 // src/util/retry-with-exponential-backoff.ts
 var import_provider17 = require("@ai-sdk/provider");
-var import_provider_utils7 = require("@ai-sdk/provider-utils");
+var import_provider_utils8 = require("@ai-sdk/provider-utils");
 var retryWithExponentialBackoff = ({
   maxRetries = 2,
   initialDelayInMs = 2e3,
@@ -2047,13 +2501,13 @@ async function _retryWithExponentialBackoff(f, {
   try {
     return await f();
   } catch (error) {
-    if ((0, import_provider_utils7.isAbortError)(error)) {
+    if ((0, import_provider_utils8.isAbortError)(error)) {
       throw error;
     }
     if (maxRetries === 0) {
       throw error;
     }
-    const errorMessage = (0, import_provider_utils7.getErrorMessage)(error);
+    const errorMessage = (0, import_provider_utils8.getErrorMessage)(error);
     const newErrors = [...errors, error];
     const tryNumber = newErrors.length;
     if (tryNumber > maxRetries) {
@@ -2064,7 +2518,7 @@ async function _retryWithExponentialBackoff(f, {
       });
     }
     if (error instanceof Error && import_provider17.APICallError.isInstance(error) && error.isRetryable === true && tryNumber <= maxRetries) {
-      await (0, import_provider_utils7.delay)(delayInMs);
+      await (0, import_provider_utils8.delay)(delayInMs);
       return _retryWithExponentialBackoff(
         f,
         { maxRetries, delayInMs: backoffFactor * delayInMs, backoffFactor },
@@ -2623,7 +3077,7 @@ var DefaultEmbedManyResult = class {
 };
 
 // src/util/detect-media-type.ts
-var import_provider_utils8 = require("@ai-sdk/provider-utils");
+var import_provider_utils9 = require("@ai-sdk/provider-utils");
 var imageMediaTypeSignatures = [
   {
     mediaType: "image/gif",
@@ -2730,7 +3184,7 @@ var audioMediaTypeSignatures = [
   }
 ];
 var stripID3 = (data) => {
-  const bytes = typeof data === "string" ? (0, import_provider_utils8.convertBase64ToUint8Array)(data) : data;
+  const bytes = typeof data === "string" ? (0, import_provider_utils9.convertBase64ToUint8Array)(data) : data;
   const id3Size = (bytes[6] & 127) << 21 | (bytes[7] & 127) << 14 | (bytes[8] & 127) << 7 | bytes[9] & 127;
   return bytes.slice(id3Size + 10);
 };
@@ -2756,7 +3210,7 @@ function detectMediaType({
 }
 
 // core/generate-text/generated-file.ts
-var import_provider_utils9 = require("@ai-sdk/provider-utils");
+var import_provider_utils10 = require("@ai-sdk/provider-utils");
 var DefaultGeneratedFile = class {
   constructor({
     data,
@@ -2770,14 +3224,14 @@ var DefaultGeneratedFile = class {
   // lazy conversion with caching to avoid unnecessary conversion overhead:
   get base64() {
     if (this.base64Data == null) {
-      this.base64Data = (0, import_provider_utils9.convertUint8ArrayToBase64)(this.uint8ArrayData);
+      this.base64Data = (0, import_provider_utils10.convertUint8ArrayToBase64)(this.uint8ArrayData);
     }
     return this.base64Data;
   }
   // lazy conversion with caching to avoid unnecessary conversion overhead:
   get uint8Array() {
     if (this.uint8ArrayData == null) {
-      this.uint8ArrayData = (0, import_provider_utils9.convertBase64ToUint8Array)(this.base64Data);
+      this.uint8ArrayData = (0, import_provider_utils10.convertBase64ToUint8Array)(this.base64Data);
     }
     return this.uint8ArrayData;
   }
@@ -2884,7 +3338,7 @@ var DefaultGenerateImageResult = class {
 
 // core/generate-object/generate-object.ts
 var import_provider21 = require("@ai-sdk/provider");
-var import_provider_utils14 = require("@ai-sdk/provider-utils");
+var import_provider_utils15 = require("@ai-sdk/provider-utils");
 
 // core/generate-text/extract-content-text.ts
 function extractContentText(content) {
@@ -2898,7 +3352,7 @@ function extractContentText(content) {
 }
 
 // core/prompt/convert-to-language-model-prompt.ts
-var import_provider_utils11 = require("@ai-sdk/provider-utils");
+var import_provider_utils12 = require("@ai-sdk/provider-utils");
 
 // src/util/download.ts
 async function download({ url }) {
@@ -2927,7 +3381,7 @@ async function download({ url }) {
 
 // core/prompt/data-content.ts
 var import_provider18 = require("@ai-sdk/provider");
-var import_provider_utils10 = require("@ai-sdk/provider-utils");
+var import_provider_utils11 = require("@ai-sdk/provider-utils");
 var import_zod2 = require("zod");
 
 // core/prompt/split-data-url.ts
@@ -2993,7 +3447,7 @@ function convertDataContentToUint8Array(content) {
   }
   if (typeof content === "string") {
     try {
-      return (0, import_provider_utils10.convertBase64ToUint8Array)(content);
+      return (0, import_provider_utils11.convertBase64ToUint8Array)(content);
     } catch (error) {
       throw new InvalidDataContentError({
         message: "Invalid data content. Content string is not a base64-encoded media.",
@@ -3144,7 +3598,7 @@ async function downloadAssets(messages, downloadImplementation, supportedUrls) {
     }
     return { mediaType, data };
   }).filter(
-    (part) => part.data instanceof URL && part.mediaType != null && !(0, import_provider_utils11.isUrlSupported)({
+    (part) => part.data instanceof URL && part.mediaType != null && !(0, import_provider_utils12.isUrlSupported)({
       url: part.data.toString(),
       mediaType: part.mediaType,
       supportedUrls
@@ -3315,7 +3769,7 @@ function prepareCallSettings({
 
 // core/prompt/standardize-prompt.ts
 var import_provider19 = require("@ai-sdk/provider");
-var import_provider_utils12 = require("@ai-sdk/provider-utils");
+var import_provider_utils13 = require("@ai-sdk/provider-utils");
 var import_zod8 = require("zod");
 
 // core/prompt/message.ts
@@ -3487,7 +3941,7 @@ async function standardizePrompt(prompt) {
       message: "messages must not be empty"
     });
   }
-  const validationResult = await (0, import_provider_utils12.safeValidateTypes)({
+  const validationResult = await (0, import_provider_utils13.safeValidateTypes)({
     value: messages,
     schema: import_zod8.z.array(modelMessageSchema)
   });
@@ -3506,7 +3960,7 @@ async function standardizePrompt(prompt) {
 
 // core/generate-object/output-strategy.ts
 var import_provider20 = require("@ai-sdk/provider");
-var import_provider_utils13 = require("@ai-sdk/provider-utils");
+var import_provider_utils14 = require("@ai-sdk/provider-utils");
 
 // src/util/async-iterable-stream.ts
 function createAsyncIterableStream(source) {
@@ -3562,7 +4016,7 @@ var objectOutputStrategy = (schema) => ({
     };
   },
   async validateFinalResult(value) {
-    return (0, import_provider_utils13.safeValidateTypes)({ value, schema });
+    return (0, import_provider_utils14.safeValidateTypes)({ value, schema });
   },
   createElementStream() {
     throw new import_provider20.UnsupportedFunctionalityError({
@@ -3606,7 +4060,7 @@ var arrayOutputStrategy = (schema) => {
       const resultArray = [];
       for (let i = 0; i < inputArray.length; i++) {
         const element = inputArray[i];
-        const result = await (0, import_provider_utils13.safeValidateTypes)({ value: element, schema });
+        const result = await (0, import_provider_utils14.safeValidateTypes)({ value: element, schema });
         if (i === inputArray.length - 1 && !isFinalDelta) {
           continue;
         }
@@ -3647,7 +4101,7 @@ var arrayOutputStrategy = (schema) => {
       }
       const inputArray = value.elements;
       for (const element of inputArray) {
-        const result = await (0, import_provider_utils13.safeValidateTypes)({ value: element, schema });
+        const result = await (0, import_provider_utils14.safeValidateTypes)({ value: element, schema });
         if (!result.success) {
           return result;
         }
@@ -3765,9 +4219,9 @@ function getOutputStrategy({
 }) {
   switch (output) {
     case "object":
-      return objectOutputStrategy((0, import_provider_utils13.asSchema)(schema));
+      return objectOutputStrategy((0, import_provider_utils14.asSchema)(schema));
     case "array":
-      return arrayOutputStrategy((0, import_provider_utils13.asSchema)(schema));
+      return arrayOutputStrategy((0, import_provider_utils14.asSchema)(schema));
     case "enum":
       return enumOutputStrategy(enumValues);
     case "no-schema":
@@ -3898,7 +4352,7 @@ function validateObjectGenerationInput({
 }
 
 // core/generate-object/generate-object.ts
-var originalGenerateId = (0, import_provider_utils14.createIdGenerator)({ prefix: "aiobj", size: 24 });
+var originalGenerateId = (0, import_provider_utils15.createIdGenerator)({ prefix: "aiobj", size: 24 });
 async function generateObject(options) {
   const {
     model,
@@ -4074,7 +4528,7 @@ async function generateObject(options) {
       request = (_a17 = generateResult.request) != null ? _a17 : {};
       response = generateResult.responseData;
       async function processResult(result2) {
-        const parseResult = await (0, import_provider_utils14.safeParseJSON)({ text: result2 });
+        const parseResult = await (0, import_provider_utils15.safeParseJSON)({ text: result2 });
         if (!parseResult.success) {
           throw new NoObjectGeneratedError({
             message: "No object generated: could not parse the response.",
@@ -4170,7 +4624,7 @@ var DefaultGenerateObjectResult = class {
 };
 
 // core/generate-object/stream-object.ts
-var import_provider_utils15 = require("@ai-sdk/provider-utils");
+var import_provider_utils16 = require("@ai-sdk/provider-utils");
 
 // src/util/create-resolvable-promise.ts
 function createResolvablePromise() {
@@ -4314,7 +4768,7 @@ function now() {
 }
 
 // core/generate-object/stream-object.ts
-var originalGenerateId2 = (0, import_provider_utils15.createIdGenerator)({ prefix: "aiobj", size: 24 });
+var originalGenerateId2 = (0, import_provider_utils16.createIdGenerator)({ prefix: "aiobj", size: 24 });
 function streamObject(options) {
   const {
     model,
@@ -4909,10 +5363,10 @@ var DefaultSpeechResult = class {
 };
 
 // core/generate-text/generate-text.ts
-var import_provider_utils18 = require("@ai-sdk/provider-utils");
+var import_provider_utils19 = require("@ai-sdk/provider-utils");
 
 // core/prompt/prepare-tools-and-tool-choice.ts
-var import_provider_utils16 = require("@ai-sdk/provider-utils");
+var import_provider_utils17 = require("@ai-sdk/provider-utils");
 
 // src/util/is-non-empty-object.ts
 function isNonEmptyObject(object2) {
@@ -4944,7 +5398,7 @@ function prepareToolsAndToolChoice({
             type: "function",
             name: name17,
             description: tool2.description,
-            parameters: (0, import_provider_utils16.asSchema)(tool2.parameters).jsonSchema
+            parameters: (0, import_provider_utils17.asSchema)(tool2.parameters).jsonSchema
           };
         case "provider-defined":
           return {
@@ -5014,7 +5468,7 @@ function asContent({
 }
 
 // core/generate-text/parse-tool-call.ts
-var import_provider_utils17 = require("@ai-sdk/provider-utils");
+var import_provider_utils18 = require("@ai-sdk/provider-utils");
 async function parseToolCall({
   toolCall,
   tools,
@@ -5038,7 +5492,7 @@ async function parseToolCall({
         tools,
         parameterSchema: ({ toolName }) => {
           const { parameters } = tools[toolName];
-          return (0, import_provider_utils17.asSchema)(parameters).jsonSchema;
+          return (0, import_provider_utils18.asSchema)(parameters).jsonSchema;
         },
         system,
         messages,
@@ -5068,8 +5522,8 @@ async function doParseToolCall({
       availableTools: Object.keys(tools)
     });
   }
-  const schema = (0, import_provider_utils17.asSchema)(tool2.parameters);
-  const parseResult = toolCall.args.trim() === "" ? await (0, import_provider_utils17.safeValidateTypes)({ value: {}, schema }) : await (0, import_provider_utils17.safeParseJSON)({ text: toolCall.args, schema });
+  const schema = (0, import_provider_utils18.asSchema)(tool2.parameters);
+  const parseResult = toolCall.args.trim() === "" ? await (0, import_provider_utils18.safeValidateTypes)({ value: {}, schema }) : await (0, import_provider_utils18.safeParseJSON)({ text: toolCall.args, schema });
   if (parseResult.success === false) {
     throw new InvalidToolArgumentsError({
       toolName,
@@ -5186,7 +5640,7 @@ function toResponseMessages({
 }
 
 // core/generate-text/generate-text.ts
-var originalGenerateId3 = (0, import_provider_utils18.createIdGenerator)({
+var originalGenerateId3 = (0, import_provider_utils19.createIdGenerator)({
   prefix: "aitxt",
   size: 24
 });
@@ -5634,7 +6088,7 @@ __export(output_exports, {
   object: () => object,
   text: () => text
 });
-var import_provider_utils19 = require("@ai-sdk/provider-utils");
+var import_provider_utils20 = require("@ai-sdk/provider-utils");
 var text = () => ({
   type: "text",
   responseFormat: { type: "text" },
@@ -5648,7 +6102,7 @@ var text = () => ({
 var object = ({
   schema: inputSchema
 }) => {
-  const schema = (0, import_provider_utils19.asSchema)(inputSchema);
+  const schema = (0, import_provider_utils20.asSchema)(inputSchema);
   return {
     type: "object",
     responseFormat: {
@@ -5674,7 +6128,7 @@ var object = ({
       }
     },
     async parseOutput({ text: text2 }, context) {
-      const parseResult = await (0, import_provider_utils19.safeParseJSON)({ text: text2 });
+      const parseResult = await (0, import_provider_utils20.safeParseJSON)({ text: text2 });
       if (!parseResult.success) {
         throw new NoObjectGeneratedError({
           message: "No object generated: could not parse the response.",
@@ -5685,7 +6139,7 @@ var object = ({
           finishReason: context.finishReason
         });
       }
-      const validationResult = await (0, import_provider_utils19.safeValidateTypes)({
+      const validationResult = await (0, import_provider_utils20.safeValidateTypes)({
         value: parseResult.value,
         schema
       });
@@ -5705,7 +6159,7 @@ var object = ({
 };
 
 // core/generate-text/smooth-stream.ts
-var import_provider_utils20 = require("@ai-sdk/provider-utils");
+var import_provider_utils21 = require("@ai-sdk/provider-utils");
 var import_provider23 = require("@ai-sdk/provider");
 var CHUNKING_REGEXPS = {
   word: /\S+\s+/m,
@@ -5714,7 +6168,7 @@ var CHUNKING_REGEXPS = {
 function smoothStream({
   delayInMs = 10,
   chunking = "word",
-  _internal: { delay: delay2 = import_provider_utils20.delay } = {}
+  _internal: { delay: delay2 = import_provider_utils21.delay } = {}
 } = {}) {
   let detectChunk;
   if (typeof chunking === "function") {
@@ -5774,7 +6228,7 @@ function smoothStream({
 }
 
 // core/generate-text/stream-text.ts
-var import_provider_utils22 = require("@ai-sdk/provider-utils");
+var import_provider_utils23 = require("@ai-sdk/provider-utils");
 
 // src/util/as-array.ts
 function asArray(value) {
@@ -5782,7 +6236,7 @@ function asArray(value) {
 }
 
 // core/generate-text/run-tools-transformation.ts
-var import_provider_utils21 = require("@ai-sdk/provider-utils");
+var import_provider_utils22 = require("@ai-sdk/provider-utils");
 function runToolsTransformation({
   tools,
   generatorStream,
@@ -5868,7 +6322,7 @@ function runToolsTransformation({
             controller.enqueue(toolCall);
             const tool2 = tools[toolCall.toolName];
             if (tool2.execute != null) {
-              const toolExecutionId = (0, import_provider_utils21.generateId)();
+              const toolExecutionId = (0, import_provider_utils22.generateId)();
               outstandingToolResults.add(toolExecutionId);
               recordSpan({
                 name: "ai.toolCall",
@@ -5977,7 +6431,7 @@ function runToolsTransformation({
 }
 
 // core/generate-text/stream-text.ts
-var originalGenerateId4 = (0, import_provider_utils22.createIdGenerator)({
+var originalGenerateId4 = (0, import_provider_utils23.createIdGenerator)({
   prefix: "aitxt",
   size: 24
 });
@@ -6764,7 +7218,7 @@ var DefaultStreamTextResult = class {
       )
     );
   }
-  toDataStream({
+  toUIMessageStream({
     newMessageId,
     originalMessages = [],
     onFinish,
@@ -6916,24 +7370,40 @@ var DefaultStreamTextResult = class {
         }
       })
     );
-    return onFinish == null ? baseStream : processChatResponse({
-      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
+            ]
+          });
+        }
+      })
+    );
   }
-  pipeDataStreamToResponse(response, {
+  pipeUIMessageStreamToResponse(response, {
     newMessageId,
     originalMessages,
     onFinish,
@@ -6945,9 +7415,9 @@ var DefaultStreamTextResult = class {
     onError,
     ...init
   } = {}) {
-    pipeDataStreamToResponse({
+    pipeUIMessageStreamToResponse({
       response,
-      dataStream: this.toDataStream({
+      stream: this.toUIMessageStream({
         newMessageId,
         originalMessages,
         onFinish,
@@ -6968,7 +7438,7 @@ var DefaultStreamTextResult = class {
       ...init
     });
   }
-  toDataStreamResponse({
+  toUIMessageStreamResponse({
     newMessageId,
     originalMessages,
     onFinish,
@@ -6980,8 +7450,8 @@ var DefaultStreamTextResult = class {
     onError,
     ...init
   } = {}) {
-    return createDataStreamResponse({
-      dataStream: this.toDataStream({
+    return createUIMessageStreamResponse({
+      stream: this.toUIMessageStream({
         newMessageId,
         originalMessages,
         onFinish,
@@ -7379,7 +7849,7 @@ var DefaultProviderRegistry = class {
 };
 
 // core/tool/mcp/mcp-client.ts
-var import_provider_utils24 = require("@ai-sdk/provider-utils");
+var import_provider_utils25 = require("@ai-sdk/provider-utils");
 
 // core/tool/tool.ts
 function tool(tool2) {
@@ -7387,7 +7857,7 @@ function tool(tool2) {
 }
 
 // core/tool/mcp/mcp-sse-transport.ts
-var import_provider_utils23 = require("@ai-sdk/provider-utils");
+var import_provider_utils24 = require("@ai-sdk/provider-utils");
 
 // core/tool/mcp/json-rpc-message.ts
 var import_zod10 = require("zod");
@@ -7558,7 +8028,7 @@ var SseMCPTransport = class {
             (_b = this.onerror) == null ? void 0 : _b.call(this, error);
             return reject(error);
           }
-          const stream = response.body.pipeThrough(new TextDecoderStream()).pipeThrough((0, import_provider_utils23.createEventSourceParserStream)());
+          const stream = response.body.pipeThrough(new TextDecoderStream()).pipeThrough((0, import_provider_utils24.createEventSourceParserStream)());
           const reader = stream.getReader();
           const processEvents = async () => {
             var _a18, _b2, _c2;
@@ -7882,7 +8352,7 @@ var MCPClient = class {
         if (schemas !== "automatic" && !(name17 in schemas)) {
           continue;
         }
-        const parameters = schemas === "automatic" ? (0, import_provider_utils24.jsonSchema)({
+        const parameters = schemas === "automatic" ? (0, import_provider_utils25.jsonSchema)({
           ...inputSchema,
           properties: (_a17 = inputSchema.properties) != null ? _a17 : {},
           additionalProperties: false
@@ -8012,6 +8482,8 @@ var DefaultTranscriptionResult = class {
 0 && (module.exports = {
   AISDKError,
   APICallError,
+  ChatStore,
+  DefaultChatTransport,
   DownloadError,
   EmptyResponseBodyError,
   InvalidArgumentError,
@@ -8053,12 +8525,13 @@ var DefaultTranscriptionResult = class {
   coreToolMessageSchema,
   coreUserMessageSchema,
   cosineSimilarity,
-  createDataStream,
-  createDataStreamResponse,
   createIdGenerator,
   createProviderRegistry,
   createTextStreamResponse,
+  createUIMessageStream,
+  createUIMessageStreamResponse,
   customProvider,
+  defaultChatStore,
   defaultSettingsMiddleware,
   embed,
   embedMany,
@@ -8080,9 +8553,8 @@ var DefaultTranscriptionResult = class {
   jsonSchema,
   modelMessageSchema,
   parsePartialJson,
-  pipeDataStreamToResponse,
   pipeTextStreamToResponse,
-  processTextStream,
+  pipeUIMessageStreamToResponse,
   shouldResubmitMessages,
   simulateReadableStream,
   simulateStreamingMiddleware,