ai 5.0.0-canary.11 → 5.0.0-canary.13

package/dist/internal/index.mjs

@@ -275,23 +275,11 @@ function convertToCoreMessages(messages, options) {
                   break;
                 }
                 case "reasoning": {
-                  for (const detail of part.details) {
-                    switch (detail.type) {
-                      case "text":
-                        content2.push({
-                          type: "reasoning",
-                          text: detail.text,
-                          signature: detail.signature
-                        });
-                        break;
-                      case "redacted":
-                        content2.push({
-                          type: "redacted-reasoning",
-                          data: detail.data
-                        });
-                        break;
-                    }
-                  }
+                  content2.push({
+                    type: "reasoning",
+                    text: part.reasoning,
+                    providerOptions: part.providerMetadata
+                  });
                   break;
                 }
                 case "tool-invocation":
@@ -561,11 +549,6 @@ var reasoningPartSchema = z5.object({
   text: z5.string(),
   providerOptions: providerMetadataSchema.optional()
 });
-var redactedReasoningPartSchema = z5.object({
-  type: z5.literal("redacted-reasoning"),
-  data: z5.string(),
-  providerOptions: providerMetadataSchema.optional()
-});
 var toolCallPartSchema = z5.object({
   type: z5.literal("tool-call"),
   toolCallId: z5.string(),
@@ -606,7 +589,6 @@ var coreAssistantMessageSchema = z6.object({
         textPartSchema,
         filePartSchema,
         reasoningPartSchema,
-        redactedReasoningPartSchema,
         toolCallPartSchema
       ])
     )
@@ -626,7 +608,7 @@ var coreMessageSchema = z6.union([
 ]);
 
 // core/prompt/standardize-prompt.ts
-function standardizePrompt({
+async function standardizePrompt({
   prompt,
   tools
 }) {
@@ -683,7 +665,7 @@ function standardizePrompt({
         message: "messages must not be empty"
       });
     }
-    const validationResult = safeValidateTypes({
+    const validationResult = await safeValidateTypes({
       value: messages,
       schema: z7.array(coreMessageSchema)
     });
@@ -706,6 +688,262 @@ function standardizePrompt({
 // core/util/index.ts
 import { generateId } from "@ai-sdk/provider-utils";
 
+// core/util/data-stream-parts.ts
+var textStreamPart = {
+  code: "0",
+  name: "text",
+  parse: (value) => {
+    if (typeof value !== "string") {
+      throw new Error('"text" parts expect a string value.');
+    }
+    return { type: "text", value };
+  }
+};
+var dataStreamPart = {
+  code: "2",
+  name: "data",
+  parse: (value) => {
+    if (!Array.isArray(value)) {
+      throw new Error('"data" parts expect an array value.');
+    }
+    return { type: "data", value };
+  }
+};
+var errorStreamPart = {
+  code: "3",
+  name: "error",
+  parse: (value) => {
+    if (typeof value !== "string") {
+      throw new Error('"error" parts expect a string value.');
+    }
+    return { type: "error", value };
+  }
+};
+var messageAnnotationsStreamPart = {
+  code: "8",
+  name: "message_annotations",
+  parse: (value) => {
+    if (!Array.isArray(value)) {
+      throw new Error('"message_annotations" parts expect an array value.');
+    }
+    return { type: "message_annotations", value };
+  }
+};
+var toolCallStreamPart = {
+  code: "9",
+  name: "tool_call",
+  parse: (value) => {
+    if (value == null || typeof value !== "object" || !("toolCallId" in value) || typeof value.toolCallId !== "string" || !("toolName" in value) || typeof value.toolName !== "string" || !("args" in value) || typeof value.args !== "object") {
+      throw new Error(
+        '"tool_call" parts expect an object with a "toolCallId", "toolName", and "args" property.'
+      );
+    }
+    return {
+      type: "tool_call",
+      value
+    };
+  }
+};
+var toolResultStreamPart = {
+  code: "a",
+  name: "tool_result",
+  parse: (value) => {
+    if (value == null || typeof value !== "object" || !("toolCallId" in value) || typeof value.toolCallId !== "string" || !("result" in value)) {
+      throw new Error(
+        '"tool_result" parts expect an object with a "toolCallId" and a "result" property.'
+      );
+    }
+    return {
+      type: "tool_result",
+      value
+    };
+  }
+};
+var toolCallStreamingStartStreamPart = {
+  code: "b",
+  name: "tool_call_streaming_start",
+  parse: (value) => {
+    if (value == null || typeof value !== "object" || !("toolCallId" in value) || typeof value.toolCallId !== "string" || !("toolName" in value) || typeof value.toolName !== "string") {
+      throw new Error(
+        '"tool_call_streaming_start" parts expect an object with a "toolCallId" and "toolName" property.'
+      );
+    }
+    return {
+      type: "tool_call_streaming_start",
+      value
+    };
+  }
+};
+var toolCallDeltaStreamPart = {
+  code: "c",
+  name: "tool_call_delta",
+  parse: (value) => {
+    if (value == null || typeof value !== "object" || !("toolCallId" in value) || typeof value.toolCallId !== "string" || !("argsTextDelta" in value) || typeof value.argsTextDelta !== "string") {
+      throw new Error(
+        '"tool_call_delta" parts expect an object with a "toolCallId" and "argsTextDelta" property.'
+      );
+    }
+    return {
+      type: "tool_call_delta",
+      value
+    };
+  }
+};
+var finishMessageStreamPart = {
+  code: "d",
+  name: "finish_message",
+  parse: (value) => {
+    if (value == null || typeof value !== "object" || !("finishReason" in value) || typeof value.finishReason !== "string") {
+      throw new Error(
+        '"finish_message" parts expect an object with a "finishReason" property.'
+      );
+    }
+    const result = {
+      finishReason: value.finishReason
+    };
+    if ("usage" in value && value.usage != null && typeof value.usage === "object" && "promptTokens" in value.usage && "completionTokens" in value.usage) {
+      result.usage = {
+        promptTokens: typeof value.usage.promptTokens === "number" ? value.usage.promptTokens : Number.NaN,
+        completionTokens: typeof value.usage.completionTokens === "number" ? value.usage.completionTokens : Number.NaN
+      };
+    }
+    return {
+      type: "finish_message",
+      value: result
+    };
+  }
+};
+var finishStepStreamPart = {
+  code: "e",
+  name: "finish_step",
+  parse: (value) => {
+    if (value == null || typeof value !== "object" || !("finishReason" in value) || typeof value.finishReason !== "string") {
+      throw new Error(
+        '"finish_step" parts expect an object with a "finishReason" property.'
+      );
+    }
+    const result = {
+      finishReason: value.finishReason,
+      isContinued: false
+    };
+    if ("usage" in value && value.usage != null && typeof value.usage === "object" && "promptTokens" in value.usage && "completionTokens" in value.usage) {
+      result.usage = {
+        promptTokens: typeof value.usage.promptTokens === "number" ? value.usage.promptTokens : Number.NaN,
+        completionTokens: typeof value.usage.completionTokens === "number" ? value.usage.completionTokens : Number.NaN
+      };
+    }
+    if ("isContinued" in value && typeof value.isContinued === "boolean") {
+      result.isContinued = value.isContinued;
+    }
+    return {
+      type: "finish_step",
+      value: result
+    };
+  }
+};
+var startStepStreamPart = {
+  code: "f",
+  name: "start_step",
+  parse: (value) => {
+    if (value == null || typeof value !== "object" || !("messageId" in value) || typeof value.messageId !== "string") {
+      throw new Error(
+        '"start_step" parts expect an object with an "id" property.'
+      );
+    }
+    return {
+      type: "start_step",
+      value: {
+        messageId: value.messageId
+      }
+    };
+  }
+};
+var reasoningStreamPart = {
+  code: "g",
+  name: "reasoning",
+  parse: (value) => {
+    if (value == null || typeof value !== "object" || !("text" in value) || typeof value.text !== "string" || "providerMetadata" in value && typeof value.providerMetadata !== "object") {
+      throw new Error(
+        '"reasoning" parts expect an object with a "text" property.'
+      );
+    }
+    return {
+      type: "reasoning",
+      value: {
+        text: value.text,
+        providerMetadata: value.providerMetadata
+      }
+    };
+  }
+};
+var sourcePart = {
+  code: "h",
+  name: "source",
+  parse: (value) => {
+    if (value == null || typeof value !== "object") {
+      throw new Error('"source" parts expect a Source object.');
+    }
+    return {
+      type: "source",
+      value
+    };
+  }
+};
+var fileStreamPart = {
+  code: "k",
+  name: "file",
+  parse: (value) => {
+    if (value == null || typeof value !== "object" || !("data" in value) || typeof value.data !== "string" || !("mimeType" in value) || typeof value.mimeType !== "string") {
+      throw new Error(
+        '"file" parts expect an object with a "data" and "mimeType" property.'
+      );
+    }
+    return { type: "file", value };
+  }
+};
+var reasoningPartFinishStreamPart = {
+  code: "l",
+  name: "reasoning_part_finish",
+  parse: () => {
+    return {
+      type: "reasoning_part_finish",
+      value: {}
+    };
+  }
+};
+var dataStreamParts = [
+  textStreamPart,
+  dataStreamPart,
+  errorStreamPart,
+  messageAnnotationsStreamPart,
+  toolCallStreamPart,
+  toolResultStreamPart,
+  toolCallStreamingStartStreamPart,
+  toolCallDeltaStreamPart,
+  finishMessageStreamPart,
+  finishStepStreamPart,
+  startStepStreamPart,
+  reasoningStreamPart,
+  sourcePart,
+  reasoningPartFinishStreamPart,
+  fileStreamPart
+];
+var dataStreamPartsByCode = Object.fromEntries(
+  dataStreamParts.map((part) => [part.code, part])
+);
+var DataStreamStringPrefixes = Object.fromEntries(
+  dataStreamParts.map((part) => [part.name, part.code])
+);
+var validCodes = dataStreamParts.map((part) => part.code);
+function formatDataStreamPart(type, value) {
+  const streamPart = dataStreamParts.find((part) => part.name === type);
+  if (!streamPart) {
+    throw new Error(`Invalid stream part type: ${type}`);
+  }
+  return `${streamPart.code}:${JSON.stringify(value)}
+`;
+}
+
 // core/util/schema.ts
 import { validatorSymbol } from "@ai-sdk/provider-utils";
 
@@ -1278,14 +1516,6 @@ function convertToLanguageModelMessage(message, downloadedAssets) {
               return {
                 type: "reasoning",
                 text: part.text,
-                signature: part.signature,
-                providerOptions
-              };
-            }
-            case "redacted-reasoning": {
-              return {
-                type: "redacted-reasoning",
-                data: part.data,
                 providerOptions
               };
             }
@@ -1436,13 +1666,213 @@ function calculateLanguageModelUsage({
   };
 }
 
+// core/util/prepare-response-headers.ts
+function prepareResponseHeaders(headers, {
+  contentType,
+  dataStreamVersion
+}) {
+  const responseHeaders = new Headers(headers != null ? headers : {});
+  if (!responseHeaders.has("Content-Type")) {
+    responseHeaders.set("Content-Type", contentType);
+  }
+  if (dataStreamVersion !== void 0) {
+    responseHeaders.set("X-Vercel-AI-Data-Stream", dataStreamVersion);
+  }
+  return responseHeaders;
+}
+
+// core/util/merge-streams.ts
+function mergeStreams(stream1, stream2) {
+  const reader1 = stream1.getReader();
+  const reader2 = stream2.getReader();
+  let lastRead1 = void 0;
+  let lastRead2 = void 0;
+  let stream1Done = false;
+  let stream2Done = false;
+  async function readStream1(controller) {
+    try {
+      if (lastRead1 == null) {
+        lastRead1 = reader1.read();
+      }
+      const result = await lastRead1;
+      lastRead1 = void 0;
+      if (!result.done) {
+        controller.enqueue(result.value);
+      } else {
+        controller.close();
+      }
+    } catch (error) {
+      controller.error(error);
+    }
+  }
+  async function readStream2(controller) {
+    try {
+      if (lastRead2 == null) {
+        lastRead2 = reader2.read();
+      }
+      const result = await lastRead2;
+      lastRead2 = void 0;
+      if (!result.done) {
+        controller.enqueue(result.value);
+      } else {
+        controller.close();
+      }
+    } catch (error) {
+      controller.error(error);
+    }
+  }
+  return new ReadableStream({
+    async pull(controller) {
+      try {
+        if (stream1Done) {
+          await readStream2(controller);
+          return;
+        }
+        if (stream2Done) {
+          await readStream1(controller);
+          return;
+        }
+        if (lastRead1 == null) {
+          lastRead1 = reader1.read();
+        }
+        if (lastRead2 == null) {
+          lastRead2 = reader2.read();
+        }
+        const { result, reader } = await Promise.race([
+          lastRead1.then((result2) => ({ result: result2, reader: reader1 })),
+          lastRead2.then((result2) => ({ result: result2, reader: reader2 }))
+        ]);
+        if (!result.done) {
+          controller.enqueue(result.value);
+        }
+        if (reader === reader1) {
+          lastRead1 = void 0;
+          if (result.done) {
+            await readStream2(controller);
+            stream1Done = true;
+          }
+        } else {
+          lastRead2 = void 0;
+          if (result.done) {
+            stream2Done = true;
+            await readStream1(controller);
+          }
+        }
+      } catch (error) {
+        controller.error(error);
+      }
+    },
+    cancel() {
+      reader1.cancel();
+      reader2.cancel();
+    }
+  });
+}
+
+// streams/stream-callbacks.ts
+function createCallbacksTransformer(callbacks = {}) {
+  const textEncoder = new TextEncoder();
+  let aggregatedResponse = "";
+  return new TransformStream({
+    async start() {
+      if (callbacks.onStart)
+        await callbacks.onStart();
+    },
+    async transform(message, controller) {
+      controller.enqueue(textEncoder.encode(message));
+      aggregatedResponse += message;
+      if (callbacks.onToken)
+        await callbacks.onToken(message);
+      if (callbacks.onText && typeof message === "string") {
+        await callbacks.onText(message);
+      }
+    },
+    async flush() {
+      if (callbacks.onCompletion) {
+        await callbacks.onCompletion(aggregatedResponse);
+      }
+      if (callbacks.onFinal) {
+        await callbacks.onFinal(aggregatedResponse);
+      }
+    }
+  });
+}
+
 // util/constants.ts
 var HANGING_STREAM_WARNING_TIME_MS = 15 * 1e3;
+
+// streams/stream-data.ts
+var StreamData = class {
+  constructor() {
+    this.encoder = new TextEncoder();
+    this.controller = null;
+    this.isClosed = false;
+    this.warningTimeout = null;
+    const self = this;
+    this.stream = new ReadableStream({
+      start: async (controller) => {
+        self.controller = controller;
+        if (process.env.NODE_ENV === "development") {
+          self.warningTimeout = setTimeout(() => {
+            console.warn(
+              "The data stream is hanging. Did you forget to close it with `data.close()`?"
+            );
+          }, HANGING_STREAM_WARNING_TIME_MS);
+        }
+      },
+      pull: (controller) => {
+      },
+      cancel: (reason) => {
+        this.isClosed = true;
+      }
+    });
+  }
+  async close() {
+    if (this.isClosed) {
+      throw new Error("Data Stream has already been closed.");
+    }
+    if (!this.controller) {
+      throw new Error("Stream controller is not initialized.");
+    }
+    this.controller.close();
+    this.isClosed = true;
+    if (this.warningTimeout) {
+      clearTimeout(this.warningTimeout);
+    }
+  }
+  append(value) {
+    if (this.isClosed) {
+      throw new Error("Data Stream has already been closed.");
+    }
+    if (!this.controller) {
+      throw new Error("Stream controller is not initialized.");
+    }
+    this.controller.enqueue(
+      this.encoder.encode(formatDataStreamPart("data", [value]))
+    );
+  }
+  appendMessageAnnotation(value) {
+    if (this.isClosed) {
+      throw new Error("Data Stream has already been closed.");
+    }
+    if (!this.controller) {
+      throw new Error("Stream controller is not initialized.");
+    }
+    this.controller.enqueue(
+      this.encoder.encode(formatDataStreamPart("message_annotations", [value]))
+    );
+  }
+};
 export {
   HANGING_STREAM_WARNING_TIME_MS,
+  StreamData,
   calculateLanguageModelUsage,
   convertToLanguageModelPrompt,
+  createCallbacksTransformer,
+  formatDataStreamPart,
+  mergeStreams,
   prepareCallSettings,
+  prepareResponseHeaders,
   prepareRetries,
   prepareToolsAndToolChoice,
   standardizePrompt