ai 6.0.0-beta.58 → 6.0.0-beta.60

package/dist/index.mjs

@@ -775,7 +775,7 @@ import {
 } from "@ai-sdk/provider-utils";
 
 // src/version.ts
-var VERSION = true ? "6.0.0-beta.58" : "0.0.0-test";
+var VERSION = true ? "6.0.0-beta.60" : "0.0.0-test";
 
 // src/util/download/download.ts
 var download = async ({ url }) => {
@@ -6245,6 +6245,185 @@ var DefaultStreamTextResult = class {
   }
 };
 
+// src/agent/tool-loop-agent.ts
+var ToolLoopAgent = class {
+  constructor(settings) {
+    this.version = "agent-v1";
+    this.settings = settings;
+  }
+  /**
+   * The id of the agent.
+   */
+  get id() {
+    return this.settings.id;
+  }
+  /**
+   * The tools that the agent can use.
+   */
+  get tools() {
+    return this.settings.tools;
+  }
+  /**
+   * Generates an output from the agent (non-streaming).
+   */
+  async generate(options) {
+    var _a17;
+    return generateText({
+      ...this.settings,
+      stopWhen: (_a17 = this.settings.stopWhen) != null ? _a17 : stepCountIs(20),
+      ...options
+    });
+  }
+  /**
+   * Streams an output from the agent (streaming).
+   */
+  stream(options) {
+    var _a17;
+    return streamText({
+      ...this.settings,
+      stopWhen: (_a17 = this.settings.stopWhen) != null ? _a17 : stepCountIs(20),
+      ...options
+    });
+  }
+};
+
+// src/ui-message-stream/create-ui-message-stream.ts
+import {
+  generateId as generateIdFunc,
+  getErrorMessage as getErrorMessage8
+} from "@ai-sdk/provider-utils";
+function createUIMessageStream({
+  execute,
+  onError = getErrorMessage8,
+  originalMessages,
+  onFinish,
+  generateId: generateId2 = generateIdFunc
+}) {
+  let controller;
+  const ongoingStreamPromises = [];
+  const stream = new ReadableStream({
+    start(controllerArg) {
+      controller = controllerArg;
+    }
+  });
+  function safeEnqueue(data) {
+    try {
+      controller.enqueue(data);
+    } catch (error) {
+    }
+  }
+  try {
+    const result = execute({
+      writer: {
+        write(part) {
+          safeEnqueue(part);
+        },
+        merge(streamArg) {
+          ongoingStreamPromises.push(
+            (async () => {
+              const reader = streamArg.getReader();
+              while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                  break;
+                safeEnqueue(value);
+              }
+            })().catch((error) => {
+              safeEnqueue({
+                type: "error",
+                errorText: onError(error)
+              });
+            })
+          );
+        },
+        onError
+      }
+    });
+    if (result) {
+      ongoingStreamPromises.push(
+        result.catch((error) => {
+          safeEnqueue({
+            type: "error",
+            errorText: onError(error)
+          });
+        })
+      );
+    }
+  } catch (error) {
+    safeEnqueue({
+      type: "error",
+      errorText: onError(error)
+    });
+  }
+  const waitForStreams = new Promise(async (resolve3) => {
+    while (ongoingStreamPromises.length > 0) {
+      await ongoingStreamPromises.shift();
+    }
+    resolve3();
+  });
+  waitForStreams.finally(() => {
+    try {
+      controller.close();
+    } catch (error) {
+    }
+  });
+  return handleUIMessageStreamFinish({
+    stream,
+    messageId: generateId2(),
+    originalMessages,
+    onFinish,
+    onError
+  });
+}
+
+// src/ui-message-stream/read-ui-message-stream.ts
+function readUIMessageStream({
+  message,
+  stream,
+  onError,
+  terminateOnError = false
+}) {
+  var _a17;
+  let controller;
+  let hasErrored = false;
+  const outputStream = new ReadableStream({
+    start(controllerParam) {
+      controller = controllerParam;
+    }
+  });
+  const state = createStreamingUIMessageState({
+    messageId: (_a17 = message == null ? void 0 : message.id) != null ? _a17 : "",
+    lastMessage: message
+  });
+  const handleError = (error) => {
+    onError == null ? void 0 : onError(error);
+    if (!hasErrored && terminateOnError) {
+      hasErrored = true;
+      controller == null ? void 0 : controller.error(error);
+    }
+  };
+  consumeStream({
+    stream: processUIMessageStream({
+      stream,
+      runUpdateMessageJob(job) {
+        return job({
+          state,
+          write: () => {
+            controller == null ? void 0 : controller.enqueue(structuredClone(state.message));
+          }
+        });
+      },
+      onError: handleError
+    }),
+    onError: handleError
+  }).finally(() => {
+    if (!hasErrored) {
+      controller == null ? void 0 : controller.close();
+    }
+  });
+  return createAsyncIterableStream(outputStream);
+}
+
 // src/ui/convert-to-model-messages.ts
 function convertToModelMessages(messages, options) {
   const modelMessages = [];
@@ -6450,90 +6629,439 @@ function convertToModelMessages(messages, options) {
 }
 var convertToCoreMessages = convertToModelMessages;
 
-// src/agent/tool-loop-agent.ts
-var ToolLoopAgent = class {
-  constructor(settings) {
-    this.version = "agent-v1";
-    this.settings = settings;
-  }
-  /**
-   * The id of the agent.
-   */
-  get id() {
-    return this.settings.id;
-  }
-  /**
-   * The tools that the agent can use.
-   */
-  get tools() {
-    return this.settings.tools;
-  }
-  /**
-   * Generates an output from the agent (non-streaming).
-   */
-  async generate(options) {
-    var _a17;
-    return generateText({
-      ...this.settings,
-      stopWhen: (_a17 = this.settings.stopWhen) != null ? _a17 : stepCountIs(20),
-      ...options
-    });
-  }
-  /**
-   * Streams an output from the agent (streaming).
-   */
-  stream(options) {
-    var _a17;
-    return streamText({
-      ...this.settings,
-      stopWhen: (_a17 = this.settings.stopWhen) != null ? _a17 : stepCountIs(20),
-      ...options
-    });
-  }
-  /**
-   * Creates a response object that streams UI messages to the client.
-   */
-  respond(options) {
-    return this.stream({
-      prompt: convertToModelMessages(options.messages, { tools: this.tools })
-    }).toUIMessageStreamResponse();
-  }
-};
-
-// src/embed/embed.ts
-import { withUserAgentSuffix as withUserAgentSuffix3 } from "@ai-sdk/provider-utils";
-async function embed({
-  model: modelArg,
-  value,
-  providerOptions,
-  maxRetries: maxRetriesArg,
-  abortSignal,
-  headers,
-  experimental_telemetry: telemetry
-}) {
-  const model = resolveEmbeddingModel(modelArg);
-  const { maxRetries, retry } = prepareRetries({
-    maxRetries: maxRetriesArg,
-    abortSignal
-  });
-  const headersWithUserAgent = withUserAgentSuffix3(
-    headers != null ? headers : {},
-    `ai/${VERSION}`
-  );
-  const baseTelemetryAttributes = getBaseTelemetryAttributes({
-    model,
-    telemetry,
-    headers: headersWithUserAgent,
-    settings: { maxRetries }
-  });
-  const tracer = getTracer(telemetry);
-  return recordSpan({
-    name: "ai.embed",
-    attributes: selectTelemetryAttributes({
-      telemetry,
-      attributes: {
-        ...assembleOperationName({ operationId: "ai.embed", telemetry }),
-        ...baseTelemetryAttributes,
+// src/ui/validate-ui-messages.ts
+import { TypeValidationError as TypeValidationError2 } from "@ai-sdk/provider";
+import {
+  lazySchema as lazySchema2,
+  validateTypes as validateTypes2,
+  zodSchema as zodSchema2
+} from "@ai-sdk/provider-utils";
+import { z as z8 } from "zod/v4";
+var uiMessagesSchema = lazySchema2(
+  () => zodSchema2(
+    z8.array(
+      z8.object({
+        id: z8.string(),
+        role: z8.enum(["system", "user", "assistant"]),
+        metadata: z8.unknown().optional(),
+        parts: z8.array(
+          z8.union([
+            z8.object({
+              type: z8.literal("text"),
+              text: z8.string(),
+              state: z8.enum(["streaming", "done"]).optional(),
+              providerMetadata: providerMetadataSchema.optional()
+            }),
+            z8.object({
+              type: z8.literal("reasoning"),
+              text: z8.string(),
+              state: z8.enum(["streaming", "done"]).optional(),
+              providerMetadata: providerMetadataSchema.optional()
+            }),
+            z8.object({
+              type: z8.literal("source-url"),
+              sourceId: z8.string(),
+              url: z8.string(),
+              title: z8.string().optional(),
+              providerMetadata: providerMetadataSchema.optional()
+            }),
+            z8.object({
+              type: z8.literal("source-document"),
+              sourceId: z8.string(),
+              mediaType: z8.string(),
+              title: z8.string(),
+              filename: z8.string().optional(),
+              providerMetadata: providerMetadataSchema.optional()
+            }),
+            z8.object({
+              type: z8.literal("file"),
+              mediaType: z8.string(),
+              filename: z8.string().optional(),
+              url: z8.string(),
+              providerMetadata: providerMetadataSchema.optional()
+            }),
+            z8.object({
+              type: z8.literal("step-start")
+            }),
+            z8.object({
+              type: z8.string().startsWith("data-"),
+              id: z8.string().optional(),
+              data: z8.unknown()
+            }),
+            z8.object({
+              type: z8.literal("dynamic-tool"),
+              toolName: z8.string(),
+              toolCallId: z8.string(),
+              state: z8.literal("input-streaming"),
+              input: z8.unknown().optional(),
+              providerExecuted: z8.boolean().optional(),
+              output: z8.never().optional(),
+              errorText: z8.never().optional(),
+              approval: z8.never().optional()
+            }),
+            z8.object({
+              type: z8.literal("dynamic-tool"),
+              toolName: z8.string(),
+              toolCallId: z8.string(),
+              state: z8.literal("input-available"),
+              input: z8.unknown(),
+              providerExecuted: z8.boolean().optional(),
+              output: z8.never().optional(),
+              errorText: z8.never().optional(),
+              callProviderMetadata: providerMetadataSchema.optional(),
+              approval: z8.never().optional()
+            }),
+            z8.object({
+              type: z8.literal("dynamic-tool"),
+              toolName: z8.string(),
+              toolCallId: z8.string(),
+              state: z8.literal("approval-requested"),
+              input: z8.unknown(),
+              providerExecuted: z8.boolean().optional(),
+              output: z8.never().optional(),
+              errorText: z8.never().optional(),
+              callProviderMetadata: providerMetadataSchema.optional(),
+              approval: z8.object({
+                id: z8.string(),
+                approved: z8.never().optional(),
+                reason: z8.never().optional()
+              })
+            }),
+            z8.object({
+              type: z8.literal("dynamic-tool"),
+              toolName: z8.string(),
+              toolCallId: z8.string(),
+              state: z8.literal("approval-responded"),
+              input: z8.unknown(),
+              providerExecuted: z8.boolean().optional(),
+              output: z8.never().optional(),
+              errorText: z8.never().optional(),
+              callProviderMetadata: providerMetadataSchema.optional(),
+              approval: z8.object({
+                id: z8.string(),
+                approved: z8.boolean(),
+                reason: z8.string().optional()
+              })
+            }),
+            z8.object({
+              type: z8.literal("dynamic-tool"),
+              toolName: z8.string(),
+              toolCallId: z8.string(),
+              state: z8.literal("output-available"),
+              input: z8.unknown(),
+              providerExecuted: z8.boolean().optional(),
+              output: z8.unknown(),
+              errorText: z8.never().optional(),
+              callProviderMetadata: providerMetadataSchema.optional(),
+              preliminary: z8.boolean().optional(),
+              approval: z8.object({
+                id: z8.string(),
+                approved: z8.literal(true),
+                reason: z8.string().optional()
+              }).optional()
+            }),
+            z8.object({
+              type: z8.literal("dynamic-tool"),
+              toolName: z8.string(),
+              toolCallId: z8.string(),
+              state: z8.literal("output-error"),
+              input: z8.unknown(),
+              providerExecuted: z8.boolean().optional(),
+              output: z8.never().optional(),
+              errorText: z8.string(),
+              callProviderMetadata: providerMetadataSchema.optional(),
+              approval: z8.object({
+                id: z8.string(),
+                approved: z8.literal(true),
+                reason: z8.string().optional()
+              }).optional()
+            }),
+            z8.object({
+              type: z8.literal("dynamic-tool"),
+              toolName: z8.string(),
+              toolCallId: z8.string(),
+              state: z8.literal("output-denied"),
+              input: z8.unknown(),
+              providerExecuted: z8.boolean().optional(),
+              output: z8.never().optional(),
+              errorText: z8.never().optional(),
+              callProviderMetadata: providerMetadataSchema.optional(),
+              approval: z8.object({
+                id: z8.string(),
+                approved: z8.literal(false),
+                reason: z8.string().optional()
+              })
+            }),
+            z8.object({
+              type: z8.string().startsWith("tool-"),
+              toolCallId: z8.string(),
+              state: z8.literal("input-streaming"),
+              providerExecuted: z8.boolean().optional(),
+              input: z8.unknown().optional(),
+              output: z8.never().optional(),
+              errorText: z8.never().optional(),
+              approval: z8.never().optional()
+            }),
+            z8.object({
+              type: z8.string().startsWith("tool-"),
+              toolCallId: z8.string(),
+              state: z8.literal("input-available"),
+              providerExecuted: z8.boolean().optional(),
+              input: z8.unknown(),
+              output: z8.never().optional(),
+              errorText: z8.never().optional(),
+              callProviderMetadata: providerMetadataSchema.optional(),
+              approval: z8.never().optional()
+            }),
+            z8.object({
+              type: z8.string().startsWith("tool-"),
+              toolCallId: z8.string(),
+              state: z8.literal("approval-requested"),
+              input: z8.unknown(),
+              providerExecuted: z8.boolean().optional(),
+              output: z8.never().optional(),
+              errorText: z8.never().optional(),
+              callProviderMetadata: providerMetadataSchema.optional(),
+              approval: z8.object({
+                id: z8.string(),
+                approved: z8.never().optional(),
+                reason: z8.never().optional()
+              })
+            }),
+            z8.object({
+              type: z8.string().startsWith("tool-"),
+              toolCallId: z8.string(),
+              state: z8.literal("approval-responded"),
+              input: z8.unknown(),
+              providerExecuted: z8.boolean().optional(),
+              output: z8.never().optional(),
+              errorText: z8.never().optional(),
+              callProviderMetadata: providerMetadataSchema.optional(),
+              approval: z8.object({
+                id: z8.string(),
+                approved: z8.boolean(),
+                reason: z8.string().optional()
+              })
+            }),
+            z8.object({
+              type: z8.string().startsWith("tool-"),
+              toolCallId: z8.string(),
+              state: z8.literal("output-available"),
+              providerExecuted: z8.boolean().optional(),
+              input: z8.unknown(),
+              output: z8.unknown(),
+              errorText: z8.never().optional(),
+              callProviderMetadata: providerMetadataSchema.optional(),
+              preliminary: z8.boolean().optional(),
+              approval: z8.object({
+                id: z8.string(),
+                approved: z8.literal(true),
+                reason: z8.string().optional()
+              }).optional()
+            }),
+            z8.object({
+              type: z8.string().startsWith("tool-"),
+              toolCallId: z8.string(),
+              state: z8.literal("output-error"),
+              providerExecuted: z8.boolean().optional(),
+              input: z8.unknown(),
+              output: z8.never().optional(),
+              errorText: z8.string(),
+              callProviderMetadata: providerMetadataSchema.optional(),
+              approval: z8.object({
+                id: z8.string(),
+                approved: z8.literal(true),
+                reason: z8.string().optional()
+              }).optional()
+            }),
+            z8.object({
+              type: z8.string().startsWith("tool-"),
+              toolCallId: z8.string(),
+              state: z8.literal("output-denied"),
+              providerExecuted: z8.boolean().optional(),
+              input: z8.unknown(),
+              output: z8.never().optional(),
+              errorText: z8.never().optional(),
+              callProviderMetadata: providerMetadataSchema.optional(),
+              approval: z8.object({
+                id: z8.string(),
+                approved: z8.literal(false),
+                reason: z8.string().optional()
+              })
+            })
+          ])
+        )
+      })
+    )
+  )
+);
+async function safeValidateUIMessages({
+  messages,
+  metadataSchema,
+  dataSchemas,
+  tools
+}) {
+  try {
+    if (messages == null) {
+      return {
+        success: false,
+        error: new InvalidArgumentError({
+          parameter: "messages",
+          value: messages,
+          message: "messages parameter must be provided"
+        })
+      };
+    }
+    const validatedMessages = await validateTypes2({
+      value: messages,
+      schema: uiMessagesSchema
+    });
+    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) {
+            return {
+              success: false,
+              error: new TypeValidationError2({
+                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) {
+            return {
+              success: false,
+              error: new TypeValidationError2({
+                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 {
+      success: true,
+      data: validatedMessages
+    };
+  } catch (error) {
+    const err = error;
+    return {
+      success: false,
+      error: err
+    };
+  }
+}
+async function validateUIMessages({
+  messages,
+  metadataSchema,
+  dataSchemas,
+  tools
+}) {
+  const response = await safeValidateUIMessages({
+    messages,
+    metadataSchema,
+    dataSchemas,
+    tools
+  });
+  if (!response.success)
+    throw response.error;
+  return response.data;
+}
+
+// src/agent/create-agent-stream-response.ts
+async function createAgentStreamResponse({
+  agent,
+  messages,
+  ...options
+}) {
+  const validatedMessages = await validateUIMessages({
+    messages,
+    tools: agent.tools
+  });
+  const modelMessages = convertToModelMessages(validatedMessages, {
+    tools: agent.tools
+  });
+  const result = agent.stream({ prompt: modelMessages });
+  return createUIMessageStreamResponse({
+    stream: result.toUIMessageStream(options)
+  });
+}
+
+// src/embed/embed.ts
+import { withUserAgentSuffix as withUserAgentSuffix3 } from "@ai-sdk/provider-utils";
+async function embed({
+  model: modelArg,
+  value,
+  providerOptions,
+  maxRetries: maxRetriesArg,
+  abortSignal,
+  headers,
+  experimental_telemetry: telemetry
+}) {
+  const model = resolveEmbeddingModel(modelArg);
+  const { maxRetries, retry } = prepareRetries({
+    maxRetries: maxRetriesArg,
+    abortSignal
+  });
+  const headersWithUserAgent = withUserAgentSuffix3(
+    headers != null ? headers : {},
+    `ai/${VERSION}`
+  );
+  const baseTelemetryAttributes = getBaseTelemetryAttributes({
+    model,
+    telemetry,
+    headers: headersWithUserAgent,
+    settings: { maxRetries }
+  });
+  const tracer = getTracer(telemetry);
+  return recordSpan({
+    name: "ai.embed",
+    attributes: selectTelemetryAttributes({
+      telemetry,
+      attributes: {
+        ...assembleOperationName({ operationId: "ai.embed", telemetry }),
+        ...baseTelemetryAttributes,
         "ai.value": { input: () => JSON.stringify(value) }
       }
     }),
@@ -7004,7 +7532,7 @@ function extractReasoningContent(content) {
 import {
   isJSONArray,
   isJSONObject,
-  TypeValidationError as TypeValidationError2,
+  TypeValidationError as TypeValidationError3,
   UnsupportedFunctionalityError as UnsupportedFunctionalityError2
 } from "@ai-sdk/provider";
 import {
@@ -7085,7 +7613,7 @@ var arrayOutputStrategy = (schema) => {
       if (!isJSONObject(value) || !isJSONArray(value.elements)) {
         return {
           success: false,
-          error: new TypeValidationError2({
+          error: new TypeValidationError3({
             value,
             cause: "value must be an object that contains an array of elements"
           })
@@ -7128,7 +7656,7 @@ var arrayOutputStrategy = (schema) => {
       if (!isJSONObject(value) || !isJSONArray(value.elements)) {
         return {
           success: false,
-          error: new TypeValidationError2({
+          error: new TypeValidationError3({
             value,
             cause: "value must be an object that contains an array of elements"
           })
@@ -7194,7 +7722,7 @@ var enumOutputStrategy = (enumValues) => {
       if (!isJSONObject(value) || typeof value.result !== "string") {
         return {
           success: false,
-          error: new TypeValidationError2({
+          error: new TypeValidationError3({
             value,
             cause: 'value must be an object that contains a string in the "result" property.'
           })
@@ -7203,7 +7731,7 @@ var enumOutputStrategy = (enumValues) => {
       const result = value.result;
       return enumValues.includes(result) ? { success: true, value: result } : {
         success: false,
-        error: new TypeValidationError2({
+        error: new TypeValidationError3({
           value,
           cause: "value must be a string in the enum"
         })
@@ -7213,7 +7741,7 @@ var enumOutputStrategy = (enumValues) => {
       if (!isJSONObject(value) || typeof value.result !== "string") {
         return {
           success: false,
-          error: new TypeValidationError2({
+          error: new TypeValidationError3({
             value,
             cause: 'value must be an object that contains a string in the "result" property.'
           })
@@ -7226,7 +7754,7 @@ var enumOutputStrategy = (enumValues) => {
       if (value.result.length === 0 || possibleEnumValues.length === 0) {
         return {
           success: false,
-          error: new TypeValidationError2({
+          error: new TypeValidationError3({
             value,
             cause: "value must be a string in the enum"
           })
@@ -7269,7 +7797,7 @@ function getOutputStrategy({
 }
 
 // src/generate-object/parse-and-validate-object-result.ts
-import { JSONParseError as JSONParseError2, TypeValidationError as TypeValidationError3 } from "@ai-sdk/provider";
+import { JSONParseError as JSONParseError2, TypeValidationError as TypeValidationError4 } from "@ai-sdk/provider";
 import { safeParseJSON as safeParseJSON3 } from "@ai-sdk/provider-utils";
 async function parseAndValidateObjectResult(result, outputStrategy, context) {
   const parseResult = await safeParseJSON3({ text: result });
@@ -7307,7 +7835,7 @@ async function parseAndValidateObjectResultWithRepair(result, outputStrategy, re
   try {
     return await parseAndValidateObjectResult(result, outputStrategy, context);
   } catch (error) {
-    if (repairText != null && NoObjectGeneratedError.isInstance(error) && (JSONParseError2.isInstance(error.cause) || TypeValidationError3.isInstance(error.cause))) {
+    if (repairText != null && NoObjectGeneratedError.isInstance(error) && (JSONParseError2.isInstance(error.cause) || TypeValidationError4.isInstance(error.cause))) {
       const repairedText = await repairText({
         text: result,
         error: error.cause
@@ -9248,137 +9776,137 @@ import {
 } from "@ai-sdk/provider-utils";
 
 // src/tool/mcp/json-rpc-message.ts
-import { z as z9 } from "zod/v4";
+import { z as z10 } from "zod/v4";
 
 // src/tool/mcp/types.ts
-import { z as z8 } from "zod/v4";
+import { z as z9 } from "zod/v4";
 var LATEST_PROTOCOL_VERSION = "2025-06-18";
 var SUPPORTED_PROTOCOL_VERSIONS = [
   LATEST_PROTOCOL_VERSION,
   "2025-03-26",
   "2024-11-05"
 ];
-var ClientOrServerImplementationSchema = z8.looseObject({
-  name: z8.string(),
-  version: z8.string()
+var ClientOrServerImplementationSchema = z9.looseObject({
+  name: z9.string(),
+  version: z9.string()
 });
-var BaseParamsSchema = z8.looseObject({
-  _meta: z8.optional(z8.object({}).loose())
+var BaseParamsSchema = z9.looseObject({
+  _meta: z9.optional(z9.object({}).loose())
 });
 var ResultSchema = BaseParamsSchema;
-var RequestSchema = z8.object({
-  method: z8.string(),
-  params: z8.optional(BaseParamsSchema)
+var RequestSchema = z9.object({
+  method: z9.string(),
+  params: z9.optional(BaseParamsSchema)
 });
-var ServerCapabilitiesSchema = z8.looseObject({
-  experimental: z8.optional(z8.object({}).loose()),
-  logging: z8.optional(z8.object({}).loose()),
-  prompts: z8.optional(
-    z8.looseObject({
-      listChanged: z8.optional(z8.boolean())
+var ServerCapabilitiesSchema = z9.looseObject({
+  experimental: z9.optional(z9.object({}).loose()),
+  logging: z9.optional(z9.object({}).loose()),
+  prompts: z9.optional(
+    z9.looseObject({
+      listChanged: z9.optional(z9.boolean())
     })
   ),
-  resources: z8.optional(
-    z8.looseObject({
-      subscribe: z8.optional(z8.boolean()),
-      listChanged: z8.optional(z8.boolean())
+  resources: z9.optional(
+    z9.looseObject({
+      subscribe: z9.optional(z9.boolean()),
+      listChanged: z9.optional(z9.boolean())
     })
   ),
-  tools: z8.optional(
-    z8.looseObject({
-      listChanged: z8.optional(z8.boolean())
+  tools: z9.optional(
+    z9.looseObject({
+      listChanged: z9.optional(z9.boolean())
     })
   )
 });
 var InitializeResultSchema = ResultSchema.extend({
-  protocolVersion: z8.string(),
+  protocolVersion: z9.string(),
   capabilities: ServerCapabilitiesSchema,
   serverInfo: ClientOrServerImplementationSchema,
-  instructions: z8.optional(z8.string())
+  instructions: z9.optional(z9.string())
 });
 var PaginatedResultSchema = ResultSchema.extend({
-  nextCursor: z8.optional(z8.string())
+  nextCursor: z9.optional(z9.string())
 });
-var ToolSchema = z8.object({
-  name: z8.string(),
-  description: z8.optional(z8.string()),
-  inputSchema: z8.object({
-    type: z8.literal("object"),
-    properties: z8.optional(z8.object({}).loose())
+var ToolSchema = z9.object({
+  name: z9.string(),
+  description: z9.optional(z9.string()),
+  inputSchema: z9.object({
+    type: z9.literal("object"),
+    properties: z9.optional(z9.object({}).loose())
   }).loose()
 }).loose();
 var ListToolsResultSchema = PaginatedResultSchema.extend({
-  tools: z8.array(ToolSchema)
+  tools: z9.array(ToolSchema)
 });
-var TextContentSchema = z8.object({
-  type: z8.literal("text"),
-  text: z8.string()
+var TextContentSchema = z9.object({
+  type: z9.literal("text"),
+  text: z9.string()
 }).loose();
-var ImageContentSchema = z8.object({
-  type: z8.literal("image"),
-  data: z8.base64(),
-  mimeType: z8.string()
+var ImageContentSchema = z9.object({
+  type: z9.literal("image"),
+  data: z9.base64(),
+  mimeType: z9.string()
 }).loose();
-var ResourceContentsSchema = z8.object({
+var ResourceContentsSchema = z9.object({
   /**
    * The URI of this resource.
    */
-  uri: z8.string(),
+  uri: z9.string(),
   /**
    * The MIME type of this resource, if known.
    */
-  mimeType: z8.optional(z8.string())
+  mimeType: z9.optional(z9.string())
 }).loose();
 var TextResourceContentsSchema = ResourceContentsSchema.extend({
-  text: z8.string()
+  text: z9.string()
 });
 var BlobResourceContentsSchema = ResourceContentsSchema.extend({
-  blob: z8.base64()
+  blob: z9.base64()
 });
-var EmbeddedResourceSchema = z8.object({
-  type: z8.literal("resource"),
-  resource: z8.union([TextResourceContentsSchema, BlobResourceContentsSchema])
+var EmbeddedResourceSchema = z9.object({
+  type: z9.literal("resource"),
+  resource: z9.union([TextResourceContentsSchema, BlobResourceContentsSchema])
 }).loose();
 var CallToolResultSchema = ResultSchema.extend({
-  content: z8.array(
-    z8.union([TextContentSchema, ImageContentSchema, EmbeddedResourceSchema])
+  content: z9.array(
+    z9.union([TextContentSchema, ImageContentSchema, EmbeddedResourceSchema])
   ),
-  isError: z8.boolean().default(false).optional()
+  isError: z9.boolean().default(false).optional()
 }).or(
   ResultSchema.extend({
-    toolResult: z8.unknown()
+    toolResult: z9.unknown()
   })
 );
 
 // src/tool/mcp/json-rpc-message.ts
 var JSONRPC_VERSION = "2.0";
-var JSONRPCRequestSchema = z9.object({
-  jsonrpc: z9.literal(JSONRPC_VERSION),
-  id: z9.union([z9.string(), z9.number().int()])
+var JSONRPCRequestSchema = z10.object({
+  jsonrpc: z10.literal(JSONRPC_VERSION),
+  id: z10.union([z10.string(), z10.number().int()])
 }).merge(RequestSchema).strict();
-var JSONRPCResponseSchema = z9.object({
-  jsonrpc: z9.literal(JSONRPC_VERSION),
-  id: z9.union([z9.string(), z9.number().int()]),
+var JSONRPCResponseSchema = z10.object({
+  jsonrpc: z10.literal(JSONRPC_VERSION),
+  id: z10.union([z10.string(), z10.number().int()]),
   result: ResultSchema
 }).strict();
-var JSONRPCErrorSchema = z9.object({
-  jsonrpc: z9.literal(JSONRPC_VERSION),
-  id: z9.union([z9.string(), z9.number().int()]),
-  error: z9.object({
-    code: z9.number().int(),
-    message: z9.string(),
-    data: z9.optional(z9.unknown())
+var JSONRPCErrorSchema = z10.object({
+  jsonrpc: z10.literal(JSONRPC_VERSION),
+  id: z10.union([z10.string(), z10.number().int()]),
+  error: z10.object({
+    code: z10.number().int(),
+    message: z10.string(),
+    data: z10.optional(z10.unknown())
   })
 }).strict();
-var JSONRPCNotificationSchema = z9.object({
-  jsonrpc: z9.literal(JSONRPC_VERSION)
+var JSONRPCNotificationSchema = z10.object({
+  jsonrpc: z10.literal(JSONRPC_VERSION)
 }).merge(
-  z9.object({
-    method: z9.string(),
-    params: z9.optional(BaseParamsSchema)
+  z10.object({
+    method: z10.string(),
+    params: z10.optional(BaseParamsSchema)
   })
 ).strict();
-var JSONRPCMessageSchema = z9.union([
+var JSONRPCMessageSchema = z10.union([
   JSONRPCRequestSchema,
   JSONRPCNotificationSchema,
   JSONRPCResponseSchema,
@@ -10037,7 +10565,7 @@ async function callCompletionApi({
 
 // src/ui/chat.ts
 import {
-  generateId as generateIdFunc
+  generateId as generateIdFunc2
 } from "@ai-sdk/provider-utils";
 
 // src/ui/convert-file-list-to-file-ui-parts.ts
@@ -10218,7 +10746,7 @@ var DefaultChatTransport = class extends HttpChatTransport {
 // src/ui/chat.ts
 var AbstractChat = class {
   constructor({
-    generateId: generateId2 = generateIdFunc,
+    generateId: generateId2 = generateIdFunc2,
     id = generateId2(),
     transport = new DefaultChatTransport(),
     messageMetadataSchema,
@@ -10644,523 +11172,6 @@ var TextStreamChatTransport = class extends HttpChatTransport {
     });
   }
 };
-
-// src/ui/validate-ui-messages.ts
-import { TypeValidationError as TypeValidationError4 } from "@ai-sdk/provider";
-import {
-  lazySchema as lazySchema2,
-  validateTypes as validateTypes2,
-  zodSchema as zodSchema2
-} from "@ai-sdk/provider-utils";
-import { z as z10 } from "zod/v4";
-var uiMessagesSchema = lazySchema2(
-  () => zodSchema2(
-    z10.array(
-      z10.object({
-        id: z10.string(),
-        role: z10.enum(["system", "user", "assistant"]),
-        metadata: z10.unknown().optional(),
-        parts: z10.array(
-          z10.union([
-            z10.object({
-              type: z10.literal("text"),
-              text: z10.string(),
-              state: z10.enum(["streaming", "done"]).optional(),
-              providerMetadata: providerMetadataSchema.optional()
-            }),
-            z10.object({
-              type: z10.literal("reasoning"),
-              text: z10.string(),
-              state: z10.enum(["streaming", "done"]).optional(),
-              providerMetadata: providerMetadataSchema.optional()
-            }),
-            z10.object({
-              type: z10.literal("source-url"),
-              sourceId: z10.string(),
-              url: z10.string(),
-              title: z10.string().optional(),
-              providerMetadata: providerMetadataSchema.optional()
-            }),
-            z10.object({
-              type: z10.literal("source-document"),
-              sourceId: z10.string(),
-              mediaType: z10.string(),
-              title: z10.string(),
-              filename: z10.string().optional(),
-              providerMetadata: providerMetadataSchema.optional()
-            }),
-            z10.object({
-              type: z10.literal("file"),
-              mediaType: z10.string(),
-              filename: z10.string().optional(),
-              url: z10.string(),
-              providerMetadata: providerMetadataSchema.optional()
-            }),
-            z10.object({
-              type: z10.literal("step-start")
-            }),
-            z10.object({
-              type: z10.string().startsWith("data-"),
-              id: z10.string().optional(),
-              data: z10.unknown()
-            }),
-            z10.object({
-              type: z10.literal("dynamic-tool"),
-              toolName: z10.string(),
-              toolCallId: z10.string(),
-              state: z10.literal("input-streaming"),
-              input: z10.unknown().optional(),
-              providerExecuted: z10.boolean().optional(),
-              output: z10.never().optional(),
-              errorText: z10.never().optional(),
-              approval: z10.never().optional()
-            }),
-            z10.object({
-              type: z10.literal("dynamic-tool"),
-              toolName: z10.string(),
-              toolCallId: z10.string(),
-              state: z10.literal("input-available"),
-              input: z10.unknown(),
-              providerExecuted: z10.boolean().optional(),
-              output: z10.never().optional(),
-              errorText: z10.never().optional(),
-              callProviderMetadata: providerMetadataSchema.optional(),
-              approval: z10.never().optional()
-            }),
-            z10.object({
-              type: z10.literal("dynamic-tool"),
-              toolName: z10.string(),
-              toolCallId: z10.string(),
-              state: z10.literal("approval-requested"),
-              input: z10.unknown(),
-              providerExecuted: z10.boolean().optional(),
-              output: z10.never().optional(),
-              errorText: z10.never().optional(),
-              callProviderMetadata: providerMetadataSchema.optional(),
-              approval: z10.object({
-                id: z10.string(),
-                approved: z10.never().optional(),
-                reason: z10.never().optional()
-              })
-            }),
-            z10.object({
-              type: z10.literal("dynamic-tool"),
-              toolName: z10.string(),
-              toolCallId: z10.string(),
-              state: z10.literal("approval-responded"),
-              input: z10.unknown(),
-              providerExecuted: z10.boolean().optional(),
-              output: z10.never().optional(),
-              errorText: z10.never().optional(),
-              callProviderMetadata: providerMetadataSchema.optional(),
-              approval: z10.object({
-                id: z10.string(),
-                approved: z10.boolean(),
-                reason: z10.string().optional()
-              })
-            }),
-            z10.object({
-              type: z10.literal("dynamic-tool"),
-              toolName: z10.string(),
-              toolCallId: z10.string(),
-              state: z10.literal("output-available"),
-              input: z10.unknown(),
-              providerExecuted: z10.boolean().optional(),
-              output: z10.unknown(),
-              errorText: z10.never().optional(),
-              callProviderMetadata: providerMetadataSchema.optional(),
-              preliminary: z10.boolean().optional(),
-              approval: z10.object({
-                id: z10.string(),
-                approved: z10.literal(true),
-                reason: z10.string().optional()
-              }).optional()
-            }),
-            z10.object({
-              type: z10.literal("dynamic-tool"),
-              toolName: z10.string(),
-              toolCallId: z10.string(),
-              state: z10.literal("output-error"),
-              input: z10.unknown(),
-              providerExecuted: z10.boolean().optional(),
-              output: z10.never().optional(),
-              errorText: z10.string(),
-              callProviderMetadata: providerMetadataSchema.optional(),
-              approval: z10.object({
-                id: z10.string(),
-                approved: z10.literal(true),
-                reason: z10.string().optional()
-              }).optional()
-            }),
-            z10.object({
-              type: z10.literal("dynamic-tool"),
-              toolName: z10.string(),
-              toolCallId: z10.string(),
-              state: z10.literal("output-denied"),
-              input: z10.unknown(),
-              providerExecuted: z10.boolean().optional(),
-              output: z10.never().optional(),
-              errorText: z10.never().optional(),
-              callProviderMetadata: providerMetadataSchema.optional(),
-              approval: z10.object({
-                id: z10.string(),
-                approved: z10.literal(false),
-                reason: z10.string().optional()
-              })
-            }),
-            z10.object({
-              type: z10.string().startsWith("tool-"),
-              toolCallId: z10.string(),
-              state: z10.literal("input-streaming"),
-              providerExecuted: z10.boolean().optional(),
-              input: z10.unknown().optional(),
-              output: z10.never().optional(),
-              errorText: z10.never().optional(),
-              approval: z10.never().optional()
-            }),
-            z10.object({
-              type: z10.string().startsWith("tool-"),
-              toolCallId: z10.string(),
-              state: z10.literal("input-available"),
-              providerExecuted: z10.boolean().optional(),
-              input: z10.unknown(),
-              output: z10.never().optional(),
-              errorText: z10.never().optional(),
-              callProviderMetadata: providerMetadataSchema.optional(),
-              approval: z10.never().optional()
-            }),
-            z10.object({
-              type: z10.string().startsWith("tool-"),
-              toolCallId: z10.string(),
-              state: z10.literal("approval-requested"),
-              input: z10.unknown(),
-              providerExecuted: z10.boolean().optional(),
-              output: z10.never().optional(),
-              errorText: z10.never().optional(),
-              callProviderMetadata: providerMetadataSchema.optional(),
-              approval: z10.object({
-                id: z10.string(),
-                approved: z10.never().optional(),
-                reason: z10.never().optional()
-              })
-            }),
-            z10.object({
-              type: z10.string().startsWith("tool-"),
-              toolCallId: z10.string(),
-              state: z10.literal("approval-responded"),
-              input: z10.unknown(),
-              providerExecuted: z10.boolean().optional(),
-              output: z10.never().optional(),
-              errorText: z10.never().optional(),
-              callProviderMetadata: providerMetadataSchema.optional(),
-              approval: z10.object({
-                id: z10.string(),
-                approved: z10.boolean(),
-                reason: z10.string().optional()
-              })
-            }),
-            z10.object({
-              type: z10.string().startsWith("tool-"),
-              toolCallId: z10.string(),
-              state: z10.literal("output-available"),
-              providerExecuted: z10.boolean().optional(),
-              input: z10.unknown(),
-              output: z10.unknown(),
-              errorText: z10.never().optional(),
-              callProviderMetadata: providerMetadataSchema.optional(),
-              preliminary: z10.boolean().optional(),
-              approval: z10.object({
-                id: z10.string(),
-                approved: z10.literal(true),
-                reason: z10.string().optional()
-              }).optional()
-            }),
-            z10.object({
-              type: z10.string().startsWith("tool-"),
-              toolCallId: z10.string(),
-              state: z10.literal("output-error"),
-              providerExecuted: z10.boolean().optional(),
-              input: z10.unknown(),
-              output: z10.never().optional(),
-              errorText: z10.string(),
-              callProviderMetadata: providerMetadataSchema.optional(),
-              approval: z10.object({
-                id: z10.string(),
-                approved: z10.literal(true),
-                reason: z10.string().optional()
-              }).optional()
-            }),
-            z10.object({
-              type: z10.string().startsWith("tool-"),
-              toolCallId: z10.string(),
-              state: z10.literal("output-denied"),
-              providerExecuted: z10.boolean().optional(),
-              input: z10.unknown(),
-              output: z10.never().optional(),
-              errorText: z10.never().optional(),
-              callProviderMetadata: providerMetadataSchema.optional(),
-              approval: z10.object({
-                id: z10.string(),
-                approved: z10.literal(false),
-                reason: z10.string().optional()
-              })
-            })
-          ])
-        )
-      })
-    )
-  )
-);
-async function safeValidateUIMessages({
-  messages,
-  metadataSchema,
-  dataSchemas,
-  tools
-}) {
-  try {
-    if (messages == null) {
-      return {
-        success: false,
-        error: new InvalidArgumentError({
-          parameter: "messages",
-          value: messages,
-          message: "messages parameter must be provided"
-        })
-      };
-    }
-    const validatedMessages = await validateTypes2({
-      value: messages,
-      schema: uiMessagesSchema
-    });
-    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) {
-            return {
-              success: false,
-              error: 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) {
-            return {
-              success: false,
-              error: 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 {
-      success: true,
-      data: validatedMessages
-    };
-  } catch (error) {
-    const err = error;
-    return {
-      success: false,
-      error: err
-    };
-  }
-}
-async function validateUIMessages({
-  messages,
-  metadataSchema,
-  dataSchemas,
-  tools
-}) {
-  const response = await safeValidateUIMessages({
-    messages,
-    metadataSchema,
-    dataSchemas,
-    tools
-  });
-  if (!response.success)
-    throw response.error;
-  return response.data;
-}
-
-// src/ui-message-stream/create-ui-message-stream.ts
-import {
-  generateId as generateIdFunc2,
-  getErrorMessage as getErrorMessage8
-} from "@ai-sdk/provider-utils";
-function createUIMessageStream({
-  execute,
-  onError = getErrorMessage8,
-  originalMessages,
-  onFinish,
-  generateId: generateId2 = generateIdFunc2
-}) {
-  let controller;
-  const ongoingStreamPromises = [];
-  const stream = new ReadableStream({
-    start(controllerArg) {
-      controller = controllerArg;
-    }
-  });
-  function safeEnqueue(data) {
-    try {
-      controller.enqueue(data);
-    } catch (error) {
-    }
-  }
-  try {
-    const result = execute({
-      writer: {
-        write(part) {
-          safeEnqueue(part);
-        },
-        merge(streamArg) {
-          ongoingStreamPromises.push(
-            (async () => {
-              const reader = streamArg.getReader();
-              while (true) {
-                const { done, value } = await reader.read();
-                if (done)
-                  break;
-                safeEnqueue(value);
-              }
-            })().catch((error) => {
-              safeEnqueue({
-                type: "error",
-                errorText: onError(error)
-              });
-            })
-          );
-        },
-        onError
-      }
-    });
-    if (result) {
-      ongoingStreamPromises.push(
-        result.catch((error) => {
-          safeEnqueue({
-            type: "error",
-            errorText: onError(error)
-          });
-        })
-      );
-    }
-  } catch (error) {
-    safeEnqueue({
-      type: "error",
-      errorText: onError(error)
-    });
-  }
-  const waitForStreams = new Promise(async (resolve3) => {
-    while (ongoingStreamPromises.length > 0) {
-      await ongoingStreamPromises.shift();
-    }
-    resolve3();
-  });
-  waitForStreams.finally(() => {
-    try {
-      controller.close();
-    } catch (error) {
-    }
-  });
-  return handleUIMessageStreamFinish({
-    stream,
-    messageId: generateId2(),
-    originalMessages,
-    onFinish,
-    onError
-  });
-}
-
-// src/ui-message-stream/read-ui-message-stream.ts
-function readUIMessageStream({
-  message,
-  stream,
-  onError,
-  terminateOnError = false
-}) {
-  var _a17;
-  let controller;
-  let hasErrored = false;
-  const outputStream = new ReadableStream({
-    start(controllerParam) {
-      controller = controllerParam;
-    }
-  });
-  const state = createStreamingUIMessageState({
-    messageId: (_a17 = message == null ? void 0 : message.id) != null ? _a17 : "",
-    lastMessage: message
-  });
-  const handleError = (error) => {
-    onError == null ? void 0 : onError(error);
-    if (!hasErrored && terminateOnError) {
-      hasErrored = true;
-      controller == null ? void 0 : controller.error(error);
-    }
-  };
-  consumeStream({
-    stream: processUIMessageStream({
-      stream,
-      runUpdateMessageJob(job) {
-        return job({
-          state,
-          write: () => {
-            controller == null ? void 0 : controller.enqueue(structuredClone(state.message));
-          }
-        });
-      },
-      onError: handleError
-    }),
-    onError: handleError
-  }).finally(() => {
-    if (!hasErrored) {
-      controller == null ? void 0 : controller.close();
-    }
-  });
-  return createAsyncIterableStream(outputStream);
-}
 export {
   AISDKError18 as AISDKError,
   APICallError,
@@ -11216,6 +11227,7 @@ export {
   coreToolMessageSchema,
   coreUserMessageSchema,
   cosineSimilarity,
+  createAgentStreamResponse,
   createGateway,
   createIdGenerator5 as createIdGenerator,
   createProviderRegistry,