ai 5.0.0-canary.23 → 5.0.0-canary.24

package/dist/index.js

@@ -88,9 +88,11 @@ __export(src_exports, {
   generateText: () => generateText,
   getTextFromDataUrl: () => getTextFromDataUrl,
   getToolInvocations: () => getToolInvocations,
+  hasToolCall: () => hasToolCall,
   isAssistantMessageWithCompletedToolCalls: () => isAssistantMessageWithCompletedToolCalls,
   isDeepEqualData: () => isDeepEqualData,
   jsonSchema: () => import_provider_utils26.jsonSchema,
+  maxSteps: () => maxSteps,
   modelMessageSchema: () => modelMessageSchema,
   parsePartialJson: () => parsePartialJson,
   pipeTextStreamToResponse: () => pipeTextStreamToResponse,
@@ -552,102 +554,84 @@ var import_provider_utils3 = require("@ai-sdk/provider-utils");
 
 // 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(),
-  toolName: import_zod.z.string(),
-  args: import_zod.z.unknown()
-});
-var toolResultValueSchema = import_zod.z.object({
-  toolCallId: import_zod.z.string(),
-  result: import_zod.z.unknown(),
-  providerMetadata: import_zod.z.any().optional()
-});
-var sourceSchema = import_zod.z.object({
-  type: import_zod.z.literal("source"),
-  sourceType: import_zod.z.literal("url"),
-  id: import_zod.z.string(),
-  url: import_zod.z.string(),
-  title: import_zod.z.string().optional(),
-  providerMetadata: import_zod.z.any().optional()
-  // Use z.any() for generic metadata
-});
-var uiMessageStreamPartSchema = import_zod.z.discriminatedUnion("type", [
+var uiMessageStreamPartSchema = import_zod.z.union([
   import_zod.z.object({
     type: import_zod.z.literal("text"),
-    value: import_zod.z.string()
+    text: import_zod.z.string()
   }),
   import_zod.z.object({
     type: import_zod.z.literal("error"),
-    value: import_zod.z.string()
+    errorText: import_zod.z.string()
   }),
   import_zod.z.object({
-    type: import_zod.z.literal("tool-call"),
-    value: toolCallSchema
+    type: import_zod.z.literal("tool-call-streaming-start"),
+    toolCallId: import_zod.z.string(),
+    toolName: import_zod.z.string()
   }),
   import_zod.z.object({
-    type: import_zod.z.literal("tool-result"),
-    value: toolResultValueSchema
+    type: import_zod.z.literal("tool-call-delta"),
+    toolCallId: import_zod.z.string(),
+    argsTextDelta: import_zod.z.string()
   }),
   import_zod.z.object({
-    type: import_zod.z.literal("tool-call-streaming-start"),
-    value: import_zod.z.object({ toolCallId: import_zod.z.string(), toolName: import_zod.z.string() })
+    type: import_zod.z.literal("tool-call"),
+    toolCallId: import_zod.z.string(),
+    toolName: import_zod.z.string(),
+    args: import_zod.z.unknown()
   }),
   import_zod.z.object({
-    type: import_zod.z.literal("tool-call-delta"),
-    value: import_zod.z.object({ toolCallId: import_zod.z.string(), argsTextDelta: import_zod.z.string() })
+    type: import_zod.z.literal("tool-result"),
+    toolCallId: import_zod.z.string(),
+    result: import_zod.z.unknown(),
+    providerMetadata: import_zod.z.any().optional()
   }),
   import_zod.z.object({
     type: import_zod.z.literal("reasoning"),
-    value: import_zod.z.object({
-      text: import_zod.z.string(),
-      providerMetadata: import_zod.z.record(import_zod.z.any()).optional()
-    })
+    text: import_zod.z.string(),
+    providerMetadata: import_zod.z.record(import_zod.z.any()).optional()
   }),
   import_zod.z.object({
     type: import_zod.z.literal("source"),
-    value: sourceSchema
+    sourceType: import_zod.z.literal("url"),
+    id: import_zod.z.string(),
+    url: import_zod.z.string(),
+    title: import_zod.z.string().optional(),
+    providerMetadata: import_zod.z.any().optional()
+    // Use z.any() for generic metadata
   }),
   import_zod.z.object({
     type: import_zod.z.literal("file"),
-    value: import_zod.z.object({
-      url: import_zod.z.string(),
-      mediaType: import_zod.z.string()
-    })
+    url: import_zod.z.string(),
+    mediaType: import_zod.z.string()
+  }),
+  import_zod.z.object({
+    type: import_zod.z.string().startsWith("data-"),
+    id: import_zod.z.string().optional(),
+    data: import_zod.z.unknown()
   }),
   import_zod.z.object({
     type: import_zod.z.literal("metadata"),
-    value: import_zod.z.object({
-      metadata: import_zod.z.unknown()
-    })
+    value: import_zod.z.object({ metadata: import_zod.z.unknown() })
   }),
   import_zod.z.object({
     type: import_zod.z.literal("start-step"),
-    value: import_zod.z.object({
-      metadata: import_zod.z.unknown()
-    })
+    metadata: import_zod.z.unknown().optional()
   }),
   import_zod.z.object({
     type: import_zod.z.literal("finish-step"),
-    value: import_zod.z.object({
-      metadata: import_zod.z.unknown()
-    })
+    metadata: import_zod.z.unknown().optional()
   }),
   import_zod.z.object({
     type: import_zod.z.literal("start"),
-    value: import_zod.z.object({
-      messageId: import_zod.z.string().optional(),
-      metadata: import_zod.z.unknown()
-    })
+    messageId: import_zod.z.string().optional(),
+    metadata: import_zod.z.unknown().optional()
   }),
   import_zod.z.object({
     type: import_zod.z.literal("finish"),
-    value: import_zod.z.object({
-      metadata: import_zod.z.unknown()
-    })
+    metadata: import_zod.z.unknown().optional()
   }),
   import_zod.z.object({
-    type: import_zod.z.literal("reasoning-part-finish"),
-    value: import_zod.z.null()
+    type: import_zod.z.literal("reasoning-part-finish")
   })
 ]);
 
@@ -1088,14 +1072,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",
@@ -1115,17 +1099,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;
@@ -1134,13 +1117,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;
@@ -1154,8 +1137,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;
@@ -1163,39 +1146,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
               });
@@ -1203,22 +1192,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();
@@ -1232,25 +1224,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;
             }
@@ -1258,45 +1249,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);
         });
       }
     })
@@ -1310,15 +1317,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" });
       }
     })
   );
@@ -1538,12 +1545,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);
                 }
               }
             })
@@ -1619,18 +1626,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) {
@@ -1671,7 +1678,7 @@ var ChatStore = class {
     generateId: generateId3,
     messageMetadataSchema,
     transport,
-    maxSteps = 1
+    maxSteps: maxSteps2 = 1
   }) {
     this.chats = new Map(
       Object.entries(chats).map(([id, state]) => [
@@ -1685,7 +1692,7 @@ var ChatStore = class {
         }
       ])
     );
-    this.maxSteps = maxSteps;
+    this.maxSteps = maxSteps2;
     this.transport = transport;
     this.subscribers = /* @__PURE__ */ new Set();
     this.generateId = generateId3 != null ? generateId3 : import_provider_utils5.generateId;
@@ -1743,14 +1750,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];
@@ -1893,6 +1892,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(
@@ -2235,7 +2235,7 @@ function defaultChatStore({
   prepareRequestBody,
   generateId: generateId3 = import_provider_utils6.generateId,
   messageMetadataSchema,
-  maxSteps = 1,
+  maxSteps: maxSteps2 = 1,
   chats
 }) {
   return new ChatStore({
@@ -2250,7 +2250,7 @@ function defaultChatStore({
     }),
     generateId: generateId3,
     messageMetadataSchema,
-    maxSteps,
+    maxSteps: maxSteps2,
     chats
   });
 }
@@ -2290,7 +2290,7 @@ function createUIMessageStream({
               safeEnqueue(value);
             }
           })().catch((error) => {
-            safeEnqueue({ type: "error", value: onError(error) });
+            safeEnqueue({ type: "error", errorText: onError(error) });
           })
         );
       },
@@ -2299,12 +2299,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) {
@@ -3948,7 +3948,7 @@ async function standardizePrompt(prompt) {
   if (!validationResult.success) {
     throw new import_provider19.InvalidPromptError({
       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
     });
   }
@@ -5581,6 +5581,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,
@@ -5654,7 +5667,7 @@ async function generateText({
   maxRetries: maxRetriesArg,
   abortSignal,
   headers,
-  maxSteps = 1,
+  continueUntil = maxSteps(1),
   experimental_output: output,
   experimental_telemetry: telemetry,
   providerOptions,
@@ -5668,13 +5681,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({
@@ -5705,8 +5711,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,
@@ -5716,7 +5721,6 @@ async function generateText({
       let currentModelResponse;
       let currentToolCalls = [];
       let currentToolResults = [];
-      let stepCount = 0;
       const responseMessages = [];
       const steps = [];
       do {
@@ -5727,8 +5731,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: {
@@ -5883,9 +5886,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,
@@ -6445,7 +6451,7 @@ function streamText({
   maxRetries,
   abortSignal,
   headers,
-  maxSteps = 1,
+  maxSteps: maxSteps2 = 1,
   experimental_output: output,
   experimental_telemetry: telemetry,
   providerOptions,
@@ -6481,7 +6487,7 @@ function streamText({
     transforms: asArray(transform),
     activeTools,
     repairToolCall,
-    maxSteps,
+    maxSteps: maxSteps2,
     output,
     providerOptions,
     onChunk,
@@ -6558,7 +6564,7 @@ var DefaultStreamTextResult = class {
     transforms,
     activeTools,
     repairToolCall,
-    maxSteps,
+    maxSteps: maxSteps2,
     output,
     providerOptions,
     now: now2,
@@ -6572,10 +6578,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"
       });
     }
@@ -6732,6 +6738,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({
@@ -6766,7 +6779,7 @@ var DefaultStreamTextResult = class {
           "ai.prompt": {
             input: () => JSON.stringify({ system, prompt, messages })
           },
-          "ai.settings.maxSteps": maxSteps
+          "ai.settings.maxSteps": maxSteps2
         }
       }),
       tracer,
@@ -6904,7 +6917,6 @@ var DefaultStreamTextResult = class {
                   var _a17, _b, _c, _d;
                   if (chunk.type === "stream-start") {
                     warnings = chunk.warnings;
-                    controller.enqueue({ type: "start" });
                     return;
                   }
                   if (stepFirstChunk) {
@@ -7054,7 +7066,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(
@@ -7239,125 +7251,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;
@@ -8548,9 +8557,11 @@ var DefaultTranscriptionResult = class {
   generateText,
   getTextFromDataUrl,
   getToolInvocations,
+  hasToolCall,
   isAssistantMessageWithCompletedToolCalls,
   isDeepEqualData,
   jsonSchema,
+  maxSteps,
   modelMessageSchema,
   parsePartialJson,
   pipeTextStreamToResponse,