ai 5.0.0-beta.25 → 5.0.0-beta.26

package/dist/bin/ai.js

@@ -1,4736 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name9 in all)
-    __defProp(target, name9, { get: all[name9], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/bin/ai.ts
-var ai_exports = {};
-__export(ai_exports, {
-  formatAttachedFiles: () => formatAttachedFiles,
-  getMediaType: () => getMediaType,
-  isStdinAvailable: () => isStdinAvailable,
-  main: () => main,
-  parseArgs: () => parseArgs,
-  readFileContent: () => readFileContent,
-  resolveModel: () => resolveModel,
-  showHelp: () => showHelp,
-  showVersion: () => showVersion
-});
-module.exports = __toCommonJS(ai_exports);
-
-// src/generate-text/stream-text.ts
-var import_provider16 = require("@ai-sdk/provider");
-var import_provider_utils12 = require("@ai-sdk/provider-utils");
-
-// src/error/no-output-specified-error.ts
-var import_provider = require("@ai-sdk/provider");
-var name = "AI_NoOutputSpecifiedError";
-var marker = `vercel.ai.error.${name}`;
-var symbol = Symbol.for(marker);
-var _a;
-var NoOutputSpecifiedError = class extends import_provider.AISDKError {
-  // used in isInstance
-  constructor({ message = "No output specified." } = {}) {
-    super({ name, message });
-    this[_a] = true;
-  }
-  static isInstance(error) {
-    return import_provider.AISDKError.hasMarker(error, marker);
-  }
-};
-_a = symbol;
-
-// src/util/prepare-headers.ts
-function prepareHeaders(headers, defaultHeaders) {
-  const responseHeaders = new Headers(headers != null ? headers : {});
-  for (const [key, value] of Object.entries(defaultHeaders)) {
-    if (!responseHeaders.has(key)) {
-      responseHeaders.set(key, value);
-    }
-  }
-  return responseHeaders;
-}
-
-// src/text-stream/create-text-stream-response.ts
-function createTextStreamResponse({
-  status,
-  statusText,
-  headers,
-  textStream
-}) {
-  return new Response(textStream.pipeThrough(new TextEncoderStream()), {
-    status: status != null ? status : 200,
-    statusText,
-    headers: prepareHeaders(headers, {
-      "content-type": "text/plain; charset=utf-8"
-    })
-  });
-}
-
-// src/util/write-to-server-response.ts
-function writeToServerResponse({
-  response,
-  status,
-  statusText,
-  headers,
-  stream
-}) {
-  response.writeHead(status != null ? status : 200, statusText, headers);
-  const reader = stream.getReader();
-  const read = async () => {
-    try {
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done)
-          break;
-        response.write(value);
-      }
-    } catch (error) {
-      throw error;
-    } finally {
-      response.end();
-    }
-  };
-  read();
-}
-
-// src/text-stream/pipe-text-stream-to-response.ts
-function pipeTextStreamToResponse({
-  response,
-  status,
-  statusText,
-  headers,
-  textStream
-}) {
-  writeToServerResponse({
-    response,
-    status,
-    statusText,
-    headers: Object.fromEntries(
-      prepareHeaders(headers, {
-        "content-type": "text/plain; charset=utf-8"
-      }).entries()
-    ),
-    stream: textStream.pipeThrough(new TextEncoderStream())
-  });
-}
-
-// src/ui-message-stream/json-to-sse-transform-stream.ts
-var JsonToSseTransformStream = class extends TransformStream {
-  constructor() {
-    super({
-      transform(part, controller) {
-        controller.enqueue(`data: ${JSON.stringify(part)}
-
-`);
-      },
-      flush(controller) {
-        controller.enqueue("data: [DONE]\n\n");
-      }
-    });
-  }
-};
-
-// src/ui-message-stream/ui-message-stream-headers.ts
-var UI_MESSAGE_STREAM_HEADERS = {
-  "content-type": "text/event-stream",
-  "cache-control": "no-cache",
-  connection: "keep-alive",
-  "x-vercel-ai-ui-message-stream": "v1",
-  "x-accel-buffering": "no"
-  // disable nginx buffering
-};
-
-// src/ui-message-stream/create-ui-message-stream-response.ts
-function createUIMessageStreamResponse({
-  status,
-  statusText,
-  headers,
-  stream,
-  consumeSseStream
-}) {
-  let sseStream = stream.pipeThrough(new JsonToSseTransformStream());
-  if (consumeSseStream) {
-    const [stream1, stream2] = sseStream.tee();
-    sseStream = stream1;
-    consumeSseStream({ stream: stream2 });
-  }
-  return new Response(sseStream.pipeThrough(new TextEncoderStream()), {
-    status,
-    statusText,
-    headers: prepareHeaders(headers, UI_MESSAGE_STREAM_HEADERS)
-  });
-}
-
-// src/ui-message-stream/get-response-ui-message-id.ts
-function getResponseUIMessageId({
-  originalMessages,
-  responseMessageId
-}) {
-  if (originalMessages == null) {
-    return void 0;
-  }
-  const lastMessage = originalMessages[originalMessages.length - 1];
-  return (lastMessage == null ? void 0 : lastMessage.role) === "assistant" ? lastMessage.id : typeof responseMessageId === "function" ? responseMessageId() : responseMessageId;
-}
-
-// src/ui/process-ui-message-stream.ts
-var import_provider_utils2 = require("@ai-sdk/provider-utils");
-
-// src/ui-message-stream/ui-message-chunks.ts
-var import_v43 = require("zod/v4");
-
-// src/types/provider-metadata.ts
-var import_v42 = require("zod/v4");
-
-// src/types/json-value.ts
-var import_v4 = require("zod/v4");
-var jsonValueSchema = import_v4.z.lazy(
-  () => import_v4.z.union([
-    import_v4.z.null(),
-    import_v4.z.string(),
-    import_v4.z.number(),
-    import_v4.z.boolean(),
-    import_v4.z.record(import_v4.z.string(), jsonValueSchema),
-    import_v4.z.array(jsonValueSchema)
-  ])
-);
-
-// src/types/provider-metadata.ts
-var providerMetadataSchema = import_v42.z.record(
-  import_v42.z.string(),
-  import_v42.z.record(import_v42.z.string(), jsonValueSchema)
-);
-
-// src/ui-message-stream/ui-message-chunks.ts
-var uiMessageChunkSchema = import_v43.z.union([
-  import_v43.z.strictObject({
-    type: import_v43.z.literal("text-start"),
-    id: import_v43.z.string(),
-    providerMetadata: providerMetadataSchema.optional()
-  }),
-  import_v43.z.strictObject({
-    type: import_v43.z.literal("text-delta"),
-    id: import_v43.z.string(),
-    delta: import_v43.z.string(),
-    providerMetadata: providerMetadataSchema.optional()
-  }),
-  import_v43.z.strictObject({
-    type: import_v43.z.literal("text-end"),
-    id: import_v43.z.string(),
-    providerMetadata: providerMetadataSchema.optional()
-  }),
-  import_v43.z.strictObject({
-    type: import_v43.z.literal("error"),
-    errorText: import_v43.z.string()
-  }),
-  import_v43.z.strictObject({
-    type: import_v43.z.literal("tool-input-start"),
-    toolCallId: import_v43.z.string(),
-    toolName: import_v43.z.string(),
-    providerExecuted: import_v43.z.boolean().optional()
-  }),
-  import_v43.z.strictObject({
-    type: import_v43.z.literal("tool-input-delta"),
-    toolCallId: import_v43.z.string(),
-    inputTextDelta: import_v43.z.string()
-  }),
-  import_v43.z.strictObject({
-    type: import_v43.z.literal("tool-input-available"),
-    toolCallId: import_v43.z.string(),
-    toolName: import_v43.z.string(),
-    input: import_v43.z.unknown(),
-    providerExecuted: import_v43.z.boolean().optional(),
-    providerMetadata: providerMetadataSchema.optional()
-  }),
-  import_v43.z.strictObject({
-    type: import_v43.z.literal("tool-output-available"),
-    toolCallId: import_v43.z.string(),
-    output: import_v43.z.unknown(),
-    providerExecuted: import_v43.z.boolean().optional()
-  }),
-  import_v43.z.strictObject({
-    type: import_v43.z.literal("tool-output-error"),
-    toolCallId: import_v43.z.string(),
-    errorText: import_v43.z.string(),
-    providerExecuted: import_v43.z.boolean().optional()
-  }),
-  import_v43.z.strictObject({
-    type: import_v43.z.literal("reasoning"),
-    text: import_v43.z.string(),
-    providerMetadata: providerMetadataSchema.optional()
-  }),
-  import_v43.z.strictObject({
-    type: import_v43.z.literal("reasoning-start"),
-    id: import_v43.z.string(),
-    providerMetadata: providerMetadataSchema.optional()
-  }),
-  import_v43.z.strictObject({
-    type: import_v43.z.literal("reasoning-delta"),
-    id: import_v43.z.string(),
-    delta: import_v43.z.string(),
-    providerMetadata: providerMetadataSchema.optional()
-  }),
-  import_v43.z.strictObject({
-    type: import_v43.z.literal("reasoning-end"),
-    id: import_v43.z.string(),
-    providerMetadata: providerMetadataSchema.optional()
-  }),
-  import_v43.z.strictObject({
-    type: import_v43.z.literal("reasoning-part-finish")
-  }),
-  import_v43.z.strictObject({
-    type: import_v43.z.literal("source-url"),
-    sourceId: import_v43.z.string(),
-    url: import_v43.z.string(),
-    title: import_v43.z.string().optional(),
-    providerMetadata: providerMetadataSchema.optional()
-  }),
-  import_v43.z.strictObject({
-    type: import_v43.z.literal("source-document"),
-    sourceId: import_v43.z.string(),
-    mediaType: import_v43.z.string(),
-    title: import_v43.z.string(),
-    filename: import_v43.z.string().optional(),
-    providerMetadata: providerMetadataSchema.optional()
-  }),
-  import_v43.z.strictObject({
-    type: import_v43.z.literal("file"),
-    url: import_v43.z.string(),
-    mediaType: import_v43.z.string(),
-    providerMetadata: providerMetadataSchema.optional()
-  }),
-  import_v43.z.strictObject({
-    type: import_v43.z.string().startsWith("data-"),
-    id: import_v43.z.string().optional(),
-    data: import_v43.z.unknown(),
-    transient: import_v43.z.boolean().optional()
-  }),
-  import_v43.z.strictObject({
-    type: import_v43.z.literal("start-step")
-  }),
-  import_v43.z.strictObject({
-    type: import_v43.z.literal("finish-step")
-  }),
-  import_v43.z.strictObject({
-    type: import_v43.z.literal("start"),
-    messageId: import_v43.z.string().optional(),
-    messageMetadata: import_v43.z.unknown().optional()
-  }),
-  import_v43.z.strictObject({
-    type: import_v43.z.literal("finish"),
-    messageMetadata: import_v43.z.unknown().optional()
-  }),
-  import_v43.z.strictObject({
-    type: import_v43.z.literal("abort")
-  }),
-  import_v43.z.strictObject({
-    type: import_v43.z.literal("message-metadata"),
-    messageMetadata: import_v43.z.unknown()
-  })
-]);
-function isDataUIMessageChunk(chunk) {
-  return chunk.type.startsWith("data-");
-}
-
-// src/util/merge-objects.ts
-function mergeObjects(base, overrides) {
-  if (base === void 0 && overrides === void 0) {
-    return void 0;
-  }
-  if (base === void 0) {
-    return overrides;
-  }
-  if (overrides === void 0) {
-    return base;
-  }
-  const result = { ...base };
-  for (const key in overrides) {
-    if (Object.prototype.hasOwnProperty.call(overrides, key)) {
-      const overridesValue = overrides[key];
-      if (overridesValue === void 0)
-        continue;
-      const baseValue = key in base ? base[key] : void 0;
-      const isSourceObject = overridesValue !== null && typeof overridesValue === "object" && !Array.isArray(overridesValue) && !(overridesValue instanceof Date) && !(overridesValue instanceof RegExp);
-      const isTargetObject = baseValue !== null && baseValue !== void 0 && typeof baseValue === "object" && !Array.isArray(baseValue) && !(baseValue instanceof Date) && !(baseValue instanceof RegExp);
-      if (isSourceObject && isTargetObject) {
-        result[key] = mergeObjects(
-          baseValue,
-          overridesValue
-        );
-      } else {
-        result[key] = overridesValue;
-      }
-    }
-  }
-  return result;
-}
-
-// src/util/parse-partial-json.ts
-var import_provider_utils = require("@ai-sdk/provider-utils");
-
-// src/util/fix-json.ts
-function fixJson(input) {
-  const stack = ["ROOT"];
-  let lastValidIndex = -1;
-  let literalStart = null;
-  function processValueStart(char, i, swapState) {
-    {
-      switch (char) {
-        case '"': {
-          lastValidIndex = i;
-          stack.pop();
-          stack.push(swapState);
-          stack.push("INSIDE_STRING");
-          break;
-        }
-        case "f":
-        case "t":
-        case "n": {
-          lastValidIndex = i;
-          literalStart = i;
-          stack.pop();
-          stack.push(swapState);
-          stack.push("INSIDE_LITERAL");
-          break;
-        }
-        case "-": {
-          stack.pop();
-          stack.push(swapState);
-          stack.push("INSIDE_NUMBER");
-          break;
-        }
-        case "0":
-        case "1":
-        case "2":
-        case "3":
-        case "4":
-        case "5":
-        case "6":
-        case "7":
-        case "8":
-        case "9": {
-          lastValidIndex = i;
-          stack.pop();
-          stack.push(swapState);
-          stack.push("INSIDE_NUMBER");
-          break;
-        }
-        case "{": {
-          lastValidIndex = i;
-          stack.pop();
-          stack.push(swapState);
-          stack.push("INSIDE_OBJECT_START");
-          break;
-        }
-        case "[": {
-          lastValidIndex = i;
-          stack.pop();
-          stack.push(swapState);
-          stack.push("INSIDE_ARRAY_START");
-          break;
-        }
-      }
-    }
-  }
-  function processAfterObjectValue(char, i) {
-    switch (char) {
-      case ",": {
-        stack.pop();
-        stack.push("INSIDE_OBJECT_AFTER_COMMA");
-        break;
-      }
-      case "}": {
-        lastValidIndex = i;
-        stack.pop();
-        break;
-      }
-    }
-  }
-  function processAfterArrayValue(char, i) {
-    switch (char) {
-      case ",": {
-        stack.pop();
-        stack.push("INSIDE_ARRAY_AFTER_COMMA");
-        break;
-      }
-      case "]": {
-        lastValidIndex = i;
-        stack.pop();
-        break;
-      }
-    }
-  }
-  for (let i = 0; i < input.length; i++) {
-    const char = input[i];
-    const currentState = stack[stack.length - 1];
-    switch (currentState) {
-      case "ROOT":
-        processValueStart(char, i, "FINISH");
-        break;
-      case "INSIDE_OBJECT_START": {
-        switch (char) {
-          case '"': {
-            stack.pop();
-            stack.push("INSIDE_OBJECT_KEY");
-            break;
-          }
-          case "}": {
-            lastValidIndex = i;
-            stack.pop();
-            break;
-          }
-        }
-        break;
-      }
-      case "INSIDE_OBJECT_AFTER_COMMA": {
-        switch (char) {
-          case '"': {
-            stack.pop();
-            stack.push("INSIDE_OBJECT_KEY");
-            break;
-          }
-        }
-        break;
-      }
-      case "INSIDE_OBJECT_KEY": {
-        switch (char) {
-          case '"': {
-            stack.pop();
-            stack.push("INSIDE_OBJECT_AFTER_KEY");
-            break;
-          }
-        }
-        break;
-      }
-      case "INSIDE_OBJECT_AFTER_KEY": {
-        switch (char) {
-          case ":": {
-            stack.pop();
-            stack.push("INSIDE_OBJECT_BEFORE_VALUE");
-            break;
-          }
-        }
-        break;
-      }
-      case "INSIDE_OBJECT_BEFORE_VALUE": {
-        processValueStart(char, i, "INSIDE_OBJECT_AFTER_VALUE");
-        break;
-      }
-      case "INSIDE_OBJECT_AFTER_VALUE": {
-        processAfterObjectValue(char, i);
-        break;
-      }
-      case "INSIDE_STRING": {
-        switch (char) {
-          case '"': {
-            stack.pop();
-            lastValidIndex = i;
-            break;
-          }
-          case "\\": {
-            stack.push("INSIDE_STRING_ESCAPE");
-            break;
-          }
-          default: {
-            lastValidIndex = i;
-          }
-        }
-        break;
-      }
-      case "INSIDE_ARRAY_START": {
-        switch (char) {
-          case "]": {
-            lastValidIndex = i;
-            stack.pop();
-            break;
-          }
-          default: {
-            lastValidIndex = i;
-            processValueStart(char, i, "INSIDE_ARRAY_AFTER_VALUE");
-            break;
-          }
-        }
-        break;
-      }
-      case "INSIDE_ARRAY_AFTER_VALUE": {
-        switch (char) {
-          case ",": {
-            stack.pop();
-            stack.push("INSIDE_ARRAY_AFTER_COMMA");
-            break;
-          }
-          case "]": {
-            lastValidIndex = i;
-            stack.pop();
-            break;
-          }
-          default: {
-            lastValidIndex = i;
-            break;
-          }
-        }
-        break;
-      }
-      case "INSIDE_ARRAY_AFTER_COMMA": {
-        processValueStart(char, i, "INSIDE_ARRAY_AFTER_VALUE");
-        break;
-      }
-      case "INSIDE_STRING_ESCAPE": {
-        stack.pop();
-        lastValidIndex = i;
-        break;
-      }
-      case "INSIDE_NUMBER": {
-        switch (char) {
-          case "0":
-          case "1":
-          case "2":
-          case "3":
-          case "4":
-          case "5":
-          case "6":
-          case "7":
-          case "8":
-          case "9": {
-            lastValidIndex = i;
-            break;
-          }
-          case "e":
-          case "E":
-          case "-":
-          case ".": {
-            break;
-          }
-          case ",": {
-            stack.pop();
-            if (stack[stack.length - 1] === "INSIDE_ARRAY_AFTER_VALUE") {
-              processAfterArrayValue(char, i);
-            }
-            if (stack[stack.length - 1] === "INSIDE_OBJECT_AFTER_VALUE") {
-              processAfterObjectValue(char, i);
-            }
-            break;
-          }
-          case "}": {
-            stack.pop();
-            if (stack[stack.length - 1] === "INSIDE_OBJECT_AFTER_VALUE") {
-              processAfterObjectValue(char, i);
-            }
-            break;
-          }
-          case "]": {
-            stack.pop();
-            if (stack[stack.length - 1] === "INSIDE_ARRAY_AFTER_VALUE") {
-              processAfterArrayValue(char, i);
-            }
-            break;
-          }
-          default: {
-            stack.pop();
-            break;
-          }
-        }
-        break;
-      }
-      case "INSIDE_LITERAL": {
-        const partialLiteral = input.substring(literalStart, i + 1);
-        if (!"false".startsWith(partialLiteral) && !"true".startsWith(partialLiteral) && !"null".startsWith(partialLiteral)) {
-          stack.pop();
-          if (stack[stack.length - 1] === "INSIDE_OBJECT_AFTER_VALUE") {
-            processAfterObjectValue(char, i);
-          } else if (stack[stack.length - 1] === "INSIDE_ARRAY_AFTER_VALUE") {
-            processAfterArrayValue(char, i);
-          }
-        } else {
-          lastValidIndex = i;
-        }
-        break;
-      }
-    }
-  }
-  let result = input.slice(0, lastValidIndex + 1);
-  for (let i = stack.length - 1; i >= 0; i--) {
-    const state = stack[i];
-    switch (state) {
-      case "INSIDE_STRING": {
-        result += '"';
-        break;
-      }
-      case "INSIDE_OBJECT_KEY":
-      case "INSIDE_OBJECT_AFTER_KEY":
-      case "INSIDE_OBJECT_AFTER_COMMA":
-      case "INSIDE_OBJECT_START":
-      case "INSIDE_OBJECT_BEFORE_VALUE":
-      case "INSIDE_OBJECT_AFTER_VALUE": {
-        result += "}";
-        break;
-      }
-      case "INSIDE_ARRAY_START":
-      case "INSIDE_ARRAY_AFTER_COMMA":
-      case "INSIDE_ARRAY_AFTER_VALUE": {
-        result += "]";
-        break;
-      }
-      case "INSIDE_LITERAL": {
-        const partialLiteral = input.substring(literalStart, input.length);
-        if ("true".startsWith(partialLiteral)) {
-          result += "true".slice(partialLiteral.length);
-        } else if ("false".startsWith(partialLiteral)) {
-          result += "false".slice(partialLiteral.length);
-        } else if ("null".startsWith(partialLiteral)) {
-          result += "null".slice(partialLiteral.length);
-        }
-      }
-    }
-  }
-  return result;
-}
-
-// src/util/parse-partial-json.ts
-async function parsePartialJson(jsonText) {
-  if (jsonText === void 0) {
-    return { value: void 0, state: "undefined-input" };
-  }
-  let result = await (0, import_provider_utils.safeParseJSON)({ text: jsonText });
-  if (result.success) {
-    return { value: result.value, state: "successful-parse" };
-  }
-  result = await (0, import_provider_utils.safeParseJSON)({ text: fixJson(jsonText) });
-  if (result.success) {
-    return { value: result.value, state: "repaired-parse" };
-  }
-  return { value: void 0, state: "failed-parse" };
-}
-
-// src/ui/ui-messages.ts
-function isToolUIPart(part) {
-  return part.type.startsWith("tool-");
-}
-function getToolName(part) {
-  return part.type.split("-").slice(1).join("-");
-}
-
-// src/ui/process-ui-message-stream.ts
-function createStreamingUIMessageState({
-  lastMessage,
-  messageId
-}) {
-  return {
-    message: (lastMessage == null ? void 0 : lastMessage.role) === "assistant" ? lastMessage : {
-      id: messageId,
-      metadata: void 0,
-      role: "assistant",
-      parts: []
-    },
-    activeTextParts: {},
-    activeReasoningParts: {},
-    partialToolCalls: {}
-  };
-}
-function processUIMessageStream({
-  stream,
-  onToolCall,
-  messageMetadataSchema,
-  dataPartSchemas,
-  runUpdateMessageJob,
-  onError,
-  onData
-}) {
-  return stream.pipeThrough(
-    new TransformStream({
-      async transform(chunk, controller) {
-        await runUpdateMessageJob(async ({ state, write }) => {
-          var _a9, _b, _c, _d;
-          function updateToolInvocationPart(options) {
-            var _a10;
-            const part = state.message.parts.find(
-              (part2) => isToolUIPart(part2) && part2.toolCallId === options.toolCallId
-            );
-            const anyOptions = options;
-            const anyPart = part;
-            if (part != null) {
-              part.state = options.state;
-              anyPart.input = anyOptions.input;
-              anyPart.output = anyOptions.output;
-              anyPart.errorText = anyOptions.errorText;
-              anyPart.providerExecuted = (_a10 = anyOptions.providerExecuted) != null ? _a10 : part.providerExecuted;
-              if (anyOptions.providerMetadata != null && part.state === "input-available") {
-                part.callProviderMetadata = anyOptions.providerMetadata;
-              }
-            } else {
-              state.message.parts.push({
-                type: `tool-${options.toolName}`,
-                toolCallId: options.toolCallId,
-                state: options.state,
-                input: anyOptions.input,
-                output: anyOptions.output,
-                errorText: anyOptions.errorText,
-                providerExecuted: anyOptions.providerExecuted,
-                ...anyOptions.providerMetadata != null ? { callProviderMetadata: anyOptions.providerMetadata } : {}
-              });
-            }
-          }
-          async function updateMessageMetadata(metadata) {
-            if (metadata != null) {
-              const mergedMetadata = state.message.metadata != null ? mergeObjects(state.message.metadata, metadata) : metadata;
-              if (messageMetadataSchema != null) {
-                await (0, import_provider_utils2.validateTypes)({
-                  value: mergedMetadata,
-                  schema: messageMetadataSchema
-                });
-              }
-              state.message.metadata = mergedMetadata;
-            }
-          }
-          switch (chunk.type) {
-            case "text-start": {
-              const textPart = {
-                type: "text",
-                text: "",
-                providerMetadata: chunk.providerMetadata,
-                state: "streaming"
-              };
-              state.activeTextParts[chunk.id] = textPart;
-              state.message.parts.push(textPart);
-              write();
-              break;
-            }
-            case "text-delta": {
-              const textPart = state.activeTextParts[chunk.id];
-              textPart.text += chunk.delta;
-              textPart.providerMetadata = (_a9 = chunk.providerMetadata) != null ? _a9 : textPart.providerMetadata;
-              write();
-              break;
-            }
-            case "text-end": {
-              const textPart = state.activeTextParts[chunk.id];
-              textPart.state = "done";
-              textPart.providerMetadata = (_b = chunk.providerMetadata) != null ? _b : textPart.providerMetadata;
-              delete state.activeTextParts[chunk.id];
-              write();
-              break;
-            }
-            case "reasoning-start": {
-              const reasoningPart = {
-                type: "reasoning",
-                text: "",
-                providerMetadata: chunk.providerMetadata,
-                state: "streaming"
-              };
-              state.activeReasoningParts[chunk.id] = reasoningPart;
-              state.message.parts.push(reasoningPart);
-              write();
-              break;
-            }
-            case "reasoning-delta": {
-              const reasoningPart = state.activeReasoningParts[chunk.id];
-              reasoningPart.text += chunk.delta;
-              reasoningPart.providerMetadata = (_c = chunk.providerMetadata) != null ? _c : reasoningPart.providerMetadata;
-              write();
-              break;
-            }
-            case "reasoning-end": {
-              const reasoningPart = state.activeReasoningParts[chunk.id];
-              reasoningPart.providerMetadata = (_d = chunk.providerMetadata) != null ? _d : reasoningPart.providerMetadata;
-              reasoningPart.state = "done";
-              delete state.activeReasoningParts[chunk.id];
-              write();
-              break;
-            }
-            case "file": {
-              state.message.parts.push({
-                type: "file",
-                mediaType: chunk.mediaType,
-                url: chunk.url
-              });
-              write();
-              break;
-            }
-            case "source-url": {
-              state.message.parts.push({
-                type: "source-url",
-                sourceId: chunk.sourceId,
-                url: chunk.url,
-                title: chunk.title,
-                providerMetadata: chunk.providerMetadata
-              });
-              write();
-              break;
-            }
-            case "source-document": {
-              state.message.parts.push({
-                type: "source-document",
-                sourceId: chunk.sourceId,
-                mediaType: chunk.mediaType,
-                title: chunk.title,
-                filename: chunk.filename,
-                providerMetadata: chunk.providerMetadata
-              });
-              write();
-              break;
-            }
-            case "tool-input-start": {
-              const toolInvocations = state.message.parts.filter(isToolUIPart);
-              state.partialToolCalls[chunk.toolCallId] = {
-                text: "",
-                toolName: chunk.toolName,
-                index: toolInvocations.length
-              };
-              updateToolInvocationPart({
-                toolCallId: chunk.toolCallId,
-                toolName: chunk.toolName,
-                state: "input-streaming",
-                input: void 0,
-                providerExecuted: chunk.providerExecuted
-              });
-              write();
-              break;
-            }
-            case "tool-input-delta": {
-              const partialToolCall = state.partialToolCalls[chunk.toolCallId];
-              partialToolCall.text += chunk.inputTextDelta;
-              const { value: partialArgs } = await parsePartialJson(
-                partialToolCall.text
-              );
-              updateToolInvocationPart({
-                toolCallId: chunk.toolCallId,
-                toolName: partialToolCall.toolName,
-                state: "input-streaming",
-                input: partialArgs
-              });
-              write();
-              break;
-            }
-            case "tool-input-available": {
-              updateToolInvocationPart({
-                toolCallId: chunk.toolCallId,
-                toolName: chunk.toolName,
-                state: "input-available",
-                input: chunk.input,
-                providerExecuted: chunk.providerExecuted,
-                providerMetadata: chunk.providerMetadata
-              });
-              write();
-              if (onToolCall && !chunk.providerExecuted) {
-                const result = await onToolCall({
-                  toolCall: chunk
-                });
-                if (result != null) {
-                  updateToolInvocationPart({
-                    toolCallId: chunk.toolCallId,
-                    toolName: chunk.toolName,
-                    state: "output-available",
-                    input: chunk.input,
-                    output: result
-                  });
-                  write();
-                }
-              }
-              break;
-            }
-            case "tool-output-available": {
-              const toolInvocations = state.message.parts.filter(isToolUIPart);
-              if (toolInvocations == null) {
-                throw new Error("tool_result must be preceded by a tool_call");
-              }
-              const toolInvocationIndex = toolInvocations.findIndex(
-                (invocation) => invocation.toolCallId === chunk.toolCallId
-              );
-              if (toolInvocationIndex === -1) {
-                throw new Error(
-                  "tool_result must be preceded by a tool_call with the same toolCallId"
-                );
-              }
-              const toolName = getToolName(
-                toolInvocations[toolInvocationIndex]
-              );
-              updateToolInvocationPart({
-                toolCallId: chunk.toolCallId,
-                toolName,
-                state: "output-available",
-                input: toolInvocations[toolInvocationIndex].input,
-                output: chunk.output,
-                providerExecuted: chunk.providerExecuted
-              });
-              write();
-              break;
-            }
-            case "tool-output-error": {
-              const toolInvocations = state.message.parts.filter(isToolUIPart);
-              if (toolInvocations == null) {
-                throw new Error("tool_result must be preceded by a tool_call");
-              }
-              const toolInvocationIndex = toolInvocations.findIndex(
-                (invocation) => invocation.toolCallId === chunk.toolCallId
-              );
-              if (toolInvocationIndex === -1) {
-                throw new Error(
-                  "tool_result must be preceded by a tool_call with the same toolCallId"
-                );
-              }
-              const toolName = getToolName(
-                toolInvocations[toolInvocationIndex]
-              );
-              updateToolInvocationPart({
-                toolCallId: chunk.toolCallId,
-                toolName,
-                state: "output-error",
-                input: toolInvocations[toolInvocationIndex].input,
-                errorText: chunk.errorText,
-                providerExecuted: chunk.providerExecuted
-              });
-              write();
-              break;
-            }
-            case "start-step": {
-              state.message.parts.push({ type: "step-start" });
-              break;
-            }
-            case "finish-step": {
-              state.activeTextParts = {};
-              state.activeReasoningParts = {};
-              break;
-            }
-            case "start": {
-              if (chunk.messageId != null) {
-                state.message.id = chunk.messageId;
-              }
-              await updateMessageMetadata(chunk.messageMetadata);
-              if (chunk.messageId != null || chunk.messageMetadata != null) {
-                write();
-              }
-              break;
-            }
-            case "finish": {
-              await updateMessageMetadata(chunk.messageMetadata);
-              if (chunk.messageMetadata != null) {
-                write();
-              }
-              break;
-            }
-            case "message-metadata": {
-              await updateMessageMetadata(chunk.messageMetadata);
-              if (chunk.messageMetadata != null) {
-                write();
-              }
-              break;
-            }
-            case "error": {
-              onError == null ? void 0 : onError(new Error(chunk.errorText));
-              break;
-            }
-            default: {
-              if (isDataUIMessageChunk(chunk)) {
-                if ((dataPartSchemas == null ? void 0 : dataPartSchemas[chunk.type]) != null) {
-                  await (0, import_provider_utils2.validateTypes)({
-                    value: chunk.data,
-                    schema: dataPartSchemas[chunk.type]
-                  });
-                }
-                const dataChunk = chunk;
-                if (dataChunk.transient) {
-                  onData == null ? void 0 : onData(dataChunk);
-                  break;
-                }
-                const existingUIPart = dataChunk.id != null ? state.message.parts.find(
-                  (chunkArg) => dataChunk.type === chunkArg.type && dataChunk.id === chunkArg.id
-                ) : void 0;
-                if (existingUIPart != null) {
-                  existingUIPart.data = dataChunk.data;
-                } else {
-                  state.message.parts.push(dataChunk);
-                }
-                onData == null ? void 0 : onData(dataChunk);
-                write();
-              }
-            }
-          }
-          controller.enqueue(chunk);
-        });
-      }
-    })
-  );
-}
-
-// src/ui-message-stream/handle-ui-message-stream-finish.ts
-function handleUIMessageStreamFinish({
-  messageId,
-  originalMessages = [],
-  onFinish,
-  onError,
-  stream
-}) {
-  let lastMessage = originalMessages == null ? void 0 : originalMessages[originalMessages.length - 1];
-  if ((lastMessage == null ? void 0 : lastMessage.role) !== "assistant") {
-    lastMessage = void 0;
-  } else {
-    messageId = lastMessage.id;
-  }
-  let isAborted = false;
-  const idInjectedStream = stream.pipeThrough(
-    new TransformStream({
-      transform(chunk, controller) {
-        if (chunk.type === "start") {
-          const startChunk = chunk;
-          if (startChunk.messageId == null && messageId != null) {
-            startChunk.messageId = messageId;
-          }
-        }
-        if (chunk.type === "abort") {
-          isAborted = true;
-        }
-        controller.enqueue(chunk);
-      }
-    })
-  );
-  if (onFinish == null) {
-    return idInjectedStream;
-  }
-  const state = createStreamingUIMessageState({
-    lastMessage: lastMessage ? structuredClone(lastMessage) : void 0,
-    messageId: messageId != null ? messageId : ""
-    // will be overridden by the stream
-  });
-  const runUpdateMessageJob = async (job) => {
-    await job({ state, write: () => {
-    } });
-  };
-  return processUIMessageStream({
-    stream: idInjectedStream,
-    runUpdateMessageJob,
-    onError
-  }).pipeThrough(
-    new TransformStream({
-      transform(chunk, controller) {
-        controller.enqueue(chunk);
-      },
-      async flush() {
-        const isContinuation = state.message.id === (lastMessage == null ? void 0 : lastMessage.id);
-        await onFinish({
-          isAborted,
-          isContinuation,
-          responseMessage: state.message,
-          messages: [
-            ...isContinuation ? originalMessages.slice(0, -1) : originalMessages,
-            state.message
-          ]
-        });
-      }
-    })
-  );
-}
-
-// src/ui-message-stream/pipe-ui-message-stream-to-response.ts
-function pipeUIMessageStreamToResponse({
-  response,
-  status,
-  statusText,
-  headers,
-  stream,
-  consumeSseStream
-}) {
-  let sseStream = stream.pipeThrough(new JsonToSseTransformStream());
-  if (consumeSseStream) {
-    const [stream1, stream2] = sseStream.tee();
-    sseStream = stream1;
-    consumeSseStream({ stream: stream2 });
-  }
-  writeToServerResponse({
-    response,
-    status,
-    statusText,
-    headers: Object.fromEntries(
-      prepareHeaders(headers, UI_MESSAGE_STREAM_HEADERS).entries()
-    ),
-    stream: sseStream.pipeThrough(new TextEncoderStream())
-  });
-}
-
-// src/util/as-array.ts
-function asArray(value) {
-  return value === void 0 ? [] : Array.isArray(value) ? value : [value];
-}
-
-// src/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;
-}
-
-// src/util/consume-stream.ts
-async function consumeStream({
-  stream,
-  onError
-}) {
-  const reader = stream.getReader();
-  try {
-    while (true) {
-      const { done } = await reader.read();
-      if (done)
-        break;
-    }
-  } catch (error) {
-    onError == null ? void 0 : onError(error);
-  } finally {
-    reader.releaseLock();
-  }
-}
-
-// src/util/create-resolvable-promise.ts
-function createResolvablePromise() {
-  let resolve2;
-  let reject;
-  const promise = new Promise((res, rej) => {
-    resolve2 = res;
-    reject = rej;
-  });
-  return {
-    promise,
-    resolve: resolve2,
-    reject
-  };
-}
-
-// src/util/create-stitchable-stream.ts
-function createStitchableStream() {
-  let innerStreamReaders = [];
-  let controller = null;
-  let isClosed = false;
-  let waitForNewStream = createResolvablePromise();
-  const terminate = () => {
-    isClosed = true;
-    waitForNewStream.resolve();
-    innerStreamReaders.forEach((reader) => reader.cancel());
-    innerStreamReaders = [];
-    controller == null ? void 0 : controller.close();
-  };
-  const processPull = async () => {
-    if (isClosed && innerStreamReaders.length === 0) {
-      controller == null ? void 0 : controller.close();
-      return;
-    }
-    if (innerStreamReaders.length === 0) {
-      waitForNewStream = createResolvablePromise();
-      await waitForNewStream.promise;
-      return processPull();
-    }
-    try {
-      const { value, done } = await innerStreamReaders[0].read();
-      if (done) {
-        innerStreamReaders.shift();
-        if (innerStreamReaders.length > 0) {
-          await processPull();
-        } else if (isClosed) {
-          controller == null ? void 0 : controller.close();
-        }
-      } else {
-        controller == null ? void 0 : controller.enqueue(value);
-      }
-    } catch (error) {
-      controller == null ? void 0 : controller.error(error);
-      innerStreamReaders.shift();
-      terminate();
-    }
-  };
-  return {
-    stream: new ReadableStream({
-      start(controllerParam) {
-        controller = controllerParam;
-      },
-      pull: processPull,
-      async cancel() {
-        for (const reader of innerStreamReaders) {
-          await reader.cancel();
-        }
-        innerStreamReaders = [];
-        isClosed = true;
-      }
-    }),
-    addStream: (innerStream) => {
-      if (isClosed) {
-        throw new Error("Cannot add inner stream: outer stream is closed");
-      }
-      innerStreamReaders.push(innerStream.getReader());
-      waitForNewStream.resolve();
-    },
-    /**
-     * Gracefully close the outer stream. This will let the inner streams
-     * finish processing and then close the outer stream.
-     */
-    close: () => {
-      isClosed = true;
-      waitForNewStream.resolve();
-      if (innerStreamReaders.length === 0) {
-        controller == null ? void 0 : controller.close();
-      }
-    },
-    /**
-     * Immediately close the outer stream. This will cancel all inner streams
-     * and close the outer stream.
-     */
-    terminate
-  };
-}
-
-// src/util/delayed-promise.ts
-var DelayedPromise = class {
-  constructor() {
-    this.status = { type: "pending" };
-    this._resolve = void 0;
-    this._reject = void 0;
-  }
-  get promise() {
-    if (this._promise) {
-      return this._promise;
-    }
-    this._promise = new Promise((resolve2, reject) => {
-      if (this.status.type === "resolved") {
-        resolve2(this.status.value);
-      } else if (this.status.type === "rejected") {
-        reject(this.status.error);
-      }
-      this._resolve = resolve2;
-      this._reject = reject;
-    });
-    return this._promise;
-  }
-  resolve(value) {
-    var _a9;
-    this.status = { type: "resolved", value };
-    if (this._promise) {
-      (_a9 = this._resolve) == null ? void 0 : _a9.call(this, value);
-    }
-  }
-  reject(error) {
-    var _a9;
-    this.status = { type: "rejected", error };
-    if (this._promise) {
-      (_a9 = this._reject) == null ? void 0 : _a9.call(this, error);
-    }
-  }
-};
-
-// src/util/now.ts
-function now() {
-  var _a9, _b;
-  return (_b = (_a9 = globalThis == null ? void 0 : globalThis.performance) == null ? void 0 : _a9.now()) != null ? _b : Date.now();
-}
-
-// src/error/invalid-argument-error.ts
-var import_provider2 = require("@ai-sdk/provider");
-var name2 = "AI_InvalidArgumentError";
-var marker2 = `vercel.ai.error.${name2}`;
-var symbol2 = Symbol.for(marker2);
-var _a2;
-var InvalidArgumentError = class extends import_provider2.AISDKError {
-  constructor({
-    parameter,
-    value,
-    message
-  }) {
-    super({
-      name: name2,
-      message: `Invalid argument for parameter ${parameter}: ${message}`
-    });
-    this[_a2] = true;
-    this.parameter = parameter;
-    this.value = value;
-  }
-  static isInstance(error) {
-    return import_provider2.AISDKError.hasMarker(error, marker2);
-  }
-};
-_a2 = symbol2;
-
-// src/util/retry-with-exponential-backoff.ts
-var import_provider4 = require("@ai-sdk/provider");
-var import_provider_utils3 = require("@ai-sdk/provider-utils");
-
-// src/util/retry-error.ts
-var import_provider3 = require("@ai-sdk/provider");
-var name3 = "AI_RetryError";
-var marker3 = `vercel.ai.error.${name3}`;
-var symbol3 = Symbol.for(marker3);
-var _a3;
-var RetryError = class extends import_provider3.AISDKError {
-  constructor({
-    message,
-    reason,
-    errors
-  }) {
-    super({ name: name3, message });
-    this[_a3] = true;
-    this.reason = reason;
-    this.errors = errors;
-    this.lastError = errors[errors.length - 1];
-  }
-  static isInstance(error) {
-    return import_provider3.AISDKError.hasMarker(error, marker3);
-  }
-};
-_a3 = symbol3;
-
-// src/util/retry-with-exponential-backoff.ts
-function getRetryDelay(error, exponentialBackoffDelay) {
-  const headers = error.responseHeaders;
-  if (!headers)
-    return exponentialBackoffDelay;
-  let timeoutMillis;
-  const retryAfterMs = headers["retry-after-ms"];
-  if (retryAfterMs) {
-    const timeoutMs = parseFloat(retryAfterMs);
-    if (!Number.isNaN(timeoutMs)) {
-      timeoutMillis = timeoutMs;
-    }
-  }
-  const retryAfter = headers["retry-after"];
-  if (retryAfter && timeoutMillis === void 0) {
-    const timeoutSeconds = parseFloat(retryAfter);
-    if (!Number.isNaN(timeoutSeconds)) {
-      timeoutMillis = timeoutSeconds * 1e3;
-    } else {
-      timeoutMillis = Date.parse(retryAfter) - Date.now();
-    }
-  }
-  if (timeoutMillis !== void 0 && 0 <= timeoutMillis && timeoutMillis < 60 * 1e3) {
-    return timeoutMillis;
-  }
-  return exponentialBackoffDelay;
-}
-var retryWithExponentialBackoffRespectingRetryHeaders = ({
-  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 ((0, import_provider_utils3.isAbortError)(error)) {
-      throw error;
-    }
-    if (maxRetries === 0) {
-      throw error;
-    }
-    const errorMessage = (0, import_provider_utils3.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 && import_provider4.APICallError.isInstance(error) && error.isRetryable === true && tryNumber <= maxRetries) {
-      const actualDelay = getRetryDelay(error, delayInMs);
-      await (0, import_provider_utils3.delay)(actualDelay);
-      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
-    });
-  }
-}
-
-// src/util/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: retryWithExponentialBackoffRespectingRetryHeaders({
-      maxRetries: maxRetriesResult
-    })
-  };
-}
-
-// src/prompt/convert-to-language-model-prompt.ts
-var import_provider_utils6 = require("@ai-sdk/provider-utils");
-
-// src/util/detect-media-type.ts
-var import_provider_utils4 = require("@ai-sdk/provider-utils");
-var imageMediaTypeSignatures = [
-  {
-    mediaType: "image/gif",
-    bytesPrefix: [71, 73, 70],
-    base64Prefix: "R0lG"
-  },
-  {
-    mediaType: "image/png",
-    bytesPrefix: [137, 80, 78, 71],
-    base64Prefix: "iVBORw"
-  },
-  {
-    mediaType: "image/jpeg",
-    bytesPrefix: [255, 216],
-    base64Prefix: "/9j/"
-  },
-  {
-    mediaType: "image/webp",
-    bytesPrefix: [82, 73, 70, 70],
-    base64Prefix: "UklGRg"
-  },
-  {
-    mediaType: "image/bmp",
-    bytesPrefix: [66, 77],
-    base64Prefix: "Qk"
-  },
-  {
-    mediaType: "image/tiff",
-    bytesPrefix: [73, 73, 42, 0],
-    base64Prefix: "SUkqAA"
-  },
-  {
-    mediaType: "image/tiff",
-    bytesPrefix: [77, 77, 0, 42],
-    base64Prefix: "TU0AKg"
-  },
-  {
-    mediaType: "image/avif",
-    bytesPrefix: [
-      0,
-      0,
-      0,
-      32,
-      102,
-      116,
-      121,
-      112,
-      97,
-      118,
-      105,
-      102
-    ],
-    base64Prefix: "AAAAIGZ0eXBhdmlm"
-  },
-  {
-    mediaType: "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" ? (0, import_provider_utils4.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 detectMediaType({
-  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.mediaType;
-    }
-  }
-  return void 0;
-}
-
-// src/util/download-error.ts
-var import_provider5 = require("@ai-sdk/provider");
-var name4 = "AI_DownloadError";
-var marker4 = `vercel.ai.error.${name4}`;
-var symbol4 = Symbol.for(marker4);
-var _a4;
-var DownloadError = class extends import_provider5.AISDKError {
-  constructor({
-    url,
-    statusCode,
-    statusText,
-    cause,
-    message = cause == null ? `Failed to download ${url}: ${statusCode} ${statusText}` : `Failed to download ${url}: ${cause}`
-  }) {
-    super({ name: name4, message, cause });
-    this[_a4] = true;
-    this.url = url;
-    this.statusCode = statusCode;
-    this.statusText = statusText;
-  }
-  static isInstance(error) {
-    return import_provider5.AISDKError.hasMarker(error, marker4);
-  }
-};
-_a4 = symbol4;
-
-// src/util/download.ts
-async function download({ url }) {
-  var _a9;
-  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()),
-      mediaType: (_a9 = response.headers.get("content-type")) != null ? _a9 : void 0
-    };
-  } catch (error) {
-    if (DownloadError.isInstance(error)) {
-      throw error;
-    }
-    throw new DownloadError({ url: urlText, cause: error });
-  }
-}
-
-// src/prompt/data-content.ts
-var import_provider6 = require("@ai-sdk/provider");
-var import_provider_utils5 = require("@ai-sdk/provider-utils");
-var import_v44 = require("zod/v4");
-
-// src/prompt/split-data-url.ts
-function splitDataUrl(dataUrl) {
-  try {
-    const [header, base64Content] = dataUrl.split(",");
-    return {
-      mediaType: header.split(";")[0].split(":")[1],
-      base64Content
-    };
-  } catch (error) {
-    return {
-      mediaType: void 0,
-      base64Content: void 0
-    };
-  }
-}
-
-// src/prompt/data-content.ts
-var dataContentSchema = import_v44.z.union([
-  import_v44.z.string(),
-  import_v44.z.instanceof(Uint8Array),
-  import_v44.z.instanceof(ArrayBuffer),
-  import_v44.z.custom(
-    // Buffer might not be available in some environments such as CloudFlare:
-    (value) => {
-      var _a9, _b;
-      return (_b = (_a9 = globalThis.Buffer) == null ? void 0 : _a9.isBuffer(value)) != null ? _b : false;
-    },
-    { message: "Must be a Buffer" }
-  )
-]);
-function convertToLanguageModelV2DataContent(content) {
-  if (content instanceof Uint8Array) {
-    return { data: content, mediaType: void 0 };
-  }
-  if (content instanceof ArrayBuffer) {
-    return { data: new Uint8Array(content), mediaType: void 0 };
-  }
-  if (typeof content === "string") {
-    try {
-      content = new URL(content);
-    } catch (error) {
-    }
-  }
-  if (content instanceof URL && content.protocol === "data:") {
-    const { mediaType: dataUrlMediaType, base64Content } = splitDataUrl(
-      content.toString()
-    );
-    if (dataUrlMediaType == null || base64Content == null) {
-      throw new import_provider6.AISDKError({
-        name: "InvalidDataContentError",
-        message: `Invalid data URL format in content ${content.toString()}`
-      });
-    }
-    return { data: base64Content, mediaType: dataUrlMediaType };
-  }
-  return { data: content, mediaType: void 0 };
-}
-function convertDataContentToBase64String(content) {
-  if (typeof content === "string") {
-    return content;
-  }
-  if (content instanceof ArrayBuffer) {
-    return (0, import_provider_utils5.convertUint8ArrayToBase64)(new Uint8Array(content));
-  }
-  return (0, import_provider_utils5.convertUint8ArrayToBase64)(content);
-}
-
-// src/prompt/invalid-message-role-error.ts
-var import_provider7 = require("@ai-sdk/provider");
-var name5 = "AI_InvalidMessageRoleError";
-var marker5 = `vercel.ai.error.${name5}`;
-var symbol5 = Symbol.for(marker5);
-var _a5;
-var InvalidMessageRoleError = class extends import_provider7.AISDKError {
-  constructor({
-    role,
-    message = `Invalid message role: '${role}'. Must be one of: "system", "user", "assistant", "tool".`
-  }) {
-    super({ name: name5, message });
-    this[_a5] = true;
-    this.role = role;
-  }
-  static isInstance(error) {
-    return import_provider7.AISDKError.hasMarker(error, marker5);
-  }
-};
-_a5 = symbol5;
-
-// src/prompt/convert-to-language-model-prompt.ts
-async function convertToLanguageModelPrompt({
-  prompt,
-  supportedUrls,
-  downloadImplementation = download
-}) {
-  const downloadedAssets = await downloadAssets(
-    prompt.messages,
-    downloadImplementation,
-    supportedUrls
-  );
-  return [
-    ...prompt.system != null ? [{ role: "system", content: prompt.system }] : [],
-    ...prompt.messages.map(
-      (message) => convertToLanguageModelMessage({ message, downloadedAssets })
-    )
-  ];
-}
-function convertToLanguageModelMessage({
-  message,
-  downloadedAssets
-}) {
-  const role = message.role;
-  switch (role) {
-    case "system": {
-      return {
-        role: "system",
-        content: message.content,
-        providerOptions: message.providerOptions
-      };
-    }
-    case "user": {
-      if (typeof message.content === "string") {
-        return {
-          role: "user",
-          content: [{ type: "text", text: message.content }],
-          providerOptions: message.providerOptions
-        };
-      }
-      return {
-        role: "user",
-        content: message.content.map((part) => convertPartToLanguageModelPart(part, downloadedAssets)).filter((part) => part.type !== "text" || part.text !== ""),
-        providerOptions: message.providerOptions
-      };
-    }
-    case "assistant": {
-      if (typeof message.content === "string") {
-        return {
-          role: "assistant",
-          content: [{ type: "text", text: message.content }],
-          providerOptions: message.providerOptions
-        };
-      }
-      return {
-        role: "assistant",
-        content: message.content.filter(
-          // remove empty text parts:
-          (part) => part.type !== "text" || part.text !== ""
-        ).map((part) => {
-          const providerOptions = part.providerOptions;
-          switch (part.type) {
-            case "file": {
-              const { data, mediaType } = convertToLanguageModelV2DataContent(
-                part.data
-              );
-              return {
-                type: "file",
-                data,
-                filename: part.filename,
-                mediaType: mediaType != null ? mediaType : part.mediaType,
-                providerOptions
-              };
-            }
-            case "reasoning": {
-              return {
-                type: "reasoning",
-                text: part.text,
-                providerOptions
-              };
-            }
-            case "text": {
-              return {
-                type: "text",
-                text: part.text,
-                providerOptions
-              };
-            }
-            case "tool-call": {
-              return {
-                type: "tool-call",
-                toolCallId: part.toolCallId,
-                toolName: part.toolName,
-                input: part.input,
-                providerExecuted: part.providerExecuted,
-                providerOptions
-              };
-            }
-            case "tool-result": {
-              return {
-                type: "tool-result",
-                toolCallId: part.toolCallId,
-                toolName: part.toolName,
-                output: part.output,
-                providerOptions
-              };
-            }
-          }
-        }),
-        providerOptions: message.providerOptions
-      };
-    }
-    case "tool": {
-      return {
-        role: "tool",
-        content: message.content.map((part) => ({
-          type: "tool-result",
-          toolCallId: part.toolCallId,
-          toolName: part.toolName,
-          output: part.output,
-          providerOptions: part.providerOptions
-        })),
-        providerOptions: message.providerOptions
-      };
-    }
-    default: {
-      const _exhaustiveCheck = role;
-      throw new InvalidMessageRoleError({ role: _exhaustiveCheck });
-    }
-  }
-}
-async function downloadAssets(messages, downloadImplementation, supportedUrls) {
-  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"
-  ).map((part) => {
-    var _a9;
-    const mediaType = (_a9 = part.mediaType) != null ? _a9 : part.type === "image" ? "image/*" : void 0;
-    let data = part.type === "image" ? part.image : part.data;
-    if (typeof data === "string") {
-      try {
-        data = new URL(data);
-      } catch (ignored) {
-      }
-    }
-    return { mediaType, data };
-  }).filter(
-    (part) => part.data instanceof URL && part.mediaType != null && !(0, import_provider_utils6.isUrlSupported)({
-      url: part.data.toString(),
-      mediaType: part.mediaType,
-      supportedUrls
-    })
-  ).map((part) => part.data);
-  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 _a9;
-  if (part.type === "text") {
-    return {
-      type: "text",
-      text: part.text,
-      providerOptions: part.providerOptions
-    };
-  }
-  let originalData;
-  const type = part.type;
-  switch (type) {
-    case "image":
-      originalData = part.image;
-      break;
-    case "file":
-      originalData = part.data;
-      break;
-    default:
-      throw new Error(`Unsupported part type: ${type}`);
-  }
-  const { data: convertedData, mediaType: convertedMediaType } = convertToLanguageModelV2DataContent(originalData);
-  let mediaType = convertedMediaType != null ? convertedMediaType : part.mediaType;
-  let data = convertedData;
-  if (data instanceof URL) {
-    const downloadedFile = downloadedAssets[data.toString()];
-    if (downloadedFile) {
-      data = downloadedFile.data;
-      mediaType != null ? mediaType : mediaType = downloadedFile.mediaType;
-    }
-  }
-  switch (type) {
-    case "image": {
-      if (data instanceof Uint8Array || typeof data === "string") {
-        mediaType = (_a9 = detectMediaType({ data, signatures: imageMediaTypeSignatures })) != null ? _a9 : mediaType;
-      }
-      return {
-        type: "file",
-        mediaType: mediaType != null ? mediaType : "image/*",
-        // any image
-        filename: void 0,
-        data,
-        providerOptions: part.providerOptions
-      };
-    }
-    case "file": {
-      if (mediaType == null) {
-        throw new Error(`Media type is missing for file part`);
-      }
-      return {
-        type: "file",
-        mediaType,
-        filename: part.filename,
-        data,
-        providerOptions: part.providerOptions
-      };
-    }
-  }
-}
-
-// src/prompt/prepare-call-settings.ts
-function prepareCallSettings({
-  maxOutputTokens,
-  temperature,
-  topP,
-  topK,
-  presencePenalty,
-  frequencyPenalty,
-  seed,
-  stopSequences
-}) {
-  if (maxOutputTokens != null) {
-    if (!Number.isInteger(maxOutputTokens)) {
-      throw new InvalidArgumentError({
-        parameter: "maxOutputTokens",
-        value: maxOutputTokens,
-        message: "maxOutputTokens must be an integer"
-      });
-    }
-    if (maxOutputTokens < 1) {
-      throw new InvalidArgumentError({
-        parameter: "maxOutputTokens",
-        value: maxOutputTokens,
-        message: "maxOutputTokens 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 {
-    maxOutputTokens,
-    temperature,
-    topP,
-    topK,
-    presencePenalty,
-    frequencyPenalty,
-    stopSequences,
-    seed
-  };
-}
-
-// src/prompt/prepare-tools-and-tool-choice.ts
-var import_provider_utils7 = require("@ai-sdk/provider-utils");
-
-// src/util/is-non-empty-object.ts
-function isNonEmptyObject(object) {
-  return object != null && Object.keys(object).length > 0;
-}
-
-// src/prompt/prepare-tools-and-tool-choice.ts
-function prepareToolsAndToolChoice({
-  tools,
-  toolChoice,
-  activeTools
-}) {
-  if (!isNonEmptyObject(tools)) {
-    return {
-      tools: void 0,
-      toolChoice: void 0
-    };
-  }
-  const filteredTools = activeTools != null ? Object.entries(tools).filter(
-    ([name9]) => activeTools.includes(name9)
-  ) : Object.entries(tools);
-  return {
-    tools: filteredTools.map(([name9, tool]) => {
-      const toolType = tool.type;
-      switch (toolType) {
-        case void 0:
-        case "function":
-          return {
-            type: "function",
-            name: name9,
-            description: tool.description,
-            inputSchema: (0, import_provider_utils7.asSchema)(tool.inputSchema).jsonSchema
-          };
-        case "provider-defined":
-          return {
-            type: "provider-defined",
-            name: name9,
-            id: tool.id,
-            args: tool.args
-          };
-        default: {
-          const exhaustiveCheck = toolType;
-          throw new Error(`Unsupported tool type: ${exhaustiveCheck}`);
-        }
-      }
-    }),
-    toolChoice: toolChoice == null ? { type: "auto" } : typeof toolChoice === "string" ? { type: toolChoice } : { type: "tool", toolName: toolChoice.toolName }
-  };
-}
-
-// src/prompt/resolve-language-model.ts
-var import_gateway = require("@ai-sdk/gateway");
-
-// src/error/index.ts
-var import_provider12 = require("@ai-sdk/provider");
-
-// src/error/invalid-tool-input-error.ts
-var import_provider8 = require("@ai-sdk/provider");
-var name6 = "AI_InvalidToolInputError";
-var marker6 = `vercel.ai.error.${name6}`;
-var symbol6 = Symbol.for(marker6);
-var _a6;
-var InvalidToolInputError = class extends import_provider8.AISDKError {
-  constructor({
-    toolInput,
-    toolName,
-    cause,
-    message = `Invalid input for tool ${toolName}: ${(0, import_provider8.getErrorMessage)(cause)}`
-  }) {
-    super({ name: name6, message, cause });
-    this[_a6] = true;
-    this.toolInput = toolInput;
-    this.toolName = toolName;
-  }
-  static isInstance(error) {
-    return import_provider8.AISDKError.hasMarker(error, marker6);
-  }
-};
-_a6 = symbol6;
-
-// src/error/no-such-tool-error.ts
-var import_provider9 = require("@ai-sdk/provider");
-var name7 = "AI_NoSuchToolError";
-var marker7 = `vercel.ai.error.${name7}`;
-var symbol7 = Symbol.for(marker7);
-var _a7;
-var NoSuchToolError = class extends import_provider9.AISDKError {
-  constructor({
-    toolName,
-    availableTools = void 0,
-    message = `Model tried to call unavailable tool '${toolName}'. ${availableTools === void 0 ? "No tools are available." : `Available tools: ${availableTools.join(", ")}.`}`
-  }) {
-    super({ name: name7, message });
-    this[_a7] = true;
-    this.toolName = toolName;
-    this.availableTools = availableTools;
-  }
-  static isInstance(error) {
-    return import_provider9.AISDKError.hasMarker(error, marker7);
-  }
-};
-_a7 = symbol7;
-
-// src/error/tool-call-repair-error.ts
-var import_provider10 = require("@ai-sdk/provider");
-var name8 = "AI_ToolCallRepairError";
-var marker8 = `vercel.ai.error.${name8}`;
-var symbol8 = Symbol.for(marker8);
-var _a8;
-var ToolCallRepairError = class extends import_provider10.AISDKError {
-  constructor({
-    cause,
-    originalError,
-    message = `Error repairing tool call: ${(0, import_provider10.getErrorMessage)(cause)}`
-  }) {
-    super({ name: name8, message, cause });
-    this[_a8] = true;
-    this.originalError = originalError;
-  }
-  static isInstance(error) {
-    return import_provider10.AISDKError.hasMarker(error, marker8);
-  }
-};
-_a8 = symbol8;
-
-// src/error/unsupported-model-version-error.ts
-var import_provider11 = require("@ai-sdk/provider");
-var UnsupportedModelVersionError = class extends import_provider11.AISDKError {
-  constructor(options) {
-    super({
-      name: "AI_UnsupportedModelVersionError",
-      message: `Unsupported model version ${options.version} for provider "${options.provider}" and model "${options.modelId}". AI SDK 5 only supports models that implement specification version "v2".`
-    });
-    this.version = options.version;
-    this.provider = options.provider;
-    this.modelId = options.modelId;
-  }
-};
-
-// src/prompt/resolve-language-model.ts
-function resolveLanguageModel(model) {
-  if (typeof model !== "string") {
-    if (model.specificationVersion !== "v2") {
-      throw new UnsupportedModelVersionError({
-        version: model.specificationVersion,
-        provider: model.provider,
-        modelId: model.modelId
-      });
-    }
-    return model;
-  }
-  const globalProvider = globalThis.AI_SDK_DEFAULT_PROVIDER;
-  return (globalProvider != null ? globalProvider : import_gateway.gateway).languageModel(model);
-}
-
-// src/prompt/standardize-prompt.ts
-var import_provider13 = require("@ai-sdk/provider");
-var import_provider_utils8 = require("@ai-sdk/provider-utils");
-var import_v47 = require("zod/v4");
-
-// src/prompt/message.ts
-var import_v46 = require("zod/v4");
-
-// src/prompt/content-part.ts
-var import_v45 = require("zod/v4");
-var textPartSchema = import_v45.z.object({
-  type: import_v45.z.literal("text"),
-  text: import_v45.z.string(),
-  providerOptions: providerMetadataSchema.optional()
-});
-var imagePartSchema = import_v45.z.object({
-  type: import_v45.z.literal("image"),
-  image: import_v45.z.union([dataContentSchema, import_v45.z.instanceof(URL)]),
-  mediaType: import_v45.z.string().optional(),
-  providerOptions: providerMetadataSchema.optional()
-});
-var filePartSchema = import_v45.z.object({
-  type: import_v45.z.literal("file"),
-  data: import_v45.z.union([dataContentSchema, import_v45.z.instanceof(URL)]),
-  filename: import_v45.z.string().optional(),
-  mediaType: import_v45.z.string(),
-  providerOptions: providerMetadataSchema.optional()
-});
-var reasoningPartSchema = import_v45.z.object({
-  type: import_v45.z.literal("reasoning"),
-  text: import_v45.z.string(),
-  providerOptions: providerMetadataSchema.optional()
-});
-var toolCallPartSchema = import_v45.z.object({
-  type: import_v45.z.literal("tool-call"),
-  toolCallId: import_v45.z.string(),
-  toolName: import_v45.z.string(),
-  input: import_v45.z.unknown(),
-  providerOptions: providerMetadataSchema.optional(),
-  providerExecuted: import_v45.z.boolean().optional()
-});
-var outputSchema = import_v45.z.discriminatedUnion("type", [
-  import_v45.z.object({
-    type: import_v45.z.literal("text"),
-    value: import_v45.z.string()
-  }),
-  import_v45.z.object({
-    type: import_v45.z.literal("json"),
-    value: jsonValueSchema
-  }),
-  import_v45.z.object({
-    type: import_v45.z.literal("error-text"),
-    value: import_v45.z.string()
-  }),
-  import_v45.z.object({
-    type: import_v45.z.literal("error-json"),
-    value: jsonValueSchema
-  }),
-  import_v45.z.object({
-    type: import_v45.z.literal("content"),
-    value: import_v45.z.array(
-      import_v45.z.union([
-        import_v45.z.object({
-          type: import_v45.z.literal("text"),
-          text: import_v45.z.string()
-        }),
-        import_v45.z.object({
-          type: import_v45.z.literal("media"),
-          data: import_v45.z.string(),
-          mediaType: import_v45.z.string()
-        })
-      ])
-    )
-  })
-]);
-var toolResultPartSchema = import_v45.z.object({
-  type: import_v45.z.literal("tool-result"),
-  toolCallId: import_v45.z.string(),
-  toolName: import_v45.z.string(),
-  output: outputSchema,
-  providerOptions: providerMetadataSchema.optional()
-});
-
-// src/prompt/message.ts
-var systemModelMessageSchema = import_v46.z.object(
-  {
-    role: import_v46.z.literal("system"),
-    content: import_v46.z.string(),
-    providerOptions: providerMetadataSchema.optional()
-  }
-);
-var userModelMessageSchema = import_v46.z.object({
-  role: import_v46.z.literal("user"),
-  content: import_v46.z.union([
-    import_v46.z.string(),
-    import_v46.z.array(import_v46.z.union([textPartSchema, imagePartSchema, filePartSchema]))
-  ]),
-  providerOptions: providerMetadataSchema.optional()
-});
-var assistantModelMessageSchema = import_v46.z.object({
-  role: import_v46.z.literal("assistant"),
-  content: import_v46.z.union([
-    import_v46.z.string(),
-    import_v46.z.array(
-      import_v46.z.union([
-        textPartSchema,
-        filePartSchema,
-        reasoningPartSchema,
-        toolCallPartSchema,
-        toolResultPartSchema
-      ])
-    )
-  ]),
-  providerOptions: providerMetadataSchema.optional()
-});
-var toolModelMessageSchema = import_v46.z.object({
-  role: import_v46.z.literal("tool"),
-  content: import_v46.z.array(toolResultPartSchema),
-  providerOptions: providerMetadataSchema.optional()
-});
-var modelMessageSchema = import_v46.z.union([
-  systemModelMessageSchema,
-  userModelMessageSchema,
-  assistantModelMessageSchema,
-  toolModelMessageSchema
-]);
-
-// src/prompt/standardize-prompt.ts
-async function standardizePrompt(prompt) {
-  if (prompt.prompt == null && prompt.messages == null) {
-    throw new import_provider13.InvalidPromptError({
-      prompt,
-      message: "prompt or messages must be defined"
-    });
-  }
-  if (prompt.prompt != null && prompt.messages != null) {
-    throw new import_provider13.InvalidPromptError({
-      prompt,
-      message: "prompt and messages cannot be defined at the same time"
-    });
-  }
-  if (prompt.system != null && typeof prompt.system !== "string") {
-    throw new import_provider13.InvalidPromptError({
-      prompt,
-      message: "system must be a string"
-    });
-  }
-  let messages;
-  if (prompt.prompt != null && typeof prompt.prompt === "string") {
-    messages = [{ role: "user", content: prompt.prompt }];
-  } else if (prompt.prompt != null && Array.isArray(prompt.prompt)) {
-    messages = prompt.prompt;
-  } else if (prompt.messages != null) {
-    messages = prompt.messages;
-  } else {
-    throw new import_provider13.InvalidPromptError({
-      prompt,
-      message: "prompt or messages must be defined"
-    });
-  }
-  if (messages.length === 0) {
-    throw new import_provider13.InvalidPromptError({
-      prompt,
-      message: "messages must not be empty"
-    });
-  }
-  const validationResult = await (0, import_provider_utils8.safeValidateTypes)({
-    value: messages,
-    schema: import_v47.z.array(modelMessageSchema)
-  });
-  if (!validationResult.success) {
-    throw new import_provider13.InvalidPromptError({
-      prompt,
-      message: "The messages must be a ModelMessage[]. If you have passed a UIMessage[], you can use convertToModelMessages to convert them.",
-      cause: validationResult.error
-    });
-  }
-  return {
-    messages,
-    system: prompt.system
-  };
-}
-
-// src/prompt/wrap-gateway-error.ts
-var import_gateway2 = require("@ai-sdk/gateway");
-var import_provider14 = require("@ai-sdk/provider");
-function wrapGatewayError(error) {
-  if (import_gateway2.GatewayAuthenticationError.isInstance(error) || import_gateway2.GatewayModelNotFoundError.isInstance(error)) {
-    return new import_provider14.AISDKError({
-      name: "GatewayError",
-      message: "Vercel AI Gateway access failed. If you want to use AI SDK providers directly, use the providers, e.g. @ai-sdk/openai, or register a different global default provider.",
-      cause: error
-    });
-  }
-  return error;
-}
-
-// src/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
-  };
-}
-
-// src/telemetry/get-base-telemetry-attributes.ts
-function getBaseTelemetryAttributes({
-  model,
-  settings,
-  telemetry,
-  headers
-}) {
-  var _a9;
-  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((_a9 = telemetry == null ? void 0 : telemetry.metadata) != null ? _a9 : {}).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;
-    }, {})
-  };
-}
-
-// src/telemetry/get-tracer.ts
-var import_api = require("@opentelemetry/api");
-
-// src/telemetry/noop-tracer.ts
-var noopTracer = {
-  startSpan() {
-    return noopSpan;
-  },
-  startActiveSpan(name9, 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
-};
-
-// src/telemetry/get-tracer.ts
-function getTracer({
-  isEnabled = false,
-  tracer
-} = {}) {
-  if (!isEnabled) {
-    return noopTracer;
-  }
-  if (tracer) {
-    return tracer;
-  }
-  return import_api.trace.getTracer("ai");
-}
-
-// src/telemetry/record-span.ts
-var import_api2 = require("@opentelemetry/api");
-function recordSpan({
-  name: name9,
-  tracer,
-  attributes,
-  fn,
-  endWhenDone = true
-}) {
-  return tracer.startActiveSpan(name9, { 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: import_api2.SpanStatusCode.ERROR,
-      message: error.message
-    });
-  } else {
-    span.setStatus({ code: import_api2.SpanStatusCode.ERROR });
-  }
-}
-
-// src/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 == null) {
-      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 == null ? 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 == null ? attributes2 : { ...attributes2, [key]: result };
-    }
-    return { ...attributes2, [key]: value };
-  }, {});
-}
-
-// src/telemetry/stringify-for-telemetry.ts
-function stringifyForTelemetry(prompt) {
-  return JSON.stringify(
-    prompt.map((message) => ({
-      ...message,
-      content: typeof message.content === "string" ? message.content : message.content.map(
-        (part) => part.type === "file" ? {
-          ...part,
-          data: part.data instanceof Uint8Array ? convertDataContentToBase64String(part.data) : part.data
-        } : part
-      )
-    }))
-  );
-}
-
-// src/types/usage.ts
-function addLanguageModelUsage(usage1, usage2) {
-  return {
-    inputTokens: addTokenCounts(usage1.inputTokens, usage2.inputTokens),
-    outputTokens: addTokenCounts(usage1.outputTokens, usage2.outputTokens),
-    totalTokens: addTokenCounts(usage1.totalTokens, usage2.totalTokens),
-    reasoningTokens: addTokenCounts(
-      usage1.reasoningTokens,
-      usage2.reasoningTokens
-    ),
-    cachedInputTokens: addTokenCounts(
-      usage1.cachedInputTokens,
-      usage2.cachedInputTokens
-    )
-  };
-}
-function addTokenCounts(tokenCount1, tokenCount2) {
-  return tokenCount1 == null && tokenCount2 == null ? void 0 : (tokenCount1 != null ? tokenCount1 : 0) + (tokenCount2 != null ? tokenCount2 : 0);
-}
-
-// src/util/filter-stream-errors.ts
-function filterStreamErrors(readable, onError) {
-  return new ReadableStream({
-    async start(controller) {
-      const reader = readable.getReader();
-      try {
-        while (true) {
-          const { done, value } = await reader.read();
-          if (done) {
-            controller.close();
-            break;
-          }
-          controller.enqueue(value);
-        }
-      } catch (error) {
-        await onError({ error, controller });
-      }
-    },
-    cancel(reason) {
-      return readable.cancel(reason);
-    }
-  });
-}
-
-// src/generate-text/run-tools-transformation.ts
-var import_provider_utils11 = require("@ai-sdk/provider-utils");
-
-// src/generate-text/generated-file.ts
-var import_provider_utils9 = require("@ai-sdk/provider-utils");
-var DefaultGeneratedFile = class {
-  constructor({
-    data,
-    mediaType
-  }) {
-    const isUint8Array = data instanceof Uint8Array;
-    this.base64Data = isUint8Array ? void 0 : data;
-    this.uint8ArrayData = isUint8Array ? data : void 0;
-    this.mediaType = mediaType;
-  }
-  // lazy conversion with caching to avoid unnecessary conversion overhead:
-  get base64() {
-    if (this.base64Data == null) {
-      this.base64Data = (0, import_provider_utils9.convertUint8ArrayToBase64)(this.uint8ArrayData);
-    }
-    return this.base64Data;
-  }
-  // lazy conversion with caching to avoid unnecessary conversion overhead:
-  get uint8Array() {
-    if (this.uint8ArrayData == null) {
-      this.uint8ArrayData = (0, import_provider_utils9.convertBase64ToUint8Array)(this.base64Data);
-    }
-    return this.uint8ArrayData;
-  }
-};
-var DefaultGeneratedFileWithType = class extends DefaultGeneratedFile {
-  constructor(options) {
-    super(options);
-    this.type = "file";
-  }
-};
-
-// src/generate-text/parse-tool-call.ts
-var import_provider_utils10 = require("@ai-sdk/provider-utils");
-async function parseToolCall({
-  toolCall,
-  tools,
-  repairToolCall,
-  system,
-  messages
-}) {
-  if (tools == null) {
-    throw new NoSuchToolError({ toolName: toolCall.toolName });
-  }
-  try {
-    return await doParseToolCall({ toolCall, tools });
-  } catch (error) {
-    if (repairToolCall == null || !(NoSuchToolError.isInstance(error) || InvalidToolInputError.isInstance(error))) {
-      throw error;
-    }
-    let repairedToolCall = null;
-    try {
-      repairedToolCall = await repairToolCall({
-        toolCall,
-        tools,
-        inputSchema: ({ toolName }) => {
-          const { inputSchema } = tools[toolName];
-          return (0, import_provider_utils10.asSchema)(inputSchema).jsonSchema;
-        },
-        system,
-        messages,
-        error
-      });
-    } catch (repairError) {
-      throw new ToolCallRepairError({
-        cause: repairError,
-        originalError: error
-      });
-    }
-    if (repairedToolCall == null) {
-      throw error;
-    }
-    return await doParseToolCall({ toolCall: repairedToolCall, tools });
-  }
-}
-async function doParseToolCall({
-  toolCall,
-  tools
-}) {
-  const toolName = toolCall.toolName;
-  const tool = tools[toolName];
-  if (tool == null) {
-    throw new NoSuchToolError({
-      toolName: toolCall.toolName,
-      availableTools: Object.keys(tools)
-    });
-  }
-  const schema = (0, import_provider_utils10.asSchema)(tool.inputSchema);
-  const parseResult = toolCall.input.trim() === "" ? await (0, import_provider_utils10.safeValidateTypes)({ value: {}, schema }) : await (0, import_provider_utils10.safeParseJSON)({ text: toolCall.input, schema });
-  if (parseResult.success === false) {
-    throw new InvalidToolInputError({
-      toolName,
-      toolInput: toolCall.input,
-      cause: parseResult.error
-    });
-  }
-  return {
-    type: "tool-call",
-    toolCallId: toolCall.toolCallId,
-    toolName,
-    input: parseResult.value,
-    providerExecuted: toolCall.providerExecuted,
-    providerMetadata: toolCall.providerMetadata
-  };
-}
-
-// src/generate-text/run-tools-transformation.ts
-function runToolsTransformation({
-  tools,
-  generatorStream,
-  tracer,
-  telemetry,
-  system,
-  messages,
-  abortSignal,
-  repairToolCall
-}) {
-  let toolResultsStreamController = null;
-  const toolResultsStream = new ReadableStream({
-    start(controller) {
-      toolResultsStreamController = controller;
-    }
-  });
-  const outstandingToolResults = /* @__PURE__ */ new Set();
-  const toolInputs = /* @__PURE__ */ new Map();
-  let canClose = false;
-  let finishChunk = void 0;
-  function attemptClose() {
-    if (canClose && outstandingToolResults.size === 0) {
-      if (finishChunk != null) {
-        toolResultsStreamController.enqueue(finishChunk);
-      }
-      toolResultsStreamController.close();
-    }
-  }
-  const forwardStream = new TransformStream({
-    async transform(chunk, controller) {
-      const chunkType = chunk.type;
-      switch (chunkType) {
-        case "stream-start":
-        case "text-start":
-        case "text-delta":
-        case "text-end":
-        case "reasoning-start":
-        case "reasoning-delta":
-        case "reasoning-end":
-        case "tool-input-start":
-        case "tool-input-delta":
-        case "tool-input-end":
-        case "source":
-        case "response-metadata":
-        case "error":
-        case "raw": {
-          controller.enqueue(chunk);
-          break;
-        }
-        case "file": {
-          controller.enqueue({
-            type: "file",
-            file: new DefaultGeneratedFileWithType({
-              data: chunk.data,
-              mediaType: chunk.mediaType
-            })
-          });
-          break;
-        }
-        case "finish": {
-          finishChunk = {
-            type: "finish",
-            finishReason: chunk.finishReason,
-            usage: chunk.usage,
-            providerMetadata: chunk.providerMetadata
-          };
-          break;
-        }
-        case "tool-call": {
-          try {
-            const toolCall = await parseToolCall({
-              toolCall: chunk,
-              tools,
-              repairToolCall,
-              system,
-              messages
-            });
-            controller.enqueue(toolCall);
-            const tool = tools[toolCall.toolName];
-            toolInputs.set(toolCall.toolCallId, toolCall.input);
-            if (tool.onInputAvailable != null) {
-              await tool.onInputAvailable({
-                input: toolCall.input,
-                toolCallId: toolCall.toolCallId,
-                messages,
-                abortSignal
-              });
-            }
-            if (tool.execute != null && toolCall.providerExecuted !== true) {
-              const toolExecutionId = (0, import_provider_utils11.generateId)();
-              outstandingToolResults.add(toolExecutionId);
-              recordSpan({
-                name: "ai.toolCall",
-                attributes: selectTelemetryAttributes({
-                  telemetry,
-                  attributes: {
-                    ...assembleOperationName({
-                      operationId: "ai.toolCall",
-                      telemetry
-                    }),
-                    "ai.toolCall.name": toolCall.toolName,
-                    "ai.toolCall.id": toolCall.toolCallId,
-                    "ai.toolCall.input": {
-                      output: () => JSON.stringify(toolCall.input)
-                    }
-                  }
-                }),
-                tracer,
-                fn: async (span) => {
-                  let output;
-                  try {
-                    output = await tool.execute(toolCall.input, {
-                      toolCallId: toolCall.toolCallId,
-                      messages,
-                      abortSignal
-                    });
-                  } catch (error) {
-                    recordErrorOnSpan(span, error);
-                    toolResultsStreamController.enqueue({
-                      ...toolCall,
-                      type: "tool-error",
-                      error
-                    });
-                    outstandingToolResults.delete(toolExecutionId);
-                    attemptClose();
-                    return;
-                  }
-                  toolResultsStreamController.enqueue({
-                    ...toolCall,
-                    type: "tool-result",
-                    output
-                  });
-                  outstandingToolResults.delete(toolExecutionId);
-                  attemptClose();
-                  try {
-                    span.setAttributes(
-                      selectTelemetryAttributes({
-                        telemetry,
-                        attributes: {
-                          "ai.toolCall.output": {
-                            output: () => JSON.stringify(output)
-                          }
-                        }
-                      })
-                    );
-                  } catch (ignored) {
-                  }
-                }
-              });
-            }
-          } catch (error) {
-            toolResultsStreamController.enqueue({ type: "error", error });
-          }
-          break;
-        }
-        case "tool-result": {
-          const toolName = chunk.toolName;
-          if (chunk.isError) {
-            toolResultsStreamController.enqueue({
-              type: "tool-error",
-              toolCallId: chunk.toolCallId,
-              toolName,
-              input: toolInputs.get(chunk.toolCallId),
-              providerExecuted: chunk.providerExecuted,
-              error: chunk.result
-            });
-          } else {
-            controller.enqueue({
-              type: "tool-result",
-              toolCallId: chunk.toolCallId,
-              toolName,
-              input: toolInputs.get(chunk.toolCallId),
-              output: chunk.result,
-              providerExecuted: chunk.providerExecuted
-            });
-          }
-          break;
-        }
-        default: {
-          const _exhaustiveCheck = chunkType;
-          throw new Error(`Unhandled chunk type: ${_exhaustiveCheck}`);
-        }
-      }
-    },
-    flush() {
-      canClose = true;
-      attemptClose();
-    }
-  });
-  return new ReadableStream({
-    async start(controller) {
-      return Promise.all([
-        generatorStream.pipeThrough(forwardStream).pipeTo(
-          new WritableStream({
-            write(chunk) {
-              controller.enqueue(chunk);
-            },
-            close() {
-            }
-          })
-        ),
-        toolResultsStream.pipeTo(
-          new WritableStream({
-            write(chunk) {
-              controller.enqueue(chunk);
-            },
-            close() {
-              controller.close();
-            }
-          })
-        )
-      ]);
-    }
-  });
-}
-
-// src/generate-text/step-result.ts
-var DefaultStepResult = class {
-  constructor({
-    content,
-    finishReason,
-    usage,
-    warnings,
-    request,
-    response,
-    providerMetadata
-  }) {
-    this.content = content;
-    this.finishReason = finishReason;
-    this.usage = usage;
-    this.warnings = warnings;
-    this.request = request;
-    this.response = response;
-    this.providerMetadata = providerMetadata;
-  }
-  get text() {
-    return this.content.filter((part) => part.type === "text").map((part) => part.text).join("");
-  }
-  get reasoning() {
-    return this.content.filter((part) => part.type === "reasoning");
-  }
-  get reasoningText() {
-    return this.reasoning.length === 0 ? void 0 : this.reasoning.map((part) => part.text).join("");
-  }
-  get files() {
-    return this.content.filter((part) => part.type === "file").map((part) => part.file);
-  }
-  get sources() {
-    return this.content.filter((part) => part.type === "source");
-  }
-  get toolCalls() {
-    return this.content.filter((part) => part.type === "tool-call");
-  }
-  get toolResults() {
-    return this.content.filter((part) => part.type === "tool-result");
-  }
-};
-
-// src/generate-text/stop-condition.ts
-function stepCountIs(stepCount) {
-  return ({ steps }) => steps.length === stepCount;
-}
-async function isStopConditionMet({
-  stopConditions,
-  steps
-}) {
-  return (await Promise.all(stopConditions.map((condition) => condition({ steps })))).some((result) => result);
-}
-
-// src/prompt/create-tool-model-output.ts
-var import_provider15 = require("@ai-sdk/provider");
-function createToolModelOutput({
-  output,
-  tool,
-  errorMode
-}) {
-  if (errorMode === "text") {
-    return { type: "error-text", value: (0, import_provider15.getErrorMessage)(output) };
-  } else if (errorMode === "json") {
-    return { type: "error-json", value: output };
-  }
-  if (tool == null ? void 0 : tool.toModelOutput) {
-    return tool.toModelOutput(output);
-  }
-  return typeof output === "string" ? { type: "text", value: output } : { type: "json", value: output };
-}
-
-// src/generate-text/to-response-messages.ts
-function toResponseMessages({
-  content: inputContent,
-  tools
-}) {
-  const responseMessages = [];
-  const content = inputContent.filter((part) => part.type !== "source").filter(
-    (part) => (part.type !== "tool-result" || part.providerExecuted) && (part.type !== "tool-error" || part.providerExecuted)
-  ).filter((part) => part.type !== "text" || part.text.length > 0).map((part) => {
-    switch (part.type) {
-      case "text":
-        return {
-          type: "text",
-          text: part.text,
-          providerOptions: part.providerMetadata
-        };
-      case "reasoning":
-        return {
-          type: "reasoning",
-          text: part.text,
-          providerOptions: part.providerMetadata
-        };
-      case "file":
-        return {
-          type: "file",
-          data: part.file.base64,
-          mediaType: part.file.mediaType,
-          providerOptions: part.providerMetadata
-        };
-      case "tool-call":
-        return {
-          type: "tool-call",
-          toolCallId: part.toolCallId,
-          toolName: part.toolName,
-          input: part.input,
-          providerExecuted: part.providerExecuted,
-          providerOptions: part.providerMetadata
-        };
-      case "tool-result":
-        return {
-          type: "tool-result",
-          toolCallId: part.toolCallId,
-          toolName: part.toolName,
-          output: createToolModelOutput({
-            tool: tools == null ? void 0 : tools[part.toolName],
-            output: part.output,
-            errorMode: "none"
-          }),
-          providerExecuted: true,
-          providerOptions: part.providerMetadata
-        };
-      case "tool-error":
-        return {
-          type: "tool-result",
-          toolCallId: part.toolCallId,
-          toolName: part.toolName,
-          output: createToolModelOutput({
-            tool: tools == null ? void 0 : tools[part.toolName],
-            output: part.error,
-            errorMode: "json"
-          }),
-          providerOptions: part.providerMetadata
-        };
-    }
-  });
-  if (content.length > 0) {
-    responseMessages.push({
-      role: "assistant",
-      content
-    });
-  }
-  const toolResultContent = inputContent.filter((part) => part.type === "tool-result" || part.type === "tool-error").filter((part) => !part.providerExecuted).map((toolResult) => ({
-    type: "tool-result",
-    toolCallId: toolResult.toolCallId,
-    toolName: toolResult.toolName,
-    output: createToolModelOutput({
-      tool: tools == null ? void 0 : tools[toolResult.toolName],
-      output: toolResult.type === "tool-result" ? toolResult.output : toolResult.error,
-      errorMode: toolResult.type === "tool-error" ? "text" : "none"
-    })
-  }));
-  if (toolResultContent.length > 0) {
-    responseMessages.push({
-      role: "tool",
-      content: toolResultContent
-    });
-  }
-  return responseMessages;
-}
-
-// src/generate-text/stream-text.ts
-var originalGenerateId = (0, import_provider_utils12.createIdGenerator)({
-  prefix: "aitxt",
-  size: 24
-});
-function streamText({
-  model,
-  tools,
-  toolChoice,
-  system,
-  prompt,
-  messages,
-  maxRetries,
-  abortSignal,
-  headers,
-  stopWhen = stepCountIs(1),
-  experimental_output: output,
-  experimental_telemetry: telemetry,
-  prepareStep,
-  providerOptions,
-  experimental_activeTools,
-  activeTools = experimental_activeTools,
-  experimental_repairToolCall: repairToolCall,
-  experimental_transform: transform,
-  includeRawChunks = false,
-  onChunk,
-  onError = ({ error }) => {
-    console.error(error);
-  },
-  onFinish,
-  onAbort,
-  onStepFinish,
-  _internal: {
-    now: now2 = now,
-    generateId: generateId2 = originalGenerateId,
-    currentDate = () => /* @__PURE__ */ new Date()
-  } = {},
-  ...settings
-}) {
-  return new DefaultStreamTextResult({
-    model: resolveLanguageModel(model),
-    telemetry,
-    headers,
-    settings,
-    maxRetries,
-    abortSignal,
-    system,
-    prompt,
-    messages,
-    tools,
-    toolChoice,
-    transforms: asArray(transform),
-    activeTools,
-    repairToolCall,
-    stopConditions: asArray(stopWhen),
-    output,
-    providerOptions,
-    prepareStep,
-    includeRawChunks,
-    onChunk,
-    onError,
-    onFinish,
-    onAbort,
-    onStepFinish,
-    now: now2,
-    currentDate,
-    generateId: generateId2
-  });
-}
-function createOutputTransformStream(output) {
-  if (!output) {
-    return new TransformStream({
-      transform(chunk, controller) {
-        controller.enqueue({ part: chunk, partialOutput: void 0 });
-      }
-    });
-  }
-  let firstTextChunkId = void 0;
-  let text = "";
-  let textChunk = "";
-  let lastPublishedJson = "";
-  function publishTextChunk({
-    controller,
-    partialOutput = void 0
-  }) {
-    controller.enqueue({
-      part: {
-        type: "text",
-        id: firstTextChunkId,
-        text: textChunk
-      },
-      partialOutput
-    });
-    textChunk = "";
-  }
-  return new TransformStream({
-    async transform(chunk, controller) {
-      if (chunk.type === "finish-step" && textChunk.length > 0) {
-        publishTextChunk({ controller });
-      }
-      if (chunk.type !== "text" && chunk.type !== "text-start" && chunk.type !== "text-end") {
-        controller.enqueue({ part: chunk, partialOutput: void 0 });
-        return;
-      }
-      if (firstTextChunkId == null) {
-        firstTextChunkId = chunk.id;
-      } else if (chunk.id !== firstTextChunkId) {
-        controller.enqueue({ part: chunk, partialOutput: void 0 });
-        return;
-      }
-      if (chunk.type === "text-start") {
-        controller.enqueue({ part: chunk, partialOutput: void 0 });
-        return;
-      }
-      if (chunk.type === "text-end") {
-        if (textChunk.length > 0) {
-          publishTextChunk({ controller });
-        }
-        controller.enqueue({ part: chunk, partialOutput: void 0 });
-        return;
-      }
-      text += chunk.text;
-      textChunk += chunk.text;
-      const result = await output.parsePartial({ text });
-      if (result != null) {
-        const currentJson = JSON.stringify(result.partial);
-        if (currentJson !== lastPublishedJson) {
-          publishTextChunk({ controller, partialOutput: result.partial });
-          lastPublishedJson = currentJson;
-        }
-      }
-    }
-  });
-}
-var DefaultStreamTextResult = class {
-  constructor({
-    model,
-    telemetry,
-    headers,
-    settings,
-    maxRetries: maxRetriesArg,
-    abortSignal,
-    system,
-    prompt,
-    messages,
-    tools,
-    toolChoice,
-    transforms,
-    activeTools,
-    repairToolCall,
-    stopConditions,
-    output,
-    providerOptions,
-    prepareStep,
-    includeRawChunks,
-    now: now2,
-    currentDate,
-    generateId: generateId2,
-    onChunk,
-    onError,
-    onFinish,
-    onAbort,
-    onStepFinish
-  }) {
-    this._totalUsage = new DelayedPromise();
-    this._finishReason = new DelayedPromise();
-    this._steps = new DelayedPromise();
-    this.output = output;
-    this.includeRawChunks = includeRawChunks;
-    let stepFinish;
-    let recordedContent = [];
-    const recordedResponseMessages = [];
-    let recordedFinishReason = void 0;
-    let recordedTotalUsage = void 0;
-    let recordedRequest = {};
-    let recordedWarnings = [];
-    const recordedSteps = [];
-    let rootSpan;
-    let activeTextContent = {};
-    let activeReasoningContent = {};
-    const eventProcessor = new TransformStream({
-      async transform(chunk, controller) {
-        var _a9, _b, _c;
-        controller.enqueue(chunk);
-        const { part } = chunk;
-        if (part.type === "text" || part.type === "reasoning" || part.type === "source" || part.type === "tool-call" || part.type === "tool-result" || part.type === "tool-input-start" || part.type === "tool-input-delta" || part.type === "raw") {
-          await (onChunk == null ? void 0 : onChunk({ chunk: part }));
-        }
-        if (part.type === "error") {
-          await onError({ error: wrapGatewayError(part.error) });
-        }
-        if (part.type === "text-start") {
-          activeTextContent[part.id] = {
-            type: "text",
-            text: "",
-            providerMetadata: part.providerMetadata
-          };
-          recordedContent.push(activeTextContent[part.id]);
-        }
-        if (part.type === "text") {
-          const activeText = activeTextContent[part.id];
-          if (activeText == null) {
-            controller.enqueue({
-              part: {
-                type: "error",
-                error: `text part ${part.id} not found`
-              },
-              partialOutput: void 0
-            });
-            return;
-          }
-          activeText.text += part.text;
-          activeText.providerMetadata = (_a9 = part.providerMetadata) != null ? _a9 : activeText.providerMetadata;
-        }
-        if (part.type === "text-end") {
-          delete activeTextContent[part.id];
-        }
-        if (part.type === "reasoning-start") {
-          activeReasoningContent[part.id] = {
-            type: "reasoning",
-            text: "",
-            providerMetadata: part.providerMetadata
-          };
-          recordedContent.push(activeReasoningContent[part.id]);
-        }
-        if (part.type === "reasoning") {
-          const activeReasoning = activeReasoningContent[part.id];
-          if (activeReasoning == null) {
-            controller.enqueue({
-              part: {
-                type: "error",
-                error: `reasoning part ${part.id} not found`
-              },
-              partialOutput: void 0
-            });
-            return;
-          }
-          activeReasoning.text += part.text;
-          activeReasoning.providerMetadata = (_b = part.providerMetadata) != null ? _b : activeReasoning.providerMetadata;
-        }
-        if (part.type === "reasoning-end") {
-          const activeReasoning = activeReasoningContent[part.id];
-          if (activeReasoning == null) {
-            controller.enqueue({
-              part: {
-                type: "error",
-                error: `reasoning part ${part.id} not found`
-              },
-              partialOutput: void 0
-            });
-            return;
-          }
-          activeReasoning.providerMetadata = (_c = part.providerMetadata) != null ? _c : activeReasoning.providerMetadata;
-          delete activeReasoningContent[part.id];
-        }
-        if (part.type === "file") {
-          recordedContent.push({ type: "file", file: part.file });
-        }
-        if (part.type === "source") {
-          recordedContent.push(part);
-        }
-        if (part.type === "tool-call") {
-          recordedContent.push(part);
-        }
-        if (part.type === "tool-result") {
-          recordedContent.push(part);
-        }
-        if (part.type === "tool-error") {
-          recordedContent.push(part);
-        }
-        if (part.type === "start-step") {
-          recordedRequest = part.request;
-          recordedWarnings = part.warnings;
-        }
-        if (part.type === "finish-step") {
-          const stepMessages = toResponseMessages({
-            content: recordedContent,
-            tools
-          });
-          const currentStepResult = new DefaultStepResult({
-            content: recordedContent,
-            finishReason: part.finishReason,
-            usage: part.usage,
-            warnings: recordedWarnings,
-            request: recordedRequest,
-            response: {
-              ...part.response,
-              messages: [...recordedResponseMessages, ...stepMessages]
-            },
-            providerMetadata: part.providerMetadata
-          });
-          await (onStepFinish == null ? void 0 : onStepFinish(currentStepResult));
-          recordedSteps.push(currentStepResult);
-          recordedContent = [];
-          activeReasoningContent = {};
-          activeTextContent = {};
-          recordedResponseMessages.push(...stepMessages);
-          stepFinish.resolve();
-        }
-        if (part.type === "finish") {
-          recordedTotalUsage = part.totalUsage;
-          recordedFinishReason = part.finishReason;
-        }
-      },
-      async flush(controller) {
-        try {
-          if (recordedSteps.length === 0) {
-            return;
-          }
-          const finishReason = recordedFinishReason != null ? recordedFinishReason : "unknown";
-          const totalUsage = recordedTotalUsage != null ? recordedTotalUsage : {
-            inputTokens: void 0,
-            outputTokens: void 0,
-            totalTokens: void 0
-          };
-          self._finishReason.resolve(finishReason);
-          self._totalUsage.resolve(totalUsage);
-          self._steps.resolve(recordedSteps);
-          const finalStep = recordedSteps[recordedSteps.length - 1];
-          await (onFinish == null ? void 0 : onFinish({
-            finishReason,
-            totalUsage,
-            usage: finalStep.usage,
-            content: finalStep.content,
-            text: finalStep.text,
-            reasoningText: finalStep.reasoningText,
-            reasoning: finalStep.reasoning,
-            files: finalStep.files,
-            sources: finalStep.sources,
-            toolCalls: finalStep.toolCalls,
-            toolResults: finalStep.toolResults,
-            request: finalStep.request,
-            response: finalStep.response,
-            warnings: finalStep.warnings,
-            providerMetadata: finalStep.providerMetadata,
-            steps: recordedSteps
-          }));
-          rootSpan.setAttributes(
-            selectTelemetryAttributes({
-              telemetry,
-              attributes: {
-                "ai.response.finishReason": finishReason,
-                "ai.response.text": { output: () => finalStep.text },
-                "ai.response.toolCalls": {
-                  output: () => {
-                    var _a9;
-                    return ((_a9 = finalStep.toolCalls) == null ? void 0 : _a9.length) ? JSON.stringify(finalStep.toolCalls) : void 0;
-                  }
-                },
-                "ai.response.providerMetadata": JSON.stringify(
-                  finalStep.providerMetadata
-                ),
-                "ai.usage.inputTokens": totalUsage.inputTokens,
-                "ai.usage.outputTokens": totalUsage.outputTokens,
-                "ai.usage.totalTokens": totalUsage.totalTokens,
-                "ai.usage.reasoningTokens": totalUsage.reasoningTokens,
-                "ai.usage.cachedInputTokens": totalUsage.cachedInputTokens
-              }
-            })
-          );
-        } catch (error) {
-          controller.error(error);
-        } finally {
-          rootSpan.end();
-        }
-      }
-    });
-    const stitchableStream = createStitchableStream();
-    this.addStream = stitchableStream.addStream;
-    this.closeStream = stitchableStream.close;
-    let stream = stitchableStream.stream;
-    stream = filterStreamErrors(stream, ({ error, controller }) => {
-      if ((0, import_provider_utils12.isAbortError)(error) && (abortSignal == null ? void 0 : abortSignal.aborted)) {
-        onAbort == null ? void 0 : onAbort({ steps: recordedSteps });
-        controller.enqueue({ type: "abort" });
-        controller.close();
-      } else {
-        controller.error(error);
-      }
-    });
-    stream = stream.pipeThrough(
-      new TransformStream({
-        start(controller) {
-          controller.enqueue({ type: "start" });
-        }
-      })
-    );
-    for (const transform of transforms) {
-      stream = stream.pipeThrough(
-        transform({
-          tools,
-          stopStream() {
-            stitchableStream.terminate();
-          }
-        })
-      );
-    }
-    this.baseStream = stream.pipeThrough(createOutputTransformStream(output)).pipeThrough(eventProcessor);
-    const { maxRetries, retry } = prepareRetries({
-      maxRetries: maxRetriesArg
-    });
-    const tracer = getTracer(telemetry);
-    const callSettings = prepareCallSettings(settings);
-    const baseTelemetryAttributes = getBaseTelemetryAttributes({
-      model,
-      telemetry,
-      headers,
-      settings: { ...callSettings, maxRetries }
-    });
-    const self = this;
-    recordSpan({
-      name: "ai.streamText",
-      attributes: selectTelemetryAttributes({
-        telemetry,
-        attributes: {
-          ...assembleOperationName({ operationId: "ai.streamText", telemetry }),
-          ...baseTelemetryAttributes,
-          // specific settings that only make sense on the outer level:
-          "ai.prompt": {
-            input: () => JSON.stringify({ system, prompt, messages })
-          }
-        }
-      }),
-      tracer,
-      endWhenDone: false,
-      fn: async (rootSpanArg) => {
-        rootSpan = rootSpanArg;
-        async function streamStep({
-          currentStep,
-          responseMessages,
-          usage
-        }) {
-          var _a9, _b, _c, _d, _e;
-          const includeRawChunks2 = self.includeRawChunks;
-          stepFinish = new DelayedPromise();
-          const initialPrompt = await standardizePrompt({
-            system,
-            prompt,
-            messages
-          });
-          const stepInputMessages = [
-            ...initialPrompt.messages,
-            ...responseMessages
-          ];
-          const prepareStepResult = await (prepareStep == null ? void 0 : prepareStep({
-            model,
-            steps: recordedSteps,
-            stepNumber: recordedSteps.length,
-            messages: stepInputMessages
-          }));
-          const promptMessages = await convertToLanguageModelPrompt({
-            prompt: {
-              system: (_a9 = prepareStepResult == null ? void 0 : prepareStepResult.system) != null ? _a9 : initialPrompt.system,
-              messages: (_b = prepareStepResult == null ? void 0 : prepareStepResult.messages) != null ? _b : stepInputMessages
-            },
-            supportedUrls: await model.supportedUrls
-          });
-          const stepModel = resolveLanguageModel(
-            (_c = prepareStepResult == null ? void 0 : prepareStepResult.model) != null ? _c : model
-          );
-          const { toolChoice: stepToolChoice, tools: stepTools } = prepareToolsAndToolChoice({
-            tools,
-            toolChoice: (_d = prepareStepResult == null ? void 0 : prepareStepResult.toolChoice) != null ? _d : toolChoice,
-            activeTools: (_e = prepareStepResult == null ? void 0 : prepareStepResult.activeTools) != null ? _e : activeTools
-          });
-          const {
-            result: { stream: stream2, response, request },
-            doStreamSpan,
-            startTimestampMs
-          } = await retry(
-            () => recordSpan({
-              name: "ai.streamText.doStream",
-              attributes: selectTelemetryAttributes({
-                telemetry,
-                attributes: {
-                  ...assembleOperationName({
-                    operationId: "ai.streamText.doStream",
-                    telemetry
-                  }),
-                  ...baseTelemetryAttributes,
-                  // model:
-                  "ai.model.provider": stepModel.provider,
-                  "ai.model.id": stepModel.modelId,
-                  // prompt:
-                  "ai.prompt.messages": {
-                    input: () => stringifyForTelemetry(promptMessages)
-                  },
-                  "ai.prompt.tools": {
-                    // convert the language model level tools:
-                    input: () => stepTools == null ? void 0 : stepTools.map((tool) => JSON.stringify(tool))
-                  },
-                  "ai.prompt.toolChoice": {
-                    input: () => stepToolChoice != null ? JSON.stringify(stepToolChoice) : void 0
-                  },
-                  // standardized gen-ai llm span attributes:
-                  "gen_ai.system": stepModel.provider,
-                  "gen_ai.request.model": stepModel.modelId,
-                  "gen_ai.request.frequency_penalty": callSettings.frequencyPenalty,
-                  "gen_ai.request.max_tokens": callSettings.maxOutputTokens,
-                  "gen_ai.request.presence_penalty": callSettings.presencePenalty,
-                  "gen_ai.request.stop_sequences": callSettings.stopSequences,
-                  "gen_ai.request.temperature": callSettings.temperature,
-                  "gen_ai.request.top_k": callSettings.topK,
-                  "gen_ai.request.top_p": callSettings.topP
-                }
-              }),
-              tracer,
-              endWhenDone: false,
-              fn: async (doStreamSpan2) => {
-                return {
-                  startTimestampMs: now2(),
-                  // get before the call
-                  doStreamSpan: doStreamSpan2,
-                  result: await stepModel.doStream({
-                    ...callSettings,
-                    tools: stepTools,
-                    toolChoice: stepToolChoice,
-                    responseFormat: output == null ? void 0 : output.responseFormat,
-                    prompt: promptMessages,
-                    providerOptions,
-                    abortSignal,
-                    headers,
-                    includeRawChunks: includeRawChunks2
-                  })
-                };
-              }
-            })
-          );
-          const streamWithToolResults = runToolsTransformation({
-            tools,
-            generatorStream: stream2,
-            tracer,
-            telemetry,
-            system,
-            messages: stepInputMessages,
-            repairToolCall,
-            abortSignal
-          });
-          const stepRequest = request != null ? request : {};
-          const stepToolCalls = [];
-          const stepToolOutputs = [];
-          let warnings;
-          const activeToolCallToolNames = {};
-          let stepFinishReason = "unknown";
-          let stepUsage = {
-            inputTokens: void 0,
-            outputTokens: void 0,
-            totalTokens: void 0
-          };
-          let stepProviderMetadata;
-          let stepFirstChunk = true;
-          let stepResponse = {
-            id: generateId2(),
-            timestamp: currentDate(),
-            modelId: model.modelId
-          };
-          let activeText = "";
-          self.addStream(
-            streamWithToolResults.pipeThrough(
-              new TransformStream({
-                async transform(chunk, controller) {
-                  var _a10, _b2, _c2, _d2;
-                  if (chunk.type === "stream-start") {
-                    warnings = chunk.warnings;
-                    return;
-                  }
-                  if (stepFirstChunk) {
-                    const msToFirstChunk = now2() - startTimestampMs;
-                    stepFirstChunk = false;
-                    doStreamSpan.addEvent("ai.stream.firstChunk", {
-                      "ai.response.msToFirstChunk": msToFirstChunk
-                    });
-                    doStreamSpan.setAttributes({
-                      "ai.response.msToFirstChunk": msToFirstChunk
-                    });
-                    controller.enqueue({
-                      type: "start-step",
-                      request: stepRequest,
-                      warnings: warnings != null ? warnings : []
-                    });
-                  }
-                  const chunkType = chunk.type;
-                  switch (chunkType) {
-                    case "text-start":
-                    case "text-end": {
-                      controller.enqueue(chunk);
-                      break;
-                    }
-                    case "text-delta": {
-                      if (chunk.delta.length > 0) {
-                        controller.enqueue({
-                          type: "text",
-                          id: chunk.id,
-                          text: chunk.delta,
-                          providerMetadata: chunk.providerMetadata
-                        });
-                        activeText += chunk.delta;
-                      }
-                      break;
-                    }
-                    case "reasoning-start":
-                    case "reasoning-end": {
-                      controller.enqueue(chunk);
-                      break;
-                    }
-                    case "reasoning-delta": {
-                      controller.enqueue({
-                        type: "reasoning",
-                        id: chunk.id,
-                        text: chunk.delta,
-                        providerMetadata: chunk.providerMetadata
-                      });
-                      break;
-                    }
-                    case "tool-call": {
-                      controller.enqueue(chunk);
-                      stepToolCalls.push(chunk);
-                      break;
-                    }
-                    case "tool-result": {
-                      controller.enqueue(chunk);
-                      stepToolOutputs.push(chunk);
-                      break;
-                    }
-                    case "tool-error": {
-                      controller.enqueue(chunk);
-                      stepToolOutputs.push(chunk);
-                      break;
-                    }
-                    case "response-metadata": {
-                      stepResponse = {
-                        id: (_a10 = chunk.id) != null ? _a10 : stepResponse.id,
-                        timestamp: (_b2 = chunk.timestamp) != null ? _b2 : stepResponse.timestamp,
-                        modelId: (_c2 = chunk.modelId) != null ? _c2 : stepResponse.modelId
-                      };
-                      break;
-                    }
-                    case "finish": {
-                      stepUsage = chunk.usage;
-                      stepFinishReason = chunk.finishReason;
-                      stepProviderMetadata = chunk.providerMetadata;
-                      const msToFinish = now2() - startTimestampMs;
-                      doStreamSpan.addEvent("ai.stream.finish");
-                      doStreamSpan.setAttributes({
-                        "ai.response.msToFinish": msToFinish,
-                        "ai.response.avgOutputTokensPerSecond": 1e3 * ((_d2 = stepUsage.outputTokens) != null ? _d2 : 0) / msToFinish
-                      });
-                      break;
-                    }
-                    case "file": {
-                      controller.enqueue(chunk);
-                      break;
-                    }
-                    case "source": {
-                      controller.enqueue(chunk);
-                      break;
-                    }
-                    case "tool-input-start": {
-                      activeToolCallToolNames[chunk.id] = chunk.toolName;
-                      const tool = tools == null ? void 0 : tools[chunk.toolName];
-                      if ((tool == null ? void 0 : tool.onInputStart) != null) {
-                        await tool.onInputStart({
-                          toolCallId: chunk.id,
-                          messages: stepInputMessages,
-                          abortSignal
-                        });
-                      }
-                      controller.enqueue(chunk);
-                      break;
-                    }
-                    case "tool-input-end": {
-                      delete activeToolCallToolNames[chunk.id];
-                      controller.enqueue(chunk);
-                      break;
-                    }
-                    case "tool-input-delta": {
-                      const toolName = activeToolCallToolNames[chunk.id];
-                      const tool = tools == null ? void 0 : tools[toolName];
-                      if ((tool == null ? void 0 : tool.onInputDelta) != null) {
-                        await tool.onInputDelta({
-                          inputTextDelta: chunk.delta,
-                          toolCallId: chunk.id,
-                          messages: stepInputMessages,
-                          abortSignal
-                        });
-                      }
-                      controller.enqueue(chunk);
-                      break;
-                    }
-                    case "error": {
-                      controller.enqueue(chunk);
-                      stepFinishReason = "error";
-                      break;
-                    }
-                    case "raw": {
-                      if (includeRawChunks2) {
-                        controller.enqueue(chunk);
-                      }
-                      break;
-                    }
-                    default: {
-                      const exhaustiveCheck = chunkType;
-                      throw new Error(`Unknown chunk type: ${exhaustiveCheck}`);
-                    }
-                  }
-                },
-                // invoke onFinish callback and resolve toolResults promise when the stream is about to close:
-                async flush(controller) {
-                  const stepToolCallsJson = stepToolCalls.length > 0 ? JSON.stringify(stepToolCalls) : void 0;
-                  try {
-                    doStreamSpan.setAttributes(
-                      selectTelemetryAttributes({
-                        telemetry,
-                        attributes: {
-                          "ai.response.finishReason": stepFinishReason,
-                          "ai.response.text": {
-                            output: () => activeText
-                          },
-                          "ai.response.toolCalls": {
-                            output: () => stepToolCallsJson
-                          },
-                          "ai.response.id": stepResponse.id,
-                          "ai.response.model": stepResponse.modelId,
-                          "ai.response.timestamp": stepResponse.timestamp.toISOString(),
-                          "ai.response.providerMetadata": JSON.stringify(stepProviderMetadata),
-                          "ai.usage.inputTokens": stepUsage.inputTokens,
-                          "ai.usage.outputTokens": stepUsage.outputTokens,
-                          "ai.usage.totalTokens": stepUsage.totalTokens,
-                          "ai.usage.reasoningTokens": stepUsage.reasoningTokens,
-                          "ai.usage.cachedInputTokens": stepUsage.cachedInputTokens,
-                          // standardized gen-ai llm span attributes:
-                          "gen_ai.response.finish_reasons": [stepFinishReason],
-                          "gen_ai.response.id": stepResponse.id,
-                          "gen_ai.response.model": stepResponse.modelId,
-                          "gen_ai.usage.input_tokens": stepUsage.inputTokens,
-                          "gen_ai.usage.output_tokens": stepUsage.outputTokens
-                        }
-                      })
-                    );
-                  } catch (error) {
-                  } finally {
-                    doStreamSpan.end();
-                  }
-                  controller.enqueue({
-                    type: "finish-step",
-                    finishReason: stepFinishReason,
-                    usage: stepUsage,
-                    providerMetadata: stepProviderMetadata,
-                    response: {
-                      ...stepResponse,
-                      headers: response == null ? void 0 : response.headers
-                    }
-                  });
-                  const combinedUsage = addLanguageModelUsage(usage, stepUsage);
-                  await stepFinish.promise;
-                  const clientToolCalls = stepToolCalls.filter(
-                    (toolCall) => toolCall.providerExecuted !== true
-                  );
-                  const clientToolOutputs = stepToolOutputs.filter(
-                    (toolOutput) => toolOutput.providerExecuted !== true
-                  );
-                  if (clientToolCalls.length > 0 && // all current tool calls have outputs (incl. execution errors):
-                  clientToolOutputs.length === clientToolCalls.length && // continue until a stop condition is met:
-                  !await isStopConditionMet({
-                    stopConditions,
-                    steps: recordedSteps
-                  })) {
-                    responseMessages.push(
-                      ...toResponseMessages({
-                        content: (
-                          // use transformed content to create the messages for the next step:
-                          recordedSteps[recordedSteps.length - 1].content
-                        ),
-                        tools
-                      })
-                    );
-                    try {
-                      await streamStep({
-                        currentStep: currentStep + 1,
-                        responseMessages,
-                        usage: combinedUsage
-                      });
-                    } catch (error) {
-                      controller.enqueue({
-                        type: "error",
-                        error
-                      });
-                      self.closeStream();
-                    }
-                  } else {
-                    controller.enqueue({
-                      type: "finish",
-                      finishReason: stepFinishReason,
-                      totalUsage: combinedUsage
-                    });
-                    self.closeStream();
-                  }
-                }
-              })
-            )
-          );
-        }
-        await streamStep({
-          currentStep: 0,
-          responseMessages: [],
-          usage: {
-            inputTokens: void 0,
-            outputTokens: void 0,
-            totalTokens: void 0
-          }
-        });
-      }
-    }).catch((error) => {
-      self.addStream(
-        new ReadableStream({
-          start(controller) {
-            controller.enqueue({ type: "error", error });
-            controller.close();
-          }
-        })
-      );
-      self.closeStream();
-    });
-  }
-  get steps() {
-    return this._steps.promise;
-  }
-  get finalStep() {
-    return this.steps.then((steps) => steps[steps.length - 1]);
-  }
-  get content() {
-    return this.finalStep.then((step) => step.content);
-  }
-  get warnings() {
-    return this.finalStep.then((step) => step.warnings);
-  }
-  get providerMetadata() {
-    return this.finalStep.then((step) => step.providerMetadata);
-  }
-  get text() {
-    return this.finalStep.then((step) => step.text);
-  }
-  get reasoningText() {
-    return this.finalStep.then((step) => step.reasoningText);
-  }
-  get reasoning() {
-    return this.finalStep.then((step) => step.reasoning);
-  }
-  get sources() {
-    return this.finalStep.then((step) => step.sources);
-  }
-  get files() {
-    return this.finalStep.then((step) => step.files);
-  }
-  get toolCalls() {
-    return this.finalStep.then((step) => step.toolCalls);
-  }
-  get toolResults() {
-    return this.finalStep.then((step) => step.toolResults);
-  }
-  get usage() {
-    return this.finalStep.then((step) => step.usage);
-  }
-  get request() {
-    return this.finalStep.then((step) => step.request);
-  }
-  get response() {
-    return this.finalStep.then((step) => step.response);
-  }
-  get totalUsage() {
-    return this._totalUsage.promise;
-  }
-  get finishReason() {
-    return this._finishReason.promise;
-  }
-  /**
-  Split out a new stream from the original stream.
-  The original stream is replaced to allow for further splitting,
-  since we do not know how many times the stream will be split.
-  
-  Note: this leads to buffering the stream content on the server.
-  However, the LLM results are expected to be small enough to not cause issues.
-     */
-  teeStream() {
-    const [stream1, stream2] = this.baseStream.tee();
-    this.baseStream = stream2;
-    return stream1;
-  }
-  get textStream() {
-    return createAsyncIterableStream(
-      this.teeStream().pipeThrough(
-        new TransformStream({
-          transform({ part }, controller) {
-            if (part.type === "text") {
-              controller.enqueue(part.text);
-            }
-          }
-        })
-      )
-    );
-  }
-  get fullStream() {
-    return createAsyncIterableStream(
-      this.teeStream().pipeThrough(
-        new TransformStream({
-          transform({ part }, controller) {
-            controller.enqueue(part);
-          }
-        })
-      )
-    );
-  }
-  async consumeStream(options) {
-    var _a9;
-    try {
-      await consumeStream({
-        stream: this.fullStream,
-        onError: options == null ? void 0 : options.onError
-      });
-    } catch (error) {
-      (_a9 = options == null ? void 0 : options.onError) == null ? void 0 : _a9.call(options, error);
-    }
-  }
-  get experimental_partialOutputStream() {
-    if (this.output == null) {
-      throw new NoOutputSpecifiedError();
-    }
-    return createAsyncIterableStream(
-      this.teeStream().pipeThrough(
-        new TransformStream({
-          transform({ partialOutput }, controller) {
-            if (partialOutput != null) {
-              controller.enqueue(partialOutput);
-            }
-          }
-        })
-      )
-    );
-  }
-  toUIMessageStream({
-    originalMessages,
-    generateMessageId,
-    onFinish,
-    messageMetadata,
-    sendReasoning = true,
-    sendSources = false,
-    sendStart = true,
-    sendFinish = true,
-    onError = import_provider16.getErrorMessage
-  } = {}) {
-    const responseMessageId = generateMessageId != null ? getResponseUIMessageId({
-      originalMessages,
-      responseMessageId: generateMessageId
-    }) : void 0;
-    const baseStream = this.fullStream.pipeThrough(
-      new TransformStream({
-        transform: async (part, controller) => {
-          const messageMetadataValue = messageMetadata == null ? void 0 : messageMetadata({ part });
-          const partType = part.type;
-          switch (partType) {
-            case "text-start": {
-              controller.enqueue({
-                type: "text-start",
-                id: part.id,
-                ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {}
-              });
-              break;
-            }
-            case "text": {
-              controller.enqueue({
-                type: "text-delta",
-                id: part.id,
-                delta: part.text,
-                ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {}
-              });
-              break;
-            }
-            case "text-end": {
-              controller.enqueue({
-                type: "text-end",
-                id: part.id,
-                ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {}
-              });
-              break;
-            }
-            case "reasoning-start": {
-              controller.enqueue({
-                type: "reasoning-start",
-                id: part.id,
-                ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {}
-              });
-              break;
-            }
-            case "reasoning": {
-              if (sendReasoning) {
-                controller.enqueue({
-                  type: "reasoning-delta",
-                  id: part.id,
-                  delta: part.text,
-                  ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {}
-                });
-              }
-              break;
-            }
-            case "reasoning-end": {
-              controller.enqueue({
-                type: "reasoning-end",
-                id: part.id,
-                ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {}
-              });
-              break;
-            }
-            case "file": {
-              controller.enqueue({
-                type: "file",
-                mediaType: part.file.mediaType,
-                url: `data:${part.file.mediaType};base64,${part.file.base64}`
-              });
-              break;
-            }
-            case "source": {
-              if (sendSources && part.sourceType === "url") {
-                controller.enqueue({
-                  type: "source-url",
-                  sourceId: part.id,
-                  url: part.url,
-                  title: part.title,
-                  ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {}
-                });
-              }
-              if (sendSources && part.sourceType === "document") {
-                controller.enqueue({
-                  type: "source-document",
-                  sourceId: part.id,
-                  mediaType: part.mediaType,
-                  title: part.title,
-                  filename: part.filename,
-                  ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {}
-                });
-              }
-              break;
-            }
-            case "tool-input-start": {
-              controller.enqueue({
-                type: "tool-input-start",
-                toolCallId: part.id,
-                toolName: part.toolName,
-                providerExecuted: part.providerExecuted
-              });
-              break;
-            }
-            case "tool-input-delta": {
-              controller.enqueue({
-                type: "tool-input-delta",
-                toolCallId: part.id,
-                inputTextDelta: part.delta
-              });
-              break;
-            }
-            case "tool-call": {
-              controller.enqueue({
-                type: "tool-input-available",
-                toolCallId: part.toolCallId,
-                toolName: part.toolName,
-                input: part.input,
-                providerExecuted: part.providerExecuted,
-                providerMetadata: part.providerMetadata
-              });
-              break;
-            }
-            case "tool-result": {
-              controller.enqueue({
-                type: "tool-output-available",
-                toolCallId: part.toolCallId,
-                output: part.output,
-                providerExecuted: part.providerExecuted
-              });
-              break;
-            }
-            case "tool-error": {
-              controller.enqueue({
-                type: "tool-output-error",
-                toolCallId: part.toolCallId,
-                errorText: onError(part.error),
-                providerExecuted: part.providerExecuted
-              });
-              break;
-            }
-            case "error": {
-              controller.enqueue({
-                type: "error",
-                errorText: onError(part.error)
-              });
-              break;
-            }
-            case "start-step": {
-              controller.enqueue({ type: "start-step" });
-              break;
-            }
-            case "finish-step": {
-              controller.enqueue({ type: "finish-step" });
-              break;
-            }
-            case "start": {
-              if (sendStart) {
-                controller.enqueue({
-                  type: "start",
-                  ...messageMetadataValue != null ? { messageMetadata: messageMetadataValue } : {},
-                  ...responseMessageId != null ? { messageId: responseMessageId } : {}
-                });
-              }
-              break;
-            }
-            case "finish": {
-              if (sendFinish) {
-                controller.enqueue({
-                  type: "finish",
-                  ...messageMetadataValue != null ? { messageMetadata: messageMetadataValue } : {}
-                });
-              }
-              break;
-            }
-            case "abort": {
-              controller.enqueue(part);
-              break;
-            }
-            case "tool-input-end": {
-              break;
-            }
-            case "raw": {
-              break;
-            }
-            default: {
-              const exhaustiveCheck = partType;
-              throw new Error(`Unknown chunk type: ${exhaustiveCheck}`);
-            }
-          }
-          if (messageMetadataValue != null && partType !== "start" && partType !== "finish") {
-            controller.enqueue({
-              type: "message-metadata",
-              messageMetadata: messageMetadataValue
-            });
-          }
-        }
-      })
-    );
-    return createAsyncIterableStream(
-      handleUIMessageStreamFinish({
-        stream: baseStream,
-        messageId: responseMessageId != null ? responseMessageId : generateMessageId == null ? void 0 : generateMessageId(),
-        originalMessages,
-        onFinish,
-        onError
-      })
-    );
-  }
-  pipeUIMessageStreamToResponse(response, {
-    originalMessages,
-    generateMessageId,
-    onFinish,
-    messageMetadata,
-    sendReasoning,
-    sendSources,
-    sendFinish,
-    sendStart,
-    onError,
-    ...init
-  } = {}) {
-    pipeUIMessageStreamToResponse({
-      response,
-      stream: this.toUIMessageStream({
-        originalMessages,
-        generateMessageId,
-        onFinish,
-        messageMetadata,
-        sendReasoning,
-        sendSources,
-        sendFinish,
-        sendStart,
-        onError
-      }),
-      ...init
-    });
-  }
-  pipeTextStreamToResponse(response, init) {
-    pipeTextStreamToResponse({
-      response,
-      textStream: this.textStream,
-      ...init
-    });
-  }
-  toUIMessageStreamResponse({
-    originalMessages,
-    generateMessageId,
-    onFinish,
-    messageMetadata,
-    sendReasoning,
-    sendSources,
-    sendFinish,
-    sendStart,
-    onError,
-    ...init
-  } = {}) {
-    return createUIMessageStreamResponse({
-      stream: this.toUIMessageStream({
-        originalMessages,
-        generateMessageId,
-        onFinish,
-        messageMetadata,
-        sendReasoning,
-        sendSources,
-        sendFinish,
-        sendStart,
-        onError
-      }),
-      ...init
-    });
-  }
-  toTextStreamResponse(init) {
-    return createTextStreamResponse({
-      textStream: this.textStream,
-      ...init
-    });
-  }
-};
-
-// src/bin/ai.ts
-var import_fs = require("fs");
-var import_path = require("path");
-var import_gateway3 = require("@ai-sdk/gateway");
-function isStdinAvailable() {
-  return !process.stdin.isTTY;
-}
-async function readStdin() {
-  return new Promise((resolve2) => {
-    let data = "";
-    process.stdin.setEncoding("utf8");
-    process.stdin.on("data", (chunk) => {
-      data += chunk;
-    });
-    process.stdin.on("end", () => {
-      resolve2(data.trim());
-    });
-  });
-}
-function getMediaType(filePath) {
-  var _a9;
-  const ext = (_a9 = filePath.split(".").pop()) == null ? void 0 : _a9.toLowerCase();
-  const mimeTypes = {
-    js: "application/javascript",
-    ts: "application/typescript",
-    jsx: "text/jsx",
-    tsx: "text/tsx",
-    json: "application/json",
-    md: "text/markdown",
-    txt: "text/plain",
-    py: "text/x-python",
-    html: "text/html",
-    css: "text/css",
-    xml: "application/xml",
-    yaml: "application/yaml",
-    yml: "application/yaml",
-    jpg: "image/jpeg",
-    jpeg: "image/jpeg",
-    png: "image/png",
-    gif: "image/gif",
-    webp: "image/webp",
-    svg: "image/svg+xml",
-    bmp: "image/bmp",
-    tiff: "image/tiff",
-    tif: "image/tiff"
-  };
-  return mimeTypes[ext || ""] || "text/plain";
-}
-function readFileContent(filePath) {
-  const absolutePath = (0, import_path.resolve)(filePath);
-  if (!(0, import_fs.existsSync)(absolutePath)) {
-    throw new Error(`File not found: ${filePath}`);
-  }
-  const mediaType = getMediaType(filePath);
-  const isImage = mediaType.startsWith("image/");
-  let content;
-  if (isImage) {
-    const buffer = (0, import_fs.readFileSync)(absolutePath);
-    content = `data:${mediaType};base64,${buffer.toString("base64")}`;
-  } else {
-    content = (0, import_fs.readFileSync)(absolutePath, "utf8");
-  }
-  return {
-    name: filePath,
-    content,
-    mediaType
-  };
-}
-function parseArgs() {
-  const args = process.argv.slice(2);
-  const options = {
-    model: process.env.AI_DEFAULT_MODEL || "openai/gpt-4",
-    files: [],
-    help: false,
-    version: false,
-    verbose: process.env.AI_VERBOSE === "true",
-    system: process.env.AI_SYSTEM
-  };
-  const promptArgs = [];
-  let i = 0;
-  while (i < args.length) {
-    const arg = args[i];
-    switch (arg) {
-      case "-h":
-      case "--help":
-        options.help = true;
-        break;
-      case "-V":
-      case "--version":
-        options.version = true;
-        break;
-      case "-v":
-      case "--verbose":
-        options.verbose = true;
-        break;
-      case "-m":
-      case "--model":
-        if (i + 1 < args.length) {
-          options.model = args[i + 1];
-          i++;
-        } else {
-          throw new Error("Model option requires a value");
-        }
-        break;
-      case "-f":
-      case "--file":
-        if (i + 1 < args.length) {
-          options.files.push(args[i + 1]);
-          i++;
-        } else {
-          throw new Error("File option requires a value");
-        }
-        break;
-      case "-s":
-      case "--system":
-        if (i + 1 < args.length) {
-          options.system = args[i + 1];
-          i++;
-        } else {
-          throw new Error("System option requires a value");
-        }
-        break;
-      default:
-        if (arg.startsWith("-")) {
-          throw new Error(`Unknown option: ${arg}`);
-        } else {
-          promptArgs.push(arg);
-        }
-    }
-    i++;
-  }
-  if (promptArgs.length > 0) {
-    options.prompt = promptArgs.join(" ");
-  }
-  return options;
-}
-function showHelp() {
-  console.log(`Usage: ai [options] [prompt]
-
-AI CLI - Stream text generation from various AI models
-
-Options:
-  -m, --model <model>      Model to use (default: "openai/gpt-4")
-                           Format: provider/model (e.g., anthropic/claude-3-5-sonnet)
-  -f, --file <file>        Attach file(s) to prompt
-  -s, --system <message>   System message
-  -v, --verbose            Show detailed output
-  -h, --help               Show help
-  -V, --version            Show version
-
-Authentication (required):
-  export AI_GATEWAY_API_KEY="your-key"     # Get from Vercel Dashboard (AI tab)
-  
-Environment Variables:
-  AI_DEFAULT_MODEL: Default model to use
-  AI_SYSTEM: Default system message
-  AI_VERBOSE: Set to 'true' for detailed output
-
-Examples:
-  npx ai "Hello, world!"
-  npx ai "Write a poem" -m anthropic/claude-3-5-sonnet
-  npx ai "Explain this code" -f script.js -f README.md
-  echo "What is life?" | npx ai
-  cat file.txt | npx ai "Summarize this content"
-  npx ai -f package.json "What dependencies does this project have?"
-
-Unix-style piping:
-  echo "Hello world" | npx ai "Translate to French"
-  cat README.md | npx ai "Summarize this"
-  curl -s https://api.github.com/repos/vercel/ai | npx ai "What is this repository about?"
-  
-  The gateway supports OpenAI, Anthropic, Google, Groq, and more providers.
-  
-  For detailed setup instructions, visit: https://ai-sdk.dev/docs/cli/authentication`);
-}
-function showVersion() {
-  console.log("1.0.0");
-}
-function resolveModel(modelString) {
-  return import_gateway3.gateway.languageModel(modelString);
-}
-function formatAttachedFiles(files) {
-  if (files.length === 0)
-    return "";
-  const textFiles = files.filter((f) => {
-    var _a9;
-    return !((_a9 = f.mediaType) == null ? void 0 : _a9.startsWith("image/"));
-  });
-  if (textFiles.length === 0)
-    return "";
-  let result = "\n\nAttached files:\n";
-  for (const file of textFiles) {
-    result += `
---- ${file.name} ---
-`;
-    result += file.content;
-    result += "\n";
-  }
-  return result;
-}
-async function main() {
-  try {
-    const options = parseArgs();
-    if (options.help) {
-      showHelp();
-      return;
-    }
-    if (options.version) {
-      showVersion();
-      return;
-    }
-    let prompt = options.prompt || "";
-    if (isStdinAvailable()) {
-      const stdinContent = await readStdin();
-      if (stdinContent) {
-        prompt = prompt ? `${stdinContent}
-
-${prompt}` : stdinContent;
-      }
-    }
-    if (!prompt.trim()) {
-      console.error(
-        "Error: No prompt provided. Use --help for usage information."
-      );
-      process.exit(1);
-    }
-    const attachedFiles = [];
-    for (const filePath of options.files) {
-      try {
-        const file = readFileContent(filePath);
-        attachedFiles.push(file);
-      } catch (error) {
-        console.error(
-          `Error reading file ${filePath}: ${error instanceof Error ? error.message : "Unknown error"}`
-        );
-        process.exit(1);
-      }
-    }
-    const textPrompt = prompt + formatAttachedFiles(attachedFiles);
-    const imageFiles = attachedFiles.filter(
-      (f) => {
-        var _a9;
-        return (_a9 = f.mediaType) == null ? void 0 : _a9.startsWith("image/");
-      }
-    );
-    if (imageFiles.length > 0 && options.model === "openai/gpt-4") {
-      options.model = "openai/gpt-4o";
-    }
-    if (options.verbose) {
-      console.error(`Using model: ${options.model}`);
-      if (attachedFiles.length > 0) {
-        console.error(
-          `Attached files: ${attachedFiles.map((f) => f.name).join(", ")}`
-        );
-      }
-      console.error("");
-    }
-    const hasApiKey = process.env.AI_GATEWAY_API_KEY;
-    if (!hasApiKey) {
-      console.error(`Error: Authentication required.
-
-Set up authentication with one of these options:
-
-  # Option 1: Export in current session
-  export AI_GATEWAY_API_KEY="your-key-here"
-  export AI_DEFAULT_MODEL="anthropic/claude-3-5-sonnet"
-
-  # Option 2: Add to shell profile (~/.bashrc, ~/.zshrc)
-  echo 'export AI_GATEWAY_API_KEY="your-key"' >> ~/.bashrc
-  
-Get your API key from the Vercel Dashboard (AI tab > API keys).
-Use --help for more details and examples.`);
-      process.exit(1);
-    }
-    const model = resolveModel(options.model);
-    let messages;
-    if (imageFiles.length > 0) {
-      const content = [{ type: "text", text: textPrompt }];
-      for (const img of imageFiles) {
-        content.push({
-          type: "image",
-          image: img.content
-        });
-      }
-      messages = [{ role: "user", content }];
-    }
-    const result = await streamText(
-      messages ? {
-        model,
-        messages,
-        system: options.system
-      } : {
-        model,
-        prompt: textPrompt,
-        system: options.system
-      }
-    );
-    for await (const chunk of result.textStream) {
-      process.stdout.write(chunk);
-    }
-    process.stdout.write("\n");
-    if (options.verbose) {
-      const usage = await result.usage;
-      if (usage) {
-        console.error(
-          `
-Usage: ${usage.inputTokens} prompt + ${usage.outputTokens} completion = ${usage.totalTokens} total tokens`
-        );
-      }
-    }
-  } catch (error) {
-    console.error(
-      `Error: ${error instanceof Error ? error.message : "Unknown error"}`
-    );
-    process.exit(1);
-  }
-}
-process.on("SIGINT", () => {
-  process.exit(0);
-});
-process.on("SIGTERM", () => {
-  process.exit(0);
-});
-main().catch((error) => {
-  console.error(
-    `Fatal error: ${error instanceof Error ? error.message : "Unknown error"}`
-  );
-  process.exit(1);
-});
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  formatAttachedFiles,
-  getMediaType,
-  isStdinAvailable,
-  main,
-  parseArgs,
-  readFileContent,
-  resolveModel,
-  showHelp,
-  showVersion
-});
-//# sourceMappingURL=ai.js.map