ai 5.0.0-canary.23 → 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")
   })
 ]);
 
@@ -1003,14 +985,14 @@ function processUIMessageStream({
 }) {
   return stream.pipeThrough(
     new TransformStream({
-      async transform(chunk, controller) {
+      async transform(part, controller) {
         await runUpdateMessageJob(async ({ state, write }) => {
           function updateToolInvocationPart(toolCallId, invocation) {
-            const part = state.message.parts.find(
-              (part2) => part2.type === "tool-invocation" && part2.toolInvocation.toolCallId === toolCallId
+            const part2 = state.message.parts.find(
+              (part3) => part3.type === "tool-invocation" && part3.toolInvocation.toolCallId === toolCallId
             );
-            if (part != null) {
-              part.toolInvocation = invocation;
+            if (part2 != null) {
+              part2.toolInvocation = invocation;
             } else {
               state.message.parts.push({
                 type: "tool-invocation",
@@ -1030,17 +1012,16 @@ function processUIMessageStream({
               state.message.metadata = mergedMetadata;
             }
           }
-          const { type, value } = chunk;
-          switch (type) {
+          switch (part.type) {
             case "text": {
               if (state.activeTextPart == null) {
                 state.activeTextPart = {
                   type: "text",
-                  text: value
+                  text: part.text
                 };
                 state.message.parts.push(state.activeTextPart);
               } else {
-                state.activeTextPart.text += value;
+                state.activeTextPart.text += part.text;
               }
               write();
               break;
@@ -1049,13 +1030,13 @@ function processUIMessageStream({
               if (state.activeReasoningPart == null) {
                 state.activeReasoningPart = {
                   type: "reasoning",
-                  text: value.text,
-                  providerMetadata: value.providerMetadata
+                  text: part.text,
+                  providerMetadata: part.providerMetadata
                 };
                 state.message.parts.push(state.activeReasoningPart);
               } else {
-                state.activeReasoningPart.text += value.text;
-                state.activeReasoningPart.providerMetadata = value.providerMetadata;
+                state.activeReasoningPart.text += part.text;
+                state.activeReasoningPart.providerMetadata = part.providerMetadata;
               }
               write();
               break;
@@ -1069,8 +1050,8 @@ function processUIMessageStream({
             case "file": {
               state.message.parts.push({
                 type: "file",
-                mediaType: value.mediaType,
-                url: value.url
+                mediaType: part.mediaType,
+                url: part.url
               });
               write();
               break;
@@ -1078,39 +1059,45 @@ function processUIMessageStream({
             case "source": {
               state.message.parts.push({
                 type: "source",
-                source: value
+                source: {
+                  sourceType: "url",
+                  id: part.id,
+                  url: part.url,
+                  title: part.title,
+                  providerMetadata: part.providerMetadata
+                }
               });
               write();
               break;
             }
             case "tool-call-streaming-start": {
               const toolInvocations = getToolInvocations(state.message);
-              state.partialToolCalls[value.toolCallId] = {
+              state.partialToolCalls[part.toolCallId] = {
                 text: "",
                 step: state.step,
-                toolName: value.toolName,
+                toolName: part.toolName,
                 index: toolInvocations.length
               };
-              updateToolInvocationPart(value.toolCallId, {
+              updateToolInvocationPart(part.toolCallId, {
                 state: "partial-call",
                 step: state.step,
-                toolCallId: value.toolCallId,
-                toolName: value.toolName,
+                toolCallId: part.toolCallId,
+                toolName: part.toolName,
                 args: void 0
               });
               write();
               break;
             }
             case "tool-call-delta": {
-              const partialToolCall = state.partialToolCalls[value.toolCallId];
-              partialToolCall.text += value.argsTextDelta;
+              const partialToolCall = state.partialToolCalls[part.toolCallId];
+              partialToolCall.text += part.argsTextDelta;
               const { value: partialArgs } = await parsePartialJson(
                 partialToolCall.text
               );
-              updateToolInvocationPart(value.toolCallId, {
+              updateToolInvocationPart(part.toolCallId, {
                 state: "partial-call",
                 step: partialToolCall.step,
-                toolCallId: value.toolCallId,
+                toolCallId: part.toolCallId,
                 toolName: partialToolCall.toolName,
                 args: partialArgs
               });
@@ -1118,22 +1105,25 @@ function processUIMessageStream({
               break;
             }
             case "tool-call": {
-              const call = { args: value.args, ...value };
-              updateToolInvocationPart(value.toolCallId, {
+              updateToolInvocationPart(part.toolCallId, {
                 state: "call",
                 step: state.step,
-                ...call
+                toolCallId: part.toolCallId,
+                toolName: part.toolName,
+                args: part.args
               });
               write();
               if (onToolCall) {
                 const result = await onToolCall({
-                  toolCall: call
+                  toolCall: part
                 });
                 if (result != null) {
-                  updateToolInvocationPart(value.toolCallId, {
+                  updateToolInvocationPart(part.toolCallId, {
                     state: "result",
                     step: state.step,
-                    ...call,
+                    toolCallId: part.toolCallId,
+                    toolName: part.toolName,
+                    args: part.args,
                     result
                   });
                   write();
@@ -1147,25 +1137,24 @@ function processUIMessageStream({
                 throw new Error("tool_result must be preceded by a tool_call");
               }
               const toolInvocationIndex = toolInvocations.findIndex(
-                (invocation) => invocation.toolCallId === value.toolCallId
+                (invocation) => invocation.toolCallId === part.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, {
+              updateToolInvocationPart(part.toolCallId, {
                 ...toolInvocations[toolInvocationIndex],
                 state: "result",
-                ...result
+                result: part.result
               });
               write();
               break;
             }
             case "start-step": {
               state.message.parts.push({ type: "step-start" });
-              await updateMessageMetadata(value.metadata);
+              await updateMessageMetadata(part.metadata);
               write();
               break;
             }
@@ -1173,45 +1162,61 @@ function processUIMessageStream({
               state.step += 1;
               state.activeTextPart = void 0;
               state.activeReasoningPart = void 0;
-              await updateMessageMetadata(value.metadata);
-              if (value.metadata != null) {
+              await updateMessageMetadata(part.metadata);
+              if (part.metadata != null) {
                 write();
               }
               break;
             }
             case "start": {
-              if (value.messageId != null) {
-                state.message.id = value.messageId;
+              if (part.messageId != null) {
+                state.message.id = part.messageId;
               }
-              await updateMessageMetadata(value.metadata);
-              if (value.messageId != null || value.metadata != null) {
+              await updateMessageMetadata(part.metadata);
+              if (part.messageId != null || part.metadata != null) {
                 write();
               }
               break;
             }
             case "finish": {
-              await updateMessageMetadata(value.metadata);
-              if (value.metadata != null) {
+              await updateMessageMetadata(part.metadata);
+              if (part.metadata != null) {
                 write();
               }
               break;
             }
             case "metadata": {
-              await updateMessageMetadata(value.metadata);
-              if (value.metadata != null) {
+              await updateMessageMetadata(part.metadata);
+              if (part.metadata != null) {
                 write();
               }
               break;
             }
             case "error": {
-              throw new Error(value);
+              throw new Error(part.errorText);
             }
             default: {
-              const _exhaustiveCheck = type;
-              throw new Error(`Unhandled stream part: ${_exhaustiveCheck}`);
+              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();
+              }
             }
           }
-          controller.enqueue(chunk);
+          controller.enqueue(part);
         });
       }
     })
@@ -1225,15 +1230,15 @@ function transformTextToUiMessageStream({
   return stream.pipeThrough(
     new TransformStream({
       start(controller) {
-        controller.enqueue({ type: "start", value: {} });
-        controller.enqueue({ type: "start-step", value: {} });
+        controller.enqueue({ type: "start" });
+        controller.enqueue({ type: "start-step" });
       },
       async transform(part, controller) {
-        controller.enqueue({ type: "text", value: part });
+        controller.enqueue({ type: "text", text: part });
       },
       async flush(controller) {
-        controller.enqueue({ type: "finish-step", value: {} });
-        controller.enqueue({ type: "finish", value: {} });
+        controller.enqueue({ type: "finish-step" });
+        controller.enqueue({ type: "finish" });
       }
     })
   );
@@ -1453,12 +1458,12 @@ async function callCompletionApi({
                 if (!part.success) {
                   throw part.error;
                 }
-                const { type, value } = part.value;
-                if (type === "text") {
-                  result += value;
+                const streamPart = part.value;
+                if (streamPart.type === "text") {
+                  result += streamPart.text;
                   setCompletion(result);
-                } else if (type === "error") {
-                  throw new Error(value);
+                } else if (streamPart.type === "error") {
+                  throw new Error(streamPart.errorText);
                 }
               }
             })
@@ -1536,18 +1541,18 @@ var SerialJobExecutor = class {
 function shouldResubmitMessages({
   originalMaxToolInvocationStep,
   originalMessageCount,
-  maxSteps,
+  maxSteps: maxSteps2,
   messages
 }) {
   var _a17;
   const lastMessage = messages[messages.length - 1];
   return (
     // check if the feature is enabled:
-    maxSteps > 1 && // ensure there is a last message:
+    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) < maxSteps
+    ((_a17 = extractMaxToolInvocationStep(getToolInvocations(lastMessage))) != null ? _a17 : 0) < maxSteps2
   );
 }
 function isAssistantMessageWithCompletedToolCalls(message) {
@@ -1588,7 +1593,7 @@ var ChatStore = class {
     generateId: generateId3,
     messageMetadataSchema,
     transport,
-    maxSteps = 1
+    maxSteps: maxSteps2 = 1
   }) {
     this.chats = new Map(
       Object.entries(chats).map(([id, state]) => [
@@ -1602,7 +1607,7 @@ var ChatStore = class {
         }
       ])
     );
-    this.maxSteps = maxSteps;
+    this.maxSteps = maxSteps2;
     this.transport = transport;
     this.subscribers = /* @__PURE__ */ new Set();
     this.generateId = generateId3 != null ? generateId3 : generateIdFunc;
@@ -1660,14 +1665,6 @@ var ChatStore = class {
     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];
@@ -1810,6 +1807,7 @@ var ChatStore = class {
   }) {
     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(
@@ -2154,7 +2152,7 @@ function defaultChatStore({
   prepareRequestBody,
   generateId: generateId3 = generateIdFunc2,
   messageMetadataSchema,
-  maxSteps = 1,
+  maxSteps: maxSteps2 = 1,
   chats
 }) {
   return new ChatStore({
@@ -2169,7 +2167,7 @@ function defaultChatStore({
     }),
     generateId: generateId3,
     messageMetadataSchema,
-    maxSteps,
+    maxSteps: maxSteps2,
     chats
   });
 }
@@ -2209,7 +2207,7 @@ function createUIMessageStream({
               safeEnqueue(value);
             }
           })().catch((error) => {
-            safeEnqueue({ type: "error", value: onError(error) });
+            safeEnqueue({ type: "error", errorText: onError(error) });
           })
         );
       },
@@ -2218,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) {
@@ -3879,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
     });
   }
@@ -5524,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,
@@ -5597,7 +5608,7 @@ async function generateText({
   maxRetries: maxRetriesArg,
   abortSignal,
   headers,
-  maxSteps = 1,
+  continueUntil = maxSteps(1),
   experimental_output: output,
   experimental_telemetry: telemetry,
   providerOptions,
@@ -5611,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({
@@ -5648,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,
@@ -5659,7 +5662,6 @@ async function generateText({
       let currentModelResponse;
       let currentToolCalls = [];
       let currentToolResults = [];
-      let stepCount = 0;
       const responseMessages = [];
       const steps = [];
       do {
@@ -5670,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: {
@@ -5826,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,
@@ -6392,7 +6396,7 @@ function streamText({
   maxRetries,
   abortSignal,
   headers,
-  maxSteps = 1,
+  maxSteps: maxSteps2 = 1,
   experimental_output: output,
   experimental_telemetry: telemetry,
   providerOptions,
@@ -6428,7 +6432,7 @@ function streamText({
     transforms: asArray(transform),
     activeTools,
     repairToolCall,
-    maxSteps,
+    maxSteps: maxSteps2,
     output,
     providerOptions,
     onChunk,
@@ -6505,7 +6509,7 @@ var DefaultStreamTextResult = class {
     transforms,
     activeTools,
     repairToolCall,
-    maxSteps,
+    maxSteps: maxSteps2,
     output,
     providerOptions,
     now: now2,
@@ -6519,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"
       });
     }
@@ -6679,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({
@@ -6713,7 +6724,7 @@ var DefaultStreamTextResult = class {
           "ai.prompt": {
             input: () => JSON.stringify({ system, prompt, messages })
           },
-          "ai.settings.maxSteps": maxSteps
+          "ai.settings.maxSteps": maxSteps2
         }
       }),
       tracer,
@@ -6851,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) {
@@ -7001,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(
@@ -7186,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;
@@ -8494,9 +8501,11 @@ export {
   generateText,
   getTextFromDataUrl,
   getToolInvocations,
+  hasToolCall,
   isAssistantMessageWithCompletedToolCalls,
   isDeepEqualData,
   jsonSchema2 as jsonSchema,
+  maxSteps,
   modelMessageSchema,
   parsePartialJson,
   pipeTextStreamToResponse,