ai 5.0.14 → 5.0.16

package/dist/index.mjs

@@ -9670,6 +9670,223 @@ var TextStreamChatTransport = class extends HttpChatTransport {
   }
 };
 
+// src/ui/validate-ui-messages.ts
+import { TypeValidationError as TypeValidationError4 } from "@ai-sdk/provider";
+import {
+  validateTypes as validateTypes2
+} from "@ai-sdk/provider-utils";
+import { z as z10 } from "zod/v4";
+var textUIPartSchema = z10.object({
+  type: z10.literal("text"),
+  text: z10.string(),
+  state: z10.enum(["streaming", "done"]).optional(),
+  providerMetadata: providerMetadataSchema.optional()
+});
+var reasoningUIPartSchema = z10.object({
+  type: z10.literal("reasoning"),
+  text: z10.string(),
+  state: z10.enum(["streaming", "done"]).optional(),
+  providerMetadata: providerMetadataSchema.optional()
+});
+var sourceUrlUIPartSchema = z10.object({
+  type: z10.literal("source-url"),
+  sourceId: z10.string(),
+  url: z10.string(),
+  title: z10.string().optional(),
+  providerMetadata: providerMetadataSchema.optional()
+});
+var sourceDocumentUIPartSchema = z10.object({
+  type: z10.literal("source-document"),
+  sourceId: z10.string(),
+  mediaType: z10.string(),
+  title: z10.string(),
+  filename: z10.string().optional(),
+  providerMetadata: providerMetadataSchema.optional()
+});
+var fileUIPartSchema = z10.object({
+  type: z10.literal("file"),
+  mediaType: z10.string(),
+  filename: z10.string().optional(),
+  url: z10.string(),
+  providerMetadata: providerMetadataSchema.optional()
+});
+var stepStartUIPartSchema = z10.object({
+  type: z10.literal("step-start")
+});
+var dataUIPartSchema = z10.object({
+  type: z10.string().startsWith("data-"),
+  id: z10.string().optional(),
+  data: z10.unknown()
+});
+var dynamicToolUIPartSchemas = [
+  z10.object({
+    type: z10.literal("dynamic-tool"),
+    toolName: z10.string(),
+    toolCallId: z10.string(),
+    state: z10.literal("input-streaming"),
+    input: z10.unknown().optional(),
+    output: z10.never().optional(),
+    errorText: z10.never().optional()
+  }),
+  z10.object({
+    type: z10.literal("dynamic-tool"),
+    toolName: z10.string(),
+    toolCallId: z10.string(),
+    state: z10.literal("input-available"),
+    input: z10.unknown(),
+    output: z10.never().optional(),
+    errorText: z10.never().optional(),
+    callProviderMetadata: providerMetadataSchema.optional()
+  }),
+  z10.object({
+    type: z10.literal("dynamic-tool"),
+    toolName: z10.string(),
+    toolCallId: z10.string(),
+    state: z10.literal("output-available"),
+    input: z10.unknown(),
+    output: z10.unknown(),
+    errorText: z10.never().optional(),
+    callProviderMetadata: providerMetadataSchema.optional(),
+    preliminary: z10.boolean().optional()
+  }),
+  z10.object({
+    type: z10.literal("dynamic-tool"),
+    toolName: z10.string(),
+    toolCallId: z10.string(),
+    state: z10.literal("output-error"),
+    input: z10.unknown(),
+    output: z10.never().optional(),
+    errorText: z10.string(),
+    callProviderMetadata: providerMetadataSchema.optional()
+  })
+];
+var toolUIPartSchemas = [
+  z10.object({
+    type: z10.string().startsWith("tool-"),
+    toolCallId: z10.string(),
+    state: z10.literal("input-streaming"),
+    input: z10.unknown().optional(),
+    output: z10.never().optional(),
+    errorText: z10.never().optional()
+  }),
+  z10.object({
+    type: z10.string().startsWith("tool-"),
+    toolCallId: z10.string(),
+    state: z10.literal("input-available"),
+    input: z10.unknown(),
+    output: z10.never().optional(),
+    errorText: z10.never().optional(),
+    callProviderMetadata: providerMetadataSchema.optional()
+  }),
+  z10.object({
+    type: z10.string().startsWith("tool-"),
+    toolCallId: z10.string(),
+    state: z10.literal("output-available"),
+    input: z10.unknown(),
+    output: z10.unknown(),
+    errorText: z10.never().optional(),
+    callProviderMetadata: providerMetadataSchema.optional(),
+    preliminary: z10.boolean().optional()
+  }),
+  z10.object({
+    type: z10.string().startsWith("tool-"),
+    toolCallId: z10.string(),
+    state: z10.literal("output-error"),
+    input: z10.unknown(),
+    output: z10.never().optional(),
+    errorText: z10.string(),
+    callProviderMetadata: providerMetadataSchema.optional()
+  })
+];
+var uiMessageSchema = z10.object({
+  id: z10.string(),
+  role: z10.enum(["system", "user", "assistant"]),
+  metadata: z10.unknown().optional(),
+  parts: z10.array(
+    z10.union([
+      textUIPartSchema,
+      reasoningUIPartSchema,
+      sourceUrlUIPartSchema,
+      sourceDocumentUIPartSchema,
+      fileUIPartSchema,
+      stepStartUIPartSchema,
+      dataUIPartSchema,
+      ...dynamicToolUIPartSchemas,
+      ...toolUIPartSchemas
+    ])
+  )
+});
+async function validateUIMessages({
+  messages,
+  metadataSchema,
+  dataSchemas,
+  tools
+}) {
+  const validatedMessages = await validateTypes2({
+    value: messages,
+    schema: z10.array(uiMessageSchema)
+  });
+  if (metadataSchema) {
+    for (const message of validatedMessages) {
+      await validateTypes2({
+        value: message.metadata,
+        schema: metadataSchema
+      });
+    }
+  }
+  if (dataSchemas) {
+    for (const message of validatedMessages) {
+      const dataParts = message.parts.filter(
+        (part) => part.type.startsWith("data-")
+      );
+      for (const dataPart of dataParts) {
+        const dataName = dataPart.type.slice(5);
+        const dataSchema = dataSchemas[dataName];
+        if (!dataSchema) {
+          throw new TypeValidationError4({
+            value: dataPart.data,
+            cause: `No data schema found for data part ${dataName}`
+          });
+        }
+        await validateTypes2({
+          value: dataPart.data,
+          schema: dataSchema
+        });
+      }
+    }
+  }
+  if (tools) {
+    for (const message of validatedMessages) {
+      const toolParts = message.parts.filter(
+        (part) => part.type.startsWith("tool-")
+      );
+      for (const toolPart of toolParts) {
+        const toolName = toolPart.type.slice(5);
+        const tool3 = tools[toolName];
+        if (!tool3) {
+          throw new TypeValidationError4({
+            value: toolPart.input,
+            cause: `No tool schema found for tool part ${toolName}`
+          });
+        }
+        if (toolPart.state === "input-available" || toolPart.state === "output-available" || toolPart.state === "output-error") {
+          await validateTypes2({
+            value: toolPart.input,
+            schema: tool3.inputSchema
+          });
+        }
+        if (toolPart.state === "output-available" && tool3.outputSchema) {
+          await validateTypes2({
+            value: toolPart.output,
+            schema: tool3.outputSchema
+          });
+        }
+      }
+    }
+  }
+  return validatedMessages;
+}
+
 // src/ui-message-stream/create-ui-message-stream.ts
 import {
   generateId as generateIdFunc2,
@@ -9899,6 +10116,7 @@ export {
   tool2 as tool,
   toolModelMessageSchema,
   userModelMessageSchema,
+  validateUIMessages,
   wrapLanguageModel,
   wrapProvider,
   zodSchema