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

package/dist/index.js

@@ -74,6 +74,7 @@ __export(src_exports, {
   coreToolMessageSchema: () => coreToolMessageSchema,
   coreUserMessageSchema: () => coreUserMessageSchema,
   cosineSimilarity: () => cosineSimilarity,
+  createAgentStreamResponse: () => createAgentStreamResponse,
   createGateway: () => import_gateway3.createGateway,
   createIdGenerator: () => import_provider_utils37.createIdGenerator,
   createProviderRegistry: () => createProviderRegistry,
@@ -870,7 +871,7 @@ function detectMediaType({
 var import_provider_utils2 = require("@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 }) => {
@@ -6320,6 +6321,182 @@ 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
+var import_provider_utils17 = require("@ai-sdk/provider-utils");
+function createUIMessageStream({
+  execute,
+  onError = import_provider_utils17.getErrorMessage,
+  originalMessages,
+  onFinish,
+  generateId: generateId2 = import_provider_utils17.generateId
+}) {
+  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 = [];
@@ -6525,94 +6702,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
-var import_provider_utils17 = require("@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 = (0, import_provider_utils17.withUserAgentSuffix)(
-    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) }
-      }
-    }),
-    tracer,
+// src/ui/validate-ui-messages.ts
+var import_provider25 = require("@ai-sdk/provider");
+var import_provider_utils18 = require("@ai-sdk/provider-utils");
+var import_v48 = require("zod/v4");
+var uiMessagesSchema = (0, import_provider_utils18.lazySchema)(
+  () => (0, import_provider_utils18.zodSchema)(
+    import_v48.z.array(
+      import_v48.z.object({
+        id: import_v48.z.string(),
+        role: import_v48.z.enum(["system", "user", "assistant"]),
+        metadata: import_v48.z.unknown().optional(),
+        parts: import_v48.z.array(
+          import_v48.z.union([
+            import_v48.z.object({
+              type: import_v48.z.literal("text"),
+              text: import_v48.z.string(),
+              state: import_v48.z.enum(["streaming", "done"]).optional(),
+              providerMetadata: providerMetadataSchema.optional()
+            }),
+            import_v48.z.object({
+              type: import_v48.z.literal("reasoning"),
+              text: import_v48.z.string(),
+              state: import_v48.z.enum(["streaming", "done"]).optional(),
+              providerMetadata: providerMetadataSchema.optional()
+            }),
+            import_v48.z.object({
+              type: import_v48.z.literal("source-url"),
+              sourceId: import_v48.z.string(),
+              url: import_v48.z.string(),
+              title: import_v48.z.string().optional(),
+              providerMetadata: providerMetadataSchema.optional()
+            }),
+            import_v48.z.object({
+              type: import_v48.z.literal("source-document"),
+              sourceId: import_v48.z.string(),
+              mediaType: import_v48.z.string(),
+              title: import_v48.z.string(),
+              filename: import_v48.z.string().optional(),
+              providerMetadata: providerMetadataSchema.optional()
+            }),
+            import_v48.z.object({
+              type: import_v48.z.literal("file"),
+              mediaType: import_v48.z.string(),
+              filename: import_v48.z.string().optional(),
+              url: import_v48.z.string(),
+              providerMetadata: providerMetadataSchema.optional()
+            }),
+            import_v48.z.object({
+              type: import_v48.z.literal("step-start")
+            }),
+            import_v48.z.object({
+              type: import_v48.z.string().startsWith("data-"),
+              id: import_v48.z.string().optional(),
+              data: import_v48.z.unknown()
+            }),
+            import_v48.z.object({
+              type: import_v48.z.literal("dynamic-tool"),
+              toolName: import_v48.z.string(),
+              toolCallId: import_v48.z.string(),
+              state: import_v48.z.literal("input-streaming"),
+              input: import_v48.z.unknown().optional(),
+              providerExecuted: import_v48.z.boolean().optional(),
+              output: import_v48.z.never().optional(),
+              errorText: import_v48.z.never().optional(),
+              approval: import_v48.z.never().optional()
+            }),
+            import_v48.z.object({
+              type: import_v48.z.literal("dynamic-tool"),
+              toolName: import_v48.z.string(),
+              toolCallId: import_v48.z.string(),
+              state: import_v48.z.literal("input-available"),
+              input: import_v48.z.unknown(),
+              providerExecuted: import_v48.z.boolean().optional(),
+              output: import_v48.z.never().optional(),
+              errorText: import_v48.z.never().optional(),
+              callProviderMetadata: providerMetadataSchema.optional(),
+              approval: import_v48.z.never().optional()
+            }),
+            import_v48.z.object({
+              type: import_v48.z.literal("dynamic-tool"),
+              toolName: import_v48.z.string(),
+              toolCallId: import_v48.z.string(),
+              state: import_v48.z.literal("approval-requested"),
+              input: import_v48.z.unknown(),
+              providerExecuted: import_v48.z.boolean().optional(),
+              output: import_v48.z.never().optional(),
+              errorText: import_v48.z.never().optional(),
+              callProviderMetadata: providerMetadataSchema.optional(),
+              approval: import_v48.z.object({
+                id: import_v48.z.string(),
+                approved: import_v48.z.never().optional(),
+                reason: import_v48.z.never().optional()
+              })
+            }),
+            import_v48.z.object({
+              type: import_v48.z.literal("dynamic-tool"),
+              toolName: import_v48.z.string(),
+              toolCallId: import_v48.z.string(),
+              state: import_v48.z.literal("approval-responded"),
+              input: import_v48.z.unknown(),
+              providerExecuted: import_v48.z.boolean().optional(),
+              output: import_v48.z.never().optional(),
+              errorText: import_v48.z.never().optional(),
+              callProviderMetadata: providerMetadataSchema.optional(),
+              approval: import_v48.z.object({
+                id: import_v48.z.string(),
+                approved: import_v48.z.boolean(),
+                reason: import_v48.z.string().optional()
+              })
+            }),
+            import_v48.z.object({
+              type: import_v48.z.literal("dynamic-tool"),
+              toolName: import_v48.z.string(),
+              toolCallId: import_v48.z.string(),
+              state: import_v48.z.literal("output-available"),
+              input: import_v48.z.unknown(),
+              providerExecuted: import_v48.z.boolean().optional(),
+              output: import_v48.z.unknown(),
+              errorText: import_v48.z.never().optional(),
+              callProviderMetadata: providerMetadataSchema.optional(),
+              preliminary: import_v48.z.boolean().optional(),
+              approval: import_v48.z.object({
+                id: import_v48.z.string(),
+                approved: import_v48.z.literal(true),
+                reason: import_v48.z.string().optional()
+              }).optional()
+            }),
+            import_v48.z.object({
+              type: import_v48.z.literal("dynamic-tool"),
+              toolName: import_v48.z.string(),
+              toolCallId: import_v48.z.string(),
+              state: import_v48.z.literal("output-error"),
+              input: import_v48.z.unknown(),
+              providerExecuted: import_v48.z.boolean().optional(),
+              output: import_v48.z.never().optional(),
+              errorText: import_v48.z.string(),
+              callProviderMetadata: providerMetadataSchema.optional(),
+              approval: import_v48.z.object({
+                id: import_v48.z.string(),
+                approved: import_v48.z.literal(true),
+                reason: import_v48.z.string().optional()
+              }).optional()
+            }),
+            import_v48.z.object({
+              type: import_v48.z.literal("dynamic-tool"),
+              toolName: import_v48.z.string(),
+              toolCallId: import_v48.z.string(),
+              state: import_v48.z.literal("output-denied"),
+              input: import_v48.z.unknown(),
+              providerExecuted: import_v48.z.boolean().optional(),
+              output: import_v48.z.never().optional(),
+              errorText: import_v48.z.never().optional(),
+              callProviderMetadata: providerMetadataSchema.optional(),
+              approval: import_v48.z.object({
+                id: import_v48.z.string(),
+                approved: import_v48.z.literal(false),
+                reason: import_v48.z.string().optional()
+              })
+            }),
+            import_v48.z.object({
+              type: import_v48.z.string().startsWith("tool-"),
+              toolCallId: import_v48.z.string(),
+              state: import_v48.z.literal("input-streaming"),
+              providerExecuted: import_v48.z.boolean().optional(),
+              input: import_v48.z.unknown().optional(),
+              output: import_v48.z.never().optional(),
+              errorText: import_v48.z.never().optional(),
+              approval: import_v48.z.never().optional()
+            }),
+            import_v48.z.object({
+              type: import_v48.z.string().startsWith("tool-"),
+              toolCallId: import_v48.z.string(),
+              state: import_v48.z.literal("input-available"),
+              providerExecuted: import_v48.z.boolean().optional(),
+              input: import_v48.z.unknown(),
+              output: import_v48.z.never().optional(),
+              errorText: import_v48.z.never().optional(),
+              callProviderMetadata: providerMetadataSchema.optional(),
+              approval: import_v48.z.never().optional()
+            }),
+            import_v48.z.object({
+              type: import_v48.z.string().startsWith("tool-"),
+              toolCallId: import_v48.z.string(),
+              state: import_v48.z.literal("approval-requested"),
+              input: import_v48.z.unknown(),
+              providerExecuted: import_v48.z.boolean().optional(),
+              output: import_v48.z.never().optional(),
+              errorText: import_v48.z.never().optional(),
+              callProviderMetadata: providerMetadataSchema.optional(),
+              approval: import_v48.z.object({
+                id: import_v48.z.string(),
+                approved: import_v48.z.never().optional(),
+                reason: import_v48.z.never().optional()
+              })
+            }),
+            import_v48.z.object({
+              type: import_v48.z.string().startsWith("tool-"),
+              toolCallId: import_v48.z.string(),
+              state: import_v48.z.literal("approval-responded"),
+              input: import_v48.z.unknown(),
+              providerExecuted: import_v48.z.boolean().optional(),
+              output: import_v48.z.never().optional(),
+              errorText: import_v48.z.never().optional(),
+              callProviderMetadata: providerMetadataSchema.optional(),
+              approval: import_v48.z.object({
+                id: import_v48.z.string(),
+                approved: import_v48.z.boolean(),
+                reason: import_v48.z.string().optional()
+              })
+            }),
+            import_v48.z.object({
+              type: import_v48.z.string().startsWith("tool-"),
+              toolCallId: import_v48.z.string(),
+              state: import_v48.z.literal("output-available"),
+              providerExecuted: import_v48.z.boolean().optional(),
+              input: import_v48.z.unknown(),
+              output: import_v48.z.unknown(),
+              errorText: import_v48.z.never().optional(),
+              callProviderMetadata: providerMetadataSchema.optional(),
+              preliminary: import_v48.z.boolean().optional(),
+              approval: import_v48.z.object({
+                id: import_v48.z.string(),
+                approved: import_v48.z.literal(true),
+                reason: import_v48.z.string().optional()
+              }).optional()
+            }),
+            import_v48.z.object({
+              type: import_v48.z.string().startsWith("tool-"),
+              toolCallId: import_v48.z.string(),
+              state: import_v48.z.literal("output-error"),
+              providerExecuted: import_v48.z.boolean().optional(),
+              input: import_v48.z.unknown(),
+              output: import_v48.z.never().optional(),
+              errorText: import_v48.z.string(),
+              callProviderMetadata: providerMetadataSchema.optional(),
+              approval: import_v48.z.object({
+                id: import_v48.z.string(),
+                approved: import_v48.z.literal(true),
+                reason: import_v48.z.string().optional()
+              }).optional()
+            }),
+            import_v48.z.object({
+              type: import_v48.z.string().startsWith("tool-"),
+              toolCallId: import_v48.z.string(),
+              state: import_v48.z.literal("output-denied"),
+              providerExecuted: import_v48.z.boolean().optional(),
+              input: import_v48.z.unknown(),
+              output: import_v48.z.never().optional(),
+              errorText: import_v48.z.never().optional(),
+              callProviderMetadata: providerMetadataSchema.optional(),
+              approval: import_v48.z.object({
+                id: import_v48.z.string(),
+                approved: import_v48.z.literal(false),
+                reason: import_v48.z.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 (0, import_provider_utils18.validateTypes)({
+      value: messages,
+      schema: uiMessagesSchema
+    });
+    if (metadataSchema) {
+      for (const message of validatedMessages) {
+        await (0, import_provider_utils18.validateTypes)({
+          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 import_provider25.TypeValidationError({
+                value: dataPart.data,
+                cause: `No data schema found for data part ${dataName}`
+              })
+            };
+          }
+          await (0, import_provider_utils18.validateTypes)({
+            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 import_provider25.TypeValidationError({
+                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 (0, import_provider_utils18.validateTypes)({
+              value: toolPart.input,
+              schema: tool3.inputSchema
+            });
+          }
+          if (toolPart.state === "output-available" && tool3.outputSchema) {
+            await (0, import_provider_utils18.validateTypes)({
+              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
+var import_provider_utils19 = require("@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 = (0, import_provider_utils19.withUserAgentSuffix)(
+    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) }
+      }
+    }),
+    tracer,
     fn: async (span) => {
       const { embedding, usage, response, providerMetadata } = await retry(
         () => (
@@ -6695,7 +7217,7 @@ var DefaultEmbedResult = class {
 };
 
 // src/embed/embed-many.ts
-var import_provider_utils18 = require("@ai-sdk/provider-utils");
+var import_provider_utils20 = require("@ai-sdk/provider-utils");
 
 // src/util/split-array.ts
 function splitArray(array, chunkSize) {
@@ -6725,7 +7247,7 @@ async function embedMany({
     maxRetries: maxRetriesArg,
     abortSignal
   });
-  const headersWithUserAgent = (0, import_provider_utils18.withUserAgentSuffix)(
+  const headersWithUserAgent = (0, import_provider_utils20.withUserAgentSuffix)(
     headers != null ? headers : {},
     `ai/${VERSION}`
   );
@@ -6944,7 +7466,7 @@ var DefaultEmbedManyResult = class {
 };
 
 // src/generate-image/generate-image.ts
-var import_provider_utils19 = require("@ai-sdk/provider-utils");
+var import_provider_utils21 = require("@ai-sdk/provider-utils");
 async function generateImage({
   model,
   prompt,
@@ -6966,7 +7488,7 @@ async function generateImage({
       modelId: model.modelId
     });
   }
-  const headersWithUserAgent = (0, import_provider_utils19.withUserAgentSuffix)(
+  const headersWithUserAgent = (0, import_provider_utils21.withUserAgentSuffix)(
     headers != null ? headers : {},
     `ai/${VERSION}`
   );
@@ -7062,7 +7584,7 @@ async function invokeModelMaxImagesPerCall(model) {
 }
 
 // src/generate-object/generate-object.ts
-var import_provider_utils22 = require("@ai-sdk/provider-utils");
+var import_provider_utils24 = require("@ai-sdk/provider-utils");
 
 // src/generate-text/extract-reasoning-content.ts
 function extractReasoningContent(content) {
@@ -7073,8 +7595,8 @@ function extractReasoningContent(content) {
 }
 
 // src/generate-object/output-strategy.ts
-var import_provider25 = require("@ai-sdk/provider");
-var import_provider_utils20 = require("@ai-sdk/provider-utils");
+var import_provider26 = require("@ai-sdk/provider");
+var import_provider_utils22 = require("@ai-sdk/provider-utils");
 var noSchemaOutputStrategy = {
   type: "no-schema",
   jsonSchema: async () => void 0,
@@ -7094,7 +7616,7 @@ var noSchemaOutputStrategy = {
     } : { success: true, value };
   },
   createElementStream() {
-    throw new import_provider25.UnsupportedFunctionalityError({
+    throw new import_provider26.UnsupportedFunctionalityError({
       functionality: "element streams in no-schema mode"
     });
   }
@@ -7113,10 +7635,10 @@ var objectOutputStrategy = (schema) => ({
     };
   },
   async validateFinalResult(value) {
-    return (0, import_provider_utils20.safeValidateTypes)({ value, schema });
+    return (0, import_provider_utils22.safeValidateTypes)({ value, schema });
   },
   createElementStream() {
-    throw new import_provider25.UnsupportedFunctionalityError({
+    throw new import_provider26.UnsupportedFunctionalityError({
       functionality: "element streams in object mode"
     });
   }
@@ -7146,10 +7668,10 @@ var arrayOutputStrategy = (schema) => {
       isFinalDelta
     }) {
       var _a17;
-      if (!(0, import_provider25.isJSONObject)(value) || !(0, import_provider25.isJSONArray)(value.elements)) {
+      if (!(0, import_provider26.isJSONObject)(value) || !(0, import_provider26.isJSONArray)(value.elements)) {
         return {
           success: false,
-          error: new import_provider25.TypeValidationError({
+          error: new import_provider26.TypeValidationError({
             value,
             cause: "value must be an object that contains an array of elements"
           })
@@ -7159,7 +7681,7 @@ var arrayOutputStrategy = (schema) => {
       const resultArray = [];
       for (let i = 0; i < inputArray.length; i++) {
         const element = inputArray[i];
-        const result = await (0, import_provider_utils20.safeValidateTypes)({ value: element, schema });
+        const result = await (0, import_provider_utils22.safeValidateTypes)({ value: element, schema });
         if (i === inputArray.length - 1 && !isFinalDelta) {
           continue;
         }
@@ -7189,10 +7711,10 @@ var arrayOutputStrategy = (schema) => {
       };
     },
     async validateFinalResult(value) {
-      if (!(0, import_provider25.isJSONObject)(value) || !(0, import_provider25.isJSONArray)(value.elements)) {
+      if (!(0, import_provider26.isJSONObject)(value) || !(0, import_provider26.isJSONArray)(value.elements)) {
         return {
           success: false,
-          error: new import_provider25.TypeValidationError({
+          error: new import_provider26.TypeValidationError({
             value,
             cause: "value must be an object that contains an array of elements"
           })
@@ -7200,7 +7722,7 @@ var arrayOutputStrategy = (schema) => {
       }
       const inputArray = value.elements;
       for (const element of inputArray) {
-        const result = await (0, import_provider_utils20.safeValidateTypes)({ value: element, schema });
+        const result = await (0, import_provider_utils22.safeValidateTypes)({ value: element, schema });
         if (!result.success) {
           return result;
         }
@@ -7255,10 +7777,10 @@ var enumOutputStrategy = (enumValues) => {
       additionalProperties: false
     }),
     async validateFinalResult(value) {
-      if (!(0, import_provider25.isJSONObject)(value) || typeof value.result !== "string") {
+      if (!(0, import_provider26.isJSONObject)(value) || typeof value.result !== "string") {
         return {
           success: false,
-          error: new import_provider25.TypeValidationError({
+          error: new import_provider26.TypeValidationError({
             value,
             cause: 'value must be an object that contains a string in the "result" property.'
           })
@@ -7267,17 +7789,17 @@ var enumOutputStrategy = (enumValues) => {
       const result = value.result;
       return enumValues.includes(result) ? { success: true, value: result } : {
         success: false,
-        error: new import_provider25.TypeValidationError({
+        error: new import_provider26.TypeValidationError({
           value,
           cause: "value must be a string in the enum"
         })
       };
     },
     async validatePartialResult({ value, textDelta }) {
-      if (!(0, import_provider25.isJSONObject)(value) || typeof value.result !== "string") {
+      if (!(0, import_provider26.isJSONObject)(value) || typeof value.result !== "string") {
         return {
           success: false,
-          error: new import_provider25.TypeValidationError({
+          error: new import_provider26.TypeValidationError({
             value,
             cause: 'value must be an object that contains a string in the "result" property.'
           })
@@ -7290,7 +7812,7 @@ var enumOutputStrategy = (enumValues) => {
       if (value.result.length === 0 || possibleEnumValues.length === 0) {
         return {
           success: false,
-          error: new import_provider25.TypeValidationError({
+          error: new import_provider26.TypeValidationError({
             value,
             cause: "value must be a string in the enum"
           })
@@ -7305,7 +7827,7 @@ var enumOutputStrategy = (enumValues) => {
       };
     },
     createElementStream() {
-      throw new import_provider25.UnsupportedFunctionalityError({
+      throw new import_provider26.UnsupportedFunctionalityError({
         functionality: "element streams in enum mode"
       });
     }
@@ -7318,9 +7840,9 @@ function getOutputStrategy({
 }) {
   switch (output) {
     case "object":
-      return objectOutputStrategy((0, import_provider_utils20.asSchema)(schema));
+      return objectOutputStrategy((0, import_provider_utils22.asSchema)(schema));
     case "array":
-      return arrayOutputStrategy((0, import_provider_utils20.asSchema)(schema));
+      return arrayOutputStrategy((0, import_provider_utils22.asSchema)(schema));
     case "enum":
       return enumOutputStrategy(enumValues);
     case "no-schema":
@@ -7333,10 +7855,10 @@ function getOutputStrategy({
 }
 
 // src/generate-object/parse-and-validate-object-result.ts
-var import_provider26 = require("@ai-sdk/provider");
-var import_provider_utils21 = require("@ai-sdk/provider-utils");
+var import_provider27 = require("@ai-sdk/provider");
+var import_provider_utils23 = require("@ai-sdk/provider-utils");
 async function parseAndValidateObjectResult(result, outputStrategy, context) {
-  const parseResult = await (0, import_provider_utils21.safeParseJSON)({ text: result });
+  const parseResult = await (0, import_provider_utils23.safeParseJSON)({ text: result });
   if (!parseResult.success) {
     throw new NoObjectGeneratedError({
       message: "No object generated: could not parse the response.",
@@ -7371,7 +7893,7 @@ async function parseAndValidateObjectResultWithRepair(result, outputStrategy, re
   try {
     return await parseAndValidateObjectResult(result, outputStrategy, context);
   } catch (error) {
-    if (repairText != null && NoObjectGeneratedError.isInstance(error) && (import_provider26.JSONParseError.isInstance(error.cause) || import_provider26.TypeValidationError.isInstance(error.cause))) {
+    if (repairText != null && NoObjectGeneratedError.isInstance(error) && (import_provider27.JSONParseError.isInstance(error.cause) || import_provider27.TypeValidationError.isInstance(error.cause))) {
       const repairedText = await repairText({
         text: result,
         error: error.cause
@@ -7508,7 +8030,7 @@ function validateObjectGenerationInput({
 }
 
 // src/generate-object/generate-object.ts
-var originalGenerateId3 = (0, import_provider_utils22.createIdGenerator)({ prefix: "aiobj", size: 24 });
+var originalGenerateId3 = (0, import_provider_utils24.createIdGenerator)({ prefix: "aiobj", size: 24 });
 async function generateObject(options) {
   const {
     model: modelArg,
@@ -7553,7 +8075,7 @@ async function generateObject(options) {
     enumValues
   });
   const callSettings = prepareCallSettings(settings);
-  const headersWithUserAgent = (0, import_provider_utils22.withUserAgentSuffix)(
+  const headersWithUserAgent = (0, import_provider_utils24.withUserAgentSuffix)(
     headers != null ? headers : {},
     `ai/${VERSION}`
   );
@@ -7773,7 +8295,7 @@ var DefaultGenerateObjectResult = class {
 };
 
 // src/generate-object/stream-object.ts
-var import_provider_utils24 = require("@ai-sdk/provider-utils");
+var import_provider_utils26 = require("@ai-sdk/provider-utils");
 
 // src/util/cosine-similarity.ts
 function cosineSimilarity(vector1, vector2) {
@@ -7883,7 +8405,7 @@ var SerialJobExecutor = class {
 };
 
 // src/util/simulate-readable-stream.ts
-var import_provider_utils23 = require("@ai-sdk/provider-utils");
+var import_provider_utils25 = require("@ai-sdk/provider-utils");
 function simulateReadableStream({
   chunks,
   initialDelayInMs = 0,
@@ -7891,7 +8413,7 @@ function simulateReadableStream({
   _internal
 }) {
   var _a17;
-  const delay2 = (_a17 = _internal == null ? void 0 : _internal.delay) != null ? _a17 : import_provider_utils23.delay;
+  const delay2 = (_a17 = _internal == null ? void 0 : _internal.delay) != null ? _a17 : import_provider_utils25.delay;
   let index = 0;
   return new ReadableStream({
     async pull(controller) {
@@ -7906,7 +8428,7 @@ function simulateReadableStream({
 }
 
 // src/generate-object/stream-object.ts
-var originalGenerateId4 = (0, import_provider_utils24.createIdGenerator)({ prefix: "aiobj", size: 24 });
+var originalGenerateId4 = (0, import_provider_utils26.createIdGenerator)({ prefix: "aiobj", size: 24 });
 function streamObject(options) {
   const {
     model,
@@ -8429,7 +8951,7 @@ var DefaultStreamObjectResult = class {
 };
 
 // src/generate-speech/generate-speech.ts
-var import_provider_utils25 = require("@ai-sdk/provider-utils");
+var import_provider_utils27 = require("@ai-sdk/provider-utils");
 
 // src/generate-speech/generated-audio-file.ts
 var DefaultGeneratedAudioFile = class extends DefaultGeneratedFile {
@@ -8475,7 +8997,7 @@ async function generateSpeech({
   if (!resolvedModel) {
     throw new Error("Model could not be resolved");
   }
-  const headersWithUserAgent = (0, import_provider_utils25.withUserAgentSuffix)(
+  const headersWithUserAgent = (0, import_provider_utils27.withUserAgentSuffix)(
     headers != null ? headers : {},
     `ai/${VERSION}`
   );
@@ -8529,7 +9051,7 @@ __export(output_exports, {
   object: () => object,
   text: () => text
 });
-var import_provider_utils26 = require("@ai-sdk/provider-utils");
+var import_provider_utils28 = require("@ai-sdk/provider-utils");
 var text = () => ({
   type: "text",
   responseFormat: Promise.resolve({ type: "text" }),
@@ -8543,10 +9065,10 @@ var text = () => ({
 var object = ({
   schema: inputSchema
 }) => {
-  const schema = (0, import_provider_utils26.asSchema)(inputSchema);
+  const schema = (0, import_provider_utils28.asSchema)(inputSchema);
   return {
     type: "object",
-    responseFormat: (0, import_provider_utils26.resolve)(schema.jsonSchema).then((jsonSchema3) => ({
+    responseFormat: (0, import_provider_utils28.resolve)(schema.jsonSchema).then((jsonSchema3) => ({
       type: "json",
       schema: jsonSchema3
     })),
@@ -8569,7 +9091,7 @@ var object = ({
       }
     },
     async parseOutput({ text: text2 }, context) {
-      const parseResult = await (0, import_provider_utils26.safeParseJSON)({ text: text2 });
+      const parseResult = await (0, import_provider_utils28.safeParseJSON)({ text: text2 });
       if (!parseResult.success) {
         throw new NoObjectGeneratedError({
           message: "No object generated: could not parse the response.",
@@ -8580,7 +9102,7 @@ var object = ({
           finishReason: context.finishReason
         });
       }
-      const validationResult = await (0, import_provider_utils26.safeValidateTypes)({
+      const validationResult = await (0, import_provider_utils28.safeValidateTypes)({
         value: parseResult.value,
         schema
       });
@@ -8679,8 +9201,8 @@ function pruneMessages({
 }
 
 // src/generate-text/smooth-stream.ts
-var import_provider_utils27 = require("@ai-sdk/provider-utils");
-var import_provider27 = require("@ai-sdk/provider");
+var import_provider_utils29 = require("@ai-sdk/provider-utils");
+var import_provider28 = require("@ai-sdk/provider");
 var CHUNKING_REGEXPS = {
   word: /\S+\s+/m,
   line: /\n+/m
@@ -8688,7 +9210,7 @@ var CHUNKING_REGEXPS = {
 function smoothStream({
   delayInMs = 10,
   chunking = "word",
-  _internal: { delay: delay2 = import_provider_utils27.delay } = {}
+  _internal: { delay: delay2 = import_provider_utils29.delay } = {}
 } = {}) {
   let detectChunk;
   if (typeof chunking === "function") {
@@ -8710,7 +9232,7 @@ function smoothStream({
   } else {
     const chunkingRegex = typeof chunking === "string" ? CHUNKING_REGEXPS[chunking] : chunking;
     if (chunkingRegex == null) {
-      throw new import_provider27.InvalidArgumentError({
+      throw new import_provider28.InvalidArgumentError({
         argument: "chunking",
         message: `Chunking must be "word" or "line" or a RegExp. Received: ${chunking}`
       });
@@ -9082,7 +9604,7 @@ function wrapProvider({
 }
 
 // src/registry/custom-provider.ts
-var import_provider28 = require("@ai-sdk/provider");
+var import_provider29 = require("@ai-sdk/provider");
 function customProvider({
   languageModels,
   textEmbeddingModels,
@@ -9099,7 +9621,7 @@ function customProvider({
       if (fallbackProvider) {
         return fallbackProvider.languageModel(modelId);
       }
-      throw new import_provider28.NoSuchModelError({ modelId, modelType: "languageModel" });
+      throw new import_provider29.NoSuchModelError({ modelId, modelType: "languageModel" });
     },
     textEmbeddingModel(modelId) {
       if (textEmbeddingModels != null && modelId in textEmbeddingModels) {
@@ -9108,7 +9630,7 @@ function customProvider({
       if (fallbackProvider) {
         return fallbackProvider.textEmbeddingModel(modelId);
       }
-      throw new import_provider28.NoSuchModelError({ modelId, modelType: "textEmbeddingModel" });
+      throw new import_provider29.NoSuchModelError({ modelId, modelType: "textEmbeddingModel" });
     },
     imageModel(modelId) {
       if (imageModels != null && modelId in imageModels) {
@@ -9117,7 +9639,7 @@ function customProvider({
       if (fallbackProvider == null ? void 0 : fallbackProvider.imageModel) {
         return fallbackProvider.imageModel(modelId);
       }
-      throw new import_provider28.NoSuchModelError({ modelId, modelType: "imageModel" });
+      throw new import_provider29.NoSuchModelError({ modelId, modelType: "imageModel" });
     },
     transcriptionModel(modelId) {
       if (transcriptionModels != null && modelId in transcriptionModels) {
@@ -9126,7 +9648,7 @@ function customProvider({
       if (fallbackProvider == null ? void 0 : fallbackProvider.transcriptionModel) {
         return fallbackProvider.transcriptionModel(modelId);
       }
-      throw new import_provider28.NoSuchModelError({ modelId, modelType: "transcriptionModel" });
+      throw new import_provider29.NoSuchModelError({ modelId, modelType: "transcriptionModel" });
     },
     speechModel(modelId) {
       if (speechModels != null && modelId in speechModels) {
@@ -9135,19 +9657,19 @@ function customProvider({
       if (fallbackProvider == null ? void 0 : fallbackProvider.speechModel) {
         return fallbackProvider.speechModel(modelId);
       }
-      throw new import_provider28.NoSuchModelError({ modelId, modelType: "speechModel" });
+      throw new import_provider29.NoSuchModelError({ modelId, modelType: "speechModel" });
     }
   };
 }
 var experimental_customProvider = customProvider;
 
 // src/registry/no-such-provider-error.ts
-var import_provider29 = require("@ai-sdk/provider");
+var import_provider30 = require("@ai-sdk/provider");
 var name16 = "AI_NoSuchProviderError";
 var marker16 = `vercel.ai.error.${name16}`;
 var symbol16 = Symbol.for(marker16);
 var _a16;
-var NoSuchProviderError = class extends import_provider29.NoSuchModelError {
+var NoSuchProviderError = class extends import_provider30.NoSuchModelError {
   constructor({
     modelId,
     modelType,
@@ -9161,13 +9683,13 @@ var NoSuchProviderError = class extends import_provider29.NoSuchModelError {
     this.availableProviders = availableProviders;
   }
   static isInstance(error) {
-    return import_provider29.AISDKError.hasMarker(error, marker16);
+    return import_provider30.AISDKError.hasMarker(error, marker16);
   }
 };
 _a16 = symbol16;
 
 // src/registry/provider-registry.ts
-var import_provider30 = require("@ai-sdk/provider");
+var import_provider31 = require("@ai-sdk/provider");
 function createProviderRegistry(providers, {
   separator = ":",
   languageModelMiddleware
@@ -9212,7 +9734,7 @@ var DefaultProviderRegistry = class {
   splitId(id, modelType) {
     const index = id.indexOf(this.separator);
     if (index === -1) {
-      throw new import_provider30.NoSuchModelError({
+      throw new import_provider31.NoSuchModelError({
         modelId: id,
         modelType,
         message: `Invalid ${modelType} id for registry: ${id} (must be in the format "providerId${this.separator}modelId")`
@@ -9228,7 +9750,7 @@ var DefaultProviderRegistry = class {
       modelId
     );
     if (model == null) {
-      throw new import_provider30.NoSuchModelError({ modelId: id, modelType: "languageModel" });
+      throw new import_provider31.NoSuchModelError({ modelId: id, modelType: "languageModel" });
     }
     if (this.languageModelMiddleware != null) {
       model = wrapLanguageModel({
@@ -9244,7 +9766,7 @@ var DefaultProviderRegistry = class {
     const provider = this.getProvider(providerId, "textEmbeddingModel");
     const model = (_a17 = provider.textEmbeddingModel) == null ? void 0 : _a17.call(provider, modelId);
     if (model == null) {
-      throw new import_provider30.NoSuchModelError({
+      throw new import_provider31.NoSuchModelError({
         modelId: id,
         modelType: "textEmbeddingModel"
       });
@@ -9257,7 +9779,7 @@ var DefaultProviderRegistry = class {
     const provider = this.getProvider(providerId, "imageModel");
     const model = (_a17 = provider.imageModel) == null ? void 0 : _a17.call(provider, modelId);
     if (model == null) {
-      throw new import_provider30.NoSuchModelError({ modelId: id, modelType: "imageModel" });
+      throw new import_provider31.NoSuchModelError({ modelId: id, modelType: "imageModel" });
     }
     return model;
   }
@@ -9267,7 +9789,7 @@ var DefaultProviderRegistry = class {
     const provider = this.getProvider(providerId, "transcriptionModel");
     const model = (_a17 = provider.transcriptionModel) == null ? void 0 : _a17.call(provider, modelId);
     if (model == null) {
-      throw new import_provider30.NoSuchModelError({
+      throw new import_provider31.NoSuchModelError({
         modelId: id,
         modelType: "transcriptionModel"
       });
@@ -9280,150 +9802,150 @@ var DefaultProviderRegistry = class {
     const provider = this.getProvider(providerId, "speechModel");
     const model = (_a17 = provider.speechModel) == null ? void 0 : _a17.call(provider, modelId);
     if (model == null) {
-      throw new import_provider30.NoSuchModelError({ modelId: id, modelType: "speechModel" });
+      throw new import_provider31.NoSuchModelError({ modelId: id, modelType: "speechModel" });
     }
     return model;
   }
 };
 
 // src/tool/mcp/mcp-client.ts
-var import_provider_utils29 = require("@ai-sdk/provider-utils");
+var import_provider_utils31 = require("@ai-sdk/provider-utils");
 
 // src/tool/mcp/mcp-sse-transport.ts
-var import_provider_utils28 = require("@ai-sdk/provider-utils");
+var import_provider_utils30 = require("@ai-sdk/provider-utils");
 
 // src/tool/mcp/json-rpc-message.ts
-var import_v49 = require("zod/v4");
+var import_v410 = require("zod/v4");
 
 // src/tool/mcp/types.ts
-var import_v48 = require("zod/v4");
+var import_v49 = require("zod/v4");
 var LATEST_PROTOCOL_VERSION = "2025-06-18";
 var SUPPORTED_PROTOCOL_VERSIONS = [
   LATEST_PROTOCOL_VERSION,
   "2025-03-26",
   "2024-11-05"
 ];
-var ClientOrServerImplementationSchema = import_v48.z.looseObject({
-  name: import_v48.z.string(),
-  version: import_v48.z.string()
+var ClientOrServerImplementationSchema = import_v49.z.looseObject({
+  name: import_v49.z.string(),
+  version: import_v49.z.string()
 });
-var BaseParamsSchema = import_v48.z.looseObject({
-  _meta: import_v48.z.optional(import_v48.z.object({}).loose())
+var BaseParamsSchema = import_v49.z.looseObject({
+  _meta: import_v49.z.optional(import_v49.z.object({}).loose())
 });
 var ResultSchema = BaseParamsSchema;
-var RequestSchema = import_v48.z.object({
-  method: import_v48.z.string(),
-  params: import_v48.z.optional(BaseParamsSchema)
+var RequestSchema = import_v49.z.object({
+  method: import_v49.z.string(),
+  params: import_v49.z.optional(BaseParamsSchema)
 });
-var ServerCapabilitiesSchema = import_v48.z.looseObject({
-  experimental: import_v48.z.optional(import_v48.z.object({}).loose()),
-  logging: import_v48.z.optional(import_v48.z.object({}).loose()),
-  prompts: import_v48.z.optional(
-    import_v48.z.looseObject({
-      listChanged: import_v48.z.optional(import_v48.z.boolean())
+var ServerCapabilitiesSchema = import_v49.z.looseObject({
+  experimental: import_v49.z.optional(import_v49.z.object({}).loose()),
+  logging: import_v49.z.optional(import_v49.z.object({}).loose()),
+  prompts: import_v49.z.optional(
+    import_v49.z.looseObject({
+      listChanged: import_v49.z.optional(import_v49.z.boolean())
     })
   ),
-  resources: import_v48.z.optional(
-    import_v48.z.looseObject({
-      subscribe: import_v48.z.optional(import_v48.z.boolean()),
-      listChanged: import_v48.z.optional(import_v48.z.boolean())
+  resources: import_v49.z.optional(
+    import_v49.z.looseObject({
+      subscribe: import_v49.z.optional(import_v49.z.boolean()),
+      listChanged: import_v49.z.optional(import_v49.z.boolean())
     })
   ),
-  tools: import_v48.z.optional(
-    import_v48.z.looseObject({
-      listChanged: import_v48.z.optional(import_v48.z.boolean())
+  tools: import_v49.z.optional(
+    import_v49.z.looseObject({
+      listChanged: import_v49.z.optional(import_v49.z.boolean())
     })
   )
 });
 var InitializeResultSchema = ResultSchema.extend({
-  protocolVersion: import_v48.z.string(),
+  protocolVersion: import_v49.z.string(),
   capabilities: ServerCapabilitiesSchema,
   serverInfo: ClientOrServerImplementationSchema,
-  instructions: import_v48.z.optional(import_v48.z.string())
+  instructions: import_v49.z.optional(import_v49.z.string())
 });
 var PaginatedResultSchema = ResultSchema.extend({
-  nextCursor: import_v48.z.optional(import_v48.z.string())
+  nextCursor: import_v49.z.optional(import_v49.z.string())
 });
-var ToolSchema = import_v48.z.object({
-  name: import_v48.z.string(),
-  description: import_v48.z.optional(import_v48.z.string()),
-  inputSchema: import_v48.z.object({
-    type: import_v48.z.literal("object"),
-    properties: import_v48.z.optional(import_v48.z.object({}).loose())
+var ToolSchema = import_v49.z.object({
+  name: import_v49.z.string(),
+  description: import_v49.z.optional(import_v49.z.string()),
+  inputSchema: import_v49.z.object({
+    type: import_v49.z.literal("object"),
+    properties: import_v49.z.optional(import_v49.z.object({}).loose())
   }).loose()
 }).loose();
 var ListToolsResultSchema = PaginatedResultSchema.extend({
-  tools: import_v48.z.array(ToolSchema)
+  tools: import_v49.z.array(ToolSchema)
 });
-var TextContentSchema = import_v48.z.object({
-  type: import_v48.z.literal("text"),
-  text: import_v48.z.string()
+var TextContentSchema = import_v49.z.object({
+  type: import_v49.z.literal("text"),
+  text: import_v49.z.string()
 }).loose();
-var ImageContentSchema = import_v48.z.object({
-  type: import_v48.z.literal("image"),
-  data: import_v48.z.base64(),
-  mimeType: import_v48.z.string()
+var ImageContentSchema = import_v49.z.object({
+  type: import_v49.z.literal("image"),
+  data: import_v49.z.base64(),
+  mimeType: import_v49.z.string()
 }).loose();
-var ResourceContentsSchema = import_v48.z.object({
+var ResourceContentsSchema = import_v49.z.object({
   /**
    * The URI of this resource.
    */
-  uri: import_v48.z.string(),
+  uri: import_v49.z.string(),
   /**
    * The MIME type of this resource, if known.
    */
-  mimeType: import_v48.z.optional(import_v48.z.string())
+  mimeType: import_v49.z.optional(import_v49.z.string())
 }).loose();
 var TextResourceContentsSchema = ResourceContentsSchema.extend({
-  text: import_v48.z.string()
+  text: import_v49.z.string()
 });
 var BlobResourceContentsSchema = ResourceContentsSchema.extend({
-  blob: import_v48.z.base64()
+  blob: import_v49.z.base64()
 });
-var EmbeddedResourceSchema = import_v48.z.object({
-  type: import_v48.z.literal("resource"),
-  resource: import_v48.z.union([TextResourceContentsSchema, BlobResourceContentsSchema])
+var EmbeddedResourceSchema = import_v49.z.object({
+  type: import_v49.z.literal("resource"),
+  resource: import_v49.z.union([TextResourceContentsSchema, BlobResourceContentsSchema])
 }).loose();
 var CallToolResultSchema = ResultSchema.extend({
-  content: import_v48.z.array(
-    import_v48.z.union([TextContentSchema, ImageContentSchema, EmbeddedResourceSchema])
+  content: import_v49.z.array(
+    import_v49.z.union([TextContentSchema, ImageContentSchema, EmbeddedResourceSchema])
   ),
-  isError: import_v48.z.boolean().default(false).optional()
+  isError: import_v49.z.boolean().default(false).optional()
 }).or(
   ResultSchema.extend({
-    toolResult: import_v48.z.unknown()
+    toolResult: import_v49.z.unknown()
   })
 );
 
 // src/tool/mcp/json-rpc-message.ts
 var JSONRPC_VERSION = "2.0";
-var JSONRPCRequestSchema = import_v49.z.object({
-  jsonrpc: import_v49.z.literal(JSONRPC_VERSION),
-  id: import_v49.z.union([import_v49.z.string(), import_v49.z.number().int()])
+var JSONRPCRequestSchema = import_v410.z.object({
+  jsonrpc: import_v410.z.literal(JSONRPC_VERSION),
+  id: import_v410.z.union([import_v410.z.string(), import_v410.z.number().int()])
 }).merge(RequestSchema).strict();
-var JSONRPCResponseSchema = import_v49.z.object({
-  jsonrpc: import_v49.z.literal(JSONRPC_VERSION),
-  id: import_v49.z.union([import_v49.z.string(), import_v49.z.number().int()]),
+var JSONRPCResponseSchema = import_v410.z.object({
+  jsonrpc: import_v410.z.literal(JSONRPC_VERSION),
+  id: import_v410.z.union([import_v410.z.string(), import_v410.z.number().int()]),
   result: ResultSchema
 }).strict();
-var JSONRPCErrorSchema = import_v49.z.object({
-  jsonrpc: import_v49.z.literal(JSONRPC_VERSION),
-  id: import_v49.z.union([import_v49.z.string(), import_v49.z.number().int()]),
-  error: import_v49.z.object({
-    code: import_v49.z.number().int(),
-    message: import_v49.z.string(),
-    data: import_v49.z.optional(import_v49.z.unknown())
+var JSONRPCErrorSchema = import_v410.z.object({
+  jsonrpc: import_v410.z.literal(JSONRPC_VERSION),
+  id: import_v410.z.union([import_v410.z.string(), import_v410.z.number().int()]),
+  error: import_v410.z.object({
+    code: import_v410.z.number().int(),
+    message: import_v410.z.string(),
+    data: import_v410.z.optional(import_v410.z.unknown())
   })
 }).strict();
-var JSONRPCNotificationSchema = import_v49.z.object({
-  jsonrpc: import_v49.z.literal(JSONRPC_VERSION)
+var JSONRPCNotificationSchema = import_v410.z.object({
+  jsonrpc: import_v410.z.literal(JSONRPC_VERSION)
 }).merge(
-  import_v49.z.object({
-    method: import_v49.z.string(),
-    params: import_v49.z.optional(BaseParamsSchema)
+  import_v410.z.object({
+    method: import_v410.z.string(),
+    params: import_v410.z.optional(BaseParamsSchema)
   })
 ).strict();
-var JSONRPCMessageSchema = import_v49.z.union([
+var JSONRPCMessageSchema = import_v410.z.union([
   JSONRPCRequestSchema,
   JSONRPCNotificationSchema,
   JSONRPCResponseSchema,
@@ -9449,13 +9971,13 @@ var SseMCPTransport = class {
       const establishConnection = async () => {
         var _a17, _b, _c;
         try {
-          const headers = (0, import_provider_utils28.withUserAgentSuffix)(
+          const headers = (0, import_provider_utils30.withUserAgentSuffix)(
             {
               ...this.headers,
               Accept: "text/event-stream"
             },
             `ai-sdk/${VERSION}`,
-            (0, import_provider_utils28.getRuntimeEnvironmentUserAgent)()
+            (0, import_provider_utils30.getRuntimeEnvironmentUserAgent)()
           );
           const response = await fetch(this.url.href, {
             headers,
@@ -9468,7 +9990,7 @@ var SseMCPTransport = class {
             (_b = this.onerror) == null ? void 0 : _b.call(this, error);
             return reject(error);
           }
-          const stream = response.body.pipeThrough(new TextDecoderStream()).pipeThrough(new import_provider_utils28.EventSourceParserStream());
+          const stream = response.body.pipeThrough(new TextDecoderStream()).pipeThrough(new import_provider_utils30.EventSourceParserStream());
           const reader = stream.getReader();
           const processEvents = async () => {
             var _a18, _b2, _c2;
@@ -9547,13 +10069,13 @@ var SseMCPTransport = class {
       });
     }
     try {
-      const headers = (0, import_provider_utils28.withUserAgentSuffix)(
+      const headers = (0, import_provider_utils30.withUserAgentSuffix)(
         {
           ...this.headers,
           "Content-Type": "application/json"
         },
         `ai-sdk/${VERSION}`,
-        (0, import_provider_utils28.getRuntimeEnvironmentUserAgent)()
+        (0, import_provider_utils30.getRuntimeEnvironmentUserAgent)()
       );
       const init = {
         method: "POST",
@@ -9804,15 +10326,15 @@ var DefaultMCPClient = class {
           (_a18 = options == null ? void 0 : options.abortSignal) == null ? void 0 : _a18.throwIfAborted();
           return self.callTool({ name: name17, args, options });
         };
-        const toolWithExecute = schemas === "automatic" ? (0, import_provider_utils29.dynamicTool)({
+        const toolWithExecute = schemas === "automatic" ? (0, import_provider_utils31.dynamicTool)({
           description,
-          inputSchema: (0, import_provider_utils29.jsonSchema)({
+          inputSchema: (0, import_provider_utils31.jsonSchema)({
             ...inputSchema,
             properties: (_a17 = inputSchema.properties) != null ? _a17 : {},
             additionalProperties: false
           }),
           execute
-        }) : (0, import_provider_utils29.tool)({
+        }) : (0, import_provider_utils31.tool)({
           description,
           inputSchema: schemas[name17].inputSchema,
           execute
@@ -9864,11 +10386,11 @@ var DefaultMCPClient = class {
 };
 
 // src/transcribe/transcribe.ts
-var import_provider_utils30 = require("@ai-sdk/provider-utils");
+var import_provider_utils32 = require("@ai-sdk/provider-utils");
 
 // src/error/no-transcript-generated-error.ts
-var import_provider31 = require("@ai-sdk/provider");
-var NoTranscriptGeneratedError = class extends import_provider31.AISDKError {
+var import_provider32 = require("@ai-sdk/provider");
+var NoTranscriptGeneratedError = class extends import_provider32.AISDKError {
   constructor(options) {
     super({
       name: "AI_NoTranscriptGeneratedError",
@@ -9895,7 +10417,7 @@ async function transcribe({
     maxRetries: maxRetriesArg,
     abortSignal
   });
-  const headersWithUserAgent = (0, import_provider_utils30.withUserAgentSuffix)(
+  const headersWithUserAgent = (0, import_provider_utils32.withUserAgentSuffix)(
     headers != null ? headers : {},
     `ai/${VERSION}`
   );
@@ -9943,7 +10465,7 @@ var DefaultTranscriptionResult = class {
 };
 
 // src/ui/call-completion-api.ts
-var import_provider_utils31 = require("@ai-sdk/provider-utils");
+var import_provider_utils33 = require("@ai-sdk/provider-utils");
 
 // src/ui/process-text-stream.ts
 async function processTextStream({
@@ -9991,13 +10513,13 @@ async function callCompletionApi({
         ...body
       }),
       credentials,
-      headers: (0, import_provider_utils31.withUserAgentSuffix)(
+      headers: (0, import_provider_utils33.withUserAgentSuffix)(
         {
           "Content-Type": "application/json",
           ...headers
         },
         `ai-sdk/${VERSION}`,
-        (0, import_provider_utils31.getRuntimeEnvironmentUserAgent)()
+        (0, import_provider_utils33.getRuntimeEnvironmentUserAgent)()
       ),
       signal: abortController.signal
     }).catch((err) => {
@@ -10025,7 +10547,7 @@ async function callCompletionApi({
       }
       case "data": {
         await consumeStream({
-          stream: (0, import_provider_utils31.parseJsonEventStream)({
+          stream: (0, import_provider_utils33.parseJsonEventStream)({
             stream: response.body,
             schema: uiMessageChunkSchema
           }).pipeThrough(
@@ -10077,7 +10599,7 @@ async function callCompletionApi({
 }
 
 // src/ui/chat.ts
-var import_provider_utils34 = require("@ai-sdk/provider-utils");
+var import_provider_utils36 = require("@ai-sdk/provider-utils");
 
 // src/ui/convert-file-list-to-file-ui-parts.ts
 async function convertFileListToFileUIParts(files) {
@@ -10110,10 +10632,10 @@ async function convertFileListToFileUIParts(files) {
 }
 
 // src/ui/default-chat-transport.ts
-var import_provider_utils33 = require("@ai-sdk/provider-utils");
+var import_provider_utils35 = require("@ai-sdk/provider-utils");
 
 // src/ui/http-chat-transport.ts
-var import_provider_utils32 = require("@ai-sdk/provider-utils");
+var import_provider_utils34 = require("@ai-sdk/provider-utils");
 var HttpChatTransport = class {
   constructor({
     api = "/api/chat",
@@ -10137,9 +10659,9 @@ var HttpChatTransport = class {
     ...options
   }) {
     var _a17, _b, _c, _d, _e;
-    const resolvedBody = await (0, import_provider_utils32.resolve)(this.body);
-    const resolvedHeaders = await (0, import_provider_utils32.resolve)(this.headers);
-    const resolvedCredentials = await (0, import_provider_utils32.resolve)(this.credentials);
+    const resolvedBody = await (0, import_provider_utils34.resolve)(this.body);
+    const resolvedHeaders = await (0, import_provider_utils34.resolve)(this.headers);
+    const resolvedCredentials = await (0, import_provider_utils34.resolve)(this.credentials);
     const preparedRequest = await ((_a17 = this.prepareSendMessagesRequest) == null ? void 0 : _a17.call(this, {
       api: this.api,
       id: options.chatId,
@@ -10165,13 +10687,13 @@ var HttpChatTransport = class {
     const fetch2 = (_d = this.fetch) != null ? _d : globalThis.fetch;
     const response = await fetch2(api, {
       method: "POST",
-      headers: (0, import_provider_utils32.withUserAgentSuffix)(
+      headers: (0, import_provider_utils34.withUserAgentSuffix)(
         {
           "Content-Type": "application/json",
           ...headers
         },
         `ai-sdk/${VERSION}`,
-        (0, import_provider_utils32.getRuntimeEnvironmentUserAgent)()
+        (0, import_provider_utils34.getRuntimeEnvironmentUserAgent)()
       ),
       body: JSON.stringify(body),
       credentials,
@@ -10189,9 +10711,9 @@ var HttpChatTransport = class {
   }
   async reconnectToStream(options) {
     var _a17, _b, _c, _d, _e;
-    const resolvedBody = await (0, import_provider_utils32.resolve)(this.body);
-    const resolvedHeaders = await (0, import_provider_utils32.resolve)(this.headers);
-    const resolvedCredentials = await (0, import_provider_utils32.resolve)(this.credentials);
+    const resolvedBody = await (0, import_provider_utils34.resolve)(this.body);
+    const resolvedHeaders = await (0, import_provider_utils34.resolve)(this.headers);
+    const resolvedCredentials = await (0, import_provider_utils34.resolve)(this.credentials);
     const preparedRequest = await ((_a17 = this.prepareReconnectToStreamRequest) == null ? void 0 : _a17.call(this, {
       api: this.api,
       id: options.chatId,
@@ -10206,10 +10728,10 @@ var HttpChatTransport = class {
     const fetch2 = (_d = this.fetch) != null ? _d : globalThis.fetch;
     const response = await fetch2(api, {
       method: "GET",
-      headers: (0, import_provider_utils32.withUserAgentSuffix)(
+      headers: (0, import_provider_utils34.withUserAgentSuffix)(
         headers,
         `ai-sdk/${VERSION}`,
-        (0, import_provider_utils32.getRuntimeEnvironmentUserAgent)()
+        (0, import_provider_utils34.getRuntimeEnvironmentUserAgent)()
       ),
       credentials
     });
@@ -10234,7 +10756,7 @@ var DefaultChatTransport = class extends HttpChatTransport {
     super(options);
   }
   processResponseStream(stream) {
-    return (0, import_provider_utils33.parseJsonEventStream)({
+    return (0, import_provider_utils35.parseJsonEventStream)({
       stream,
       schema: uiMessageChunkSchema
     }).pipeThrough(
@@ -10253,7 +10775,7 @@ var DefaultChatTransport = class extends HttpChatTransport {
 // src/ui/chat.ts
 var AbstractChat = class {
   constructor({
-    generateId: generateId2 = import_provider_utils34.generateId,
+    generateId: generateId2 = import_provider_utils36.generateId,
     id = generateId2(),
     transport = new DefaultChatTransport(),
     messageMetadataSchema,
@@ -10679,516 +11201,6 @@ var TextStreamChatTransport = class extends HttpChatTransport {
     });
   }
 };
-
-// src/ui/validate-ui-messages.ts
-var import_provider32 = require("@ai-sdk/provider");
-var import_provider_utils35 = require("@ai-sdk/provider-utils");
-var import_v410 = require("zod/v4");
-var uiMessagesSchema = (0, import_provider_utils35.lazySchema)(
-  () => (0, import_provider_utils35.zodSchema)(
-    import_v410.z.array(
-      import_v410.z.object({
-        id: import_v410.z.string(),
-        role: import_v410.z.enum(["system", "user", "assistant"]),
-        metadata: import_v410.z.unknown().optional(),
-        parts: import_v410.z.array(
-          import_v410.z.union([
-            import_v410.z.object({
-              type: import_v410.z.literal("text"),
-              text: import_v410.z.string(),
-              state: import_v410.z.enum(["streaming", "done"]).optional(),
-              providerMetadata: providerMetadataSchema.optional()
-            }),
-            import_v410.z.object({
-              type: import_v410.z.literal("reasoning"),
-              text: import_v410.z.string(),
-              state: import_v410.z.enum(["streaming", "done"]).optional(),
-              providerMetadata: providerMetadataSchema.optional()
-            }),
-            import_v410.z.object({
-              type: import_v410.z.literal("source-url"),
-              sourceId: import_v410.z.string(),
-              url: import_v410.z.string(),
-              title: import_v410.z.string().optional(),
-              providerMetadata: providerMetadataSchema.optional()
-            }),
-            import_v410.z.object({
-              type: import_v410.z.literal("source-document"),
-              sourceId: import_v410.z.string(),
-              mediaType: import_v410.z.string(),
-              title: import_v410.z.string(),
-              filename: import_v410.z.string().optional(),
-              providerMetadata: providerMetadataSchema.optional()
-            }),
-            import_v410.z.object({
-              type: import_v410.z.literal("file"),
-              mediaType: import_v410.z.string(),
-              filename: import_v410.z.string().optional(),
-              url: import_v410.z.string(),
-              providerMetadata: providerMetadataSchema.optional()
-            }),
-            import_v410.z.object({
-              type: import_v410.z.literal("step-start")
-            }),
-            import_v410.z.object({
-              type: import_v410.z.string().startsWith("data-"),
-              id: import_v410.z.string().optional(),
-              data: import_v410.z.unknown()
-            }),
-            import_v410.z.object({
-              type: import_v410.z.literal("dynamic-tool"),
-              toolName: import_v410.z.string(),
-              toolCallId: import_v410.z.string(),
-              state: import_v410.z.literal("input-streaming"),
-              input: import_v410.z.unknown().optional(),
-              providerExecuted: import_v410.z.boolean().optional(),
-              output: import_v410.z.never().optional(),
-              errorText: import_v410.z.never().optional(),
-              approval: import_v410.z.never().optional()
-            }),
-            import_v410.z.object({
-              type: import_v410.z.literal("dynamic-tool"),
-              toolName: import_v410.z.string(),
-              toolCallId: import_v410.z.string(),
-              state: import_v410.z.literal("input-available"),
-              input: import_v410.z.unknown(),
-              providerExecuted: import_v410.z.boolean().optional(),
-              output: import_v410.z.never().optional(),
-              errorText: import_v410.z.never().optional(),
-              callProviderMetadata: providerMetadataSchema.optional(),
-              approval: import_v410.z.never().optional()
-            }),
-            import_v410.z.object({
-              type: import_v410.z.literal("dynamic-tool"),
-              toolName: import_v410.z.string(),
-              toolCallId: import_v410.z.string(),
-              state: import_v410.z.literal("approval-requested"),
-              input: import_v410.z.unknown(),
-              providerExecuted: import_v410.z.boolean().optional(),
-              output: import_v410.z.never().optional(),
-              errorText: import_v410.z.never().optional(),
-              callProviderMetadata: providerMetadataSchema.optional(),
-              approval: import_v410.z.object({
-                id: import_v410.z.string(),
-                approved: import_v410.z.never().optional(),
-                reason: import_v410.z.never().optional()
-              })
-            }),
-            import_v410.z.object({
-              type: import_v410.z.literal("dynamic-tool"),
-              toolName: import_v410.z.string(),
-              toolCallId: import_v410.z.string(),
-              state: import_v410.z.literal("approval-responded"),
-              input: import_v410.z.unknown(),
-              providerExecuted: import_v410.z.boolean().optional(),
-              output: import_v410.z.never().optional(),
-              errorText: import_v410.z.never().optional(),
-              callProviderMetadata: providerMetadataSchema.optional(),
-              approval: import_v410.z.object({
-                id: import_v410.z.string(),
-                approved: import_v410.z.boolean(),
-                reason: import_v410.z.string().optional()
-              })
-            }),
-            import_v410.z.object({
-              type: import_v410.z.literal("dynamic-tool"),
-              toolName: import_v410.z.string(),
-              toolCallId: import_v410.z.string(),
-              state: import_v410.z.literal("output-available"),
-              input: import_v410.z.unknown(),
-              providerExecuted: import_v410.z.boolean().optional(),
-              output: import_v410.z.unknown(),
-              errorText: import_v410.z.never().optional(),
-              callProviderMetadata: providerMetadataSchema.optional(),
-              preliminary: import_v410.z.boolean().optional(),
-              approval: import_v410.z.object({
-                id: import_v410.z.string(),
-                approved: import_v410.z.literal(true),
-                reason: import_v410.z.string().optional()
-              }).optional()
-            }),
-            import_v410.z.object({
-              type: import_v410.z.literal("dynamic-tool"),
-              toolName: import_v410.z.string(),
-              toolCallId: import_v410.z.string(),
-              state: import_v410.z.literal("output-error"),
-              input: import_v410.z.unknown(),
-              providerExecuted: import_v410.z.boolean().optional(),
-              output: import_v410.z.never().optional(),
-              errorText: import_v410.z.string(),
-              callProviderMetadata: providerMetadataSchema.optional(),
-              approval: import_v410.z.object({
-                id: import_v410.z.string(),
-                approved: import_v410.z.literal(true),
-                reason: import_v410.z.string().optional()
-              }).optional()
-            }),
-            import_v410.z.object({
-              type: import_v410.z.literal("dynamic-tool"),
-              toolName: import_v410.z.string(),
-              toolCallId: import_v410.z.string(),
-              state: import_v410.z.literal("output-denied"),
-              input: import_v410.z.unknown(),
-              providerExecuted: import_v410.z.boolean().optional(),
-              output: import_v410.z.never().optional(),
-              errorText: import_v410.z.never().optional(),
-              callProviderMetadata: providerMetadataSchema.optional(),
-              approval: import_v410.z.object({
-                id: import_v410.z.string(),
-                approved: import_v410.z.literal(false),
-                reason: import_v410.z.string().optional()
-              })
-            }),
-            import_v410.z.object({
-              type: import_v410.z.string().startsWith("tool-"),
-              toolCallId: import_v410.z.string(),
-              state: import_v410.z.literal("input-streaming"),
-              providerExecuted: import_v410.z.boolean().optional(),
-              input: import_v410.z.unknown().optional(),
-              output: import_v410.z.never().optional(),
-              errorText: import_v410.z.never().optional(),
-              approval: import_v410.z.never().optional()
-            }),
-            import_v410.z.object({
-              type: import_v410.z.string().startsWith("tool-"),
-              toolCallId: import_v410.z.string(),
-              state: import_v410.z.literal("input-available"),
-              providerExecuted: import_v410.z.boolean().optional(),
-              input: import_v410.z.unknown(),
-              output: import_v410.z.never().optional(),
-              errorText: import_v410.z.never().optional(),
-              callProviderMetadata: providerMetadataSchema.optional(),
-              approval: import_v410.z.never().optional()
-            }),
-            import_v410.z.object({
-              type: import_v410.z.string().startsWith("tool-"),
-              toolCallId: import_v410.z.string(),
-              state: import_v410.z.literal("approval-requested"),
-              input: import_v410.z.unknown(),
-              providerExecuted: import_v410.z.boolean().optional(),
-              output: import_v410.z.never().optional(),
-              errorText: import_v410.z.never().optional(),
-              callProviderMetadata: providerMetadataSchema.optional(),
-              approval: import_v410.z.object({
-                id: import_v410.z.string(),
-                approved: import_v410.z.never().optional(),
-                reason: import_v410.z.never().optional()
-              })
-            }),
-            import_v410.z.object({
-              type: import_v410.z.string().startsWith("tool-"),
-              toolCallId: import_v410.z.string(),
-              state: import_v410.z.literal("approval-responded"),
-              input: import_v410.z.unknown(),
-              providerExecuted: import_v410.z.boolean().optional(),
-              output: import_v410.z.never().optional(),
-              errorText: import_v410.z.never().optional(),
-              callProviderMetadata: providerMetadataSchema.optional(),
-              approval: import_v410.z.object({
-                id: import_v410.z.string(),
-                approved: import_v410.z.boolean(),
-                reason: import_v410.z.string().optional()
-              })
-            }),
-            import_v410.z.object({
-              type: import_v410.z.string().startsWith("tool-"),
-              toolCallId: import_v410.z.string(),
-              state: import_v410.z.literal("output-available"),
-              providerExecuted: import_v410.z.boolean().optional(),
-              input: import_v410.z.unknown(),
-              output: import_v410.z.unknown(),
-              errorText: import_v410.z.never().optional(),
-              callProviderMetadata: providerMetadataSchema.optional(),
-              preliminary: import_v410.z.boolean().optional(),
-              approval: import_v410.z.object({
-                id: import_v410.z.string(),
-                approved: import_v410.z.literal(true),
-                reason: import_v410.z.string().optional()
-              }).optional()
-            }),
-            import_v410.z.object({
-              type: import_v410.z.string().startsWith("tool-"),
-              toolCallId: import_v410.z.string(),
-              state: import_v410.z.literal("output-error"),
-              providerExecuted: import_v410.z.boolean().optional(),
-              input: import_v410.z.unknown(),
-              output: import_v410.z.never().optional(),
-              errorText: import_v410.z.string(),
-              callProviderMetadata: providerMetadataSchema.optional(),
-              approval: import_v410.z.object({
-                id: import_v410.z.string(),
-                approved: import_v410.z.literal(true),
-                reason: import_v410.z.string().optional()
-              }).optional()
-            }),
-            import_v410.z.object({
-              type: import_v410.z.string().startsWith("tool-"),
-              toolCallId: import_v410.z.string(),
-              state: import_v410.z.literal("output-denied"),
-              providerExecuted: import_v410.z.boolean().optional(),
-              input: import_v410.z.unknown(),
-              output: import_v410.z.never().optional(),
-              errorText: import_v410.z.never().optional(),
-              callProviderMetadata: providerMetadataSchema.optional(),
-              approval: import_v410.z.object({
-                id: import_v410.z.string(),
-                approved: import_v410.z.literal(false),
-                reason: import_v410.z.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 (0, import_provider_utils35.validateTypes)({
-      value: messages,
-      schema: uiMessagesSchema
-    });
-    if (metadataSchema) {
-      for (const message of validatedMessages) {
-        await (0, import_provider_utils35.validateTypes)({
-          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 import_provider32.TypeValidationError({
-                value: dataPart.data,
-                cause: `No data schema found for data part ${dataName}`
-              })
-            };
-          }
-          await (0, import_provider_utils35.validateTypes)({
-            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 import_provider32.TypeValidationError({
-                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 (0, import_provider_utils35.validateTypes)({
-              value: toolPart.input,
-              schema: tool3.inputSchema
-            });
-          }
-          if (toolPart.state === "output-available" && tool3.outputSchema) {
-            await (0, import_provider_utils35.validateTypes)({
-              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
-var import_provider_utils36 = require("@ai-sdk/provider-utils");
-function createUIMessageStream({
-  execute,
-  onError = import_provider_utils36.getErrorMessage,
-  originalMessages,
-  onFinish,
-  generateId: generateId2 = import_provider_utils36.generateId
-}) {
-  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);
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AISDKError,
@@ -11245,6 +11257,7 @@ function readUIMessageStream({
   coreToolMessageSchema,
   coreUserMessageSchema,
   cosineSimilarity,
+  createAgentStreamResponse,
   createGateway,
   createIdGenerator,
   createProviderRegistry,