ai 5.0.0-beta.2 → 5.0.0-beta.20

package/dist/bin/ai.js

@@ -0,0 +1,4664 @@
+#!/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,
+  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_v4 = require("zod/v4");
+var uiMessageChunkSchema = import_v4.z.union([
+  import_v4.z.strictObject({
+    type: import_v4.z.literal("text-start"),
+    id: import_v4.z.string()
+  }),
+  import_v4.z.strictObject({
+    type: import_v4.z.literal("text-delta"),
+    id: import_v4.z.string(),
+    delta: import_v4.z.string()
+  }),
+  import_v4.z.strictObject({
+    type: import_v4.z.literal("text-end"),
+    id: import_v4.z.string()
+  }),
+  import_v4.z.strictObject({
+    type: import_v4.z.literal("error"),
+    errorText: import_v4.z.string()
+  }),
+  import_v4.z.strictObject({
+    type: import_v4.z.literal("tool-input-start"),
+    toolCallId: import_v4.z.string(),
+    toolName: import_v4.z.string(),
+    providerExecuted: import_v4.z.boolean().optional()
+  }),
+  import_v4.z.strictObject({
+    type: import_v4.z.literal("tool-input-delta"),
+    toolCallId: import_v4.z.string(),
+    inputTextDelta: import_v4.z.string()
+  }),
+  import_v4.z.strictObject({
+    type: import_v4.z.literal("tool-input-available"),
+    toolCallId: import_v4.z.string(),
+    toolName: import_v4.z.string(),
+    input: import_v4.z.unknown(),
+    providerExecuted: import_v4.z.boolean().optional()
+  }),
+  import_v4.z.strictObject({
+    type: import_v4.z.literal("tool-output-available"),
+    toolCallId: import_v4.z.string(),
+    output: import_v4.z.unknown(),
+    providerExecuted: import_v4.z.boolean().optional()
+  }),
+  import_v4.z.strictObject({
+    type: import_v4.z.literal("tool-output-error"),
+    toolCallId: import_v4.z.string(),
+    errorText: import_v4.z.string(),
+    providerExecuted: import_v4.z.boolean().optional()
+  }),
+  import_v4.z.strictObject({
+    type: import_v4.z.literal("reasoning"),
+    text: import_v4.z.string(),
+    providerMetadata: import_v4.z.record(import_v4.z.string(), import_v4.z.any()).optional()
+  }),
+  import_v4.z.strictObject({
+    type: import_v4.z.literal("reasoning-start"),
+    id: import_v4.z.string(),
+    providerMetadata: import_v4.z.record(import_v4.z.string(), import_v4.z.any()).optional()
+  }),
+  import_v4.z.strictObject({
+    type: import_v4.z.literal("reasoning-delta"),
+    id: import_v4.z.string(),
+    delta: import_v4.z.string(),
+    providerMetadata: import_v4.z.record(import_v4.z.string(), import_v4.z.any()).optional()
+  }),
+  import_v4.z.strictObject({
+    type: import_v4.z.literal("reasoning-end"),
+    id: import_v4.z.string(),
+    providerMetadata: import_v4.z.record(import_v4.z.string(), import_v4.z.any()).optional()
+  }),
+  import_v4.z.strictObject({
+    type: import_v4.z.literal("reasoning-part-finish")
+  }),
+  import_v4.z.strictObject({
+    type: import_v4.z.literal("source-url"),
+    sourceId: import_v4.z.string(),
+    url: import_v4.z.string(),
+    title: import_v4.z.string().optional(),
+    providerMetadata: import_v4.z.any().optional()
+    // Use z.any() for generic metadata
+  }),
+  import_v4.z.strictObject({
+    type: import_v4.z.literal("source-document"),
+    sourceId: import_v4.z.string(),
+    mediaType: import_v4.z.string(),
+    title: import_v4.z.string(),
+    filename: import_v4.z.string().optional(),
+    providerMetadata: import_v4.z.any().optional()
+    // Use z.any() for generic metadata
+  }),
+  import_v4.z.strictObject({
+    type: import_v4.z.literal("file"),
+    url: import_v4.z.string(),
+    mediaType: import_v4.z.string()
+  }),
+  import_v4.z.strictObject({
+    type: import_v4.z.string().startsWith("data-"),
+    id: import_v4.z.string().optional(),
+    data: import_v4.z.unknown(),
+    transient: import_v4.z.boolean().optional()
+  }),
+  import_v4.z.strictObject({
+    type: import_v4.z.literal("start-step")
+  }),
+  import_v4.z.strictObject({
+    type: import_v4.z.literal("finish-step")
+  }),
+  import_v4.z.strictObject({
+    type: import_v4.z.literal("start"),
+    messageId: import_v4.z.string().optional(),
+    messageMetadata: import_v4.z.unknown().optional()
+  }),
+  import_v4.z.strictObject({
+    type: import_v4.z.literal("finish"),
+    messageMetadata: import_v4.z.unknown().optional()
+  }),
+  import_v4.z.strictObject({
+    type: import_v4.z.literal("message-metadata"),
+    messageMetadata: import_v4.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("-")[1];
+}
+
+// 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(part, controller) {
+        await runUpdateMessageJob(async ({ state, write }) => {
+          var _a9, _b;
+          function updateToolInvocationPart(options) {
+            var _a10;
+            const part2 = state.message.parts.find(
+              (part3) => isToolUIPart(part3) && part3.toolCallId === options.toolCallId
+            );
+            const anyOptions = options;
+            const anyPart = part2;
+            if (part2 != null) {
+              part2.state = options.state;
+              anyPart.input = anyOptions.input;
+              anyPart.output = anyOptions.output;
+              anyPart.errorText = anyOptions.errorText;
+              anyPart.providerExecuted = (_a10 = anyOptions.providerExecuted) != null ? _a10 : part2.providerExecuted;
+            } 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
+              });
+            }
+          }
+          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 (part.type) {
+            case "text-start": {
+              const textPart = {
+                type: "text",
+                text: "",
+                state: "streaming"
+              };
+              state.activeTextParts[part.id] = textPart;
+              state.message.parts.push(textPart);
+              write();
+              break;
+            }
+            case "text-delta": {
+              state.activeTextParts[part.id].text += part.delta;
+              write();
+              break;
+            }
+            case "text-end": {
+              const textPart = state.activeTextParts[part.id];
+              textPart.state = "done";
+              delete state.activeTextParts[part.id];
+              write();
+              break;
+            }
+            case "reasoning-start": {
+              const reasoningPart = {
+                type: "reasoning",
+                text: "",
+                providerMetadata: part.providerMetadata,
+                state: "streaming"
+              };
+              state.activeReasoningParts[part.id] = reasoningPart;
+              state.message.parts.push(reasoningPart);
+              write();
+              break;
+            }
+            case "reasoning-delta": {
+              const reasoningPart = state.activeReasoningParts[part.id];
+              reasoningPart.text += part.delta;
+              reasoningPart.providerMetadata = (_a9 = part.providerMetadata) != null ? _a9 : reasoningPart.providerMetadata;
+              write();
+              break;
+            }
+            case "reasoning-end": {
+              const reasoningPart = state.activeReasoningParts[part.id];
+              reasoningPart.providerMetadata = (_b = part.providerMetadata) != null ? _b : reasoningPart.providerMetadata;
+              reasoningPart.state = "done";
+              delete state.activeReasoningParts[part.id];
+              write();
+              break;
+            }
+            case "file": {
+              state.message.parts.push({
+                type: "file",
+                mediaType: part.mediaType,
+                url: part.url
+              });
+              write();
+              break;
+            }
+            case "source-url": {
+              state.message.parts.push({
+                type: "source-url",
+                sourceId: part.sourceId,
+                url: part.url,
+                title: part.title,
+                providerMetadata: part.providerMetadata
+              });
+              write();
+              break;
+            }
+            case "source-document": {
+              state.message.parts.push({
+                type: "source-document",
+                sourceId: part.sourceId,
+                mediaType: part.mediaType,
+                title: part.title,
+                filename: part.filename,
+                providerMetadata: part.providerMetadata
+              });
+              write();
+              break;
+            }
+            case "tool-input-start": {
+              const toolInvocations = state.message.parts.filter(isToolUIPart);
+              state.partialToolCalls[part.toolCallId] = {
+                text: "",
+                toolName: part.toolName,
+                index: toolInvocations.length
+              };
+              updateToolInvocationPart({
+                toolCallId: part.toolCallId,
+                toolName: part.toolName,
+                state: "input-streaming",
+                input: void 0,
+                providerExecuted: part.providerExecuted
+              });
+              write();
+              break;
+            }
+            case "tool-input-delta": {
+              const partialToolCall = state.partialToolCalls[part.toolCallId];
+              partialToolCall.text += part.inputTextDelta;
+              const { value: partialArgs } = await parsePartialJson(
+                partialToolCall.text
+              );
+              updateToolInvocationPart({
+                toolCallId: part.toolCallId,
+                toolName: partialToolCall.toolName,
+                state: "input-streaming",
+                input: partialArgs
+              });
+              write();
+              break;
+            }
+            case "tool-input-available": {
+              updateToolInvocationPart({
+                toolCallId: part.toolCallId,
+                toolName: part.toolName,
+                state: "input-available",
+                input: part.input,
+                providerExecuted: part.providerExecuted
+              });
+              write();
+              if (onToolCall && !part.providerExecuted) {
+                const result = await onToolCall({
+                  toolCall: part
+                });
+                if (result != null) {
+                  updateToolInvocationPart({
+                    toolCallId: part.toolCallId,
+                    toolName: part.toolName,
+                    state: "output-available",
+                    input: part.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 === part.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: part.toolCallId,
+                toolName,
+                state: "output-available",
+                input: toolInvocations[toolInvocationIndex].input,
+                output: part.output,
+                providerExecuted: part.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 === part.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: part.toolCallId,
+                toolName,
+                state: "output-error",
+                input: toolInvocations[toolInvocationIndex].input,
+                errorText: part.errorText,
+                providerExecuted: part.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 (part.messageId != null) {
+                state.message.id = part.messageId;
+              }
+              await updateMessageMetadata(part.messageMetadata);
+              if (part.messageId != null || part.messageMetadata != null) {
+                write();
+              }
+              break;
+            }
+            case "finish": {
+              await updateMessageMetadata(part.messageMetadata);
+              if (part.messageMetadata != null) {
+                write();
+              }
+              break;
+            }
+            case "message-metadata": {
+              await updateMessageMetadata(part.messageMetadata);
+              if (part.messageMetadata != null) {
+                write();
+              }
+              break;
+            }
+            case "error": {
+              onError == null ? void 0 : onError(new Error(part.errorText));
+              break;
+            }
+            default: {
+              if (isDataUIMessageChunk(part)) {
+                const dataPart = part;
+                if (dataPart.transient) {
+                  onData == null ? void 0 : onData(dataPart);
+                  break;
+                }
+                const existingPart = dataPart.id != null ? state.message.parts.find(
+                  (partArg) => dataPart.type === partArg.type && dataPart.id === partArg.id
+                ) : void 0;
+                if (existingPart != null) {
+                  existingPart.data = isObject(existingPart.data) && isObject(dataPart.data) ? mergeObjects(existingPart.data, dataPart.data) : dataPart.data;
+                } else {
+                  state.message.parts.push(dataPart);
+                }
+                onData == null ? void 0 : onData(dataPart);
+                write();
+              }
+            }
+          }
+          controller.enqueue(part);
+        });
+      }
+    })
+  );
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null;
+}
+
+// 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;
+  }
+  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;
+          }
+        }
+        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);
+      },
+      flush() {
+        const isContinuation = state.message.id === (lastMessage == null ? void 0 : lastMessage.id);
+        onFinish({
+          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 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();
+      if (isClosed && innerStreamReaders.length === 0) {
+        controller == null ? void 0 : controller.close();
+      }
+    }
+  };
+  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: () => {
+      isClosed = true;
+      waitForNewStream.resolve();
+      innerStreamReaders.forEach((reader) => reader.cancel());
+      innerStreamReaders = [];
+      controller == null ? void 0 : controller.close();
+    }
+  };
+}
+
+// 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_v42 = 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_v42.z.union([
+  import_v42.z.string(),
+  import_v42.z.instanceof(Uint8Array),
+  import_v42.z.instanceof(ArrayBuffer),
+  import_v42.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/types/provider-metadata.ts
+var import_v44 = require("zod/v4");
+
+// src/types/json-value.ts
+var import_v43 = require("zod/v4");
+var jsonValueSchema = import_v43.z.lazy(
+  () => import_v43.z.union([
+    import_v43.z.null(),
+    import_v43.z.string(),
+    import_v43.z.number(),
+    import_v43.z.boolean(),
+    import_v43.z.record(import_v43.z.string(), jsonValueSchema),
+    import_v43.z.array(jsonValueSchema)
+  ])
+);
+
+// src/types/provider-metadata.ts
+var providerMetadataSchema = import_v44.z.record(
+  import_v44.z.string(),
+  import_v44.z.record(import_v44.z.string(), jsonValueSchema)
+);
+
+// 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/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 part;
+      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,
+  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,
+    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,
+    onStepFinish
+  }) {
+    this._totalUsage = new DelayedPromise();
+    this._finishReason = new DelayedPromise();
+    this._steps = new DelayedPromise();
+    this.output = output;
+    this.includeRawChunks = includeRawChunks;
+    this.generateId = generateId2;
+    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;
+        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 = part.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 = (_a9 = part.providerMetadata) != null ? _a9 : 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 = (_b = part.providerMetadata) != null ? _b : 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 = 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 = getResponseUIMessageId({
+      originalMessages,
+      responseMessageId: this.generateId
+    });
+    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 });
+              break;
+            }
+            case "text": {
+              controller.enqueue({
+                type: "text-delta",
+                id: part.id,
+                delta: part.text
+              });
+              break;
+            }
+            case "text-end": {
+              controller.enqueue({ type: "text-end", id: part.id });
+              break;
+            }
+            case "reasoning-start": {
+              controller.enqueue({
+                type: "reasoning-start",
+                id: part.id,
+                providerMetadata: part.providerMetadata
+              });
+              break;
+            }
+            case "reasoning": {
+              if (sendReasoning) {
+                controller.enqueue({
+                  type: "reasoning-delta",
+                  id: part.id,
+                  delta: part.text,
+                  providerMetadata: part.providerMetadata
+                });
+              }
+              break;
+            }
+            case "reasoning-end": {
+              controller.enqueue({
+                type: "reasoning-end",
+                id: part.id,
+                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,
+                  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,
+                  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
+              });
+              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",
+                  messageId: responseMessageId,
+                  messageMetadata: messageMetadataValue
+                });
+              }
+              break;
+            }
+            case "finish": {
+              if (sendFinish) {
+                controller.enqueue({
+                  type: "finish",
+                  messageMetadata: messageMetadataValue
+                });
+              }
+              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 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_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
+
+Arguments:
+  prompt                   The prompt to send to the AI model (optional if using stdin)
+
+Options:
+  -m, --model <model>      Model to use. Format: provider/model or just model name.
+                           Examples: openai/gpt-4o, anthropic/claude-3-5-sonnet-20241022
+                           (default: "openai/gpt-4")
+  -f, --file <file>        Attach a file to the prompt (can be used multiple times)
+  -s, --system <message>   System message to set context
+  -v, --verbose            Show detailed information (model, usage, etc.)
+  -h, --help               Display help for command
+  -V, --version            Output the version number
+
+Environment Variables:
+  - AI_MODEL: Default model to use
+  - AI_SYSTEM: Default system message  
+  - AI_VERBOSE: Set to 'true' to enable verbose output
+
+Authentication (choose one):
+  - VERCEL_OIDC_TOKEN: Vercel OIDC token (for Vercel projects)
+  - AI_GATEWAY_API_KEY: AI Gateway API key
+
+Setting Environment Variables:
+  # Option 1: Export in current session
+  export AI_GATEWAY_API_KEY="your-key-here"
+  export AI_MODEL="anthropic/claude-3-5-sonnet-20241022"
+
+  # Option 2: Inline for single command
+  AI_GATEWAY_API_KEY="your-key" ai "Hello world"
+
+  # Option 3: Add to shell profile (~/.bashrc, ~/.zshrc)
+  echo 'export AI_GATEWAY_API_KEY="your-key"' >> ~/.bashrc
+
+Examples:
+  npx ai "Hello, world!"
+  npx ai "Write a poem" -m anthropic/claude-3-5-sonnet-20241022
+  npx ai "Explain quantum physics" -m groq/llama-3.1-8b-instant
+  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?"
+
+Authentication Setup:
+  This CLI uses the Vercel AI Gateway. You need ONE of these for authentication:
+
+  OIDC Token (for Vercel projects):
+  - Automatically available in Vercel deployments  
+  - For local development: run 'vercel env pull' or use 'vercel dev'
+  
+  API Key (for any environment):
+  - Get your key from the AI Gateway dashboard
+  - Set: export AI_GATEWAY_API_KEY="your-key-here"
+  
+  The gateway supports OpenAI, Anthropic, Google, Groq, and more providers.`);
+}
+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 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,
+  parseArgs,
+  readFileContent,
+  resolveModel,
+  showHelp,
+  showVersion
+});
+//# sourceMappingURL=ai.js.map