ai 5.0.0-canary.7 → 5.0.0-canary.9

package/dist/index.mjs

@@ -1993,6 +1993,7 @@ function selectTelemetryAttributes({
 async function embed({
   model,
   value,
+  providerOptions,
   maxRetries: maxRetriesArg,
   abortSignal,
   headers,
@@ -2018,7 +2019,7 @@ async function embed({
     }),
     tracer,
     fn: async (span) => {
-      const { embedding, usage, rawResponse } = await retry(
+      const { embedding, usage, response } = await retry(
         () => (
           // nested spans to align with the embedMany telemetry data:
           recordSpan({
@@ -2041,7 +2042,8 @@ async function embed({
               const modelResponse = await model.doEmbed({
                 values: [value],
                 abortSignal,
-                headers
+                headers,
+                providerOptions
               });
               const embedding2 = modelResponse.embeddings[0];
               const usage2 = (_a17 = modelResponse.usage) != null ? _a17 : { tokens: NaN };
@@ -2061,7 +2063,7 @@ async function embed({
               return {
                 embedding: embedding2,
                 usage: usage2,
-                rawResponse: modelResponse.rawResponse
+                response: modelResponse.response
               };
             }
           })
@@ -2076,7 +2078,12 @@ async function embed({
           }
         })
       );
-      return new DefaultEmbedResult({ value, embedding, usage, rawResponse });
+      return new DefaultEmbedResult({
+        value,
+        embedding,
+        usage,
+        response
+      });
     }
   });
 }
@@ -2085,7 +2092,7 @@ var DefaultEmbedResult = class {
     this.value = options.value;
     this.embedding = options.embedding;
     this.usage = options.usage;
-    this.rawResponse = options.rawResponse;
+    this.response = options.response;
   }
 };
 
@@ -2108,6 +2115,7 @@ async function embedMany({
   maxRetries: maxRetriesArg,
   abortSignal,
   headers,
+  providerOptions,
   experimental_telemetry: telemetry
 }) {
   const { maxRetries, retry } = prepareRetries({ maxRetries: maxRetriesArg });
@@ -2135,7 +2143,7 @@ async function embedMany({
     fn: async (span) => {
       const maxEmbeddingsPerCall = model.maxEmbeddingsPerCall;
       if (maxEmbeddingsPerCall == null) {
-        const { embeddings: embeddings2, usage } = await retry(() => {
+        const { embeddings: embeddings2, usage, response } = await retry(() => {
           return recordSpan({
             name: "ai.embedMany.doEmbed",
             attributes: selectTelemetryAttributes({
@@ -2158,7 +2166,8 @@ async function embedMany({
               const modelResponse = await model.doEmbed({
                 values,
                 abortSignal,
-                headers
+                headers,
+                providerOptions
               });
               const embeddings3 = modelResponse.embeddings;
               const usage2 = (_a17 = modelResponse.usage) != null ? _a17 : { tokens: NaN };
@@ -2173,7 +2182,11 @@ async function embedMany({
                   }
                 })
               );
-              return { embeddings: embeddings3, usage: usage2 };
+              return {
+                embeddings: embeddings3,
+                usage: usage2,
+                response: modelResponse.response
+              };
             }
           });
         });
@@ -2188,13 +2201,23 @@ async function embedMany({
             }
           })
         );
-        return new DefaultEmbedManyResult({ values, embeddings: embeddings2, usage });
+        return new DefaultEmbedManyResult({
+          values,
+          embeddings: embeddings2,
+          usage,
+          responses: [response]
+        });
       }
       const valueChunks = splitArray(values, maxEmbeddingsPerCall);
       const embeddings = [];
+      const responses = [];
       let tokens = 0;
       for (const chunk of valueChunks) {
-        const { embeddings: responseEmbeddings, usage } = await retry(() => {
+        const {
+          embeddings: responseEmbeddings,
+          usage,
+          response
+        } = await retry(() => {
           return recordSpan({
             name: "ai.embedMany.doEmbed",
             attributes: selectTelemetryAttributes({
@@ -2217,7 +2240,8 @@ async function embedMany({
               const modelResponse = await model.doEmbed({
                 values: chunk,
                 abortSignal,
-                headers
+                headers,
+                providerOptions
               });
               const embeddings2 = modelResponse.embeddings;
               const usage2 = (_a17 = modelResponse.usage) != null ? _a17 : { tokens: NaN };
@@ -2232,11 +2256,16 @@ async function embedMany({
                   }
                 })
               );
-              return { embeddings: embeddings2, usage: usage2 };
+              return {
+                embeddings: embeddings2,
+                usage: usage2,
+                response: modelResponse.response
+              };
             }
           });
         });
         embeddings.push(...responseEmbeddings);
+        responses.push(response);
         tokens += usage.tokens;
       }
       span.setAttributes(
@@ -2253,7 +2282,8 @@ async function embedMany({
       return new DefaultEmbedManyResult({
         values,
         embeddings,
-        usage: { tokens }
+        usage: { tokens },
+        responses
       });
     }
   });
@@ -2263,6 +2293,7 @@ var DefaultEmbedManyResult = class {
     this.values = options.values;
     this.embeddings = options.embeddings;
     this.usage = options.usage;
+    this.responses = options.responses;
   }
 };
 
@@ -4062,6 +4093,17 @@ function validateObjectGenerationInput({
   }
 }
 
+// core/generate-text/extract-content-text.ts
+function extractContentText(content) {
+  const parts = content.filter(
+    (content2) => content2.type === "text"
+  );
+  if (parts.length === 0) {
+    return void 0;
+  }
+  return parts.map((content2) => content2.text).join("");
+}
+
 // core/generate-object/generate-object.ts
 var originalGenerateId = createIdGenerator({ prefix: "aiobj", size: 24 });
 async function generateObject({
@@ -4219,7 +4261,8 @@ async function generateObject({
                   headers: (_g = result2.response) == null ? void 0 : _g.headers,
                   body: (_h = result2.response) == null ? void 0 : _h.body
                 };
-                if (result2.text === void 0) {
+                const text2 = extractContentText(result2.content);
+                if (text2 === void 0) {
                   throw new NoObjectGeneratedError({
                     message: "No object generated: the model did not return a response.",
                     response: responseData,
@@ -4232,7 +4275,7 @@ async function generateObject({
                     telemetry,
                     attributes: {
                       "ai.response.finishReason": result2.finishReason,
-                      "ai.response.object": { output: () => result2.text },
+                      "ai.response.object": { output: () => text2 },
                       "ai.response.id": responseData.id,
                       "ai.response.model": responseData.modelId,
                       "ai.response.timestamp": responseData.timestamp.toISOString(),
@@ -4248,7 +4291,7 @@ async function generateObject({
                     }
                   })
                 );
-                return { ...result2, objectText: result2.text, responseData };
+                return { ...result2, objectText: text2, responseData };
               }
             })
           );
@@ -4305,7 +4348,7 @@ async function generateObject({
               }),
               tracer,
               fn: async (span2) => {
-                var _a18, _b2, _c2, _d2, _e, _f, _g, _h, _i, _j;
+                var _a18, _b2, _c2, _d2, _e, _f, _g, _h;
                 const result2 = await model.doGenerate({
                   tools: [
                     {
@@ -4323,13 +4366,16 @@ async function generateObject({
                   abortSignal,
                   headers
                 });
-                const objectText = (_b2 = (_a18 = result2.toolCalls) == null ? void 0 : _a18[0]) == null ? void 0 : _b2.args;
+                const firstToolCall = result2.content.find(
+                  (content) => content.type === "tool-call"
+                );
+                const objectText = firstToolCall == null ? void 0 : firstToolCall.args;
                 const responseData = {
-                  id: (_d2 = (_c2 = result2.response) == null ? void 0 : _c2.id) != null ? _d2 : generateId3(),
-                  timestamp: (_f = (_e = result2.response) == null ? void 0 : _e.timestamp) != null ? _f : currentDate(),
-                  modelId: (_h = (_g = result2.response) == null ? void 0 : _g.modelId) != null ? _h : model.modelId,
-                  headers: (_i = result2.response) == null ? void 0 : _i.headers,
-                  body: (_j = result2.response) == null ? void 0 : _j.body
+                  id: (_b2 = (_a18 = result2.response) == null ? void 0 : _a18.id) != null ? _b2 : generateId3(),
+                  timestamp: (_d2 = (_c2 = result2.response) == null ? void 0 : _c2.timestamp) != null ? _d2 : currentDate(),
+                  modelId: (_f = (_e = result2.response) == null ? void 0 : _e.modelId) != null ? _f : model.modelId,
+                  headers: (_g = result2.response) == null ? void 0 : _g.headers,
+                  body: (_h = result2.response) == null ? void 0 : _h.body
                 };
                 if (objectText === void 0) {
                   throw new NoObjectGeneratedError({
@@ -4799,8 +4845,8 @@ var DefaultStreamObjectResult = class {
             transformer = {
               transform: (chunk, controller) => {
                 switch (chunk.type) {
-                  case "text-delta":
-                    controller.enqueue(chunk.textDelta);
+                  case "text":
+                    controller.enqueue(chunk.text);
                     break;
                   case "response-metadata":
                   case "finish":
@@ -4866,7 +4912,7 @@ var DefaultStreamObjectResult = class {
           }
         }
         const {
-          result: { stream, warnings, response, request },
+          result: { stream, response, request },
           doStreamSpan,
           startTimestampMs
         } = await retry(
@@ -4908,6 +4954,7 @@ var DefaultStreamObjectResult = class {
           })
         );
         self.requestPromise.resolve(request != null ? request : {});
+        let warnings;
         let usage;
         let finishReason;
         let providerMetadata;
@@ -4928,6 +4975,10 @@ var DefaultStreamObjectResult = class {
           new TransformStream({
             async transform(chunk, controller) {
               var _a18, _b2, _c;
+              if (typeof chunk === "object" && chunk.type === "stream-start") {
+                warnings = chunk.warnings;
+                return;
+              }
               if (isFirstChunk) {
                 const msToFirstChunk = now2() - startTimestampMs;
                 isFirstChunk = false;
@@ -5451,7 +5502,7 @@ async function doParseToolCall({
   };
 }
 
-// core/generate-text/reasoning-detail.ts
+// core/generate-text/reasoning.ts
 function asReasoningText(reasoning) {
   const reasoningText = reasoning.filter((part) => part.type === "text").map((part) => part.text).join("");
   return reasoningText.length > 0 ? reasoningText : void 0;
@@ -5469,23 +5520,36 @@ function toResponseMessages({
   generateMessageId
 }) {
   const responseMessages = [];
-  responseMessages.push({
-    role: "assistant",
-    content: [
+  const content = [];
+  if (reasoning.length > 0) {
+    content.push(
       ...reasoning.map(
         (part) => part.type === "text" ? { ...part, type: "reasoning" } : { ...part, type: "redacted-reasoning" }
-      ),
-      // TODO language model v2: switch to order response content (instead of type-based ordering)
+      )
+    );
+  }
+  if (files.length > 0) {
+    content.push(
       ...files.map((file) => ({
         type: "file",
         data: file.base64,
         mediaType: file.mediaType
-      })),
-      { type: "text", text: text2 },
-      ...toolCalls
-    ],
-    id: messageId
-  });
+      }))
+    );
+  }
+  if (text2.length > 0) {
+    content.push({ type: "text", text: text2 });
+  }
+  if (toolCalls.length > 0) {
+    content.push(...toolCalls);
+  }
+  if (content.length > 0) {
+    responseMessages.push({
+      role: "assistant",
+      content,
+      id: messageId
+    });
+  }
   if (toolResults.length > 0) {
     responseMessages.push({
       role: "tool",
@@ -5589,7 +5653,7 @@ async function generateText({
     }),
     tracer,
     fn: async (span) => {
-      var _a18, _b, _c, _d, _e, _f, _g;
+      var _a18, _b, _c, _d;
       const toolsAndToolChoice = {
         ...prepareToolsAndToolChoice({ tools, toolChoice, activeTools })
       };
@@ -5664,7 +5728,7 @@ async function generateText({
             }),
             tracer,
             fn: async (span2) => {
-              var _a19, _b2, _c2, _d2, _e2, _f2, _g2, _h;
+              var _a19, _b2, _c2, _d2, _e, _f, _g, _h;
               const result = await model.doGenerate({
                 ...callSettings,
                 ...toolsAndToolChoice,
@@ -5678,8 +5742,8 @@ async function generateText({
               const responseData = {
                 id: (_b2 = (_a19 = result.response) == null ? void 0 : _a19.id) != null ? _b2 : generateId3(),
                 timestamp: (_d2 = (_c2 = result.response) == null ? void 0 : _c2.timestamp) != null ? _d2 : currentDate(),
-                modelId: (_f2 = (_e2 = result.response) == null ? void 0 : _e2.modelId) != null ? _f2 : model.modelId,
-                headers: (_g2 = result.response) == null ? void 0 : _g2.headers,
+                modelId: (_f = (_e = result.response) == null ? void 0 : _e.modelId) != null ? _f : model.modelId,
+                headers: (_g = result.response) == null ? void 0 : _g.headers,
                 body: (_h = result.response) == null ? void 0 : _h.body
               };
               span2.setAttributes(
@@ -5688,10 +5752,13 @@ async function generateText({
                   attributes: {
                     "ai.response.finishReason": result.finishReason,
                     "ai.response.text": {
-                      output: () => result.text
+                      output: () => extractContentText(result.content)
                     },
                     "ai.response.toolCalls": {
-                      output: () => JSON.stringify(result.toolCalls)
+                      output: () => {
+                        const toolCalls = asToolCalls(result.content);
+                        return toolCalls == null ? void 0 : JSON.stringify(toolCalls);
+                      }
                     },
                     "ai.response.id": responseData.id,
                     "ai.response.model": responseData.modelId,
@@ -5713,7 +5780,9 @@ async function generateText({
           })
         );
         currentToolCalls = await Promise.all(
-          ((_b = currentModelResponse.toolCalls) != null ? _b : []).map(
+          currentModelResponse.content.filter(
+            (part) => part.type === "tool-call"
+          ).map(
             (toolCall) => parseToolCall({
               toolCall,
               tools,
@@ -5748,15 +5817,19 @@ async function generateText({
             nextStepType = "tool-result";
           }
         }
-        const originalText = (_c = currentModelResponse.text) != null ? _c : "";
+        const originalText = (_b = extractContentText(currentModelResponse.content)) != null ? _b : "";
         const stepTextLeadingWhitespaceTrimmed = stepType === "continue" && // only for continue steps
         text2.trimEnd() !== text2 ? originalText.trimStart() : originalText;
         const stepText = nextStepType === "continue" ? removeTextAfterLastWhitespace(stepTextLeadingWhitespaceTrimmed) : stepTextLeadingWhitespaceTrimmed;
         text2 = nextStepType === "continue" || stepType === "continue" ? text2 + stepText : stepText;
         currentReasoningDetails = asReasoningDetails(
-          currentModelResponse.reasoning
+          currentModelResponse.content
+        );
+        sources.push(
+          ...currentModelResponse.content.filter(
+            (part) => part.type === "source"
+          )
         );
-        sources.push(...(_d = currentModelResponse.sources) != null ? _d : []);
         if (stepType === "continue") {
           const lastMessage = responseMessages[responseMessages.length - 1];
           if (typeof lastMessage.content === "string") {
@@ -5771,8 +5844,8 @@ async function generateText({
           responseMessages.push(
             ...toResponseMessages({
               text: text2,
-              files: asFiles(currentModelResponse.files),
-              reasoning: asReasoningDetails(currentModelResponse.reasoning),
+              files: asFiles(currentModelResponse.content),
+              reasoning: asReasoningDetails(currentModelResponse.content),
               tools: tools != null ? tools : {},
               toolCalls: currentToolCalls,
               toolResults: currentToolResults,
@@ -5784,18 +5857,19 @@ async function generateText({
         const currentStepResult = {
           stepType,
           text: stepText,
-          // TODO v5: rename reasoning to reasoningText (and use reasoning for composite array)
-          reasoning: asReasoningText(currentReasoningDetails),
-          reasoningDetails: currentReasoningDetails,
-          files: asFiles(currentModelResponse.files),
-          sources: (_e = currentModelResponse.sources) != null ? _e : [],
+          reasoningText: asReasoningText(currentReasoningDetails),
+          reasoning: currentReasoningDetails,
+          files: asFiles(currentModelResponse.content),
+          sources: currentModelResponse.content.filter(
+            (part) => part.type === "source"
+          ),
           toolCalls: currentToolCalls,
           toolResults: currentToolResults,
           finishReason: currentModelResponse.finishReason,
           usage: currentUsage,
           warnings: currentModelResponse.warnings,
           logprobs: currentModelResponse.logprobs,
-          request: (_f = currentModelResponse.request) != null ? _f : {},
+          request: (_c = currentModelResponse.request) != null ? _c : {},
           response: {
             ...currentModelResponse.response,
             // deep clone msgs to avoid mutating past messages in multi-step:
@@ -5814,10 +5888,13 @@ async function generateText({
           attributes: {
             "ai.response.finishReason": currentModelResponse.finishReason,
             "ai.response.text": {
-              output: () => currentModelResponse.text
+              output: () => extractContentText(currentModelResponse.content)
             },
             "ai.response.toolCalls": {
-              output: () => JSON.stringify(currentModelResponse.toolCalls)
+              output: () => {
+                const toolCalls = asToolCalls(currentModelResponse.content);
+                return toolCalls == null ? void 0 : JSON.stringify(toolCalls);
+              }
             },
             // TODO rename telemetry attributes to inputTokens and outputTokens
             "ai.usage.promptTokens": currentModelResponse.usage.inputTokens,
@@ -5827,7 +5904,7 @@ async function generateText({
       );
       return new DefaultGenerateTextResult({
         text: text2,
-        files: asFiles(currentModelResponse.files),
+        files: asFiles(currentModelResponse.content),
         reasoning: asReasoningText(currentReasoningDetails),
         reasoningDetails: currentReasoningDetails,
         sources,
@@ -5849,7 +5926,7 @@ async function generateText({
         finishReason: currentModelResponse.finishReason,
         usage,
         warnings: currentModelResponse.warnings,
-        request: (_g = currentModelResponse.request) != null ? _g : {},
+        request: (_d = currentModelResponse.request) != null ? _d : {},
         response: {
           ...currentModelResponse.response,
           messages: responseMessages
@@ -5940,8 +6017,8 @@ var DefaultGenerateTextResult = class {
   constructor(options) {
     this.text = options.text;
     this.files = options.files;
-    this.reasoning = options.reasoning;
-    this.reasoningDetails = options.reasoningDetails;
+    this.reasoningText = options.reasoning;
+    this.reasoning = options.reasoningDetails;
     this.toolCalls = options.toolCalls;
     this.toolResults = options.toolResults;
     this.finishReason = options.finishReason;
@@ -5959,18 +6036,50 @@ var DefaultGenerateTextResult = class {
     return this.outputResolver();
   }
 };
-function asReasoningDetails(reasoning) {
-  if (reasoning == null) {
+function asReasoningDetails(content) {
+  const reasoning = content.filter((part) => part.type === "reasoning");
+  if (reasoning.length === 0) {
     return [];
   }
-  if (typeof reasoning === "string") {
-    return [{ type: "text", text: reasoning }];
+  const result = [];
+  let activeReasoningText;
+  for (const part of reasoning) {
+    if (part.reasoningType === "text") {
+      if (activeReasoningText == null) {
+        activeReasoningText = { type: "text", text: part.text };
+        result.push(activeReasoningText);
+      } else {
+        activeReasoningText.text += part.text;
+      }
+    } else if (part.reasoningType === "signature") {
+      if (activeReasoningText == null) {
+        activeReasoningText = { type: "text", text: "" };
+        result.push(activeReasoningText);
+      }
+      activeReasoningText.signature = part.signature;
+      activeReasoningText = void 0;
+    } else if (part.reasoningType === "redacted") {
+      result.push({ type: "redacted", data: part.data });
+    }
   }
-  return reasoning;
+  return result;
 }
-function asFiles(files) {
-  var _a17;
-  return (_a17 = files == null ? void 0 : files.map((file) => new DefaultGeneratedFile(file))) != null ? _a17 : [];
+function asFiles(content) {
+  return content.filter((part) => part.type === "file").map((part) => new DefaultGeneratedFile(part));
+}
+function asToolCalls(content) {
+  const parts = content.filter(
+    (part) => part.type === "tool-call"
+  );
+  if (parts.length === 0) {
+    return void 0;
+  }
+  return parts.map((toolCall) => ({
+    toolCallType: toolCall.toolCallType,
+    toolCallId: toolCall.toolCallId,
+    toolName: toolCall.toolName,
+    args: toolCall.args
+  }));
 }
 
 // core/generate-text/output.ts
@@ -6166,18 +6275,18 @@ function smoothStream({
     let buffer = "";
     return new TransformStream({
       async transform(chunk, controller) {
-        if (chunk.type !== "text-delta") {
+        if (chunk.type !== "text") {
           if (buffer.length > 0) {
-            controller.enqueue({ type: "text-delta", textDelta: buffer });
+            controller.enqueue({ type: "text", text: buffer });
             buffer = "";
           }
           controller.enqueue(chunk);
           return;
         }
-        buffer += chunk.textDelta;
+        buffer += chunk.text;
         let match;
         while ((match = detectChunk(buffer)) != null) {
-          controller.enqueue({ type: "text-delta", textDelta: match });
+          controller.enqueue({ type: "text", text: match });
           buffer = buffer.slice(match.length);
           await delay2(delayInMs);
         }
@@ -6187,7 +6296,9 @@ function smoothStream({
 }
 
 // core/generate-text/stream-text.ts
-import { AISDKError as AISDKError18 } from "@ai-sdk/provider";
+import {
+  AISDKError as AISDKError18
+} from "@ai-sdk/provider";
 import { createIdGenerator as createIdGenerator4 } from "@ai-sdk/provider-utils";
 
 // util/as-array.ts
@@ -6336,10 +6447,9 @@ function runToolsTransformation({
     async transform(chunk, controller) {
       const chunkType = chunk.type;
       switch (chunkType) {
-        case "text-delta":
+        case "stream-start":
+        case "text":
         case "reasoning":
-        case "reasoning-signature":
-        case "redacted-reasoning":
         case "source":
         case "response-metadata":
         case "error": {
@@ -6347,12 +6457,13 @@ function runToolsTransformation({
           break;
         }
         case "file": {
-          controller.enqueue(
-            new DefaultGeneratedFileWithType({
+          controller.enqueue({
+            type: "file",
+            file: new DefaultGeneratedFileWithType({
               data: chunk.data,
               mediaType: chunk.mediaType
             })
-          );
+          });
           break;
         }
         case "tool-call-delta": {
@@ -6591,7 +6702,7 @@ function createOutputTransformStream(output) {
     partialOutput = void 0
   }) {
     controller.enqueue({
-      part: { type: "text-delta", textDelta: textChunk },
+      part: { type: "text", text: textChunk },
       partialOutput
     });
     textChunk = "";
@@ -6601,12 +6712,12 @@ function createOutputTransformStream(output) {
       if (chunk.type === "step-finish") {
         publishTextChunk({ controller });
       }
-      if (chunk.type !== "text-delta") {
+      if (chunk.type !== "text") {
         controller.enqueue({ part: chunk, partialOutput: void 0 });
         return;
       }
-      text2 += chunk.textDelta;
-      textChunk += chunk.textDelta;
+      text2 += chunk.text;
+      textChunk += chunk.text;
       const result = output.parsePartial({ text: text2 });
       if (result != null) {
         const currentJson = JSON.stringify(result.partial);
@@ -6701,44 +6812,44 @@ var DefaultStreamTextResult = class {
       async transform(chunk, controller) {
         controller.enqueue(chunk);
         const { part } = chunk;
-        if (part.type === "text-delta" || part.type === "reasoning" || part.type === "source" || part.type === "tool-call" || part.type === "tool-result" || part.type === "tool-call-streaming-start" || part.type === "tool-call-delta") {
+        if (part.type === "text" || part.type === "reasoning" || part.type === "source" || part.type === "tool-call" || part.type === "tool-result" || part.type === "tool-call-streaming-start" || part.type === "tool-call-delta") {
           await (onChunk == null ? void 0 : onChunk({ chunk: part }));
         }
         if (part.type === "error") {
           await (onError == null ? void 0 : onError({ error: part.error }));
         }
-        if (part.type === "text-delta") {
-          recordedStepText += part.textDelta;
-          recordedContinuationText += part.textDelta;
-          recordedFullText += part.textDelta;
+        if (part.type === "text") {
+          recordedStepText += part.text;
+          recordedContinuationText += part.text;
+          recordedFullText += part.text;
         }
         if (part.type === "reasoning") {
-          if (activeReasoningText == null) {
-            activeReasoningText = { type: "text", text: part.textDelta };
-            stepReasoning.push(activeReasoningText);
-          } else {
-            activeReasoningText.text += part.textDelta;
-          }
-        }
-        if (part.type === "reasoning-signature") {
-          if (activeReasoningText == null) {
-            throw new AISDKError18({
-              name: "InvalidStreamPart",
-              message: "reasoning-signature without reasoning"
-            });
+          if (part.reasoningType === "text") {
+            if (activeReasoningText == null) {
+              activeReasoningText = { type: "text", text: part.text };
+              stepReasoning.push(activeReasoningText);
+            } else {
+              activeReasoningText.text += part.text;
+            }
+          } else if (part.reasoningType === "signature") {
+            if (activeReasoningText == null) {
+              throw new AISDKError18({
+                name: "InvalidStreamPart",
+                message: "reasoning-signature without reasoning"
+              });
+            }
+            activeReasoningText.signature = part.signature;
+            activeReasoningText = void 0;
+          } else if (part.reasoningType === "redacted") {
+            stepReasoning.push({ type: "redacted", data: part.data });
           }
-          activeReasoningText.signature = part.signature;
-          activeReasoningText = void 0;
-        }
-        if (part.type === "redacted-reasoning") {
-          stepReasoning.push({ type: "redacted", data: part.data });
         }
         if (part.type === "file") {
-          stepFiles.push(part);
+          stepFiles.push(part.file);
         }
         if (part.type === "source") {
-          recordedSources.push(part.source);
-          recordedStepSources.push(part.source);
+          recordedSources.push(part);
+          recordedStepSources.push(part);
         }
         if (part.type === "tool-call") {
           recordedToolCalls.push(part);
@@ -6774,8 +6885,8 @@ var DefaultStreamTextResult = class {
           const currentStepResult = {
             stepType,
             text: recordedStepText,
-            reasoning: asReasoningText(stepReasoning),
-            reasoningDetails: stepReasoning,
+            reasoningText: asReasoningText(stepReasoning),
+            reasoning: stepReasoning,
             files: stepFiles,
             sources: recordedStepSources,
             toolCalls: recordedToolCalls,
@@ -6831,8 +6942,8 @@ var DefaultStreamTextResult = class {
           self.toolCallsPromise.resolve(lastStep.toolCalls);
           self.toolResultsPromise.resolve(lastStep.toolResults);
           self.providerMetadataPromise.resolve(lastStep.providerMetadata);
-          self.reasoningPromise.resolve(lastStep.reasoning);
-          self.reasoningDetailsPromise.resolve(lastStep.reasoningDetails);
+          self.reasoningPromise.resolve(lastStep.reasoningText);
+          self.reasoningDetailsPromise.resolve(lastStep.reasoning);
           const finishReason = recordedFinishReason != null ? recordedFinishReason : "unknown";
           const usage = recordedUsage != null ? recordedUsage : {
             completionTokens: NaN,
@@ -6850,8 +6961,8 @@ var DefaultStreamTextResult = class {
             logprobs: void 0,
             usage,
             text: recordedFullText,
+            reasoningText: lastStep.reasoningText,
             reasoning: lastStep.reasoning,
-            reasoningDetails: lastStep.reasoningDetails,
             files: lastStep.files,
             sources: lastStep.sources,
             toolCalls: lastStep.toolCalls,
@@ -6967,7 +7078,7 @@ var DefaultStreamTextResult = class {
             ...prepareToolsAndToolChoice({ tools, toolChoice, activeTools })
           };
           const {
-            result: { stream: stream2, warnings, response, request },
+            result: { stream: stream2, response, request },
             doStreamSpan,
             startTimestampMs
           } = await retry(
@@ -7044,6 +7155,7 @@ var DefaultStreamTextResult = class {
           const stepRequest = request != null ? request : {};
           const stepToolCalls = [];
           const stepToolResults = [];
+          let warnings;
           const stepReasoning2 = [];
           const stepFiles2 = [];
           let activeReasoningText2 = void 0;
@@ -7072,16 +7184,20 @@ var DefaultStreamTextResult = class {
             chunk
           }) {
             controller.enqueue(chunk);
-            stepText += chunk.textDelta;
-            fullStepText += chunk.textDelta;
+            stepText += chunk.text;
+            fullStepText += chunk.text;
             chunkTextPublished = true;
-            hasWhitespaceSuffix = chunk.textDelta.trimEnd() !== chunk.textDelta;
+            hasWhitespaceSuffix = chunk.text.trimEnd() !== chunk.text;
           }
           self.addStream(
             transformedStream.pipeThrough(
               new TransformStream({
                 async transform(chunk, controller) {
                   var _a19, _b, _c;
+                  if (chunk.type === "stream-start") {
+                    warnings = chunk.warnings;
+                    return;
+                  }
                   if (stepFirstChunk) {
                     const msToFirstChunk = now2() - startTimestampMs;
                     stepFirstChunk = false;
@@ -7098,14 +7214,14 @@ var DefaultStreamTextResult = class {
                       warnings: warnings != null ? warnings : []
                     });
                   }
-                  if (chunk.type === "text-delta" && chunk.textDelta.length === 0) {
+                  if (chunk.type === "text" && chunk.text.length === 0) {
                     return;
                   }
                   const chunkType = chunk.type;
                   switch (chunkType) {
-                    case "text-delta": {
+                    case "text": {
                       if (continueSteps) {
-                        const trimmedChunkText = inWhitespacePrefix && hasLeadingWhitespace ? chunk.textDelta.trimStart() : chunk.textDelta;
+                        const trimmedChunkText = inWhitespacePrefix && hasLeadingWhitespace ? chunk.text.trimStart() : chunk.text;
                         if (trimmedChunkText.length === 0) {
                           break;
                         }
@@ -7117,8 +7233,8 @@ var DefaultStreamTextResult = class {
                           await publishTextChunk({
                             controller,
                             chunk: {
-                              type: "text-delta",
-                              textDelta: split.prefix + split.whitespace
+                              type: "text",
+                              text: split.prefix + split.whitespace
                             }
                           });
                         }
@@ -7129,35 +7245,31 @@ var DefaultStreamTextResult = class {
                     }
                     case "reasoning": {
                       controller.enqueue(chunk);
-                      if (activeReasoningText2 == null) {
-                        activeReasoningText2 = {
-                          type: "text",
-                          text: chunk.textDelta
-                        };
-                        stepReasoning2.push(activeReasoningText2);
-                      } else {
-                        activeReasoningText2.text += chunk.textDelta;
-                      }
-                      break;
-                    }
-                    case "reasoning-signature": {
-                      controller.enqueue(chunk);
-                      if (activeReasoningText2 == null) {
-                        throw new InvalidStreamPartError({
-                          chunk,
-                          message: "reasoning-signature without reasoning"
+                      if (chunk.reasoningType === "text") {
+                        if (activeReasoningText2 == null) {
+                          activeReasoningText2 = {
+                            type: "text",
+                            text: chunk.text
+                          };
+                          stepReasoning2.push(activeReasoningText2);
+                        } else {
+                          activeReasoningText2.text += chunk.text;
+                        }
+                      } else if (chunk.reasoningType === "signature") {
+                        if (activeReasoningText2 == null) {
+                          throw new InvalidStreamPartError({
+                            chunk,
+                            message: "reasoning-signature without reasoning"
+                          });
+                        }
+                        activeReasoningText2.signature = chunk.signature;
+                        activeReasoningText2 = void 0;
+                      } else if (chunk.reasoningType === "redacted") {
+                        stepReasoning2.push({
+                          type: "redacted",
+                          data: chunk.data
                         });
                       }
-                      activeReasoningText2.signature = chunk.signature;
-                      activeReasoningText2 = void 0;
-                      break;
-                    }
-                    case "redacted-reasoning": {
-                      controller.enqueue(chunk);
-                      stepReasoning2.push({
-                        type: "redacted",
-                        data: chunk.data
-                      });
                       break;
                     }
                     case "tool-call": {
@@ -7192,7 +7304,7 @@ var DefaultStreamTextResult = class {
                       break;
                     }
                     case "file": {
-                      stepFiles2.push(chunk);
+                      stepFiles2.push(chunk.file);
                       controller.enqueue(chunk);
                       break;
                     }
@@ -7233,10 +7345,7 @@ var DefaultStreamTextResult = class {
                   stepType2 === "continue" && !chunkTextPublished)) {
                     await publishTextChunk({
                       controller,
-                      chunk: {
-                        type: "text-delta",
-                        textDelta: chunkBuffer
-                      }
+                      chunk: { type: "text", text: chunkBuffer }
                     });
                     chunkBuffer = "";
                   }
@@ -7381,10 +7490,10 @@ var DefaultStreamTextResult = class {
   get text() {
     return this.textPromise.value;
   }
-  get reasoning() {
+  get reasoningText() {
     return this.reasoningPromise.value;
   }
-  get reasoningDetails() {
+  get reasoning() {
     return this.reasoningDetailsPromise.value;
   }
   get sources() {
@@ -7426,8 +7535,8 @@ var DefaultStreamTextResult = class {
       this.teeStream().pipeThrough(
         new TransformStream({
           transform({ part }, controller) {
-            if (part.type === "text-delta") {
-              controller.enqueue(part.textDelta);
+            if (part.type === "text") {
+              controller.enqueue(part.text);
             }
           }
         })
@@ -7485,52 +7594,45 @@ var DefaultStreamTextResult = class {
         transform: async (chunk, controller) => {
           const chunkType = chunk.type;
           switch (chunkType) {
-            case "text-delta": {
-              controller.enqueue(formatDataStreamPart("text", chunk.textDelta));
+            case "text": {
+              controller.enqueue(formatDataStreamPart("text", chunk.text));
               break;
             }
             case "reasoning": {
               if (sendReasoning) {
-                controller.enqueue(
-                  formatDataStreamPart("reasoning", chunk.textDelta)
-                );
-              }
-              break;
-            }
-            case "redacted-reasoning": {
-              if (sendReasoning) {
-                controller.enqueue(
-                  formatDataStreamPart("redacted_reasoning", {
-                    data: chunk.data
-                  })
-                );
-              }
-              break;
-            }
-            case "reasoning-signature": {
-              if (sendReasoning) {
-                controller.enqueue(
-                  formatDataStreamPart("reasoning_signature", {
-                    signature: chunk.signature
-                  })
-                );
+                if (chunk.reasoningType === "text") {
+                  controller.enqueue(
+                    formatDataStreamPart("reasoning", chunk.text)
+                  );
+                } else if (chunk.reasoningType === "signature") {
+                  controller.enqueue(
+                    formatDataStreamPart("reasoning_signature", {
+                      signature: chunk.signature
+                    })
+                  );
+                } else if (chunk.reasoningType === "redacted") {
+                  controller.enqueue(
+                    formatDataStreamPart("redacted_reasoning", {
+                      data: chunk.data
+                    })
+                  );
+                }
               }
               break;
             }
             case "file": {
               controller.enqueue(
+                // TODO update protocol to v2 or replace with event stream
                 formatDataStreamPart("file", {
-                  mimeType: chunk.mediaType,
-                  data: chunk.base64
+                  mimeType: chunk.file.mediaType,
+                  data: chunk.file.base64
                 })
               );
               break;
             }
             case "source": {
               if (sendSources) {
-                controller.enqueue(
-                  formatDataStreamPart("source", chunk.source)
-                );
+                controller.enqueue(formatDataStreamPart("source", chunk));
               }
               break;
             }
@@ -7724,9 +7826,99 @@ var DefaultStreamTextResult = class {
   }
 };
 
-// errors/no-transcript-generated-error.ts
+// errors/no-speech-generated-error.ts
 import { AISDKError as AISDKError19 } from "@ai-sdk/provider";
-var NoTranscriptGeneratedError = class extends AISDKError19 {
+var NoSpeechGeneratedError = class extends AISDKError19 {
+  constructor(options) {
+    super({
+      name: "AI_NoSpeechGeneratedError",
+      message: "No speech audio generated."
+    });
+    this.responses = options.responses;
+  }
+};
+
+// core/generate-speech/generated-audio-file.ts
+var DefaultGeneratedAudioFile = class extends DefaultGeneratedFile {
+  constructor({
+    data,
+    mediaType
+  }) {
+    super({ data, mediaType });
+    let format = "mp3";
+    if (mediaType) {
+      const mimeTypeParts = mediaType.split("/");
+      if (mimeTypeParts.length === 2) {
+        if (mediaType !== "audio/mpeg") {
+          format = mimeTypeParts[1];
+        }
+      }
+    }
+    if (!format) {
+      throw new Error(
+        "Audio format must be provided or determinable from mimeType"
+      );
+    }
+    this.format = format;
+  }
+};
+
+// core/generate-speech/generate-speech.ts
+async function generateSpeech({
+  model,
+  text: text2,
+  voice,
+  outputFormat,
+  instructions,
+  speed,
+  providerOptions = {},
+  maxRetries: maxRetriesArg,
+  abortSignal,
+  headers
+}) {
+  var _a17;
+  const { retry } = prepareRetries({ maxRetries: maxRetriesArg });
+  const result = await retry(
+    () => model.doGenerate({
+      text: text2,
+      voice,
+      outputFormat,
+      instructions,
+      speed,
+      abortSignal,
+      headers,
+      providerOptions
+    })
+  );
+  if (!result.audio || result.audio.length === 0) {
+    throw new NoSpeechGeneratedError({ responses: [result.response] });
+  }
+  return new DefaultSpeechResult({
+    audio: new DefaultGeneratedAudioFile({
+      data: result.audio,
+      mediaType: (_a17 = detectMediaType({
+        data: result.audio,
+        signatures: audioMediaTypeSignatures
+      })) != null ? _a17 : "audio/mp3"
+    }),
+    warnings: result.warnings,
+    responses: [result.response],
+    providerMetadata: result.providerMetadata
+  });
+}
+var DefaultSpeechResult = class {
+  constructor(options) {
+    var _a17;
+    this.audio = options.audio;
+    this.warnings = options.warnings;
+    this.responses = options.responses;
+    this.providerMetadata = (_a17 = options.providerMetadata) != null ? _a17 : {};
+  }
+};
+
+// errors/no-transcript-generated-error.ts
+import { AISDKError as AISDKError20 } from "@ai-sdk/provider";
+var NoTranscriptGeneratedError = class extends AISDKError20 {
   constructor(options) {
     super({
       name: "AI_NoTranscriptGeneratedError",
@@ -7873,27 +8065,41 @@ function extractReasoningMiddleware({
   return {
     middlewareVersion: "v2",
     wrapGenerate: async ({ doGenerate }) => {
-      const { text: rawText, ...rest } = await doGenerate();
-      if (rawText == null) {
-        return { text: rawText, ...rest };
-      }
-      const text2 = startWithReasoning ? openingTag + rawText : rawText;
-      const regexp = new RegExp(`${openingTag}(.*?)${closingTag}`, "gs");
-      const matches = Array.from(text2.matchAll(regexp));
-      if (!matches.length) {
-        return { text: text2, ...rest };
-      }
-      const reasoning = matches.map((match) => match[1]).join(separator);
-      let textWithoutReasoning = text2;
-      for (let i = matches.length - 1; i >= 0; i--) {
-        const match = matches[i];
-        const beforeMatch = textWithoutReasoning.slice(0, match.index);
-        const afterMatch = textWithoutReasoning.slice(
-          match.index + match[0].length
-        );
-        textWithoutReasoning = beforeMatch + (beforeMatch.length > 0 && afterMatch.length > 0 ? separator : "") + afterMatch;
+      const { content, ...rest } = await doGenerate();
+      const transformedContent = [];
+      for (const part of content) {
+        if (part.type !== "text") {
+          transformedContent.push(part);
+          continue;
+        }
+        const text2 = startWithReasoning ? openingTag + part.text : part.text;
+        const regexp = new RegExp(`${openingTag}(.*?)${closingTag}`, "gs");
+        const matches = Array.from(text2.matchAll(regexp));
+        if (!matches.length) {
+          transformedContent.push(part);
+          continue;
+        }
+        const reasoningText = matches.map((match) => match[1]).join(separator);
+        let textWithoutReasoning = text2;
+        for (let i = matches.length - 1; i >= 0; i--) {
+          const match = matches[i];
+          const beforeMatch = textWithoutReasoning.slice(0, match.index);
+          const afterMatch = textWithoutReasoning.slice(
+            match.index + match[0].length
+          );
+          textWithoutReasoning = beforeMatch + (beforeMatch.length > 0 && afterMatch.length > 0 ? separator : "") + afterMatch;
+        }
+        transformedContent.push({
+          type: "reasoning",
+          reasoningType: "text",
+          text: reasoningText
+        });
+        transformedContent.push({
+          type: "text",
+          text: textWithoutReasoning
+        });
       }
-      return { ...rest, text: textWithoutReasoning, reasoning };
+      return { content: transformedContent, ...rest };
     },
     wrapStream: async ({ doStream }) => {
       const { stream, ...rest } = await doStream();
@@ -7906,18 +8112,24 @@ function extractReasoningMiddleware({
         stream: stream.pipeThrough(
           new TransformStream({
             transform: (chunk, controller) => {
-              if (chunk.type !== "text-delta") {
+              if (chunk.type !== "text") {
                 controller.enqueue(chunk);
                 return;
               }
-              buffer += chunk.textDelta;
+              buffer += chunk.text;
               function publish(text2) {
                 if (text2.length > 0) {
                   const prefix = afterSwitch && (isReasoning ? !isFirstReasoning : !isFirstText) ? separator : "";
-                  controller.enqueue({
-                    type: isReasoning ? "reasoning" : "text-delta",
-                    textDelta: prefix + text2
-                  });
+                  controller.enqueue(
+                    isReasoning ? {
+                      type: "reasoning",
+                      reasoningType: "text",
+                      text: prefix + text2
+                    } : {
+                      type: "text",
+                      text: prefix + text2
+                    }
+                  );
                   afterSwitch = false;
                   if (isReasoning) {
                     isFirstReasoning = false;
@@ -7962,60 +8174,13 @@ function simulateStreamingMiddleware() {
       const result = await doGenerate();
       const simulatedStream = new ReadableStream({
         start(controller) {
+          controller.enqueue({
+            type: "stream-start",
+            warnings: result.warnings
+          });
           controller.enqueue({ type: "response-metadata", ...result.response });
-          if (result.reasoning) {
-            if (typeof result.reasoning === "string") {
-              controller.enqueue({
-                type: "reasoning",
-                textDelta: result.reasoning
-              });
-            } else {
-              for (const reasoning of result.reasoning) {
-                switch (reasoning.type) {
-                  case "text": {
-                    controller.enqueue({
-                      type: "reasoning",
-                      textDelta: reasoning.text
-                    });
-                    if (reasoning.signature != null) {
-                      controller.enqueue({
-                        type: "reasoning-signature",
-                        signature: reasoning.signature
-                      });
-                    }
-                    break;
-                  }
-                  case "redacted": {
-                    controller.enqueue({
-                      type: "redacted-reasoning",
-                      data: reasoning.data
-                    });
-                    break;
-                  }
-                }
-              }
-            }
-          }
-          if (result.text) {
-            controller.enqueue({
-              type: "text-delta",
-              textDelta: result.text
-            });
-          }
-          if (result.toolCalls) {
-            for (const toolCall of result.toolCalls) {
-              controller.enqueue({
-                type: "tool-call-delta",
-                toolCallType: "function",
-                toolCallId: toolCall.toolCallId,
-                toolName: toolCall.toolName,
-                argsTextDelta: toolCall.args
-              });
-              controller.enqueue({
-                type: "tool-call",
-                ...toolCall
-              });
-            }
+          for (const part of result.content) {
+            controller.enqueue(part);
           }
           controller.enqueue({
             type: "finish",
@@ -8030,8 +8195,7 @@ function simulateStreamingMiddleware() {
       return {
         stream: simulatedStream,
         request: result.request,
-        response: result.response,
-        warnings: result.warnings
+        response: result.response
       };
     }
   };
@@ -8088,7 +8252,6 @@ var doWrap = ({
     }
   };
 };
-var experimental_wrapLanguageModel = wrapLanguageModel;
 
 // core/prompt/append-client-message.ts
 function appendClientMessage({
@@ -8102,7 +8265,7 @@ function appendClientMessage({
 }
 
 // core/prompt/append-response-messages.ts
-import { AISDKError as AISDKError20 } from "@ai-sdk/provider";
+import { AISDKError as AISDKError21 } from "@ai-sdk/provider";
 function appendResponseMessages({
   messages,
   responseMessages,
@@ -8185,7 +8348,7 @@ function appendResponseMessages({
                 break;
               case "file":
                 if (part.data instanceof URL) {
-                  throw new AISDKError20({
+                  throw new AISDKError21({
                     name: "InvalidAssistantFileData",
                     message: "File data cannot be a URL"
                   });
@@ -8319,7 +8482,7 @@ function customProvider({
 var experimental_customProvider = customProvider;
 
 // core/registry/no-such-provider-error.ts
-import { AISDKError as AISDKError21, NoSuchModelError as NoSuchModelError3 } from "@ai-sdk/provider";
+import { AISDKError as AISDKError22, NoSuchModelError as NoSuchModelError3 } from "@ai-sdk/provider";
 var name16 = "AI_NoSuchProviderError";
 var marker16 = `vercel.ai.error.${name16}`;
 var symbol16 = Symbol.for(marker16);
@@ -8338,7 +8501,7 @@ var NoSuchProviderError = class extends NoSuchModelError3 {
     this.availableProviders = availableProviders;
   }
   static isInstance(error) {
-    return AISDKError21.hasMarker(error, marker16);
+    return AISDKError22.hasMarker(error, marker16);
   }
 };
 _a16 = symbol16;
@@ -8389,7 +8552,7 @@ var DefaultProviderRegistry = class {
         message: `Invalid ${modelType} id for registry: ${id} (must be in the format "providerId${this.separator}modelId")`
       });
     }
-    return [id.slice(0, index), id.slice(index + 1)];
+    return [id.slice(0, index), id.slice(index + this.separator.length)];
   }
   languageModel(id) {
     var _a17, _b;
@@ -8981,7 +9144,7 @@ var MCPClient = class {
 };
 
 // core/util/cosine-similarity.ts
-function cosineSimilarity(vector1, vector2, options) {
+function cosineSimilarity(vector1, vector2) {
   if (vector1.length !== vector2.length) {
     throw new InvalidArgumentError({
       parameter: "vector1,vector2",
@@ -8991,13 +9154,6 @@ function cosineSimilarity(vector1, vector2, options) {
   }
   const n = vector1.length;
   if (n === 0) {
-    if (options == null ? void 0 : options.throwErrorForEmptyVectors) {
-      throw new InvalidArgumentError({
-        parameter: "vector1",
-        value: vector1,
-        message: "Vectors cannot be empty"
-      });
-    }
     return 0;
   }
   let magnitudeSquared1 = 0;
@@ -9323,8 +9479,8 @@ export {
   experimental_createProviderRegistry,
   experimental_customProvider,
   generateImage as experimental_generateImage,
+  generateSpeech as experimental_generateSpeech,
   transcribe as experimental_transcribe,
-  experimental_wrapLanguageModel,
   extractMaxToolInvocationStep,
   extractReasoningMiddleware,
   fillMessageParts,