@posthog/agent 1.16.6 → 1.18.0

package/dist/node_modules/ai/dist/index.js

@@ -1,2870 +0,0 @@
-import { createIdGenerator, isAbortError, getErrorMessage, delay, safeValidateTypes, safeParseJSON, convertUint8ArrayToBase64, convertBase64ToUint8Array, convertAsyncIteratorToReadableStream } from '../../@ai-sdk/provider-utils/dist/index.js';
-import { asSchema, parsePartialJson, formatDataStreamPart } from '../../@ai-sdk/ui-utils/dist/index.js';
-export { jsonSchema, zodSchema } from '../../@ai-sdk/ui-utils/dist/index.js';
-import { AISDKError, APICallError, UnsupportedFunctionalityError, isJSONObject, TypeValidationError, isJSONArray, JSONParseError, InvalidPromptError } from '../../@ai-sdk/provider/dist/index.js';
-export { EmptyResponseBodyError, LoadAPIKeyError, NoSuchModelError } from '../../@ai-sdk/provider/dist/index.js';
-import { SpanStatusCode } from '../../@opentelemetry/api/build/esm/trace/status.js';
-import { trace } from '../../@opentelemetry/api/build/esm/trace-api.js';
-import { z } from 'zod';
-
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name17 in all)
-    __defProp(target, name17, { get: all[name17], enumerable: true });
-};
-
-// core/util/prepare-response-headers.ts
-function prepareResponseHeaders(headers, {
-  contentType,
-  dataStreamVersion
-}) {
-  const responseHeaders = new Headers(headers != null ? headers : {});
-  if (!responseHeaders.has("Content-Type")) {
-    responseHeaders.set("Content-Type", contentType);
-  }
-  if (dataStreamVersion !== void 0) {
-    responseHeaders.set("X-Vercel-AI-Data-Stream", dataStreamVersion);
-  }
-  return responseHeaders;
-}
-var UnsupportedModelVersionError = class extends AISDKError {
-  constructor() {
-    super({
-      name: "AI_UnsupportedModelVersionError",
-      message: `Unsupported model version. AI SDK 4 only supports models that implement specification version "v1". Please upgrade to AI SDK 5 to use this model.`
-    });
-  }
-};
-var name = "AI_InvalidArgumentError";
-var marker = `vercel.ai.error.${name}`;
-var symbol = Symbol.for(marker);
-var _a;
-var InvalidArgumentError = class extends AISDKError {
-  constructor({
-    parameter,
-    value,
-    message
-  }) {
-    super({
-      name,
-      message: `Invalid argument for parameter ${parameter}: ${message}`
-    });
-    this[_a] = true;
-    this.parameter = parameter;
-    this.value = value;
-  }
-  static isInstance(error) {
-    return AISDKError.hasMarker(error, marker);
-  }
-};
-_a = symbol;
-var name2 = "AI_RetryError";
-var marker2 = `vercel.ai.error.${name2}`;
-var symbol2 = Symbol.for(marker2);
-var _a2;
-var RetryError = class extends AISDKError {
-  constructor({
-    message,
-    reason,
-    errors
-  }) {
-    super({ name: name2, message });
-    this[_a2] = true;
-    this.reason = reason;
-    this.errors = errors;
-    this.lastError = errors[errors.length - 1];
-  }
-  static isInstance(error) {
-    return AISDKError.hasMarker(error, marker2);
-  }
-};
-_a2 = symbol2;
-
-// util/retry-with-exponential-backoff.ts
-var retryWithExponentialBackoff = ({
-  maxRetries = 2,
-  initialDelayInMs = 2e3,
-  backoffFactor = 2
-} = {}) => async (f) => _retryWithExponentialBackoff(f, {
-  maxRetries,
-  delayInMs: initialDelayInMs,
-  backoffFactor
-});
-async function _retryWithExponentialBackoff(f, {
-  maxRetries,
-  delayInMs,
-  backoffFactor
-}, errors = []) {
-  try {
-    return await f();
-  } catch (error) {
-    if (isAbortError(error)) {
-      throw error;
-    }
-    if (maxRetries === 0) {
-      throw error;
-    }
-    const errorMessage = getErrorMessage(error);
-    const newErrors = [...errors, error];
-    const tryNumber = newErrors.length;
-    if (tryNumber > maxRetries) {
-      throw new RetryError({
-        message: `Failed after ${tryNumber} attempts. Last error: ${errorMessage}`,
-        reason: "maxRetriesExceeded",
-        errors: newErrors
-      });
-    }
-    if (error instanceof Error && APICallError.isInstance(error) && error.isRetryable === true && tryNumber <= maxRetries) {
-      await delay(delayInMs);
-      return _retryWithExponentialBackoff(
-        f,
-        { maxRetries, delayInMs: backoffFactor * delayInMs, backoffFactor },
-        newErrors
-      );
-    }
-    if (tryNumber === 1) {
-      throw error;
-    }
-    throw new RetryError({
-      message: `Failed after ${tryNumber} attempts with non-retryable error: '${errorMessage}'`,
-      reason: "errorNotRetryable",
-      errors: newErrors
-    });
-  }
-}
-
-// core/prompt/prepare-retries.ts
-function prepareRetries({
-  maxRetries
-}) {
-  if (maxRetries != null) {
-    if (!Number.isInteger(maxRetries)) {
-      throw new InvalidArgumentError({
-        parameter: "maxRetries",
-        value: maxRetries,
-        message: "maxRetries must be an integer"
-      });
-    }
-    if (maxRetries < 0) {
-      throw new InvalidArgumentError({
-        parameter: "maxRetries",
-        value: maxRetries,
-        message: "maxRetries must be >= 0"
-      });
-    }
-  }
-  const maxRetriesResult = maxRetries != null ? maxRetries : 2;
-  return {
-    maxRetries: maxRetriesResult,
-    retry: retryWithExponentialBackoff({ maxRetries: maxRetriesResult })
-  };
-}
-
-// core/telemetry/assemble-operation-name.ts
-function assembleOperationName({
-  operationId,
-  telemetry
-}) {
-  return {
-    // standardized operation and resource name:
-    "operation.name": `${operationId}${(telemetry == null ? void 0 : telemetry.functionId) != null ? ` ${telemetry.functionId}` : ""}`,
-    "resource.name": telemetry == null ? void 0 : telemetry.functionId,
-    // detailed, AI SDK specific data:
-    "ai.operationId": operationId,
-    "ai.telemetry.functionId": telemetry == null ? void 0 : telemetry.functionId
-  };
-}
-
-// core/telemetry/get-base-telemetry-attributes.ts
-function getBaseTelemetryAttributes({
-  model,
-  settings,
-  telemetry,
-  headers
-}) {
-  var _a17;
-  return {
-    "ai.model.provider": model.provider,
-    "ai.model.id": model.modelId,
-    // settings:
-    ...Object.entries(settings).reduce((attributes, [key, value]) => {
-      attributes[`ai.settings.${key}`] = value;
-      return attributes;
-    }, {}),
-    // add metadata as attributes:
-    ...Object.entries((_a17 = telemetry == null ? void 0 : telemetry.metadata) != null ? _a17 : {}).reduce(
-      (attributes, [key, value]) => {
-        attributes[`ai.telemetry.metadata.${key}`] = value;
-        return attributes;
-      },
-      {}
-    ),
-    // request headers
-    ...Object.entries(headers != null ? headers : {}).reduce((attributes, [key, value]) => {
-      if (value !== void 0) {
-        attributes[`ai.request.headers.${key}`] = value;
-      }
-      return attributes;
-    }, {})
-  };
-}
-
-// core/telemetry/noop-tracer.ts
-var noopTracer = {
-  startSpan() {
-    return noopSpan;
-  },
-  startActiveSpan(name17, arg1, arg2, arg3) {
-    if (typeof arg1 === "function") {
-      return arg1(noopSpan);
-    }
-    if (typeof arg2 === "function") {
-      return arg2(noopSpan);
-    }
-    if (typeof arg3 === "function") {
-      return arg3(noopSpan);
-    }
-  }
-};
-var noopSpan = {
-  spanContext() {
-    return noopSpanContext;
-  },
-  setAttribute() {
-    return this;
-  },
-  setAttributes() {
-    return this;
-  },
-  addEvent() {
-    return this;
-  },
-  addLink() {
-    return this;
-  },
-  addLinks() {
-    return this;
-  },
-  setStatus() {
-    return this;
-  },
-  updateName() {
-    return this;
-  },
-  end() {
-    return this;
-  },
-  isRecording() {
-    return false;
-  },
-  recordException() {
-    return this;
-  }
-};
-var noopSpanContext = {
-  traceId: "",
-  spanId: "",
-  traceFlags: 0
-};
-
-// core/telemetry/get-tracer.ts
-function getTracer({
-  isEnabled = false,
-  tracer
-} = {}) {
-  if (!isEnabled) {
-    return noopTracer;
-  }
-  if (tracer) {
-    return tracer;
-  }
-  return trace.getTracer("ai");
-}
-function recordSpan({
-  name: name17,
-  tracer,
-  attributes,
-  fn,
-  endWhenDone = true
-}) {
-  return tracer.startActiveSpan(name17, { attributes }, async (span) => {
-    try {
-      const result = await fn(span);
-      if (endWhenDone) {
-        span.end();
-      }
-      return result;
-    } catch (error) {
-      try {
-        recordErrorOnSpan(span, error);
-      } finally {
-        span.end();
-      }
-      throw error;
-    }
-  });
-}
-function recordErrorOnSpan(span, error) {
-  if (error instanceof Error) {
-    span.recordException({
-      name: error.name,
-      message: error.message,
-      stack: error.stack
-    });
-    span.setStatus({
-      code: SpanStatusCode.ERROR,
-      message: error.message
-    });
-  } else {
-    span.setStatus({ code: SpanStatusCode.ERROR });
-  }
-}
-
-// core/telemetry/select-telemetry-attributes.ts
-function selectTelemetryAttributes({
-  telemetry,
-  attributes
-}) {
-  if ((telemetry == null ? void 0 : telemetry.isEnabled) !== true) {
-    return {};
-  }
-  return Object.entries(attributes).reduce((attributes2, [key, value]) => {
-    if (value === void 0) {
-      return attributes2;
-    }
-    if (typeof value === "object" && "input" in value && typeof value.input === "function") {
-      if ((telemetry == null ? void 0 : telemetry.recordInputs) === false) {
-        return attributes2;
-      }
-      const result = value.input();
-      return result === void 0 ? attributes2 : { ...attributes2, [key]: result };
-    }
-    if (typeof value === "object" && "output" in value && typeof value.output === "function") {
-      if ((telemetry == null ? void 0 : telemetry.recordOutputs) === false) {
-        return attributes2;
-      }
-      const result = value.output();
-      return result === void 0 ? attributes2 : { ...attributes2, [key]: result };
-    }
-    return { ...attributes2, [key]: value };
-  }, {});
-}
-var imageMimeTypeSignatures = [
-  {
-    mimeType: "image/gif",
-    bytesPrefix: [71, 73, 70],
-    base64Prefix: "R0lG"
-  },
-  {
-    mimeType: "image/png",
-    bytesPrefix: [137, 80, 78, 71],
-    base64Prefix: "iVBORw"
-  },
-  {
-    mimeType: "image/jpeg",
-    bytesPrefix: [255, 216],
-    base64Prefix: "/9j/"
-  },
-  {
-    mimeType: "image/webp",
-    bytesPrefix: [82, 73, 70, 70],
-    base64Prefix: "UklGRg"
-  },
-  {
-    mimeType: "image/bmp",
-    bytesPrefix: [66, 77],
-    base64Prefix: "Qk"
-  },
-  {
-    mimeType: "image/tiff",
-    bytesPrefix: [73, 73, 42, 0],
-    base64Prefix: "SUkqAA"
-  },
-  {
-    mimeType: "image/tiff",
-    bytesPrefix: [77, 77, 0, 42],
-    base64Prefix: "TU0AKg"
-  },
-  {
-    mimeType: "image/avif",
-    bytesPrefix: [
-      0,
-      0,
-      0,
-      32,
-      102,
-      116,
-      121,
-      112,
-      97,
-      118,
-      105,
-      102
-    ],
-    base64Prefix: "AAAAIGZ0eXBhdmlm"
-  },
-  {
-    mimeType: "image/heic",
-    bytesPrefix: [
-      0,
-      0,
-      0,
-      32,
-      102,
-      116,
-      121,
-      112,
-      104,
-      101,
-      105,
-      99
-    ],
-    base64Prefix: "AAAAIGZ0eXBoZWlj"
-  }
-];
-var stripID3 = (data) => {
-  const bytes = typeof data === "string" ? convertBase64ToUint8Array(data) : data;
-  const id3Size = (bytes[6] & 127) << 21 | (bytes[7] & 127) << 14 | (bytes[8] & 127) << 7 | bytes[9] & 127;
-  return bytes.slice(id3Size + 10);
-};
-function stripID3TagsIfPresent(data) {
-  const hasId3 = typeof data === "string" && data.startsWith("SUQz") || typeof data !== "string" && data.length > 10 && data[0] === 73 && // 'I'
-  data[1] === 68 && // 'D'
-  data[2] === 51;
-  return hasId3 ? stripID3(data) : data;
-}
-function detectMimeType({
-  data,
-  signatures
-}) {
-  const processedData = stripID3TagsIfPresent(data);
-  for (const signature of signatures) {
-    if (typeof processedData === "string" ? processedData.startsWith(signature.base64Prefix) : processedData.length >= signature.bytesPrefix.length && signature.bytesPrefix.every(
-      (byte, index) => processedData[index] === byte
-    )) {
-      return signature.mimeType;
-    }
-  }
-  return void 0;
-}
-var name4 = "AI_NoObjectGeneratedError";
-var marker4 = `vercel.ai.error.${name4}`;
-var symbol4 = Symbol.for(marker4);
-var _a4;
-var NoObjectGeneratedError = class extends AISDKError {
-  constructor({
-    message = "No object generated.",
-    cause,
-    text: text2,
-    response,
-    usage,
-    finishReason
-  }) {
-    super({ name: name4, message, cause });
-    this[_a4] = true;
-    this.text = text2;
-    this.response = response;
-    this.usage = usage;
-    this.finishReason = finishReason;
-  }
-  static isInstance(error) {
-    return AISDKError.hasMarker(error, marker4);
-  }
-};
-_a4 = symbol4;
-var name5 = "AI_DownloadError";
-var marker5 = `vercel.ai.error.${name5}`;
-var symbol5 = Symbol.for(marker5);
-var _a5;
-var DownloadError = class extends AISDKError {
-  constructor({
-    url,
-    statusCode,
-    statusText,
-    cause,
-    message = cause == null ? `Failed to download ${url}: ${statusCode} ${statusText}` : `Failed to download ${url}: ${cause}`
-  }) {
-    super({ name: name5, message, cause });
-    this[_a5] = true;
-    this.url = url;
-    this.statusCode = statusCode;
-    this.statusText = statusText;
-  }
-  static isInstance(error) {
-    return AISDKError.hasMarker(error, marker5);
-  }
-};
-_a5 = symbol5;
-
-// util/download.ts
-async function download({ url }) {
-  var _a17;
-  const urlText = url.toString();
-  try {
-    const response = await fetch(urlText);
-    if (!response.ok) {
-      throw new DownloadError({
-        url: urlText,
-        statusCode: response.status,
-        statusText: response.statusText
-      });
-    }
-    return {
-      data: new Uint8Array(await response.arrayBuffer()),
-      mimeType: (_a17 = response.headers.get("content-type")) != null ? _a17 : void 0
-    };
-  } catch (error) {
-    if (DownloadError.isInstance(error)) {
-      throw error;
-    }
-    throw new DownloadError({ url: urlText, cause: error });
-  }
-}
-var name6 = "AI_InvalidDataContentError";
-var marker6 = `vercel.ai.error.${name6}`;
-var symbol6 = Symbol.for(marker6);
-var _a6;
-var InvalidDataContentError = class extends AISDKError {
-  constructor({
-    content,
-    cause,
-    message = `Invalid data content. Expected a base64 string, Uint8Array, ArrayBuffer, or Buffer, but got ${typeof content}.`
-  }) {
-    super({ name: name6, message, cause });
-    this[_a6] = true;
-    this.content = content;
-  }
-  static isInstance(error) {
-    return AISDKError.hasMarker(error, marker6);
-  }
-};
-_a6 = symbol6;
-var dataContentSchema = z.union([
-  z.string(),
-  z.instanceof(Uint8Array),
-  z.instanceof(ArrayBuffer),
-  z.custom(
-    // Buffer might not be available in some environments such as CloudFlare:
-    (value) => {
-      var _a17, _b;
-      return (_b = (_a17 = globalThis.Buffer) == null ? void 0 : _a17.isBuffer(value)) != null ? _b : false;
-    },
-    { message: "Must be a Buffer" }
-  )
-]);
-function convertDataContentToBase64String(content) {
-  if (typeof content === "string") {
-    return content;
-  }
-  if (content instanceof ArrayBuffer) {
-    return convertUint8ArrayToBase64(new Uint8Array(content));
-  }
-  return convertUint8ArrayToBase64(content);
-}
-function convertDataContentToUint8Array(content) {
-  if (content instanceof Uint8Array) {
-    return content;
-  }
-  if (typeof content === "string") {
-    try {
-      return convertBase64ToUint8Array(content);
-    } catch (error) {
-      throw new InvalidDataContentError({
-        message: "Invalid data content. Content string is not a base64-encoded media.",
-        content,
-        cause: error
-      });
-    }
-  }
-  if (content instanceof ArrayBuffer) {
-    return new Uint8Array(content);
-  }
-  throw new InvalidDataContentError({ content });
-}
-function convertUint8ArrayToText(uint8Array) {
-  try {
-    return new TextDecoder().decode(uint8Array);
-  } catch (error) {
-    throw new Error("Error decoding Uint8Array to text");
-  }
-}
-var name7 = "AI_InvalidMessageRoleError";
-var marker7 = `vercel.ai.error.${name7}`;
-var symbol7 = Symbol.for(marker7);
-var _a7;
-var InvalidMessageRoleError = class extends AISDKError {
-  constructor({
-    role,
-    message = `Invalid message role: '${role}'. Must be one of: "system", "user", "assistant", "tool".`
-  }) {
-    super({ name: name7, message });
-    this[_a7] = true;
-    this.role = role;
-  }
-  static isInstance(error) {
-    return AISDKError.hasMarker(error, marker7);
-  }
-};
-_a7 = symbol7;
-
-// core/prompt/split-data-url.ts
-function splitDataUrl(dataUrl) {
-  try {
-    const [header, base64Content] = dataUrl.split(",");
-    return {
-      mimeType: header.split(";")[0].split(":")[1],
-      base64Content
-    };
-  } catch (error) {
-    return {
-      mimeType: void 0,
-      base64Content: void 0
-    };
-  }
-}
-
-// core/prompt/convert-to-language-model-prompt.ts
-async function convertToLanguageModelPrompt({
-  prompt,
-  modelSupportsImageUrls = true,
-  modelSupportsUrl = () => false,
-  downloadImplementation = download
-}) {
-  const downloadedAssets = await downloadAssets(
-    prompt.messages,
-    downloadImplementation,
-    modelSupportsImageUrls,
-    modelSupportsUrl
-  );
-  return [
-    ...prompt.system != null ? [{ role: "system", content: prompt.system }] : [],
-    ...prompt.messages.map(
-      (message) => convertToLanguageModelMessage(message, downloadedAssets)
-    )
-  ];
-}
-function convertToLanguageModelMessage(message, downloadedAssets) {
-  var _a17, _b, _c, _d, _e, _f;
-  const role = message.role;
-  switch (role) {
-    case "system": {
-      return {
-        role: "system",
-        content: message.content,
-        providerMetadata: (_a17 = message.providerOptions) != null ? _a17 : message.experimental_providerMetadata
-      };
-    }
-    case "user": {
-      if (typeof message.content === "string") {
-        return {
-          role: "user",
-          content: [{ type: "text", text: message.content }],
-          providerMetadata: (_b = message.providerOptions) != null ? _b : message.experimental_providerMetadata
-        };
-      }
-      return {
-        role: "user",
-        content: message.content.map((part) => convertPartToLanguageModelPart(part, downloadedAssets)).filter((part) => part.type !== "text" || part.text !== ""),
-        providerMetadata: (_c = message.providerOptions) != null ? _c : message.experimental_providerMetadata
-      };
-    }
-    case "assistant": {
-      if (typeof message.content === "string") {
-        return {
-          role: "assistant",
-          content: [{ type: "text", text: message.content }],
-          providerMetadata: (_d = message.providerOptions) != null ? _d : message.experimental_providerMetadata
-        };
-      }
-      return {
-        role: "assistant",
-        content: message.content.filter(
-          // remove empty text parts:
-          (part) => part.type !== "text" || part.text !== ""
-        ).map((part) => {
-          var _a18;
-          const providerOptions = (_a18 = part.providerOptions) != null ? _a18 : part.experimental_providerMetadata;
-          switch (part.type) {
-            case "file": {
-              return {
-                type: "file",
-                data: part.data instanceof URL ? part.data : convertDataContentToBase64String(part.data),
-                filename: part.filename,
-                mimeType: part.mimeType,
-                providerMetadata: providerOptions
-              };
-            }
-            case "reasoning": {
-              return {
-                type: "reasoning",
-                text: part.text,
-                signature: part.signature,
-                providerMetadata: providerOptions
-              };
-            }
-            case "redacted-reasoning": {
-              return {
-                type: "redacted-reasoning",
-                data: part.data,
-                providerMetadata: providerOptions
-              };
-            }
-            case "text": {
-              return {
-                type: "text",
-                text: part.text,
-                providerMetadata: providerOptions
-              };
-            }
-            case "tool-call": {
-              return {
-                type: "tool-call",
-                toolCallId: part.toolCallId,
-                toolName: part.toolName,
-                args: part.args,
-                providerMetadata: providerOptions
-              };
-            }
-          }
-        }),
-        providerMetadata: (_e = message.providerOptions) != null ? _e : message.experimental_providerMetadata
-      };
-    }
-    case "tool": {
-      return {
-        role: "tool",
-        content: message.content.map((part) => {
-          var _a18;
-          return {
-            type: "tool-result",
-            toolCallId: part.toolCallId,
-            toolName: part.toolName,
-            result: part.result,
-            content: part.experimental_content,
-            isError: part.isError,
-            providerMetadata: (_a18 = part.providerOptions) != null ? _a18 : part.experimental_providerMetadata
-          };
-        }),
-        providerMetadata: (_f = message.providerOptions) != null ? _f : message.experimental_providerMetadata
-      };
-    }
-    default: {
-      const _exhaustiveCheck = role;
-      throw new InvalidMessageRoleError({ role: _exhaustiveCheck });
-    }
-  }
-}
-async function downloadAssets(messages, downloadImplementation, modelSupportsImageUrls, modelSupportsUrl) {
-  const urls = messages.filter((message) => message.role === "user").map((message) => message.content).filter(
-    (content) => Array.isArray(content)
-  ).flat().filter(
-    (part) => part.type === "image" || part.type === "file"
-  ).filter(
-    (part) => !(part.type === "image" && modelSupportsImageUrls === true)
-  ).map((part) => part.type === "image" ? part.image : part.data).map(
-    (part) => (
-      // support string urls:
-      typeof part === "string" && (part.startsWith("http:") || part.startsWith("https:")) ? new URL(part) : part
-    )
-  ).filter((image) => image instanceof URL).filter((url) => !modelSupportsUrl(url));
-  const downloadedImages = await Promise.all(
-    urls.map(async (url) => ({
-      url,
-      data: await downloadImplementation({ url })
-    }))
-  );
-  return Object.fromEntries(
-    downloadedImages.map(({ url, data }) => [url.toString(), data])
-  );
-}
-function convertPartToLanguageModelPart(part, downloadedAssets) {
-  var _a17, _b, _c, _d;
-  if (part.type === "text") {
-    return {
-      type: "text",
-      text: part.text,
-      providerMetadata: (_a17 = part.providerOptions) != null ? _a17 : part.experimental_providerMetadata
-    };
-  }
-  let mimeType = part.mimeType;
-  let data;
-  let content;
-  let normalizedData;
-  const type = part.type;
-  switch (type) {
-    case "image":
-      data = part.image;
-      break;
-    case "file":
-      data = part.data;
-      break;
-    default:
-      throw new Error(`Unsupported part type: ${type}`);
-  }
-  try {
-    content = typeof data === "string" ? new URL(data) : data;
-  } catch (error) {
-    content = data;
-  }
-  if (content instanceof URL) {
-    if (content.protocol === "data:") {
-      const { mimeType: dataUrlMimeType, base64Content } = splitDataUrl(
-        content.toString()
-      );
-      if (dataUrlMimeType == null || base64Content == null) {
-        throw new Error(`Invalid data URL format in part ${type}`);
-      }
-      mimeType = dataUrlMimeType;
-      normalizedData = convertDataContentToUint8Array(base64Content);
-    } else {
-      const downloadedFile = downloadedAssets[content.toString()];
-      if (downloadedFile) {
-        normalizedData = downloadedFile.data;
-        mimeType != null ? mimeType : mimeType = downloadedFile.mimeType;
-      } else {
-        normalizedData = content;
-      }
-    }
-  } else {
-    normalizedData = convertDataContentToUint8Array(content);
-  }
-  switch (type) {
-    case "image": {
-      if (normalizedData instanceof Uint8Array) {
-        mimeType = (_b = detectMimeType({
-          data: normalizedData,
-          signatures: imageMimeTypeSignatures
-        })) != null ? _b : mimeType;
-      }
-      return {
-        type: "image",
-        image: normalizedData,
-        mimeType,
-        providerMetadata: (_c = part.providerOptions) != null ? _c : part.experimental_providerMetadata
-      };
-    }
-    case "file": {
-      if (mimeType == null) {
-        throw new Error(`Mime type is missing for file part`);
-      }
-      return {
-        type: "file",
-        data: normalizedData instanceof Uint8Array ? convertDataContentToBase64String(normalizedData) : normalizedData,
-        filename: part.filename,
-        mimeType,
-        providerMetadata: (_d = part.providerOptions) != null ? _d : part.experimental_providerMetadata
-      };
-    }
-  }
-}
-
-// core/prompt/prepare-call-settings.ts
-function prepareCallSettings({
-  maxTokens,
-  temperature,
-  topP,
-  topK,
-  presencePenalty,
-  frequencyPenalty,
-  stopSequences,
-  seed
-}) {
-  if (maxTokens != null) {
-    if (!Number.isInteger(maxTokens)) {
-      throw new InvalidArgumentError({
-        parameter: "maxTokens",
-        value: maxTokens,
-        message: "maxTokens must be an integer"
-      });
-    }
-    if (maxTokens < 1) {
-      throw new InvalidArgumentError({
-        parameter: "maxTokens",
-        value: maxTokens,
-        message: "maxTokens must be >= 1"
-      });
-    }
-  }
-  if (temperature != null) {
-    if (typeof temperature !== "number") {
-      throw new InvalidArgumentError({
-        parameter: "temperature",
-        value: temperature,
-        message: "temperature must be a number"
-      });
-    }
-  }
-  if (topP != null) {
-    if (typeof topP !== "number") {
-      throw new InvalidArgumentError({
-        parameter: "topP",
-        value: topP,
-        message: "topP must be a number"
-      });
-    }
-  }
-  if (topK != null) {
-    if (typeof topK !== "number") {
-      throw new InvalidArgumentError({
-        parameter: "topK",
-        value: topK,
-        message: "topK must be a number"
-      });
-    }
-  }
-  if (presencePenalty != null) {
-    if (typeof presencePenalty !== "number") {
-      throw new InvalidArgumentError({
-        parameter: "presencePenalty",
-        value: presencePenalty,
-        message: "presencePenalty must be a number"
-      });
-    }
-  }
-  if (frequencyPenalty != null) {
-    if (typeof frequencyPenalty !== "number") {
-      throw new InvalidArgumentError({
-        parameter: "frequencyPenalty",
-        value: frequencyPenalty,
-        message: "frequencyPenalty must be a number"
-      });
-    }
-  }
-  if (seed != null) {
-    if (!Number.isInteger(seed)) {
-      throw new InvalidArgumentError({
-        parameter: "seed",
-        value: seed,
-        message: "seed must be an integer"
-      });
-    }
-  }
-  return {
-    maxTokens,
-    // TODO v5 remove default 0 for temperature
-    temperature: temperature != null ? temperature : 0,
-    topP,
-    topK,
-    presencePenalty,
-    frequencyPenalty,
-    stopSequences: stopSequences != null && stopSequences.length > 0 ? stopSequences : void 0,
-    seed
-  };
-}
-
-// core/prompt/attachments-to-parts.ts
-function attachmentsToParts(attachments) {
-  var _a17, _b, _c;
-  const parts = [];
-  for (const attachment of attachments) {
-    let url;
-    try {
-      url = new URL(attachment.url);
-    } catch (error) {
-      throw new Error(`Invalid URL: ${attachment.url}`);
-    }
-    switch (url.protocol) {
-      case "http:":
-      case "https:": {
-        if ((_a17 = attachment.contentType) == null ? void 0 : _a17.startsWith("image/")) {
-          parts.push({ type: "image", image: url });
-        } else {
-          if (!attachment.contentType) {
-            throw new Error(
-              "If the attachment is not an image, it must specify a content type"
-            );
-          }
-          parts.push({
-            type: "file",
-            data: url,
-            mimeType: attachment.contentType
-          });
-        }
-        break;
-      }
-      case "data:": {
-        let header;
-        let base64Content;
-        let mimeType;
-        try {
-          [header, base64Content] = attachment.url.split(",");
-          mimeType = header.split(";")[0].split(":")[1];
-        } catch (error) {
-          throw new Error(`Error processing data URL: ${attachment.url}`);
-        }
-        if (mimeType == null || base64Content == null) {
-          throw new Error(`Invalid data URL format: ${attachment.url}`);
-        }
-        if ((_b = attachment.contentType) == null ? void 0 : _b.startsWith("image/")) {
-          parts.push({
-            type: "image",
-            image: convertDataContentToUint8Array(base64Content)
-          });
-        } else if ((_c = attachment.contentType) == null ? void 0 : _c.startsWith("text/")) {
-          parts.push({
-            type: "text",
-            text: convertUint8ArrayToText(
-              convertDataContentToUint8Array(base64Content)
-            )
-          });
-        } else {
-          if (!attachment.contentType) {
-            throw new Error(
-              "If the attachment is not an image or text, it must specify a content type"
-            );
-          }
-          parts.push({
-            type: "file",
-            data: base64Content,
-            mimeType: attachment.contentType
-          });
-        }
-        break;
-      }
-      default: {
-        throw new Error(`Unsupported URL protocol: ${url.protocol}`);
-      }
-    }
-  }
-  return parts;
-}
-var name8 = "AI_MessageConversionError";
-var marker8 = `vercel.ai.error.${name8}`;
-var symbol8 = Symbol.for(marker8);
-var _a8;
-var MessageConversionError = class extends AISDKError {
-  constructor({
-    originalMessage,
-    message
-  }) {
-    super({ name: name8, message });
-    this[_a8] = true;
-    this.originalMessage = originalMessage;
-  }
-  static isInstance(error) {
-    return AISDKError.hasMarker(error, marker8);
-  }
-};
-_a8 = symbol8;
-
-// core/prompt/convert-to-core-messages.ts
-function convertToCoreMessages(messages, options) {
-  var _a17, _b;
-  const tools = (_a17 = options == null ? void 0 : options.tools) != null ? _a17 : {};
-  const coreMessages = [];
-  for (let i = 0; i < messages.length; i++) {
-    const message = messages[i];
-    const isLastMessage = i === messages.length - 1;
-    const { role, content, experimental_attachments } = message;
-    switch (role) {
-      case "system": {
-        coreMessages.push({
-          role: "system",
-          content
-        });
-        break;
-      }
-      case "user": {
-        if (message.parts == null) {
-          coreMessages.push({
-            role: "user",
-            content: experimental_attachments ? [
-              { type: "text", text: content },
-              ...attachmentsToParts(experimental_attachments)
-            ] : content
-          });
-        } else {
-          const textParts = message.parts.filter((part) => part.type === "text").map((part) => ({
-            type: "text",
-            text: part.text
-          }));
-          coreMessages.push({
-            role: "user",
-            content: experimental_attachments ? [...textParts, ...attachmentsToParts(experimental_attachments)] : textParts
-          });
-        }
-        break;
-      }
-      case "assistant": {
-        if (message.parts != null) {
-          let processBlock2 = function() {
-            const content2 = [];
-            for (const part of block) {
-              switch (part.type) {
-                case "file":
-                case "text": {
-                  content2.push(part);
-                  break;
-                }
-                case "reasoning": {
-                  for (const detail of part.details) {
-                    switch (detail.type) {
-                      case "text":
-                        content2.push({
-                          type: "reasoning",
-                          text: detail.text,
-                          signature: detail.signature
-                        });
-                        break;
-                      case "redacted":
-                        content2.push({
-                          type: "redacted-reasoning",
-                          data: detail.data
-                        });
-                        break;
-                    }
-                  }
-                  break;
-                }
-                case "tool-invocation":
-                  content2.push({
-                    type: "tool-call",
-                    toolCallId: part.toolInvocation.toolCallId,
-                    toolName: part.toolInvocation.toolName,
-                    args: part.toolInvocation.args
-                  });
-                  break;
-                default: {
-                  const _exhaustiveCheck = part;
-                  throw new Error(`Unsupported part: ${_exhaustiveCheck}`);
-                }
-              }
-            }
-            coreMessages.push({
-              role: "assistant",
-              content: content2
-            });
-            const stepInvocations = block.filter(
-              (part) => part.type === "tool-invocation"
-            ).map((part) => part.toolInvocation);
-            if (stepInvocations.length > 0) {
-              coreMessages.push({
-                role: "tool",
-                content: stepInvocations.map(
-                  (toolInvocation) => {
-                    if (!("result" in toolInvocation)) {
-                      throw new MessageConversionError({
-                        originalMessage: message,
-                        message: "ToolInvocation must have a result: " + JSON.stringify(toolInvocation)
-                      });
-                    }
-                    const { toolCallId, toolName, result } = toolInvocation;
-                    const tool2 = tools[toolName];
-                    return (tool2 == null ? void 0 : tool2.experimental_toToolResultContent) != null ? {
-                      type: "tool-result",
-                      toolCallId,
-                      toolName,
-                      result: tool2.experimental_toToolResultContent(result),
-                      experimental_content: tool2.experimental_toToolResultContent(result)
-                    } : {
-                      type: "tool-result",
-                      toolCallId,
-                      toolName,
-                      result
-                    };
-                  }
-                )
-              });
-            }
-            block = [];
-            blockHasToolInvocations = false;
-            currentStep++;
-          };
-          let currentStep = 0;
-          let blockHasToolInvocations = false;
-          let block = [];
-          for (const part of message.parts) {
-            switch (part.type) {
-              case "text": {
-                if (blockHasToolInvocations) {
-                  processBlock2();
-                }
-                block.push(part);
-                break;
-              }
-              case "file":
-              case "reasoning": {
-                block.push(part);
-                break;
-              }
-              case "tool-invocation": {
-                if (((_b = part.toolInvocation.step) != null ? _b : 0) !== currentStep) {
-                  processBlock2();
-                }
-                block.push(part);
-                blockHasToolInvocations = true;
-                break;
-              }
-            }
-          }
-          processBlock2();
-          break;
-        }
-        const toolInvocations = message.toolInvocations;
-        if (toolInvocations == null || toolInvocations.length === 0) {
-          coreMessages.push({ role: "assistant", content });
-          break;
-        }
-        const maxStep = toolInvocations.reduce((max, toolInvocation) => {
-          var _a18;
-          return Math.max(max, (_a18 = toolInvocation.step) != null ? _a18 : 0);
-        }, 0);
-        for (let i2 = 0; i2 <= maxStep; i2++) {
-          const stepInvocations = toolInvocations.filter(
-            (toolInvocation) => {
-              var _a18;
-              return ((_a18 = toolInvocation.step) != null ? _a18 : 0) === i2;
-            }
-          );
-          if (stepInvocations.length === 0) {
-            continue;
-          }
-          coreMessages.push({
-            role: "assistant",
-            content: [
-              ...isLastMessage && content && i2 === 0 ? [{ type: "text", text: content }] : [],
-              ...stepInvocations.map(
-                ({ toolCallId, toolName, args }) => ({
-                  type: "tool-call",
-                  toolCallId,
-                  toolName,
-                  args
-                })
-              )
-            ]
-          });
-          coreMessages.push({
-            role: "tool",
-            content: stepInvocations.map((toolInvocation) => {
-              if (!("result" in toolInvocation)) {
-                throw new MessageConversionError({
-                  originalMessage: message,
-                  message: "ToolInvocation must have a result: " + JSON.stringify(toolInvocation)
-                });
-              }
-              const { toolCallId, toolName, result } = toolInvocation;
-              const tool2 = tools[toolName];
-              return (tool2 == null ? void 0 : tool2.experimental_toToolResultContent) != null ? {
-                type: "tool-result",
-                toolCallId,
-                toolName,
-                result: tool2.experimental_toToolResultContent(result),
-                experimental_content: tool2.experimental_toToolResultContent(result)
-              } : {
-                type: "tool-result",
-                toolCallId,
-                toolName,
-                result
-              };
-            })
-          });
-        }
-        if (content && !isLastMessage) {
-          coreMessages.push({ role: "assistant", content });
-        }
-        break;
-      }
-      case "data": {
-        break;
-      }
-      default: {
-        const _exhaustiveCheck = role;
-        throw new MessageConversionError({
-          originalMessage: message,
-          message: `Unsupported role: ${_exhaustiveCheck}`
-        });
-      }
-    }
-  }
-  return coreMessages;
-}
-var jsonValueSchema = z.lazy(
-  () => z.union([
-    z.null(),
-    z.string(),
-    z.number(),
-    z.boolean(),
-    z.record(z.string(), jsonValueSchema),
-    z.array(jsonValueSchema)
-  ])
-);
-
-// core/types/provider-metadata.ts
-var providerMetadataSchema = z.record(
-  z.string(),
-  z.record(z.string(), jsonValueSchema)
-);
-var toolResultContentSchema = z.array(
-  z.union([
-    z.object({ type: z.literal("text"), text: z.string() }),
-    z.object({
-      type: z.literal("image"),
-      data: z.string(),
-      mimeType: z.string().optional()
-    })
-  ])
-);
-
-// core/prompt/content-part.ts
-var textPartSchema = z.object({
-  type: z.literal("text"),
-  text: z.string(),
-  providerOptions: providerMetadataSchema.optional(),
-  experimental_providerMetadata: providerMetadataSchema.optional()
-});
-var imagePartSchema = z.object({
-  type: z.literal("image"),
-  image: z.union([dataContentSchema, z.instanceof(URL)]),
-  mimeType: z.string().optional(),
-  providerOptions: providerMetadataSchema.optional(),
-  experimental_providerMetadata: providerMetadataSchema.optional()
-});
-var filePartSchema = z.object({
-  type: z.literal("file"),
-  data: z.union([dataContentSchema, z.instanceof(URL)]),
-  filename: z.string().optional(),
-  mimeType: z.string(),
-  providerOptions: providerMetadataSchema.optional(),
-  experimental_providerMetadata: providerMetadataSchema.optional()
-});
-var reasoningPartSchema = z.object({
-  type: z.literal("reasoning"),
-  text: z.string(),
-  providerOptions: providerMetadataSchema.optional(),
-  experimental_providerMetadata: providerMetadataSchema.optional()
-});
-var redactedReasoningPartSchema = z.object({
-  type: z.literal("redacted-reasoning"),
-  data: z.string(),
-  providerOptions: providerMetadataSchema.optional(),
-  experimental_providerMetadata: providerMetadataSchema.optional()
-});
-var toolCallPartSchema = z.object({
-  type: z.literal("tool-call"),
-  toolCallId: z.string(),
-  toolName: z.string(),
-  args: z.unknown(),
-  providerOptions: providerMetadataSchema.optional(),
-  experimental_providerMetadata: providerMetadataSchema.optional()
-});
-var toolResultPartSchema = z.object({
-  type: z.literal("tool-result"),
-  toolCallId: z.string(),
-  toolName: z.string(),
-  result: z.unknown(),
-  content: toolResultContentSchema.optional(),
-  isError: z.boolean().optional(),
-  providerOptions: providerMetadataSchema.optional(),
-  experimental_providerMetadata: providerMetadataSchema.optional()
-});
-
-// core/prompt/message.ts
-var coreSystemMessageSchema = z.object({
-  role: z.literal("system"),
-  content: z.string(),
-  providerOptions: providerMetadataSchema.optional(),
-  experimental_providerMetadata: providerMetadataSchema.optional()
-});
-var coreUserMessageSchema = z.object({
-  role: z.literal("user"),
-  content: z.union([
-    z.string(),
-    z.array(z.union([textPartSchema, imagePartSchema, filePartSchema]))
-  ]),
-  providerOptions: providerMetadataSchema.optional(),
-  experimental_providerMetadata: providerMetadataSchema.optional()
-});
-var coreAssistantMessageSchema = z.object({
-  role: z.literal("assistant"),
-  content: z.union([
-    z.string(),
-    z.array(
-      z.union([
-        textPartSchema,
-        filePartSchema,
-        reasoningPartSchema,
-        redactedReasoningPartSchema,
-        toolCallPartSchema
-      ])
-    )
-  ]),
-  providerOptions: providerMetadataSchema.optional(),
-  experimental_providerMetadata: providerMetadataSchema.optional()
-});
-var coreToolMessageSchema = z.object({
-  role: z.literal("tool"),
-  content: z.array(toolResultPartSchema),
-  providerOptions: providerMetadataSchema.optional(),
-  experimental_providerMetadata: providerMetadataSchema.optional()
-});
-var coreMessageSchema = z.union([
-  coreSystemMessageSchema,
-  coreUserMessageSchema,
-  coreAssistantMessageSchema,
-  coreToolMessageSchema
-]);
-
-// core/prompt/standardize-prompt.ts
-function standardizePrompt({
-  prompt,
-  tools
-}) {
-  if (prompt.prompt == null && prompt.messages == null) {
-    throw new InvalidPromptError({
-      prompt,
-      message: "prompt or messages must be defined"
-    });
-  }
-  if (prompt.prompt != null && prompt.messages != null) {
-    throw new InvalidPromptError({
-      prompt,
-      message: "prompt and messages cannot be defined at the same time"
-    });
-  }
-  if (prompt.system != null && typeof prompt.system !== "string") {
-    throw new InvalidPromptError({
-      prompt,
-      message: "system must be a string"
-    });
-  }
-  if (prompt.prompt != null) {
-    if (typeof prompt.prompt !== "string") {
-      throw new InvalidPromptError({
-        prompt,
-        message: "prompt must be a string"
-      });
-    }
-    return {
-      type: "prompt",
-      system: prompt.system,
-      messages: [
-        {
-          role: "user",
-          content: prompt.prompt
-        }
-      ]
-    };
-  }
-  if (prompt.messages != null) {
-    const promptType = detectPromptType(prompt.messages);
-    const messages = promptType === "ui-messages" ? convertToCoreMessages(prompt.messages, {
-      tools
-    }) : prompt.messages;
-    if (messages.length === 0) {
-      throw new InvalidPromptError({
-        prompt,
-        message: "messages must not be empty"
-      });
-    }
-    const validationResult = safeValidateTypes({
-      value: messages,
-      schema: z.array(coreMessageSchema)
-    });
-    if (!validationResult.success) {
-      throw new InvalidPromptError({
-        prompt,
-        message: [
-          "message must be a CoreMessage or a UI message",
-          `Validation error: ${validationResult.error.message}`
-        ].join("\n"),
-        cause: validationResult.error
-      });
-    }
-    return {
-      type: "messages",
-      messages,
-      system: prompt.system
-    };
-  }
-  throw new Error("unreachable");
-}
-function detectPromptType(prompt) {
-  if (!Array.isArray(prompt)) {
-    throw new InvalidPromptError({
-      prompt,
-      message: [
-        "messages must be an array of CoreMessage or UIMessage",
-        `Received non-array value: ${JSON.stringify(prompt)}`
-      ].join("\n"),
-      cause: prompt
-    });
-  }
-  if (prompt.length === 0) {
-    return "messages";
-  }
-  const characteristics = prompt.map(detectSingleMessageCharacteristics);
-  if (characteristics.some((c) => c === "has-ui-specific-parts")) {
-    return "ui-messages";
-  }
-  const nonMessageIndex = characteristics.findIndex(
-    (c) => c !== "has-core-specific-parts" && c !== "message"
-  );
-  if (nonMessageIndex === -1) {
-    return "messages";
-  }
-  throw new InvalidPromptError({
-    prompt,
-    message: [
-      "messages must be an array of CoreMessage or UIMessage",
-      `Received message of type: "${characteristics[nonMessageIndex]}" at index ${nonMessageIndex}`,
-      `messages[${nonMessageIndex}]: ${JSON.stringify(prompt[nonMessageIndex])}`
-    ].join("\n"),
-    cause: prompt
-  });
-}
-function detectSingleMessageCharacteristics(message) {
-  if (typeof message === "object" && message !== null && (message.role === "function" || // UI-only role
-  message.role === "data" || // UI-only role
-  "toolInvocations" in message || // UI-specific field
-  "parts" in message || // UI-specific field
-  "experimental_attachments" in message)) {
-    return "has-ui-specific-parts";
-  } else if (typeof message === "object" && message !== null && "content" in message && (Array.isArray(message.content) || // Core messages can have array content
-  "experimental_providerMetadata" in message || "providerOptions" in message)) {
-    return "has-core-specific-parts";
-  } else if (typeof message === "object" && message !== null && "role" in message && "content" in message && typeof message.content === "string" && ["system", "user", "assistant", "tool"].includes(message.role)) {
-    return "message";
-  } else {
-    return "other";
-  }
-}
-
-// core/types/usage.ts
-function calculateLanguageModelUsage({
-  promptTokens,
-  completionTokens
-}) {
-  return {
-    promptTokens,
-    completionTokens,
-    totalTokens: promptTokens + completionTokens
-  };
-}
-
-// core/generate-object/inject-json-instruction.ts
-var DEFAULT_SCHEMA_PREFIX = "JSON schema:";
-var DEFAULT_SCHEMA_SUFFIX = "You MUST answer with a JSON object that matches the JSON schema above.";
-var DEFAULT_GENERIC_SUFFIX = "You MUST answer with JSON.";
-function injectJsonInstruction({
-  prompt,
-  schema,
-  schemaPrefix = schema != null ? DEFAULT_SCHEMA_PREFIX : void 0,
-  schemaSuffix = schema != null ? DEFAULT_SCHEMA_SUFFIX : DEFAULT_GENERIC_SUFFIX
-}) {
-  return [
-    prompt != null && prompt.length > 0 ? prompt : void 0,
-    prompt != null && prompt.length > 0 ? "" : void 0,
-    // add a newline if prompt is not null
-    schemaPrefix,
-    schema != null ? JSON.stringify(schema) : void 0,
-    schemaSuffix
-  ].filter((line) => line != null).join("\n");
-}
-
-// core/util/async-iterable-stream.ts
-function createAsyncIterableStream(source) {
-  const stream = source.pipeThrough(new TransformStream());
-  stream[Symbol.asyncIterator] = () => {
-    const reader = stream.getReader();
-    return {
-      async next() {
-        const { done, value } = await reader.read();
-        return done ? { done: true, value: void 0 } : { done: false, value };
-      }
-    };
-  };
-  return stream;
-}
-
-// core/generate-object/output-strategy.ts
-var noSchemaOutputStrategy = {
-  type: "no-schema",
-  jsonSchema: void 0,
-  validatePartialResult({ value, textDelta }) {
-    return { success: true, value: { partial: value, textDelta } };
-  },
-  validateFinalResult(value, context) {
-    return value === void 0 ? {
-      success: false,
-      error: new NoObjectGeneratedError({
-        message: "No object generated: response did not match schema.",
-        text: context.text,
-        response: context.response,
-        usage: context.usage,
-        finishReason: context.finishReason
-      })
-    } : { success: true, value };
-  },
-  createElementStream() {
-    throw new UnsupportedFunctionalityError({
-      functionality: "element streams in no-schema mode"
-    });
-  }
-};
-var objectOutputStrategy = (schema) => ({
-  type: "object",
-  jsonSchema: schema.jsonSchema,
-  validatePartialResult({ value, textDelta }) {
-    return {
-      success: true,
-      value: {
-        // Note: currently no validation of partial results:
-        partial: value,
-        textDelta
-      }
-    };
-  },
-  validateFinalResult(value) {
-    return safeValidateTypes({ value, schema });
-  },
-  createElementStream() {
-    throw new UnsupportedFunctionalityError({
-      functionality: "element streams in object mode"
-    });
-  }
-});
-var arrayOutputStrategy = (schema) => {
-  const { $schema, ...itemSchema } = schema.jsonSchema;
-  return {
-    type: "enum",
-    // wrap in object that contains array of elements, since most LLMs will not
-    // be able to generate an array directly:
-    // possible future optimization: use arrays directly when model supports grammar-guided generation
-    jsonSchema: {
-      $schema: "http://json-schema.org/draft-07/schema#",
-      type: "object",
-      properties: {
-        elements: { type: "array", items: itemSchema }
-      },
-      required: ["elements"],
-      additionalProperties: false
-    },
-    validatePartialResult({ value, latestObject, isFirstDelta, isFinalDelta }) {
-      var _a17;
-      if (!isJSONObject(value) || !isJSONArray(value.elements)) {
-        return {
-          success: false,
-          error: new TypeValidationError({
-            value,
-            cause: "value must be an object that contains an array of elements"
-          })
-        };
-      }
-      const inputArray = value.elements;
-      const resultArray = [];
-      for (let i = 0; i < inputArray.length; i++) {
-        const element = inputArray[i];
-        const result = safeValidateTypes({ value: element, schema });
-        if (i === inputArray.length - 1 && !isFinalDelta) {
-          continue;
-        }
-        if (!result.success) {
-          return result;
-        }
-        resultArray.push(result.value);
-      }
-      const publishedElementCount = (_a17 = latestObject == null ? void 0 : latestObject.length) != null ? _a17 : 0;
-      let textDelta = "";
-      if (isFirstDelta) {
-        textDelta += "[";
-      }
-      if (publishedElementCount > 0) {
-        textDelta += ",";
-      }
-      textDelta += resultArray.slice(publishedElementCount).map((element) => JSON.stringify(element)).join(",");
-      if (isFinalDelta) {
-        textDelta += "]";
-      }
-      return {
-        success: true,
-        value: {
-          partial: resultArray,
-          textDelta
-        }
-      };
-    },
-    validateFinalResult(value) {
-      if (!isJSONObject(value) || !isJSONArray(value.elements)) {
-        return {
-          success: false,
-          error: new TypeValidationError({
-            value,
-            cause: "value must be an object that contains an array of elements"
-          })
-        };
-      }
-      const inputArray = value.elements;
-      for (const element of inputArray) {
-        const result = safeValidateTypes({ value: element, schema });
-        if (!result.success) {
-          return result;
-        }
-      }
-      return { success: true, value: inputArray };
-    },
-    createElementStream(originalStream) {
-      let publishedElements = 0;
-      return createAsyncIterableStream(
-        originalStream.pipeThrough(
-          new TransformStream({
-            transform(chunk, controller) {
-              switch (chunk.type) {
-                case "object": {
-                  const array = chunk.object;
-                  for (; publishedElements < array.length; publishedElements++) {
-                    controller.enqueue(array[publishedElements]);
-                  }
-                  break;
-                }
-                case "text-delta":
-                case "finish":
-                case "error":
-                  break;
-                default: {
-                  const _exhaustiveCheck = chunk;
-                  throw new Error(
-                    `Unsupported chunk type: ${_exhaustiveCheck}`
-                  );
-                }
-              }
-            }
-          })
-        )
-      );
-    }
-  };
-};
-var enumOutputStrategy = (enumValues) => {
-  return {
-    type: "enum",
-    // wrap in object that contains result, since most LLMs will not
-    // be able to generate an enum value directly:
-    // possible future optimization: use enums directly when model supports top-level enums
-    jsonSchema: {
-      $schema: "http://json-schema.org/draft-07/schema#",
-      type: "object",
-      properties: {
-        result: { type: "string", enum: enumValues }
-      },
-      required: ["result"],
-      additionalProperties: false
-    },
-    validateFinalResult(value) {
-      if (!isJSONObject(value) || typeof value.result !== "string") {
-        return {
-          success: false,
-          error: new TypeValidationError({
-            value,
-            cause: 'value must be an object that contains a string in the "result" property.'
-          })
-        };
-      }
-      const result = value.result;
-      return enumValues.includes(result) ? { success: true, value: result } : {
-        success: false,
-        error: new TypeValidationError({
-          value,
-          cause: "value must be a string in the enum"
-        })
-      };
-    },
-    validatePartialResult() {
-      throw new UnsupportedFunctionalityError({
-        functionality: "partial results in enum mode"
-      });
-    },
-    createElementStream() {
-      throw new UnsupportedFunctionalityError({
-        functionality: "element streams in enum mode"
-      });
-    }
-  };
-};
-function getOutputStrategy({
-  output,
-  schema,
-  enumValues
-}) {
-  switch (output) {
-    case "object":
-      return objectOutputStrategy(asSchema(schema));
-    case "array":
-      return arrayOutputStrategy(asSchema(schema));
-    case "enum":
-      return enumOutputStrategy(enumValues);
-    case "no-schema":
-      return noSchemaOutputStrategy;
-    default: {
-      const _exhaustiveCheck = output;
-      throw new Error(`Unsupported output: ${_exhaustiveCheck}`);
-    }
-  }
-}
-
-// core/generate-object/validate-object-generation-input.ts
-function validateObjectGenerationInput({
-  output,
-  mode,
-  schema,
-  schemaName,
-  schemaDescription,
-  enumValues
-}) {
-  if (output != null && output !== "object" && output !== "array" && output !== "enum" && output !== "no-schema") {
-    throw new InvalidArgumentError({
-      parameter: "output",
-      value: output,
-      message: "Invalid output type."
-    });
-  }
-  if (output === "no-schema") {
-    if (mode === "auto" || mode === "tool") {
-      throw new InvalidArgumentError({
-        parameter: "mode",
-        value: mode,
-        message: 'Mode must be "json" for no-schema output.'
-      });
-    }
-    if (schema != null) {
-      throw new InvalidArgumentError({
-        parameter: "schema",
-        value: schema,
-        message: "Schema is not supported for no-schema output."
-      });
-    }
-    if (schemaDescription != null) {
-      throw new InvalidArgumentError({
-        parameter: "schemaDescription",
-        value: schemaDescription,
-        message: "Schema description is not supported for no-schema output."
-      });
-    }
-    if (schemaName != null) {
-      throw new InvalidArgumentError({
-        parameter: "schemaName",
-        value: schemaName,
-        message: "Schema name is not supported for no-schema output."
-      });
-    }
-    if (enumValues != null) {
-      throw new InvalidArgumentError({
-        parameter: "enumValues",
-        value: enumValues,
-        message: "Enum values are not supported for no-schema output."
-      });
-    }
-  }
-  if (output === "object") {
-    if (schema == null) {
-      throw new InvalidArgumentError({
-        parameter: "schema",
-        value: schema,
-        message: "Schema is required for object output."
-      });
-    }
-    if (enumValues != null) {
-      throw new InvalidArgumentError({
-        parameter: "enumValues",
-        value: enumValues,
-        message: "Enum values are not supported for object output."
-      });
-    }
-  }
-  if (output === "array") {
-    if (schema == null) {
-      throw new InvalidArgumentError({
-        parameter: "schema",
-        value: schema,
-        message: "Element schema is required for array output."
-      });
-    }
-    if (enumValues != null) {
-      throw new InvalidArgumentError({
-        parameter: "enumValues",
-        value: enumValues,
-        message: "Enum values are not supported for array output."
-      });
-    }
-  }
-  if (output === "enum") {
-    if (schema != null) {
-      throw new InvalidArgumentError({
-        parameter: "schema",
-        value: schema,
-        message: "Schema is not supported for enum output."
-      });
-    }
-    if (schemaDescription != null) {
-      throw new InvalidArgumentError({
-        parameter: "schemaDescription",
-        value: schemaDescription,
-        message: "Schema description is not supported for enum output."
-      });
-    }
-    if (schemaName != null) {
-      throw new InvalidArgumentError({
-        parameter: "schemaName",
-        value: schemaName,
-        message: "Schema name is not supported for enum output."
-      });
-    }
-    if (enumValues == null) {
-      throw new InvalidArgumentError({
-        parameter: "enumValues",
-        value: enumValues,
-        message: "Enum values are required for enum output."
-      });
-    }
-    for (const value of enumValues) {
-      if (typeof value !== "string") {
-        throw new InvalidArgumentError({
-          parameter: "enumValues",
-          value,
-          message: "Enum values must be strings."
-        });
-      }
-    }
-  }
-}
-
-// core/prompt/stringify-for-telemetry.ts
-function stringifyForTelemetry(prompt) {
-  const processedPrompt = prompt.map((message) => {
-    return {
-      ...message,
-      content: typeof message.content === "string" ? message.content : message.content.map(processPart)
-    };
-  });
-  return JSON.stringify(processedPrompt);
-}
-function processPart(part) {
-  if (part.type === "image") {
-    return {
-      ...part,
-      image: part.image instanceof Uint8Array ? convertDataContentToBase64String(part.image) : part.image
-    };
-  }
-  return part;
-}
-
-// core/generate-object/generate-object.ts
-var originalGenerateId = createIdGenerator({ prefix: "aiobj", size: 24 });
-async function generateObject({
-  model,
-  enum: enumValues,
-  // rename bc enum is reserved by typescript
-  schema: inputSchema,
-  schemaName,
-  schemaDescription,
-  mode,
-  output = "object",
-  system,
-  prompt,
-  messages,
-  maxRetries: maxRetriesArg,
-  abortSignal,
-  headers,
-  experimental_repairText: repairText,
-  experimental_telemetry: telemetry,
-  experimental_providerMetadata,
-  providerOptions = experimental_providerMetadata,
-  _internal: {
-    generateId: generateId3 = originalGenerateId,
-    currentDate = () => /* @__PURE__ */ new Date()
-  } = {},
-  ...settings
-}) {
-  if (typeof model === "string" || model.specificationVersion !== "v1") {
-    throw new UnsupportedModelVersionError();
-  }
-  validateObjectGenerationInput({
-    output,
-    mode,
-    schema: inputSchema,
-    schemaName,
-    schemaDescription,
-    enumValues
-  });
-  const { maxRetries, retry } = prepareRetries({ maxRetries: maxRetriesArg });
-  const outputStrategy = getOutputStrategy({
-    output,
-    schema: inputSchema,
-    enumValues
-  });
-  if (outputStrategy.type === "no-schema" && mode === void 0) {
-    mode = "json";
-  }
-  const baseTelemetryAttributes = getBaseTelemetryAttributes({
-    model,
-    telemetry,
-    headers,
-    settings: { ...settings, maxRetries }
-  });
-  const tracer = getTracer(telemetry);
-  return recordSpan({
-    name: "ai.generateObject",
-    attributes: selectTelemetryAttributes({
-      telemetry,
-      attributes: {
-        ...assembleOperationName({
-          operationId: "ai.generateObject",
-          telemetry
-        }),
-        ...baseTelemetryAttributes,
-        // specific settings that only make sense on the outer level:
-        "ai.prompt": {
-          input: () => JSON.stringify({ system, prompt, messages })
-        },
-        "ai.schema": outputStrategy.jsonSchema != null ? { input: () => JSON.stringify(outputStrategy.jsonSchema) } : void 0,
-        "ai.schema.name": schemaName,
-        "ai.schema.description": schemaDescription,
-        "ai.settings.output": outputStrategy.type,
-        "ai.settings.mode": mode
-      }
-    }),
-    tracer,
-    fn: async (span) => {
-      var _a17, _b, _c, _d;
-      if (mode === "auto" || mode == null) {
-        mode = model.defaultObjectGenerationMode;
-      }
-      let result;
-      let finishReason;
-      let usage;
-      let warnings;
-      let rawResponse;
-      let response;
-      let request;
-      let logprobs;
-      let resultProviderMetadata;
-      switch (mode) {
-        case "json": {
-          const standardizedPrompt = standardizePrompt({
-            prompt: {
-              system: outputStrategy.jsonSchema == null ? injectJsonInstruction({ prompt: system }) : model.supportsStructuredOutputs ? system : injectJsonInstruction({
-                prompt: system,
-                schema: outputStrategy.jsonSchema
-              }),
-              prompt,
-              messages
-            },
-            tools: void 0
-          });
-          const promptMessages = await convertToLanguageModelPrompt({
-            prompt: standardizedPrompt,
-            modelSupportsImageUrls: model.supportsImageUrls,
-            modelSupportsUrl: (_a17 = model.supportsUrl) == null ? void 0 : _a17.bind(model)
-            // support 'this' context
-          });
-          const generateResult = await retry(
-            () => recordSpan({
-              name: "ai.generateObject.doGenerate",
-              attributes: selectTelemetryAttributes({
-                telemetry,
-                attributes: {
-                  ...assembleOperationName({
-                    operationId: "ai.generateObject.doGenerate",
-                    telemetry
-                  }),
-                  ...baseTelemetryAttributes,
-                  "ai.prompt.format": {
-                    input: () => standardizedPrompt.type
-                  },
-                  "ai.prompt.messages": {
-                    input: () => JSON.stringify(promptMessages)
-                  },
-                  "ai.settings.mode": mode,
-                  // standardized gen-ai llm span attributes:
-                  "gen_ai.system": model.provider,
-                  "gen_ai.request.model": model.modelId,
-                  "gen_ai.request.frequency_penalty": settings.frequencyPenalty,
-                  "gen_ai.request.max_tokens": settings.maxTokens,
-                  "gen_ai.request.presence_penalty": settings.presencePenalty,
-                  "gen_ai.request.temperature": settings.temperature,
-                  "gen_ai.request.top_k": settings.topK,
-                  "gen_ai.request.top_p": settings.topP
-                }
-              }),
-              tracer,
-              fn: async (span2) => {
-                var _a18, _b2, _c2, _d2, _e, _f;
-                const result2 = await model.doGenerate({
-                  mode: {
-                    type: "object-json",
-                    schema: outputStrategy.jsonSchema,
-                    name: schemaName,
-                    description: schemaDescription
-                  },
-                  ...prepareCallSettings(settings),
-                  inputFormat: standardizedPrompt.type,
-                  prompt: promptMessages,
-                  providerMetadata: providerOptions,
-                  abortSignal,
-                  headers
-                });
-                const responseData = {
-                  id: (_b2 = (_a18 = result2.response) == null ? void 0 : _a18.id) != null ? _b2 : generateId3(),
-                  timestamp: (_d2 = (_c2 = result2.response) == null ? void 0 : _c2.timestamp) != null ? _d2 : currentDate(),
-                  modelId: (_f = (_e = result2.response) == null ? void 0 : _e.modelId) != null ? _f : model.modelId
-                };
-                if (result2.text === void 0) {
-                  throw new NoObjectGeneratedError({
-                    message: "No object generated: the model did not return a response.",
-                    response: responseData,
-                    usage: calculateLanguageModelUsage(result2.usage),
-                    finishReason: result2.finishReason
-                  });
-                }
-                span2.setAttributes(
-                  selectTelemetryAttributes({
-                    telemetry,
-                    attributes: {
-                      "ai.response.finishReason": result2.finishReason,
-                      "ai.response.object": { output: () => result2.text },
-                      "ai.response.id": responseData.id,
-                      "ai.response.model": responseData.modelId,
-                      "ai.response.timestamp": responseData.timestamp.toISOString(),
-                      "ai.response.providerMetadata": JSON.stringify(
-                        result2.providerMetadata
-                      ),
-                      "ai.usage.promptTokens": result2.usage.promptTokens,
-                      "ai.usage.completionTokens": result2.usage.completionTokens,
-                      // standardized gen-ai llm span attributes:
-                      "gen_ai.response.finish_reasons": [result2.finishReason],
-                      "gen_ai.response.id": responseData.id,
-                      "gen_ai.response.model": responseData.modelId,
-                      "gen_ai.usage.prompt_tokens": result2.usage.promptTokens,
-                      "gen_ai.usage.completion_tokens": result2.usage.completionTokens
-                    }
-                  })
-                );
-                return { ...result2, objectText: result2.text, responseData };
-              }
-            })
-          );
-          result = generateResult.objectText;
-          finishReason = generateResult.finishReason;
-          usage = generateResult.usage;
-          warnings = generateResult.warnings;
-          rawResponse = generateResult.rawResponse;
-          logprobs = generateResult.logprobs;
-          resultProviderMetadata = generateResult.providerMetadata;
-          request = (_b = generateResult.request) != null ? _b : {};
-          response = generateResult.responseData;
-          break;
-        }
-        case "tool": {
-          const standardizedPrompt = standardizePrompt({
-            prompt: { system, prompt, messages },
-            tools: void 0
-          });
-          const promptMessages = await convertToLanguageModelPrompt({
-            prompt: standardizedPrompt,
-            modelSupportsImageUrls: model.supportsImageUrls,
-            modelSupportsUrl: (_c = model.supportsUrl) == null ? void 0 : _c.bind(model)
-            // support 'this' context,
-          });
-          const inputFormat = standardizedPrompt.type;
-          const generateResult = await retry(
-            () => recordSpan({
-              name: "ai.generateObject.doGenerate",
-              attributes: selectTelemetryAttributes({
-                telemetry,
-                attributes: {
-                  ...assembleOperationName({
-                    operationId: "ai.generateObject.doGenerate",
-                    telemetry
-                  }),
-                  ...baseTelemetryAttributes,
-                  "ai.prompt.format": {
-                    input: () => inputFormat
-                  },
-                  "ai.prompt.messages": {
-                    input: () => stringifyForTelemetry(promptMessages)
-                  },
-                  "ai.settings.mode": mode,
-                  // standardized gen-ai llm span attributes:
-                  "gen_ai.system": model.provider,
-                  "gen_ai.request.model": model.modelId,
-                  "gen_ai.request.frequency_penalty": settings.frequencyPenalty,
-                  "gen_ai.request.max_tokens": settings.maxTokens,
-                  "gen_ai.request.presence_penalty": settings.presencePenalty,
-                  "gen_ai.request.temperature": settings.temperature,
-                  "gen_ai.request.top_k": settings.topK,
-                  "gen_ai.request.top_p": settings.topP
-                }
-              }),
-              tracer,
-              fn: async (span2) => {
-                var _a18, _b2, _c2, _d2, _e, _f, _g, _h;
-                const result2 = await model.doGenerate({
-                  mode: {
-                    type: "object-tool",
-                    tool: {
-                      type: "function",
-                      name: schemaName != null ? schemaName : "json",
-                      description: schemaDescription != null ? schemaDescription : "Respond with a JSON object.",
-                      parameters: outputStrategy.jsonSchema
-                    }
-                  },
-                  ...prepareCallSettings(settings),
-                  inputFormat,
-                  prompt: promptMessages,
-                  providerMetadata: providerOptions,
-                  abortSignal,
-                  headers
-                });
-                const objectText = (_b2 = (_a18 = result2.toolCalls) == null ? void 0 : _a18[0]) == null ? void 0 : _b2.args;
-                const responseData = {
-                  id: (_d2 = (_c2 = result2.response) == null ? void 0 : _c2.id) != null ? _d2 : generateId3(),
-                  timestamp: (_f = (_e = result2.response) == null ? void 0 : _e.timestamp) != null ? _f : currentDate(),
-                  modelId: (_h = (_g = result2.response) == null ? void 0 : _g.modelId) != null ? _h : model.modelId
-                };
-                if (objectText === void 0) {
-                  throw new NoObjectGeneratedError({
-                    message: "No object generated: the tool was not called.",
-                    response: responseData,
-                    usage: calculateLanguageModelUsage(result2.usage),
-                    finishReason: result2.finishReason
-                  });
-                }
-                span2.setAttributes(
-                  selectTelemetryAttributes({
-                    telemetry,
-                    attributes: {
-                      "ai.response.finishReason": result2.finishReason,
-                      "ai.response.object": { output: () => objectText },
-                      "ai.response.id": responseData.id,
-                      "ai.response.model": responseData.modelId,
-                      "ai.response.timestamp": responseData.timestamp.toISOString(),
-                      "ai.response.providerMetadata": JSON.stringify(
-                        result2.providerMetadata
-                      ),
-                      "ai.usage.promptTokens": result2.usage.promptTokens,
-                      "ai.usage.completionTokens": result2.usage.completionTokens,
-                      // standardized gen-ai llm span attributes:
-                      "gen_ai.response.finish_reasons": [result2.finishReason],
-                      "gen_ai.response.id": responseData.id,
-                      "gen_ai.response.model": responseData.modelId,
-                      "gen_ai.usage.input_tokens": result2.usage.promptTokens,
-                      "gen_ai.usage.output_tokens": result2.usage.completionTokens
-                    }
-                  })
-                );
-                return { ...result2, objectText, responseData };
-              }
-            })
-          );
-          result = generateResult.objectText;
-          finishReason = generateResult.finishReason;
-          usage = generateResult.usage;
-          warnings = generateResult.warnings;
-          rawResponse = generateResult.rawResponse;
-          logprobs = generateResult.logprobs;
-          resultProviderMetadata = generateResult.providerMetadata;
-          request = (_d = generateResult.request) != null ? _d : {};
-          response = generateResult.responseData;
-          break;
-        }
-        case void 0: {
-          throw new Error(
-            "Model does not have a default object generation mode."
-          );
-        }
-        default: {
-          const _exhaustiveCheck = mode;
-          throw new Error(`Unsupported mode: ${_exhaustiveCheck}`);
-        }
-      }
-      function processResult(result2) {
-        const parseResult = safeParseJSON({ text: result2 });
-        if (!parseResult.success) {
-          throw new NoObjectGeneratedError({
-            message: "No object generated: could not parse the response.",
-            cause: parseResult.error,
-            text: result2,
-            response,
-            usage: calculateLanguageModelUsage(usage),
-            finishReason
-          });
-        }
-        const validationResult = outputStrategy.validateFinalResult(
-          parseResult.value,
-          {
-            text: result2,
-            response,
-            usage: calculateLanguageModelUsage(usage)
-          }
-        );
-        if (!validationResult.success) {
-          throw new NoObjectGeneratedError({
-            message: "No object generated: response did not match schema.",
-            cause: validationResult.error,
-            text: result2,
-            response,
-            usage: calculateLanguageModelUsage(usage),
-            finishReason
-          });
-        }
-        return validationResult.value;
-      }
-      let object2;
-      try {
-        object2 = processResult(result);
-      } catch (error) {
-        if (repairText != null && NoObjectGeneratedError.isInstance(error) && (JSONParseError.isInstance(error.cause) || TypeValidationError.isInstance(error.cause))) {
-          const repairedText = await repairText({
-            text: result,
-            error: error.cause
-          });
-          if (repairedText === null) {
-            throw error;
-          }
-          object2 = processResult(repairedText);
-        } else {
-          throw error;
-        }
-      }
-      span.setAttributes(
-        selectTelemetryAttributes({
-          telemetry,
-          attributes: {
-            "ai.response.finishReason": finishReason,
-            "ai.response.object": {
-              output: () => JSON.stringify(object2)
-            },
-            "ai.usage.promptTokens": usage.promptTokens,
-            "ai.usage.completionTokens": usage.completionTokens
-          }
-        })
-      );
-      return new DefaultGenerateObjectResult({
-        object: object2,
-        finishReason,
-        usage: calculateLanguageModelUsage(usage),
-        warnings,
-        request,
-        response: {
-          ...response,
-          headers: rawResponse == null ? void 0 : rawResponse.headers,
-          body: rawResponse == null ? void 0 : rawResponse.body
-        },
-        logprobs,
-        providerMetadata: resultProviderMetadata
-      });
-    }
-  });
-}
-var DefaultGenerateObjectResult = class {
-  constructor(options) {
-    this.object = options.object;
-    this.finishReason = options.finishReason;
-    this.usage = options.usage;
-    this.warnings = options.warnings;
-    this.providerMetadata = options.providerMetadata;
-    this.experimental_providerMetadata = options.providerMetadata;
-    this.response = options.response;
-    this.request = options.request;
-    this.logprobs = options.logprobs;
-  }
-  toJsonResponse(init) {
-    var _a17;
-    return new Response(JSON.stringify(this.object), {
-      status: (_a17 = init == null ? void 0 : init.status) != null ? _a17 : 200,
-      headers: prepareResponseHeaders(init == null ? void 0 : init.headers, {
-        contentType: "application/json; charset=utf-8"
-      })
-    });
-  }
-};
-
-// core/generate-object/stream-object.ts
-createIdGenerator({ prefix: "aiobj", size: 24 });
-
-// core/generate-text/generate-text.ts
-createIdGenerator({
-  prefix: "aitxt",
-  size: 24
-});
-createIdGenerator({
-  prefix: "msg",
-  size: 24
-});
-
-// core/generate-text/output.ts
-var output_exports = {};
-__export(output_exports, {
-  object: () => object,
-  text: () => text
-});
-
-// core/generate-text/output.ts
-var text = () => ({
-  type: "text",
-  responseFormat: () => ({ type: "text" }),
-  injectIntoSystemPrompt({ system }) {
-    return system;
-  },
-  parsePartial({ text: text2 }) {
-    return { partial: text2 };
-  },
-  parseOutput({ text: text2 }) {
-    return text2;
-  }
-});
-var object = ({
-  schema: inputSchema
-}) => {
-  const schema = asSchema(inputSchema);
-  return {
-    type: "object",
-    responseFormat: ({ model }) => ({
-      type: "json",
-      schema: model.supportsStructuredOutputs ? schema.jsonSchema : void 0
-    }),
-    injectIntoSystemPrompt({ system, model }) {
-      return model.supportsStructuredOutputs ? system : injectJsonInstruction({
-        prompt: system,
-        schema: schema.jsonSchema
-      });
-    },
-    parsePartial({ text: text2 }) {
-      const result = parsePartialJson(text2);
-      switch (result.state) {
-        case "failed-parse":
-        case "undefined-input":
-          return void 0;
-        case "repaired-parse":
-        case "successful-parse":
-          return {
-            // Note: currently no validation of partial results:
-            partial: result.value
-          };
-        default: {
-          const _exhaustiveCheck = result.state;
-          throw new Error(`Unsupported parse state: ${_exhaustiveCheck}`);
-        }
-      }
-    },
-    parseOutput({ text: text2 }, context) {
-      const parseResult = safeParseJSON({ text: text2 });
-      if (!parseResult.success) {
-        throw new NoObjectGeneratedError({
-          message: "No object generated: could not parse the response.",
-          cause: parseResult.error,
-          text: text2,
-          response: context.response,
-          usage: context.usage,
-          finishReason: context.finishReason
-        });
-      }
-      const validationResult = safeValidateTypes({
-        value: parseResult.value,
-        schema
-      });
-      if (!validationResult.success) {
-        throw new NoObjectGeneratedError({
-          message: "No object generated: response did not match schema.",
-          cause: validationResult.error,
-          text: text2,
-          response: context.response,
-          usage: context.usage,
-          finishReason: context.finishReason
-        });
-      }
-      return validationResult.value;
-    }
-  };
-};
-
-// core/util/merge-streams.ts
-function mergeStreams(stream1, stream2) {
-  const reader1 = stream1.getReader();
-  const reader2 = stream2.getReader();
-  let lastRead1 = void 0;
-  let lastRead2 = void 0;
-  let stream1Done = false;
-  let stream2Done = false;
-  async function readStream1(controller) {
-    try {
-      if (lastRead1 == null) {
-        lastRead1 = reader1.read();
-      }
-      const result = await lastRead1;
-      lastRead1 = void 0;
-      if (!result.done) {
-        controller.enqueue(result.value);
-      } else {
-        controller.close();
-      }
-    } catch (error) {
-      controller.error(error);
-    }
-  }
-  async function readStream2(controller) {
-    try {
-      if (lastRead2 == null) {
-        lastRead2 = reader2.read();
-      }
-      const result = await lastRead2;
-      lastRead2 = void 0;
-      if (!result.done) {
-        controller.enqueue(result.value);
-      } else {
-        controller.close();
-      }
-    } catch (error) {
-      controller.error(error);
-    }
-  }
-  return new ReadableStream({
-    async pull(controller) {
-      try {
-        if (stream1Done) {
-          await readStream2(controller);
-          return;
-        }
-        if (stream2Done) {
-          await readStream1(controller);
-          return;
-        }
-        if (lastRead1 == null) {
-          lastRead1 = reader1.read();
-        }
-        if (lastRead2 == null) {
-          lastRead2 = reader2.read();
-        }
-        const { result, reader } = await Promise.race([
-          lastRead1.then((result2) => ({ result: result2, reader: reader1 })),
-          lastRead2.then((result2) => ({ result: result2, reader: reader2 }))
-        ]);
-        if (!result.done) {
-          controller.enqueue(result.value);
-        }
-        if (reader === reader1) {
-          lastRead1 = void 0;
-          if (result.done) {
-            await readStream2(controller);
-            stream1Done = true;
-          }
-        } else {
-          lastRead2 = void 0;
-          if (result.done) {
-            stream2Done = true;
-            await readStream1(controller);
-          }
-        }
-      } catch (error) {
-        controller.error(error);
-      }
-    },
-    cancel() {
-      reader1.cancel();
-      reader2.cancel();
-    }
-  });
-}
-
-// core/generate-text/stream-text.ts
-createIdGenerator({
-  prefix: "aitxt",
-  size: 24
-});
-createIdGenerator({
-  prefix: "msg",
-  size: 24
-});
-var ClientOrServerImplementationSchema = z.object({
-  name: z.string(),
-  version: z.string()
-}).passthrough();
-var BaseParamsSchema = z.object({
-  _meta: z.optional(z.object({}).passthrough())
-}).passthrough();
-var ResultSchema = BaseParamsSchema;
-var RequestSchema = z.object({
-  method: z.string(),
-  params: z.optional(BaseParamsSchema)
-});
-var ServerCapabilitiesSchema = z.object({
-  experimental: z.optional(z.object({}).passthrough()),
-  logging: z.optional(z.object({}).passthrough()),
-  prompts: z.optional(
-    z.object({
-      listChanged: z.optional(z.boolean())
-    }).passthrough()
-  ),
-  resources: z.optional(
-    z.object({
-      subscribe: z.optional(z.boolean()),
-      listChanged: z.optional(z.boolean())
-    }).passthrough()
-  ),
-  tools: z.optional(
-    z.object({
-      listChanged: z.optional(z.boolean())
-    }).passthrough()
-  )
-}).passthrough();
-ResultSchema.extend({
-  protocolVersion: z.string(),
-  capabilities: ServerCapabilitiesSchema,
-  serverInfo: ClientOrServerImplementationSchema,
-  instructions: z.optional(z.string())
-});
-var PaginatedResultSchema = ResultSchema.extend({
-  nextCursor: z.optional(z.string())
-});
-var ToolSchema = z.object({
-  name: z.string(),
-  description: z.optional(z.string()),
-  inputSchema: z.object({
-    type: z.literal("object"),
-    properties: z.optional(z.object({}).passthrough())
-  }).passthrough()
-}).passthrough();
-PaginatedResultSchema.extend({
-  tools: z.array(ToolSchema)
-});
-var TextContentSchema = z.object({
-  type: z.literal("text"),
-  text: z.string()
-}).passthrough();
-var ImageContentSchema = z.object({
-  type: z.literal("image"),
-  data: z.string().base64(),
-  mimeType: z.string()
-}).passthrough();
-var ResourceContentsSchema = z.object({
-  /**
-   * The URI of this resource.
-   */
-  uri: z.string(),
-  /**
-   * The MIME type of this resource, if known.
-   */
-  mimeType: z.optional(z.string())
-}).passthrough();
-var TextResourceContentsSchema = ResourceContentsSchema.extend({
-  text: z.string()
-});
-var BlobResourceContentsSchema = ResourceContentsSchema.extend({
-  blob: z.string().base64()
-});
-var EmbeddedResourceSchema = z.object({
-  type: z.literal("resource"),
-  resource: z.union([TextResourceContentsSchema, BlobResourceContentsSchema])
-}).passthrough();
-ResultSchema.extend({
-  content: z.array(
-    z.union([TextContentSchema, ImageContentSchema, EmbeddedResourceSchema])
-  ),
-  isError: z.boolean().default(false).optional()
-}).or(
-  ResultSchema.extend({
-    toolResult: z.unknown()
-  })
-);
-
-// core/tool/mcp/json-rpc-message.ts
-var JSONRPC_VERSION = "2.0";
-var JSONRPCRequestSchema = z.object({
-  jsonrpc: z.literal(JSONRPC_VERSION),
-  id: z.union([z.string(), z.number().int()])
-}).merge(RequestSchema).strict();
-var JSONRPCResponseSchema = z.object({
-  jsonrpc: z.literal(JSONRPC_VERSION),
-  id: z.union([z.string(), z.number().int()]),
-  result: ResultSchema
-}).strict();
-var JSONRPCErrorSchema = z.object({
-  jsonrpc: z.literal(JSONRPC_VERSION),
-  id: z.union([z.string(), z.number().int()]),
-  error: z.object({
-    code: z.number().int(),
-    message: z.string(),
-    data: z.optional(z.unknown())
-  })
-}).strict();
-var JSONRPCNotificationSchema = z.object({
-  jsonrpc: z.literal(JSONRPC_VERSION)
-}).merge(
-  z.object({
-    method: z.string(),
-    params: z.optional(BaseParamsSchema)
-  })
-).strict();
-z.union([
-  JSONRPCRequestSchema,
-  JSONRPCNotificationSchema,
-  JSONRPCResponseSchema,
-  JSONRPCErrorSchema
-]);
-
-// streams/langchain-adapter.ts
-var langchain_adapter_exports = {};
-__export(langchain_adapter_exports, {
-  mergeIntoDataStream: () => mergeIntoDataStream,
-  toDataStream: () => toDataStream,
-  toDataStreamResponse: () => toDataStreamResponse
-});
-
-// streams/stream-callbacks.ts
-function createCallbacksTransformer(callbacks = {}) {
-  const textEncoder = new TextEncoder();
-  let aggregatedResponse = "";
-  return new TransformStream({
-    async start() {
-      if (callbacks.onStart)
-        await callbacks.onStart();
-    },
-    async transform(message, controller) {
-      controller.enqueue(textEncoder.encode(message));
-      aggregatedResponse += message;
-      if (callbacks.onToken)
-        await callbacks.onToken(message);
-      if (callbacks.onText && typeof message === "string") {
-        await callbacks.onText(message);
-      }
-    },
-    async flush() {
-      if (callbacks.onCompletion) {
-        await callbacks.onCompletion(aggregatedResponse);
-      }
-      if (callbacks.onFinal) {
-        await callbacks.onFinal(aggregatedResponse);
-      }
-    }
-  });
-}
-
-// streams/langchain-adapter.ts
-function toDataStreamInternal(stream, callbacks) {
-  return stream.pipeThrough(
-    new TransformStream({
-      transform: async (value, controller) => {
-        var _a17;
-        if (typeof value === "string") {
-          controller.enqueue(value);
-          return;
-        }
-        if ("event" in value) {
-          if (value.event === "on_chat_model_stream") {
-            forwardAIMessageChunk(
-              (_a17 = value.data) == null ? void 0 : _a17.chunk,
-              controller
-            );
-          }
-          return;
-        }
-        forwardAIMessageChunk(value, controller);
-      }
-    })
-  ).pipeThrough(createCallbacksTransformer(callbacks)).pipeThrough(new TextDecoderStream()).pipeThrough(
-    new TransformStream({
-      transform: async (chunk, controller) => {
-        controller.enqueue(formatDataStreamPart("text", chunk));
-      }
-    })
-  );
-}
-function toDataStream(stream, callbacks) {
-  return toDataStreamInternal(stream, callbacks).pipeThrough(
-    new TextEncoderStream()
-  );
-}
-function toDataStreamResponse(stream, options) {
-  var _a17;
-  const dataStream = toDataStreamInternal(
-    stream,
-    options == null ? void 0 : options.callbacks
-  ).pipeThrough(new TextEncoderStream());
-  const data = options == null ? void 0 : options.data;
-  const init = options == null ? void 0 : options.init;
-  const responseStream = data ? mergeStreams(data.stream, dataStream) : dataStream;
-  return new Response(responseStream, {
-    status: (_a17 = init == null ? void 0 : init.status) != null ? _a17 : 200,
-    statusText: init == null ? void 0 : init.statusText,
-    headers: prepareResponseHeaders(init == null ? void 0 : init.headers, {
-      contentType: "text/plain; charset=utf-8",
-      dataStreamVersion: "v1"
-    })
-  });
-}
-function mergeIntoDataStream(stream, options) {
-  options.dataStream.merge(toDataStreamInternal(stream, options.callbacks));
-}
-function forwardAIMessageChunk(chunk, controller) {
-  if (typeof chunk.content === "string") {
-    controller.enqueue(chunk.content);
-  } else {
-    const content = chunk.content;
-    for (const item of content) {
-      if (item.type === "text") {
-        controller.enqueue(item.text);
-      }
-    }
-  }
-}
-
-// streams/llamaindex-adapter.ts
-var llamaindex_adapter_exports = {};
-__export(llamaindex_adapter_exports, {
-  mergeIntoDataStream: () => mergeIntoDataStream2,
-  toDataStream: () => toDataStream2,
-  toDataStreamResponse: () => toDataStreamResponse2
-});
-function toDataStreamInternal2(stream, callbacks) {
-  const trimStart = trimStartOfStream();
-  return convertAsyncIteratorToReadableStream(stream[Symbol.asyncIterator]()).pipeThrough(
-    new TransformStream({
-      async transform(message, controller) {
-        controller.enqueue(trimStart(message.delta));
-      }
-    })
-  ).pipeThrough(createCallbacksTransformer(callbacks)).pipeThrough(new TextDecoderStream()).pipeThrough(
-    new TransformStream({
-      transform: async (chunk, controller) => {
-        controller.enqueue(formatDataStreamPart("text", chunk));
-      }
-    })
-  );
-}
-function toDataStream2(stream, callbacks) {
-  return toDataStreamInternal2(stream, callbacks).pipeThrough(
-    new TextEncoderStream()
-  );
-}
-function toDataStreamResponse2(stream, options = {}) {
-  var _a17;
-  const { init, data, callbacks } = options;
-  const dataStream = toDataStreamInternal2(stream, callbacks).pipeThrough(
-    new TextEncoderStream()
-  );
-  const responseStream = data ? mergeStreams(data.stream, dataStream) : dataStream;
-  return new Response(responseStream, {
-    status: (_a17 = init == null ? void 0 : init.status) != null ? _a17 : 200,
-    statusText: init == null ? void 0 : init.statusText,
-    headers: prepareResponseHeaders(init == null ? void 0 : init.headers, {
-      contentType: "text/plain; charset=utf-8",
-      dataStreamVersion: "v1"
-    })
-  });
-}
-function mergeIntoDataStream2(stream, options) {
-  options.dataStream.merge(toDataStreamInternal2(stream, options.callbacks));
-}
-function trimStartOfStream() {
-  let isStreamStart = true;
-  return (text2) => {
-    if (isStreamStart) {
-      text2 = text2.trimStart();
-      if (text2)
-        isStreamStart = false;
-    }
-    return text2;
-  };
-}
-
-export { AISDKError, APICallError, DownloadError, InvalidArgumentError, InvalidDataContentError, InvalidMessageRoleError, InvalidPromptError, JSONParseError, langchain_adapter_exports as LangChainAdapter, llamaindex_adapter_exports as LlamaIndexAdapter, MessageConversionError, NoObjectGeneratedError, output_exports as Output, RetryError, TypeValidationError, UnsupportedFunctionalityError, UnsupportedModelVersionError, convertToCoreMessages, coreAssistantMessageSchema, coreMessageSchema, coreSystemMessageSchema, coreToolMessageSchema, coreUserMessageSchema, createIdGenerator, formatDataStreamPart, generateObject };
-//# sourceMappingURL=index.js.map