@mastra/rag 0.1.19-alpha.2 → 0.1.19-alpha.4

package/dist/index.js

@@ -1,12 +1,3978 @@
-import { Document, SummaryExtractor, QuestionsAnsweredExtractor, KeywordExtractor, TitleExtractor, ObjectType, NodeRelationship, IngestionPipeline } from 'llamaindex';
+import { Document, ObjectType, NodeRelationship, IngestionPipeline, BaseExtractor, PromptTemplate, defaultSummaryPrompt, TextNode, defaultQuestionExtractPrompt, defaultKeywordExtractPrompt, MetadataMode, defaultTitleExtractorPromptTemplate, defaultTitleCombinePromptTemplate } from 'llamaindex';
+import { z } from 'zod';
 import { parse } from 'node-html-better-parser';
 import { encodingForModel, getEncoding } from 'js-tiktoken';
 import { CohereRelevanceScorer, MastraAgentRelevanceScorer } from '@mastra/core/relevance';
 import { createTool } from '@mastra/core/tools';
-import { z } from 'zod';
 import { embed } from 'ai';
 
-// src/document/document.ts
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  __defProp(target, "default", { value: mod, enumerable: true }) ,
+  mod
+));
+
+// ../../node_modules/.pnpm/secure-json-parse@2.7.0/node_modules/secure-json-parse/index.js
+var require_secure_json_parse = __commonJS({
+  "../../node_modules/.pnpm/secure-json-parse@2.7.0/node_modules/secure-json-parse/index.js"(exports, module) {
+    var hasBuffer = typeof Buffer !== "undefined";
+    var suspectProtoRx = /"(?:_|\\u005[Ff])(?:_|\\u005[Ff])(?:p|\\u0070)(?:r|\\u0072)(?:o|\\u006[Ff])(?:t|\\u0074)(?:o|\\u006[Ff])(?:_|\\u005[Ff])(?:_|\\u005[Ff])"\s*:/;
+    var suspectConstructorRx = /"(?:c|\\u0063)(?:o|\\u006[Ff])(?:n|\\u006[Ee])(?:s|\\u0073)(?:t|\\u0074)(?:r|\\u0072)(?:u|\\u0075)(?:c|\\u0063)(?:t|\\u0074)(?:o|\\u006[Ff])(?:r|\\u0072)"\s*:/;
+    function _parse(text, reviver, options) {
+      if (options == null) {
+        if (reviver !== null && typeof reviver === "object") {
+          options = reviver;
+          reviver = void 0;
+        }
+      }
+      if (hasBuffer && Buffer.isBuffer(text)) {
+        text = text.toString();
+      }
+      if (text && text.charCodeAt(0) === 65279) {
+        text = text.slice(1);
+      }
+      const obj = JSON.parse(text, reviver);
+      if (obj === null || typeof obj !== "object") {
+        return obj;
+      }
+      const protoAction = options && options.protoAction || "error";
+      const constructorAction = options && options.constructorAction || "error";
+      if (protoAction === "ignore" && constructorAction === "ignore") {
+        return obj;
+      }
+      if (protoAction !== "ignore" && constructorAction !== "ignore") {
+        if (suspectProtoRx.test(text) === false && suspectConstructorRx.test(text) === false) {
+          return obj;
+        }
+      } else if (protoAction !== "ignore" && constructorAction === "ignore") {
+        if (suspectProtoRx.test(text) === false) {
+          return obj;
+        }
+      } else {
+        if (suspectConstructorRx.test(text) === false) {
+          return obj;
+        }
+      }
+      return filter(obj, { protoAction, constructorAction, safe: options && options.safe });
+    }
+    function filter(obj, { protoAction = "error", constructorAction = "error", safe } = {}) {
+      let next = [obj];
+      while (next.length) {
+        const nodes = next;
+        next = [];
+        for (const node of nodes) {
+          if (protoAction !== "ignore" && Object.prototype.hasOwnProperty.call(node, "__proto__")) {
+            if (safe === true) {
+              return null;
+            } else if (protoAction === "error") {
+              throw new SyntaxError("Object contains forbidden prototype property");
+            }
+            delete node.__proto__;
+          }
+          if (constructorAction !== "ignore" && Object.prototype.hasOwnProperty.call(node, "constructor") && Object.prototype.hasOwnProperty.call(node.constructor, "prototype")) {
+            if (safe === true) {
+              return null;
+            } else if (constructorAction === "error") {
+              throw new SyntaxError("Object contains forbidden prototype property");
+            }
+            delete node.constructor;
+          }
+          for (const key in node) {
+            const value = node[key];
+            if (value && typeof value === "object") {
+              next.push(value);
+            }
+          }
+        }
+      }
+      return obj;
+    }
+    function parse2(text, reviver, options) {
+      const stackTraceLimit = Error.stackTraceLimit;
+      Error.stackTraceLimit = 0;
+      try {
+        return _parse(text, reviver, options);
+      } finally {
+        Error.stackTraceLimit = stackTraceLimit;
+      }
+    }
+    function safeParse(text, reviver) {
+      const stackTraceLimit = Error.stackTraceLimit;
+      Error.stackTraceLimit = 0;
+      try {
+        return _parse(text, reviver, { safe: true });
+      } catch (_e) {
+        return null;
+      } finally {
+        Error.stackTraceLimit = stackTraceLimit;
+      }
+    }
+    module.exports = parse2;
+    module.exports.default = parse2;
+    module.exports.parse = parse2;
+    module.exports.safeParse = safeParse;
+    module.exports.scan = filter;
+  }
+});
+
+// ../../node_modules/.pnpm/@ai-sdk+provider@1.1.2/node_modules/@ai-sdk/provider/dist/index.mjs
+var marker = "vercel.ai.error";
+var symbol = Symbol.for(marker);
+var _a;
+var _AISDKError = class _AISDKError2 extends Error {
+  /**
+   * Creates an AI SDK Error.
+   *
+   * @param {Object} params - The parameters for creating the error.
+   * @param {string} params.name - The name of the error.
+   * @param {string} params.message - The error message.
+   * @param {unknown} [params.cause] - The underlying cause of the error.
+   */
+  constructor({
+    name: name14,
+    message,
+    cause
+  }) {
+    super(message);
+    this[_a] = true;
+    this.name = name14;
+    this.cause = cause;
+  }
+  /**
+   * Checks if the given error is an AI SDK Error.
+   * @param {unknown} error - The error to check.
+   * @returns {boolean} True if the error is an AI SDK Error, false otherwise.
+   */
+  static isInstance(error) {
+    return _AISDKError2.hasMarker(error, marker);
+  }
+  static hasMarker(error, marker15) {
+    const markerSymbol = Symbol.for(marker15);
+    return error != null && typeof error === "object" && markerSymbol in error && typeof error[markerSymbol] === "boolean" && error[markerSymbol] === true;
+  }
+};
+_a = symbol;
+var AISDKError = _AISDKError;
+var name = "AI_APICallError";
+var marker2 = `vercel.ai.error.${name}`;
+var symbol2 = Symbol.for(marker2);
+var _a2;
+var APICallError = class extends AISDKError {
+  constructor({
+    message,
+    url,
+    requestBodyValues,
+    statusCode,
+    responseHeaders,
+    responseBody,
+    cause,
+    isRetryable = statusCode != null && (statusCode === 408 || // request timeout
+    statusCode === 409 || // conflict
+    statusCode === 429 || // too many requests
+    statusCode >= 500),
+    // server error
+    data
+  }) {
+    super({ name, message, cause });
+    this[_a2] = true;
+    this.url = url;
+    this.requestBodyValues = requestBodyValues;
+    this.statusCode = statusCode;
+    this.responseHeaders = responseHeaders;
+    this.responseBody = responseBody;
+    this.isRetryable = isRetryable;
+    this.data = data;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker2);
+  }
+};
+_a2 = symbol2;
+var name2 = "AI_EmptyResponseBodyError";
+var marker3 = `vercel.ai.error.${name2}`;
+var symbol3 = Symbol.for(marker3);
+var _a3;
+var EmptyResponseBodyError = class extends AISDKError {
+  // used in isInstance
+  constructor({ message = "Empty response body" } = {}) {
+    super({ name: name2, message });
+    this[_a3] = true;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker3);
+  }
+};
+_a3 = symbol3;
+function getErrorMessage(error) {
+  if (error == null) {
+    return "unknown error";
+  }
+  if (typeof error === "string") {
+    return error;
+  }
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return JSON.stringify(error);
+}
+var name3 = "AI_InvalidArgumentError";
+var marker4 = `vercel.ai.error.${name3}`;
+var symbol4 = Symbol.for(marker4);
+var _a4;
+var InvalidArgumentError = class extends AISDKError {
+  constructor({
+    message,
+    cause,
+    argument
+  }) {
+    super({ name: name3, message, cause });
+    this[_a4] = true;
+    this.argument = argument;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker4);
+  }
+};
+_a4 = symbol4;
+var name4 = "AI_InvalidPromptError";
+var marker5 = `vercel.ai.error.${name4}`;
+var symbol5 = Symbol.for(marker5);
+var _a5;
+var InvalidPromptError = class extends AISDKError {
+  constructor({
+    prompt,
+    message,
+    cause
+  }) {
+    super({ name: name4, message: `Invalid prompt: ${message}`, cause });
+    this[_a5] = true;
+    this.prompt = prompt;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker5);
+  }
+};
+_a5 = symbol5;
+var name5 = "AI_InvalidResponseDataError";
+var marker6 = `vercel.ai.error.${name5}`;
+var symbol6 = Symbol.for(marker6);
+var _a6;
+var InvalidResponseDataError = class extends AISDKError {
+  constructor({
+    data,
+    message = `Invalid response data: ${JSON.stringify(data)}.`
+  }) {
+    super({ name: name5, message });
+    this[_a6] = true;
+    this.data = data;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker6);
+  }
+};
+_a6 = symbol6;
+var name6 = "AI_JSONParseError";
+var marker7 = `vercel.ai.error.${name6}`;
+var symbol7 = Symbol.for(marker7);
+var _a7;
+var JSONParseError = class extends AISDKError {
+  constructor({ text, cause }) {
+    super({
+      name: name6,
+      message: `JSON parsing failed: Text: ${text}.
+Error message: ${getErrorMessage(cause)}`,
+      cause
+    });
+    this[_a7] = true;
+    this.text = text;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker7);
+  }
+};
+_a7 = symbol7;
+var name7 = "AI_LoadAPIKeyError";
+var marker8 = `vercel.ai.error.${name7}`;
+var symbol8 = Symbol.for(marker8);
+var _a8;
+var LoadAPIKeyError = class extends AISDKError {
+  // used in isInstance
+  constructor({ message }) {
+    super({ name: name7, message });
+    this[_a8] = true;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker8);
+  }
+};
+_a8 = symbol8;
+var name11 = "AI_TooManyEmbeddingValuesForCallError";
+var marker12 = `vercel.ai.error.${name11}`;
+var symbol12 = Symbol.for(marker12);
+var _a12;
+var TooManyEmbeddingValuesForCallError = class extends AISDKError {
+  constructor(options) {
+    super({
+      name: name11,
+      message: `Too many values for a single embedding call. The ${options.provider} model "${options.modelId}" can only embed up to ${options.maxEmbeddingsPerCall} values per call, but ${options.values.length} values were provided.`
+    });
+    this[_a12] = true;
+    this.provider = options.provider;
+    this.modelId = options.modelId;
+    this.maxEmbeddingsPerCall = options.maxEmbeddingsPerCall;
+    this.values = options.values;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker12);
+  }
+};
+_a12 = symbol12;
+var name12 = "AI_TypeValidationError";
+var marker13 = `vercel.ai.error.${name12}`;
+var symbol13 = Symbol.for(marker13);
+var _a13;
+var _TypeValidationError = class _TypeValidationError2 extends AISDKError {
+  constructor({ value, cause }) {
+    super({
+      name: name12,
+      message: `Type validation failed: Value: ${JSON.stringify(value)}.
+Error message: ${getErrorMessage(cause)}`,
+      cause
+    });
+    this[_a13] = true;
+    this.value = value;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker13);
+  }
+  /**
+   * Wraps an error into a TypeValidationError.
+   * If the cause is already a TypeValidationError with the same value, it returns the cause.
+   * Otherwise, it creates a new TypeValidationError.
+   *
+   * @param {Object} params - The parameters for wrapping the error.
+   * @param {unknown} params.value - The value that failed validation.
+   * @param {unknown} params.cause - The original error or cause of the validation failure.
+   * @returns {TypeValidationError} A TypeValidationError instance.
+   */
+  static wrap({
+    value,
+    cause
+  }) {
+    return _TypeValidationError2.isInstance(cause) && cause.value === value ? cause : new _TypeValidationError2({ value, cause });
+  }
+};
+_a13 = symbol13;
+var TypeValidationError = _TypeValidationError;
+var name13 = "AI_UnsupportedFunctionalityError";
+var marker14 = `vercel.ai.error.${name13}`;
+var symbol14 = Symbol.for(marker14);
+var _a14;
+var UnsupportedFunctionalityError = class extends AISDKError {
+  constructor({
+    functionality,
+    message = `'${functionality}' functionality not supported.`
+  }) {
+    super({ name: name13, message });
+    this[_a14] = true;
+    this.functionality = functionality;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker14);
+  }
+};
+_a14 = symbol14;
+
+// ../../node_modules/.pnpm/nanoid@3.3.11/node_modules/nanoid/non-secure/index.js
+var customAlphabet = (alphabet, defaultSize = 21) => {
+  return (size = defaultSize) => {
+    let id = "";
+    let i = size | 0;
+    while (i--) {
+      id += alphabet[Math.random() * alphabet.length | 0];
+    }
+    return id;
+  };
+};
+
+// ../../node_modules/.pnpm/@ai-sdk+provider-utils@2.2.6_zod@3.24.2/node_modules/@ai-sdk/provider-utils/dist/index.mjs
+var import_secure_json_parse = __toESM(require_secure_json_parse());
+function combineHeaders(...headers) {
+  return headers.reduce(
+    (combinedHeaders, currentHeaders) => ({
+      ...combinedHeaders,
+      ...currentHeaders != null ? currentHeaders : {}
+    }),
+    {}
+  );
+}
+function createEventSourceParserStream() {
+  let buffer = "";
+  let event = void 0;
+  let data = [];
+  let lastEventId = void 0;
+  let retry = void 0;
+  function parseLine(line, controller) {
+    if (line === "") {
+      dispatchEvent(controller);
+      return;
+    }
+    if (line.startsWith(":")) {
+      return;
+    }
+    const colonIndex = line.indexOf(":");
+    if (colonIndex === -1) {
+      handleField(line, "");
+      return;
+    }
+    const field = line.slice(0, colonIndex);
+    const valueStart = colonIndex + 1;
+    const value = valueStart < line.length && line[valueStart] === " " ? line.slice(valueStart + 1) : line.slice(valueStart);
+    handleField(field, value);
+  }
+  function dispatchEvent(controller) {
+    if (data.length > 0) {
+      controller.enqueue({
+        event,
+        data: data.join("\n"),
+        id: lastEventId,
+        retry
+      });
+      data = [];
+      event = void 0;
+      retry = void 0;
+    }
+  }
+  function handleField(field, value) {
+    switch (field) {
+      case "event":
+        event = value;
+        break;
+      case "data":
+        data.push(value);
+        break;
+      case "id":
+        lastEventId = value;
+        break;
+      case "retry":
+        const parsedRetry = parseInt(value, 10);
+        if (!isNaN(parsedRetry)) {
+          retry = parsedRetry;
+        }
+        break;
+    }
+  }
+  return new TransformStream({
+    transform(chunk, controller) {
+      const { lines, incompleteLine } = splitLines(buffer, chunk);
+      buffer = incompleteLine;
+      for (let i = 0; i < lines.length; i++) {
+        parseLine(lines[i], controller);
+      }
+    },
+    flush(controller) {
+      parseLine(buffer, controller);
+      dispatchEvent(controller);
+    }
+  });
+}
+function splitLines(buffer, chunk) {
+  const lines = [];
+  let currentLine = buffer;
+  for (let i = 0; i < chunk.length; ) {
+    const char = chunk[i++];
+    if (char === "\n") {
+      lines.push(currentLine);
+      currentLine = "";
+    } else if (char === "\r") {
+      lines.push(currentLine);
+      currentLine = "";
+      if (chunk[i + 1] === "\n") {
+        i++;
+      }
+    } else {
+      currentLine += char;
+    }
+  }
+  return { lines, incompleteLine: currentLine };
+}
+function extractResponseHeaders(response) {
+  const headers = {};
+  response.headers.forEach((value, key) => {
+    headers[key] = value;
+  });
+  return headers;
+}
+var createIdGenerator = ({
+  prefix,
+  size: defaultSize = 16,
+  alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
+  separator = "-"
+} = {}) => {
+  const generator = customAlphabet(alphabet, defaultSize);
+  if (prefix == null) {
+    return generator;
+  }
+  if (alphabet.includes(separator)) {
+    throw new InvalidArgumentError({
+      argument: "separator",
+      message: `The separator "${separator}" must not be part of the alphabet "${alphabet}".`
+    });
+  }
+  return (size) => `${prefix}${separator}${generator(size)}`;
+};
+var generateId = createIdGenerator();
+function removeUndefinedEntries(record) {
+  return Object.fromEntries(
+    Object.entries(record).filter(([_key, value]) => value != null)
+  );
+}
+function isAbortError(error) {
+  return error instanceof Error && (error.name === "AbortError" || error.name === "TimeoutError");
+}
+function loadApiKey({
+  apiKey,
+  environmentVariableName,
+  apiKeyParameterName = "apiKey",
+  description
+}) {
+  if (typeof apiKey === "string") {
+    return apiKey;
+  }
+  if (apiKey != null) {
+    throw new LoadAPIKeyError({
+      message: `${description} API key must be a string.`
+    });
+  }
+  if (typeof process === "undefined") {
+    throw new LoadAPIKeyError({
+      message: `${description} API key is missing. Pass it using the '${apiKeyParameterName}' parameter. Environment variables is not supported in this environment.`
+    });
+  }
+  apiKey = process.env[environmentVariableName];
+  if (apiKey == null) {
+    throw new LoadAPIKeyError({
+      message: `${description} API key is missing. Pass it using the '${apiKeyParameterName}' parameter or the ${environmentVariableName} environment variable.`
+    });
+  }
+  if (typeof apiKey !== "string") {
+    throw new LoadAPIKeyError({
+      message: `${description} API key must be a string. The value of the ${environmentVariableName} environment variable is not a string.`
+    });
+  }
+  return apiKey;
+}
+var validatorSymbol = Symbol.for("vercel.ai.validator");
+function validator(validate) {
+  return { [validatorSymbol]: true, validate };
+}
+function isValidator(value) {
+  return typeof value === "object" && value !== null && validatorSymbol in value && value[validatorSymbol] === true && "validate" in value;
+}
+function asValidator(value) {
+  return isValidator(value) ? value : zodValidator(value);
+}
+function zodValidator(zodSchema) {
+  return validator((value) => {
+    const result = zodSchema.safeParse(value);
+    return result.success ? { success: true, value: result.data } : { success: false, error: result.error };
+  });
+}
+function validateTypes({
+  value,
+  schema: inputSchema
+}) {
+  const result = safeValidateTypes({ value, schema: inputSchema });
+  if (!result.success) {
+    throw TypeValidationError.wrap({ value, cause: result.error });
+  }
+  return result.value;
+}
+function safeValidateTypes({
+  value,
+  schema
+}) {
+  const validator2 = asValidator(schema);
+  try {
+    if (validator2.validate == null) {
+      return { success: true, value };
+    }
+    const result = validator2.validate(value);
+    if (result.success) {
+      return result;
+    }
+    return {
+      success: false,
+      error: TypeValidationError.wrap({ value, cause: result.error })
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: TypeValidationError.wrap({ value, cause: error })
+    };
+  }
+}
+function parseJSON({
+  text,
+  schema
+}) {
+  try {
+    const value = import_secure_json_parse.default.parse(text);
+    if (schema == null) {
+      return value;
+    }
+    return validateTypes({ value, schema });
+  } catch (error) {
+    if (JSONParseError.isInstance(error) || TypeValidationError.isInstance(error)) {
+      throw error;
+    }
+    throw new JSONParseError({ text, cause: error });
+  }
+}
+function safeParseJSON({
+  text,
+  schema
+}) {
+  try {
+    const value = import_secure_json_parse.default.parse(text);
+    if (schema == null) {
+      return { success: true, value, rawValue: value };
+    }
+    const validationResult = safeValidateTypes({ value, schema });
+    return validationResult.success ? { ...validationResult, rawValue: value } : validationResult;
+  } catch (error) {
+    return {
+      success: false,
+      error: JSONParseError.isInstance(error) ? error : new JSONParseError({ text, cause: error })
+    };
+  }
+}
+function isParsableJson(input) {
+  try {
+    import_secure_json_parse.default.parse(input);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+function parseProviderOptions({
+  provider,
+  providerOptions,
+  schema
+}) {
+  if ((providerOptions == null ? void 0 : providerOptions[provider]) == null) {
+    return void 0;
+  }
+  const parsedProviderOptions = safeValidateTypes({
+    value: providerOptions[provider],
+    schema
+  });
+  if (!parsedProviderOptions.success) {
+    throw new InvalidArgumentError({
+      argument: "providerOptions",
+      message: `invalid ${provider} provider options`,
+      cause: parsedProviderOptions.error
+    });
+  }
+  return parsedProviderOptions.value;
+}
+var getOriginalFetch2 = () => globalThis.fetch;
+var postJsonToApi = async ({
+  url,
+  headers,
+  body,
+  failedResponseHandler,
+  successfulResponseHandler,
+  abortSignal,
+  fetch
+}) => postToApi({
+  url,
+  headers: {
+    "Content-Type": "application/json",
+    ...headers
+  },
+  body: {
+    content: JSON.stringify(body),
+    values: body
+  },
+  failedResponseHandler,
+  successfulResponseHandler,
+  abortSignal,
+  fetch
+});
+var postFormDataToApi = async ({
+  url,
+  headers,
+  formData,
+  failedResponseHandler,
+  successfulResponseHandler,
+  abortSignal,
+  fetch
+}) => postToApi({
+  url,
+  headers,
+  body: {
+    content: formData,
+    values: Object.fromEntries(formData.entries())
+  },
+  failedResponseHandler,
+  successfulResponseHandler,
+  abortSignal,
+  fetch
+});
+var postToApi = async ({
+  url,
+  headers = {},
+  body,
+  successfulResponseHandler,
+  failedResponseHandler,
+  abortSignal,
+  fetch = getOriginalFetch2()
+}) => {
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: removeUndefinedEntries(headers),
+      body: body.content,
+      signal: abortSignal
+    });
+    const responseHeaders = extractResponseHeaders(response);
+    if (!response.ok) {
+      let errorInformation;
+      try {
+        errorInformation = await failedResponseHandler({
+          response,
+          url,
+          requestBodyValues: body.values
+        });
+      } catch (error) {
+        if (isAbortError(error) || APICallError.isInstance(error)) {
+          throw error;
+        }
+        throw new APICallError({
+          message: "Failed to process error response",
+          cause: error,
+          statusCode: response.status,
+          url,
+          responseHeaders,
+          requestBodyValues: body.values
+        });
+      }
+      throw errorInformation.value;
+    }
+    try {
+      return await successfulResponseHandler({
+        response,
+        url,
+        requestBodyValues: body.values
+      });
+    } catch (error) {
+      if (error instanceof Error) {
+        if (isAbortError(error) || APICallError.isInstance(error)) {
+          throw error;
+        }
+      }
+      throw new APICallError({
+        message: "Failed to process successful response",
+        cause: error,
+        statusCode: response.status,
+        url,
+        responseHeaders,
+        requestBodyValues: body.values
+      });
+    }
+  } catch (error) {
+    if (isAbortError(error)) {
+      throw error;
+    }
+    if (error instanceof TypeError && error.message === "fetch failed") {
+      const cause = error.cause;
+      if (cause != null) {
+        throw new APICallError({
+          message: `Cannot connect to API: ${cause.message}`,
+          cause,
+          url,
+          requestBodyValues: body.values,
+          isRetryable: true
+          // retry when network error
+        });
+      }
+    }
+    throw error;
+  }
+};
+var createJsonErrorResponseHandler = ({
+  errorSchema,
+  errorToMessage,
+  isRetryable
+}) => async ({ response, url, requestBodyValues }) => {
+  const responseBody = await response.text();
+  const responseHeaders = extractResponseHeaders(response);
+  if (responseBody.trim() === "") {
+    return {
+      responseHeaders,
+      value: new APICallError({
+        message: response.statusText,
+        url,
+        requestBodyValues,
+        statusCode: response.status,
+        responseHeaders,
+        responseBody,
+        isRetryable: isRetryable == null ? void 0 : isRetryable(response)
+      })
+    };
+  }
+  try {
+    const parsedError = parseJSON({
+      text: responseBody,
+      schema: errorSchema
+    });
+    return {
+      responseHeaders,
+      value: new APICallError({
+        message: errorToMessage(parsedError),
+        url,
+        requestBodyValues,
+        statusCode: response.status,
+        responseHeaders,
+        responseBody,
+        data: parsedError,
+        isRetryable: isRetryable == null ? void 0 : isRetryable(response, parsedError)
+      })
+    };
+  } catch (parseError) {
+    return {
+      responseHeaders,
+      value: new APICallError({
+        message: response.statusText,
+        url,
+        requestBodyValues,
+        statusCode: response.status,
+        responseHeaders,
+        responseBody,
+        isRetryable: isRetryable == null ? void 0 : isRetryable(response)
+      })
+    };
+  }
+};
+var createEventSourceResponseHandler = (chunkSchema) => async ({ response }) => {
+  const responseHeaders = extractResponseHeaders(response);
+  if (response.body == null) {
+    throw new EmptyResponseBodyError({});
+  }
+  return {
+    responseHeaders,
+    value: response.body.pipeThrough(new TextDecoderStream()).pipeThrough(createEventSourceParserStream()).pipeThrough(
+      new TransformStream({
+        transform({ data }, controller) {
+          if (data === "[DONE]") {
+            return;
+          }
+          controller.enqueue(
+            safeParseJSON({
+              text: data,
+              schema: chunkSchema
+            })
+          );
+        }
+      })
+    )
+  };
+};
+var createJsonResponseHandler = (responseSchema) => async ({ response, url, requestBodyValues }) => {
+  const responseBody = await response.text();
+  const parsedResult = safeParseJSON({
+    text: responseBody,
+    schema: responseSchema
+  });
+  const responseHeaders = extractResponseHeaders(response);
+  if (!parsedResult.success) {
+    throw new APICallError({
+      message: "Invalid JSON response",
+      cause: parsedResult.error,
+      statusCode: response.status,
+      responseHeaders,
+      responseBody,
+      url,
+      requestBodyValues
+    });
+  }
+  return {
+    responseHeaders,
+    value: parsedResult.value,
+    rawValue: parsedResult.rawValue
+  };
+};
+var { btoa, atob } = globalThis;
+function convertBase64ToUint8Array(base64String) {
+  const base64Url = base64String.replace(/-/g, "+").replace(/_/g, "/");
+  const latin1string = atob(base64Url);
+  return Uint8Array.from(latin1string, (byte) => byte.codePointAt(0));
+}
+function convertUint8ArrayToBase64(array) {
+  let latin1string = "";
+  for (let i = 0; i < array.length; i++) {
+    latin1string += String.fromCodePoint(array[i]);
+  }
+  return btoa(latin1string);
+}
+function withoutTrailingSlash(url) {
+  return url == null ? void 0 : url.replace(/\/$/, "");
+}
+function convertToOpenAIChatMessages({
+  prompt,
+  useLegacyFunctionCalling = false,
+  systemMessageMode = "system"
+}) {
+  const messages = [];
+  const warnings = [];
+  for (const { role, content } of prompt) {
+    switch (role) {
+      case "system": {
+        switch (systemMessageMode) {
+          case "system": {
+            messages.push({ role: "system", content });
+            break;
+          }
+          case "developer": {
+            messages.push({ role: "developer", content });
+            break;
+          }
+          case "remove": {
+            warnings.push({
+              type: "other",
+              message: "system messages are removed for this model"
+            });
+            break;
+          }
+          default: {
+            const _exhaustiveCheck = systemMessageMode;
+            throw new Error(
+              `Unsupported system message mode: ${_exhaustiveCheck}`
+            );
+          }
+        }
+        break;
+      }
+      case "user": {
+        if (content.length === 1 && content[0].type === "text") {
+          messages.push({ role: "user", content: content[0].text });
+          break;
+        }
+        messages.push({
+          role: "user",
+          content: content.map((part, index) => {
+            var _a15, _b, _c, _d;
+            switch (part.type) {
+              case "text": {
+                return { type: "text", text: part.text };
+              }
+              case "image": {
+                return {
+                  type: "image_url",
+                  image_url: {
+                    url: part.image instanceof URL ? part.image.toString() : `data:${(_a15 = part.mimeType) != null ? _a15 : "image/jpeg"};base64,${convertUint8ArrayToBase64(part.image)}`,
+                    // OpenAI specific extension: image detail
+                    detail: (_c = (_b = part.providerMetadata) == null ? void 0 : _b.openai) == null ? void 0 : _c.imageDetail
+                  }
+                };
+              }
+              case "file": {
+                if (part.data instanceof URL) {
+                  throw new UnsupportedFunctionalityError({
+                    functionality: "'File content parts with URL data' functionality not supported."
+                  });
+                }
+                switch (part.mimeType) {
+                  case "audio/wav": {
+                    return {
+                      type: "input_audio",
+                      input_audio: { data: part.data, format: "wav" }
+                    };
+                  }
+                  case "audio/mp3":
+                  case "audio/mpeg": {
+                    return {
+                      type: "input_audio",
+                      input_audio: { data: part.data, format: "mp3" }
+                    };
+                  }
+                  case "application/pdf": {
+                    return {
+                      type: "file",
+                      file: {
+                        filename: (_d = part.filename) != null ? _d : `part-${index}.pdf`,
+                        file_data: `data:application/pdf;base64,${part.data}`
+                      }
+                    };
+                  }
+                  default: {
+                    throw new UnsupportedFunctionalityError({
+                      functionality: `File content part type ${part.mimeType} in user messages`
+                    });
+                  }
+                }
+              }
+            }
+          })
+        });
+        break;
+      }
+      case "assistant": {
+        let text = "";
+        const toolCalls = [];
+        for (const part of content) {
+          switch (part.type) {
+            case "text": {
+              text += part.text;
+              break;
+            }
+            case "tool-call": {
+              toolCalls.push({
+                id: part.toolCallId,
+                type: "function",
+                function: {
+                  name: part.toolName,
+                  arguments: JSON.stringify(part.args)
+                }
+              });
+              break;
+            }
+          }
+        }
+        if (useLegacyFunctionCalling) {
+          if (toolCalls.length > 1) {
+            throw new UnsupportedFunctionalityError({
+              functionality: "useLegacyFunctionCalling with multiple tool calls in one message"
+            });
+          }
+          messages.push({
+            role: "assistant",
+            content: text,
+            function_call: toolCalls.length > 0 ? toolCalls[0].function : void 0
+          });
+        } else {
+          messages.push({
+            role: "assistant",
+            content: text,
+            tool_calls: toolCalls.length > 0 ? toolCalls : void 0
+          });
+        }
+        break;
+      }
+      case "tool": {
+        for (const toolResponse of content) {
+          if (useLegacyFunctionCalling) {
+            messages.push({
+              role: "function",
+              name: toolResponse.toolName,
+              content: JSON.stringify(toolResponse.result)
+            });
+          } else {
+            messages.push({
+              role: "tool",
+              tool_call_id: toolResponse.toolCallId,
+              content: JSON.stringify(toolResponse.result)
+            });
+          }
+        }
+        break;
+      }
+      default: {
+        const _exhaustiveCheck = role;
+        throw new Error(`Unsupported role: ${_exhaustiveCheck}`);
+      }
+    }
+  }
+  return { messages, warnings };
+}
+function mapOpenAIChatLogProbsOutput(logprobs) {
+  var _a15, _b;
+  return (_b = (_a15 = logprobs == null ? void 0 : logprobs.content) == null ? void 0 : _a15.map(({ token, logprob, top_logprobs }) => ({
+    token,
+    logprob,
+    topLogprobs: top_logprobs ? top_logprobs.map(({ token: token2, logprob: logprob2 }) => ({
+      token: token2,
+      logprob: logprob2
+    })) : []
+  }))) != null ? _b : void 0;
+}
+function mapOpenAIFinishReason(finishReason) {
+  switch (finishReason) {
+    case "stop":
+      return "stop";
+    case "length":
+      return "length";
+    case "content_filter":
+      return "content-filter";
+    case "function_call":
+    case "tool_calls":
+      return "tool-calls";
+    default:
+      return "unknown";
+  }
+}
+var openaiErrorDataSchema = z.object({
+  error: z.object({
+    message: z.string(),
+    // The additional information below is handled loosely to support
+    // OpenAI-compatible providers that have slightly different error
+    // responses:
+    type: z.string().nullish(),
+    param: z.any().nullish(),
+    code: z.union([z.string(), z.number()]).nullish()
+  })
+});
+var openaiFailedResponseHandler = createJsonErrorResponseHandler({
+  errorSchema: openaiErrorDataSchema,
+  errorToMessage: (data) => data.error.message
+});
+function getResponseMetadata({
+  id,
+  model,
+  created
+}) {
+  return {
+    id: id != null ? id : void 0,
+    modelId: model != null ? model : void 0,
+    timestamp: created != null ? new Date(created * 1e3) : void 0
+  };
+}
+function prepareTools({
+  mode,
+  useLegacyFunctionCalling = false,
+  structuredOutputs
+}) {
+  var _a15;
+  const tools = ((_a15 = mode.tools) == null ? void 0 : _a15.length) ? mode.tools : void 0;
+  const toolWarnings = [];
+  if (tools == null) {
+    return { tools: void 0, tool_choice: void 0, toolWarnings };
+  }
+  const toolChoice = mode.toolChoice;
+  if (useLegacyFunctionCalling) {
+    const openaiFunctions = [];
+    for (const tool of tools) {
+      if (tool.type === "provider-defined") {
+        toolWarnings.push({ type: "unsupported-tool", tool });
+      } else {
+        openaiFunctions.push({
+          name: tool.name,
+          description: tool.description,
+          parameters: tool.parameters
+        });
+      }
+    }
+    if (toolChoice == null) {
+      return {
+        functions: openaiFunctions,
+        function_call: void 0,
+        toolWarnings
+      };
+    }
+    const type2 = toolChoice.type;
+    switch (type2) {
+      case "auto":
+      case "none":
+      case void 0:
+        return {
+          functions: openaiFunctions,
+          function_call: void 0,
+          toolWarnings
+        };
+      case "required":
+        throw new UnsupportedFunctionalityError({
+          functionality: "useLegacyFunctionCalling and toolChoice: required"
+        });
+      default:
+        return {
+          functions: openaiFunctions,
+          function_call: { name: toolChoice.toolName },
+          toolWarnings
+        };
+    }
+  }
+  const openaiTools2 = [];
+  for (const tool of tools) {
+    if (tool.type === "provider-defined") {
+      toolWarnings.push({ type: "unsupported-tool", tool });
+    } else {
+      openaiTools2.push({
+        type: "function",
+        function: {
+          name: tool.name,
+          description: tool.description,
+          parameters: tool.parameters,
+          strict: structuredOutputs ? true : void 0
+        }
+      });
+    }
+  }
+  if (toolChoice == null) {
+    return { tools: openaiTools2, tool_choice: void 0, toolWarnings };
+  }
+  const type = toolChoice.type;
+  switch (type) {
+    case "auto":
+    case "none":
+    case "required":
+      return { tools: openaiTools2, tool_choice: type, toolWarnings };
+    case "tool":
+      return {
+        tools: openaiTools2,
+        tool_choice: {
+          type: "function",
+          function: {
+            name: toolChoice.toolName
+          }
+        },
+        toolWarnings
+      };
+    default: {
+      const _exhaustiveCheck = type;
+      throw new UnsupportedFunctionalityError({
+        functionality: `Unsupported tool choice type: ${_exhaustiveCheck}`
+      });
+    }
+  }
+}
+var OpenAIChatLanguageModel = class {
+  constructor(modelId, settings, config) {
+    this.specificationVersion = "v1";
+    this.modelId = modelId;
+    this.settings = settings;
+    this.config = config;
+  }
+  get supportsStructuredOutputs() {
+    var _a15;
+    return (_a15 = this.settings.structuredOutputs) != null ? _a15 : isReasoningModel(this.modelId);
+  }
+  get defaultObjectGenerationMode() {
+    if (isAudioModel(this.modelId)) {
+      return "tool";
+    }
+    return this.supportsStructuredOutputs ? "json" : "tool";
+  }
+  get provider() {
+    return this.config.provider;
+  }
+  get supportsImageUrls() {
+    return !this.settings.downloadImages;
+  }
+  getArgs({
+    mode,
+    prompt,
+    maxTokens,
+    temperature,
+    topP,
+    topK,
+    frequencyPenalty,
+    presencePenalty,
+    stopSequences,
+    responseFormat,
+    seed,
+    providerMetadata
+  }) {
+    var _a15, _b, _c, _d, _e, _f, _g, _h;
+    const type = mode.type;
+    const warnings = [];
+    if (topK != null) {
+      warnings.push({
+        type: "unsupported-setting",
+        setting: "topK"
+      });
+    }
+    if ((responseFormat == null ? void 0 : responseFormat.type) === "json" && responseFormat.schema != null && !this.supportsStructuredOutputs) {
+      warnings.push({
+        type: "unsupported-setting",
+        setting: "responseFormat",
+        details: "JSON response format schema is only supported with structuredOutputs"
+      });
+    }
+    const useLegacyFunctionCalling = this.settings.useLegacyFunctionCalling;
+    if (useLegacyFunctionCalling && this.settings.parallelToolCalls === true) {
+      throw new UnsupportedFunctionalityError({
+        functionality: "useLegacyFunctionCalling with parallelToolCalls"
+      });
+    }
+    if (useLegacyFunctionCalling && this.supportsStructuredOutputs) {
+      throw new UnsupportedFunctionalityError({
+        functionality: "structuredOutputs with useLegacyFunctionCalling"
+      });
+    }
+    const { messages, warnings: messageWarnings } = convertToOpenAIChatMessages(
+      {
+        prompt,
+        useLegacyFunctionCalling,
+        systemMessageMode: getSystemMessageMode(this.modelId)
+      }
+    );
+    warnings.push(...messageWarnings);
+    const baseArgs = {
+      // model id:
+      model: this.modelId,
+      // model specific settings:
+      logit_bias: this.settings.logitBias,
+      logprobs: this.settings.logprobs === true || typeof this.settings.logprobs === "number" ? true : void 0,
+      top_logprobs: typeof this.settings.logprobs === "number" ? this.settings.logprobs : typeof this.settings.logprobs === "boolean" ? this.settings.logprobs ? 0 : void 0 : void 0,
+      user: this.settings.user,
+      parallel_tool_calls: this.settings.parallelToolCalls,
+      // standardized settings:
+      max_tokens: maxTokens,
+      temperature,
+      top_p: topP,
+      frequency_penalty: frequencyPenalty,
+      presence_penalty: presencePenalty,
+      response_format: (responseFormat == null ? void 0 : responseFormat.type) === "json" ? this.supportsStructuredOutputs && responseFormat.schema != null ? {
+        type: "json_schema",
+        json_schema: {
+          schema: responseFormat.schema,
+          strict: true,
+          name: (_a15 = responseFormat.name) != null ? _a15 : "response",
+          description: responseFormat.description
+        }
+      } : { type: "json_object" } : void 0,
+      stop: stopSequences,
+      seed,
+      // openai specific settings:
+      // TODO remove in next major version; we auto-map maxTokens now
+      max_completion_tokens: (_b = providerMetadata == null ? void 0 : providerMetadata.openai) == null ? void 0 : _b.maxCompletionTokens,
+      store: (_c = providerMetadata == null ? void 0 : providerMetadata.openai) == null ? void 0 : _c.store,
+      metadata: (_d = providerMetadata == null ? void 0 : providerMetadata.openai) == null ? void 0 : _d.metadata,
+      prediction: (_e = providerMetadata == null ? void 0 : providerMetadata.openai) == null ? void 0 : _e.prediction,
+      reasoning_effort: (_g = (_f = providerMetadata == null ? void 0 : providerMetadata.openai) == null ? void 0 : _f.reasoningEffort) != null ? _g : this.settings.reasoningEffort,
+      // messages:
+      messages
+    };
+    if (isReasoningModel(this.modelId)) {
+      if (baseArgs.temperature != null) {
+        baseArgs.temperature = void 0;
+        warnings.push({
+          type: "unsupported-setting",
+          setting: "temperature",
+          details: "temperature is not supported for reasoning models"
+        });
+      }
+      if (baseArgs.top_p != null) {
+        baseArgs.top_p = void 0;
+        warnings.push({
+          type: "unsupported-setting",
+          setting: "topP",
+          details: "topP is not supported for reasoning models"
+        });
+      }
+      if (baseArgs.frequency_penalty != null) {
+        baseArgs.frequency_penalty = void 0;
+        warnings.push({
+          type: "unsupported-setting",
+          setting: "frequencyPenalty",
+          details: "frequencyPenalty is not supported for reasoning models"
+        });
+      }
+      if (baseArgs.presence_penalty != null) {
+        baseArgs.presence_penalty = void 0;
+        warnings.push({
+          type: "unsupported-setting",
+          setting: "presencePenalty",
+          details: "presencePenalty is not supported for reasoning models"
+        });
+      }
+      if (baseArgs.logit_bias != null) {
+        baseArgs.logit_bias = void 0;
+        warnings.push({
+          type: "other",
+          message: "logitBias is not supported for reasoning models"
+        });
+      }
+      if (baseArgs.logprobs != null) {
+        baseArgs.logprobs = void 0;
+        warnings.push({
+          type: "other",
+          message: "logprobs is not supported for reasoning models"
+        });
+      }
+      if (baseArgs.top_logprobs != null) {
+        baseArgs.top_logprobs = void 0;
+        warnings.push({
+          type: "other",
+          message: "topLogprobs is not supported for reasoning models"
+        });
+      }
+      if (baseArgs.max_tokens != null) {
+        if (baseArgs.max_completion_tokens == null) {
+          baseArgs.max_completion_tokens = baseArgs.max_tokens;
+        }
+        baseArgs.max_tokens = void 0;
+      }
+    }
+    switch (type) {
+      case "regular": {
+        const { tools, tool_choice, functions, function_call, toolWarnings } = prepareTools({
+          mode,
+          useLegacyFunctionCalling,
+          structuredOutputs: this.supportsStructuredOutputs
+        });
+        return {
+          args: {
+            ...baseArgs,
+            tools,
+            tool_choice,
+            functions,
+            function_call
+          },
+          warnings: [...warnings, ...toolWarnings]
+        };
+      }
+      case "object-json": {
+        return {
+          args: {
+            ...baseArgs,
+            response_format: this.supportsStructuredOutputs && mode.schema != null ? {
+              type: "json_schema",
+              json_schema: {
+                schema: mode.schema,
+                strict: true,
+                name: (_h = mode.name) != null ? _h : "response",
+                description: mode.description
+              }
+            } : { type: "json_object" }
+          },
+          warnings
+        };
+      }
+      case "object-tool": {
+        return {
+          args: useLegacyFunctionCalling ? {
+            ...baseArgs,
+            function_call: {
+              name: mode.tool.name
+            },
+            functions: [
+              {
+                name: mode.tool.name,
+                description: mode.tool.description,
+                parameters: mode.tool.parameters
+              }
+            ]
+          } : {
+            ...baseArgs,
+            tool_choice: {
+              type: "function",
+              function: { name: mode.tool.name }
+            },
+            tools: [
+              {
+                type: "function",
+                function: {
+                  name: mode.tool.name,
+                  description: mode.tool.description,
+                  parameters: mode.tool.parameters,
+                  strict: this.supportsStructuredOutputs ? true : void 0
+                }
+              }
+            ]
+          },
+          warnings
+        };
+      }
+      default: {
+        const _exhaustiveCheck = type;
+        throw new Error(`Unsupported type: ${_exhaustiveCheck}`);
+      }
+    }
+  }
+  async doGenerate(options) {
+    var _a15, _b, _c, _d, _e, _f, _g, _h;
+    const { args: body, warnings } = this.getArgs(options);
+    const {
+      responseHeaders,
+      value: response,
+      rawValue: rawResponse
+    } = await postJsonToApi({
+      url: this.config.url({
+        path: "/chat/completions",
+        modelId: this.modelId
+      }),
+      headers: combineHeaders(this.config.headers(), options.headers),
+      body,
+      failedResponseHandler: openaiFailedResponseHandler,
+      successfulResponseHandler: createJsonResponseHandler(
+        openaiChatResponseSchema
+      ),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    const { messages: rawPrompt, ...rawSettings } = body;
+    const choice = response.choices[0];
+    const completionTokenDetails = (_a15 = response.usage) == null ? void 0 : _a15.completion_tokens_details;
+    const promptTokenDetails = (_b = response.usage) == null ? void 0 : _b.prompt_tokens_details;
+    const providerMetadata = { openai: {} };
+    if ((completionTokenDetails == null ? void 0 : completionTokenDetails.reasoning_tokens) != null) {
+      providerMetadata.openai.reasoningTokens = completionTokenDetails == null ? void 0 : completionTokenDetails.reasoning_tokens;
+    }
+    if ((completionTokenDetails == null ? void 0 : completionTokenDetails.accepted_prediction_tokens) != null) {
+      providerMetadata.openai.acceptedPredictionTokens = completionTokenDetails == null ? void 0 : completionTokenDetails.accepted_prediction_tokens;
+    }
+    if ((completionTokenDetails == null ? void 0 : completionTokenDetails.rejected_prediction_tokens) != null) {
+      providerMetadata.openai.rejectedPredictionTokens = completionTokenDetails == null ? void 0 : completionTokenDetails.rejected_prediction_tokens;
+    }
+    if ((promptTokenDetails == null ? void 0 : promptTokenDetails.cached_tokens) != null) {
+      providerMetadata.openai.cachedPromptTokens = promptTokenDetails == null ? void 0 : promptTokenDetails.cached_tokens;
+    }
+    return {
+      text: (_c = choice.message.content) != null ? _c : void 0,
+      toolCalls: this.settings.useLegacyFunctionCalling && choice.message.function_call ? [
+        {
+          toolCallType: "function",
+          toolCallId: generateId(),
+          toolName: choice.message.function_call.name,
+          args: choice.message.function_call.arguments
+        }
+      ] : (_d = choice.message.tool_calls) == null ? void 0 : _d.map((toolCall) => {
+        var _a22;
+        return {
+          toolCallType: "function",
+          toolCallId: (_a22 = toolCall.id) != null ? _a22 : generateId(),
+          toolName: toolCall.function.name,
+          args: toolCall.function.arguments
+        };
+      }),
+      finishReason: mapOpenAIFinishReason(choice.finish_reason),
+      usage: {
+        promptTokens: (_f = (_e = response.usage) == null ? void 0 : _e.prompt_tokens) != null ? _f : NaN,
+        completionTokens: (_h = (_g = response.usage) == null ? void 0 : _g.completion_tokens) != null ? _h : NaN
+      },
+      rawCall: { rawPrompt, rawSettings },
+      rawResponse: { headers: responseHeaders, body: rawResponse },
+      request: { body: JSON.stringify(body) },
+      response: getResponseMetadata(response),
+      warnings,
+      logprobs: mapOpenAIChatLogProbsOutput(choice.logprobs),
+      providerMetadata
+    };
+  }
+  async doStream(options) {
+    if (this.settings.simulateStreaming) {
+      const result = await this.doGenerate(options);
+      const simulatedStream = new ReadableStream({
+        start(controller) {
+          controller.enqueue({ type: "response-metadata", ...result.response });
+          if (result.text) {
+            controller.enqueue({
+              type: "text-delta",
+              textDelta: result.text
+            });
+          }
+          if (result.toolCalls) {
+            for (const toolCall of result.toolCalls) {
+              controller.enqueue({
+                type: "tool-call-delta",
+                toolCallType: "function",
+                toolCallId: toolCall.toolCallId,
+                toolName: toolCall.toolName,
+                argsTextDelta: toolCall.args
+              });
+              controller.enqueue({
+                type: "tool-call",
+                ...toolCall
+              });
+            }
+          }
+          controller.enqueue({
+            type: "finish",
+            finishReason: result.finishReason,
+            usage: result.usage,
+            logprobs: result.logprobs,
+            providerMetadata: result.providerMetadata
+          });
+          controller.close();
+        }
+      });
+      return {
+        stream: simulatedStream,
+        rawCall: result.rawCall,
+        rawResponse: result.rawResponse,
+        warnings: result.warnings
+      };
+    }
+    const { args, warnings } = this.getArgs(options);
+    const body = {
+      ...args,
+      stream: true,
+      // only include stream_options when in strict compatibility mode:
+      stream_options: this.config.compatibility === "strict" ? { include_usage: true } : void 0
+    };
+    const { responseHeaders, value: response } = await postJsonToApi({
+      url: this.config.url({
+        path: "/chat/completions",
+        modelId: this.modelId
+      }),
+      headers: combineHeaders(this.config.headers(), options.headers),
+      body,
+      failedResponseHandler: openaiFailedResponseHandler,
+      successfulResponseHandler: createEventSourceResponseHandler(
+        openaiChatChunkSchema
+      ),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    const { messages: rawPrompt, ...rawSettings } = args;
+    const toolCalls = [];
+    let finishReason = "unknown";
+    let usage = {
+      promptTokens: void 0,
+      completionTokens: void 0
+    };
+    let logprobs;
+    let isFirstChunk = true;
+    const { useLegacyFunctionCalling } = this.settings;
+    const providerMetadata = { openai: {} };
+    return {
+      stream: response.pipeThrough(
+        new TransformStream({
+          transform(chunk, controller) {
+            var _a15, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
+            if (!chunk.success) {
+              finishReason = "error";
+              controller.enqueue({ type: "error", error: chunk.error });
+              return;
+            }
+            const value = chunk.value;
+            if ("error" in value) {
+              finishReason = "error";
+              controller.enqueue({ type: "error", error: value.error });
+              return;
+            }
+            if (isFirstChunk) {
+              isFirstChunk = false;
+              controller.enqueue({
+                type: "response-metadata",
+                ...getResponseMetadata(value)
+              });
+            }
+            if (value.usage != null) {
+              const {
+                prompt_tokens,
+                completion_tokens,
+                prompt_tokens_details,
+                completion_tokens_details
+              } = value.usage;
+              usage = {
+                promptTokens: prompt_tokens != null ? prompt_tokens : void 0,
+                completionTokens: completion_tokens != null ? completion_tokens : void 0
+              };
+              if ((completion_tokens_details == null ? void 0 : completion_tokens_details.reasoning_tokens) != null) {
+                providerMetadata.openai.reasoningTokens = completion_tokens_details == null ? void 0 : completion_tokens_details.reasoning_tokens;
+              }
+              if ((completion_tokens_details == null ? void 0 : completion_tokens_details.accepted_prediction_tokens) != null) {
+                providerMetadata.openai.acceptedPredictionTokens = completion_tokens_details == null ? void 0 : completion_tokens_details.accepted_prediction_tokens;
+              }
+              if ((completion_tokens_details == null ? void 0 : completion_tokens_details.rejected_prediction_tokens) != null) {
+                providerMetadata.openai.rejectedPredictionTokens = completion_tokens_details == null ? void 0 : completion_tokens_details.rejected_prediction_tokens;
+              }
+              if ((prompt_tokens_details == null ? void 0 : prompt_tokens_details.cached_tokens) != null) {
+                providerMetadata.openai.cachedPromptTokens = prompt_tokens_details == null ? void 0 : prompt_tokens_details.cached_tokens;
+              }
+            }
+            const choice = value.choices[0];
+            if ((choice == null ? void 0 : choice.finish_reason) != null) {
+              finishReason = mapOpenAIFinishReason(choice.finish_reason);
+            }
+            if ((choice == null ? void 0 : choice.delta) == null) {
+              return;
+            }
+            const delta = choice.delta;
+            if (delta.content != null) {
+              controller.enqueue({
+                type: "text-delta",
+                textDelta: delta.content
+              });
+            }
+            const mappedLogprobs = mapOpenAIChatLogProbsOutput(
+              choice == null ? void 0 : choice.logprobs
+            );
+            if (mappedLogprobs == null ? void 0 : mappedLogprobs.length) {
+              if (logprobs === void 0) logprobs = [];
+              logprobs.push(...mappedLogprobs);
+            }
+            const mappedToolCalls = useLegacyFunctionCalling && delta.function_call != null ? [
+              {
+                type: "function",
+                id: generateId(),
+                function: delta.function_call,
+                index: 0
+              }
+            ] : delta.tool_calls;
+            if (mappedToolCalls != null) {
+              for (const toolCallDelta of mappedToolCalls) {
+                const index = toolCallDelta.index;
+                if (toolCalls[index] == null) {
+                  if (toolCallDelta.type !== "function") {
+                    throw new InvalidResponseDataError({
+                      data: toolCallDelta,
+                      message: `Expected 'function' type.`
+                    });
+                  }
+                  if (toolCallDelta.id == null) {
+                    throw new InvalidResponseDataError({
+                      data: toolCallDelta,
+                      message: `Expected 'id' to be a string.`
+                    });
+                  }
+                  if (((_a15 = toolCallDelta.function) == null ? void 0 : _a15.name) == null) {
+                    throw new InvalidResponseDataError({
+                      data: toolCallDelta,
+                      message: `Expected 'function.name' to be a string.`
+                    });
+                  }
+                  toolCalls[index] = {
+                    id: toolCallDelta.id,
+                    type: "function",
+                    function: {
+                      name: toolCallDelta.function.name,
+                      arguments: (_b = toolCallDelta.function.arguments) != null ? _b : ""
+                    },
+                    hasFinished: false
+                  };
+                  const toolCall2 = toolCalls[index];
+                  if (((_c = toolCall2.function) == null ? void 0 : _c.name) != null && ((_d = toolCall2.function) == null ? void 0 : _d.arguments) != null) {
+                    if (toolCall2.function.arguments.length > 0) {
+                      controller.enqueue({
+                        type: "tool-call-delta",
+                        toolCallType: "function",
+                        toolCallId: toolCall2.id,
+                        toolName: toolCall2.function.name,
+                        argsTextDelta: toolCall2.function.arguments
+                      });
+                    }
+                    if (isParsableJson(toolCall2.function.arguments)) {
+                      controller.enqueue({
+                        type: "tool-call",
+                        toolCallType: "function",
+                        toolCallId: (_e = toolCall2.id) != null ? _e : generateId(),
+                        toolName: toolCall2.function.name,
+                        args: toolCall2.function.arguments
+                      });
+                      toolCall2.hasFinished = true;
+                    }
+                  }
+                  continue;
+                }
+                const toolCall = toolCalls[index];
+                if (toolCall.hasFinished) {
+                  continue;
+                }
+                if (((_f = toolCallDelta.function) == null ? void 0 : _f.arguments) != null) {
+                  toolCall.function.arguments += (_h = (_g = toolCallDelta.function) == null ? void 0 : _g.arguments) != null ? _h : "";
+                }
+                controller.enqueue({
+                  type: "tool-call-delta",
+                  toolCallType: "function",
+                  toolCallId: toolCall.id,
+                  toolName: toolCall.function.name,
+                  argsTextDelta: (_i = toolCallDelta.function.arguments) != null ? _i : ""
+                });
+                if (((_j = toolCall.function) == null ? void 0 : _j.name) != null && ((_k = toolCall.function) == null ? void 0 : _k.arguments) != null && isParsableJson(toolCall.function.arguments)) {
+                  controller.enqueue({
+                    type: "tool-call",
+                    toolCallType: "function",
+                    toolCallId: (_l = toolCall.id) != null ? _l : generateId(),
+                    toolName: toolCall.function.name,
+                    args: toolCall.function.arguments
+                  });
+                  toolCall.hasFinished = true;
+                }
+              }
+            }
+          },
+          flush(controller) {
+            var _a15, _b;
+            controller.enqueue({
+              type: "finish",
+              finishReason,
+              logprobs,
+              usage: {
+                promptTokens: (_a15 = usage.promptTokens) != null ? _a15 : NaN,
+                completionTokens: (_b = usage.completionTokens) != null ? _b : NaN
+              },
+              ...providerMetadata != null ? { providerMetadata } : {}
+            });
+          }
+        })
+      ),
+      rawCall: { rawPrompt, rawSettings },
+      rawResponse: { headers: responseHeaders },
+      request: { body: JSON.stringify(body) },
+      warnings
+    };
+  }
+};
+var openaiTokenUsageSchema = z.object({
+  prompt_tokens: z.number().nullish(),
+  completion_tokens: z.number().nullish(),
+  prompt_tokens_details: z.object({
+    cached_tokens: z.number().nullish()
+  }).nullish(),
+  completion_tokens_details: z.object({
+    reasoning_tokens: z.number().nullish(),
+    accepted_prediction_tokens: z.number().nullish(),
+    rejected_prediction_tokens: z.number().nullish()
+  }).nullish()
+}).nullish();
+var openaiChatResponseSchema = z.object({
+  id: z.string().nullish(),
+  created: z.number().nullish(),
+  model: z.string().nullish(),
+  choices: z.array(
+    z.object({
+      message: z.object({
+        role: z.literal("assistant").nullish(),
+        content: z.string().nullish(),
+        function_call: z.object({
+          arguments: z.string(),
+          name: z.string()
+        }).nullish(),
+        tool_calls: z.array(
+          z.object({
+            id: z.string().nullish(),
+            type: z.literal("function"),
+            function: z.object({
+              name: z.string(),
+              arguments: z.string()
+            })
+          })
+        ).nullish()
+      }),
+      index: z.number(),
+      logprobs: z.object({
+        content: z.array(
+          z.object({
+            token: z.string(),
+            logprob: z.number(),
+            top_logprobs: z.array(
+              z.object({
+                token: z.string(),
+                logprob: z.number()
+              })
+            )
+          })
+        ).nullable()
+      }).nullish(),
+      finish_reason: z.string().nullish()
+    })
+  ),
+  usage: openaiTokenUsageSchema
+});
+var openaiChatChunkSchema = z.union([
+  z.object({
+    id: z.string().nullish(),
+    created: z.number().nullish(),
+    model: z.string().nullish(),
+    choices: z.array(
+      z.object({
+        delta: z.object({
+          role: z.enum(["assistant"]).nullish(),
+          content: z.string().nullish(),
+          function_call: z.object({
+            name: z.string().optional(),
+            arguments: z.string().optional()
+          }).nullish(),
+          tool_calls: z.array(
+            z.object({
+              index: z.number(),
+              id: z.string().nullish(),
+              type: z.literal("function").optional(),
+              function: z.object({
+                name: z.string().nullish(),
+                arguments: z.string().nullish()
+              })
+            })
+          ).nullish()
+        }).nullish(),
+        logprobs: z.object({
+          content: z.array(
+            z.object({
+              token: z.string(),
+              logprob: z.number(),
+              top_logprobs: z.array(
+                z.object({
+                  token: z.string(),
+                  logprob: z.number()
+                })
+              )
+            })
+          ).nullable()
+        }).nullish(),
+        finish_reason: z.string().nullable().optional(),
+        index: z.number()
+      })
+    ),
+    usage: openaiTokenUsageSchema
+  }),
+  openaiErrorDataSchema
+]);
+function isReasoningModel(modelId) {
+  return modelId === "o1" || modelId.startsWith("o1-") || modelId === "o3" || modelId.startsWith("o3-");
+}
+function isAudioModel(modelId) {
+  return modelId.startsWith("gpt-4o-audio-preview");
+}
+function getSystemMessageMode(modelId) {
+  var _a15, _b;
+  if (!isReasoningModel(modelId)) {
+    return "system";
+  }
+  return (_b = (_a15 = reasoningModels[modelId]) == null ? void 0 : _a15.systemMessageMode) != null ? _b : "developer";
+}
+var reasoningModels = {
+  "o1-mini": {
+    systemMessageMode: "remove"
+  },
+  "o1-mini-2024-09-12": {
+    systemMessageMode: "remove"
+  },
+  "o1-preview": {
+    systemMessageMode: "remove"
+  },
+  "o1-preview-2024-09-12": {
+    systemMessageMode: "remove"
+  },
+  "o3-mini": {
+    systemMessageMode: "developer"
+  },
+  "o3-mini-2025-01-31": {
+    systemMessageMode: "developer"
+  }
+};
+function convertToOpenAICompletionPrompt({
+  prompt,
+  inputFormat,
+  user = "user",
+  assistant = "assistant"
+}) {
+  if (inputFormat === "prompt" && prompt.length === 1 && prompt[0].role === "user" && prompt[0].content.length === 1 && prompt[0].content[0].type === "text") {
+    return { prompt: prompt[0].content[0].text };
+  }
+  let text = "";
+  if (prompt[0].role === "system") {
+    text += `${prompt[0].content}
+
+`;
+    prompt = prompt.slice(1);
+  }
+  for (const { role, content } of prompt) {
+    switch (role) {
+      case "system": {
+        throw new InvalidPromptError({
+          message: "Unexpected system message in prompt: ${content}",
+          prompt
+        });
+      }
+      case "user": {
+        const userMessage = content.map((part) => {
+          switch (part.type) {
+            case "text": {
+              return part.text;
+            }
+            case "image": {
+              throw new UnsupportedFunctionalityError({
+                functionality: "images"
+              });
+            }
+          }
+        }).join("");
+        text += `${user}:
+${userMessage}
+
+`;
+        break;
+      }
+      case "assistant": {
+        const assistantMessage = content.map((part) => {
+          switch (part.type) {
+            case "text": {
+              return part.text;
+            }
+            case "tool-call": {
+              throw new UnsupportedFunctionalityError({
+                functionality: "tool-call messages"
+              });
+            }
+          }
+        }).join("");
+        text += `${assistant}:
+${assistantMessage}
+
+`;
+        break;
+      }
+      case "tool": {
+        throw new UnsupportedFunctionalityError({
+          functionality: "tool messages"
+        });
+      }
+      default: {
+        const _exhaustiveCheck = role;
+        throw new Error(`Unsupported role: ${_exhaustiveCheck}`);
+      }
+    }
+  }
+  text += `${assistant}:
+`;
+  return {
+    prompt: text,
+    stopSequences: [`
+${user}:`]
+  };
+}
+function mapOpenAICompletionLogProbs(logprobs) {
+  return logprobs == null ? void 0 : logprobs.tokens.map((token, index) => ({
+    token,
+    logprob: logprobs.token_logprobs[index],
+    topLogprobs: logprobs.top_logprobs ? Object.entries(logprobs.top_logprobs[index]).map(
+      ([token2, logprob]) => ({
+        token: token2,
+        logprob
+      })
+    ) : []
+  }));
+}
+var OpenAICompletionLanguageModel = class {
+  constructor(modelId, settings, config) {
+    this.specificationVersion = "v1";
+    this.defaultObjectGenerationMode = void 0;
+    this.modelId = modelId;
+    this.settings = settings;
+    this.config = config;
+  }
+  get provider() {
+    return this.config.provider;
+  }
+  getArgs({
+    mode,
+    inputFormat,
+    prompt,
+    maxTokens,
+    temperature,
+    topP,
+    topK,
+    frequencyPenalty,
+    presencePenalty,
+    stopSequences: userStopSequences,
+    responseFormat,
+    seed
+  }) {
+    var _a15;
+    const type = mode.type;
+    const warnings = [];
+    if (topK != null) {
+      warnings.push({
+        type: "unsupported-setting",
+        setting: "topK"
+      });
+    }
+    if (responseFormat != null && responseFormat.type !== "text") {
+      warnings.push({
+        type: "unsupported-setting",
+        setting: "responseFormat",
+        details: "JSON response format is not supported."
+      });
+    }
+    const { prompt: completionPrompt, stopSequences } = convertToOpenAICompletionPrompt({ prompt, inputFormat });
+    const stop = [...stopSequences != null ? stopSequences : [], ...userStopSequences != null ? userStopSequences : []];
+    const baseArgs = {
+      // model id:
+      model: this.modelId,
+      // model specific settings:
+      echo: this.settings.echo,
+      logit_bias: this.settings.logitBias,
+      logprobs: typeof this.settings.logprobs === "number" ? this.settings.logprobs : typeof this.settings.logprobs === "boolean" ? this.settings.logprobs ? 0 : void 0 : void 0,
+      suffix: this.settings.suffix,
+      user: this.settings.user,
+      // standardized settings:
+      max_tokens: maxTokens,
+      temperature,
+      top_p: topP,
+      frequency_penalty: frequencyPenalty,
+      presence_penalty: presencePenalty,
+      seed,
+      // prompt:
+      prompt: completionPrompt,
+      // stop sequences:
+      stop: stop.length > 0 ? stop : void 0
+    };
+    switch (type) {
+      case "regular": {
+        if ((_a15 = mode.tools) == null ? void 0 : _a15.length) {
+          throw new UnsupportedFunctionalityError({
+            functionality: "tools"
+          });
+        }
+        if (mode.toolChoice) {
+          throw new UnsupportedFunctionalityError({
+            functionality: "toolChoice"
+          });
+        }
+        return { args: baseArgs, warnings };
+      }
+      case "object-json": {
+        throw new UnsupportedFunctionalityError({
+          functionality: "object-json mode"
+        });
+      }
+      case "object-tool": {
+        throw new UnsupportedFunctionalityError({
+          functionality: "object-tool mode"
+        });
+      }
+      default: {
+        const _exhaustiveCheck = type;
+        throw new Error(`Unsupported type: ${_exhaustiveCheck}`);
+      }
+    }
+  }
+  async doGenerate(options) {
+    const { args, warnings } = this.getArgs(options);
+    const {
+      responseHeaders,
+      value: response,
+      rawValue: rawResponse
+    } = await postJsonToApi({
+      url: this.config.url({
+        path: "/completions",
+        modelId: this.modelId
+      }),
+      headers: combineHeaders(this.config.headers(), options.headers),
+      body: args,
+      failedResponseHandler: openaiFailedResponseHandler,
+      successfulResponseHandler: createJsonResponseHandler(
+        openaiCompletionResponseSchema
+      ),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    const { prompt: rawPrompt, ...rawSettings } = args;
+    const choice = response.choices[0];
+    return {
+      text: choice.text,
+      usage: {
+        promptTokens: response.usage.prompt_tokens,
+        completionTokens: response.usage.completion_tokens
+      },
+      finishReason: mapOpenAIFinishReason(choice.finish_reason),
+      logprobs: mapOpenAICompletionLogProbs(choice.logprobs),
+      rawCall: { rawPrompt, rawSettings },
+      rawResponse: { headers: responseHeaders, body: rawResponse },
+      response: getResponseMetadata(response),
+      warnings,
+      request: { body: JSON.stringify(args) }
+    };
+  }
+  async doStream(options) {
+    const { args, warnings } = this.getArgs(options);
+    const body = {
+      ...args,
+      stream: true,
+      // only include stream_options when in strict compatibility mode:
+      stream_options: this.config.compatibility === "strict" ? { include_usage: true } : void 0
+    };
+    const { responseHeaders, value: response } = await postJsonToApi({
+      url: this.config.url({
+        path: "/completions",
+        modelId: this.modelId
+      }),
+      headers: combineHeaders(this.config.headers(), options.headers),
+      body,
+      failedResponseHandler: openaiFailedResponseHandler,
+      successfulResponseHandler: createEventSourceResponseHandler(
+        openaiCompletionChunkSchema
+      ),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    const { prompt: rawPrompt, ...rawSettings } = args;
+    let finishReason = "unknown";
+    let usage = {
+      promptTokens: Number.NaN,
+      completionTokens: Number.NaN
+    };
+    let logprobs;
+    let isFirstChunk = true;
+    return {
+      stream: response.pipeThrough(
+        new TransformStream({
+          transform(chunk, controller) {
+            if (!chunk.success) {
+              finishReason = "error";
+              controller.enqueue({ type: "error", error: chunk.error });
+              return;
+            }
+            const value = chunk.value;
+            if ("error" in value) {
+              finishReason = "error";
+              controller.enqueue({ type: "error", error: value.error });
+              return;
+            }
+            if (isFirstChunk) {
+              isFirstChunk = false;
+              controller.enqueue({
+                type: "response-metadata",
+                ...getResponseMetadata(value)
+              });
+            }
+            if (value.usage != null) {
+              usage = {
+                promptTokens: value.usage.prompt_tokens,
+                completionTokens: value.usage.completion_tokens
+              };
+            }
+            const choice = value.choices[0];
+            if ((choice == null ? void 0 : choice.finish_reason) != null) {
+              finishReason = mapOpenAIFinishReason(choice.finish_reason);
+            }
+            if ((choice == null ? void 0 : choice.text) != null) {
+              controller.enqueue({
+                type: "text-delta",
+                textDelta: choice.text
+              });
+            }
+            const mappedLogprobs = mapOpenAICompletionLogProbs(
+              choice == null ? void 0 : choice.logprobs
+            );
+            if (mappedLogprobs == null ? void 0 : mappedLogprobs.length) {
+              if (logprobs === void 0) logprobs = [];
+              logprobs.push(...mappedLogprobs);
+            }
+          },
+          flush(controller) {
+            controller.enqueue({
+              type: "finish",
+              finishReason,
+              logprobs,
+              usage
+            });
+          }
+        })
+      ),
+      rawCall: { rawPrompt, rawSettings },
+      rawResponse: { headers: responseHeaders },
+      warnings,
+      request: { body: JSON.stringify(body) }
+    };
+  }
+};
+var openaiCompletionResponseSchema = z.object({
+  id: z.string().nullish(),
+  created: z.number().nullish(),
+  model: z.string().nullish(),
+  choices: z.array(
+    z.object({
+      text: z.string(),
+      finish_reason: z.string(),
+      logprobs: z.object({
+        tokens: z.array(z.string()),
+        token_logprobs: z.array(z.number()),
+        top_logprobs: z.array(z.record(z.string(), z.number())).nullable()
+      }).nullish()
+    })
+  ),
+  usage: z.object({
+    prompt_tokens: z.number(),
+    completion_tokens: z.number()
+  })
+});
+var openaiCompletionChunkSchema = z.union([
+  z.object({
+    id: z.string().nullish(),
+    created: z.number().nullish(),
+    model: z.string().nullish(),
+    choices: z.array(
+      z.object({
+        text: z.string(),
+        finish_reason: z.string().nullish(),
+        index: z.number(),
+        logprobs: z.object({
+          tokens: z.array(z.string()),
+          token_logprobs: z.array(z.number()),
+          top_logprobs: z.array(z.record(z.string(), z.number())).nullable()
+        }).nullish()
+      })
+    ),
+    usage: z.object({
+      prompt_tokens: z.number(),
+      completion_tokens: z.number()
+    }).nullish()
+  }),
+  openaiErrorDataSchema
+]);
+var OpenAIEmbeddingModel = class {
+  constructor(modelId, settings, config) {
+    this.specificationVersion = "v1";
+    this.modelId = modelId;
+    this.settings = settings;
+    this.config = config;
+  }
+  get provider() {
+    return this.config.provider;
+  }
+  get maxEmbeddingsPerCall() {
+    var _a15;
+    return (_a15 = this.settings.maxEmbeddingsPerCall) != null ? _a15 : 2048;
+  }
+  get supportsParallelCalls() {
+    var _a15;
+    return (_a15 = this.settings.supportsParallelCalls) != null ? _a15 : true;
+  }
+  async doEmbed({
+    values,
+    headers,
+    abortSignal
+  }) {
+    if (values.length > this.maxEmbeddingsPerCall) {
+      throw new TooManyEmbeddingValuesForCallError({
+        provider: this.provider,
+        modelId: this.modelId,
+        maxEmbeddingsPerCall: this.maxEmbeddingsPerCall,
+        values
+      });
+    }
+    const { responseHeaders, value: response } = await postJsonToApi({
+      url: this.config.url({
+        path: "/embeddings",
+        modelId: this.modelId
+      }),
+      headers: combineHeaders(this.config.headers(), headers),
+      body: {
+        model: this.modelId,
+        input: values,
+        encoding_format: "float",
+        dimensions: this.settings.dimensions,
+        user: this.settings.user
+      },
+      failedResponseHandler: openaiFailedResponseHandler,
+      successfulResponseHandler: createJsonResponseHandler(
+        openaiTextEmbeddingResponseSchema
+      ),
+      abortSignal,
+      fetch: this.config.fetch
+    });
+    return {
+      embeddings: response.data.map((item) => item.embedding),
+      usage: response.usage ? { tokens: response.usage.prompt_tokens } : void 0,
+      rawResponse: { headers: responseHeaders }
+    };
+  }
+};
+var openaiTextEmbeddingResponseSchema = z.object({
+  data: z.array(z.object({ embedding: z.array(z.number()) })),
+  usage: z.object({ prompt_tokens: z.number() }).nullish()
+});
+var modelMaxImagesPerCall = {
+  "dall-e-3": 1,
+  "dall-e-2": 10
+};
+var OpenAIImageModel = class {
+  constructor(modelId, settings, config) {
+    this.modelId = modelId;
+    this.settings = settings;
+    this.config = config;
+    this.specificationVersion = "v1";
+  }
+  get maxImagesPerCall() {
+    var _a15, _b;
+    return (_b = (_a15 = this.settings.maxImagesPerCall) != null ? _a15 : modelMaxImagesPerCall[this.modelId]) != null ? _b : 1;
+  }
+  get provider() {
+    return this.config.provider;
+  }
+  async doGenerate({
+    prompt,
+    n,
+    size,
+    aspectRatio,
+    seed,
+    providerOptions,
+    headers,
+    abortSignal
+  }) {
+    var _a15, _b, _c, _d;
+    const warnings = [];
+    if (aspectRatio != null) {
+      warnings.push({
+        type: "unsupported-setting",
+        setting: "aspectRatio",
+        details: "This model does not support aspect ratio. Use `size` instead."
+      });
+    }
+    if (seed != null) {
+      warnings.push({ type: "unsupported-setting", setting: "seed" });
+    }
+    const currentDate = (_c = (_b = (_a15 = this.config._internal) == null ? void 0 : _a15.currentDate) == null ? void 0 : _b.call(_a15)) != null ? _c : /* @__PURE__ */ new Date();
+    const { value: response, responseHeaders } = await postJsonToApi({
+      url: this.config.url({
+        path: "/images/generations",
+        modelId: this.modelId
+      }),
+      headers: combineHeaders(this.config.headers(), headers),
+      body: {
+        model: this.modelId,
+        prompt,
+        n,
+        size,
+        ...(_d = providerOptions.openai) != null ? _d : {},
+        response_format: "b64_json"
+      },
+      failedResponseHandler: openaiFailedResponseHandler,
+      successfulResponseHandler: createJsonResponseHandler(
+        openaiImageResponseSchema
+      ),
+      abortSignal,
+      fetch: this.config.fetch
+    });
+    return {
+      images: response.data.map((item) => item.b64_json),
+      warnings,
+      response: {
+        timestamp: currentDate,
+        modelId: this.modelId,
+        headers: responseHeaders
+      }
+    };
+  }
+};
+var openaiImageResponseSchema = z.object({
+  data: z.array(z.object({ b64_json: z.string() }))
+});
+var OpenAIProviderOptionsSchema = z.object({
+  include: z.array(z.string()).optional().describe(
+    "Additional information to include in the transcription response."
+  ),
+  language: z.string().optional().describe("The language of the input audio in ISO-639-1 format."),
+  prompt: z.string().optional().describe(
+    "An optional text to guide the model's style or continue a previous audio segment."
+  ),
+  temperature: z.number().min(0).max(1).optional().default(0).describe("The sampling temperature, between 0 and 1."),
+  timestampGranularities: z.array(z.enum(["word", "segment"])).optional().default(["segment"]).describe(
+    "The timestamp granularities to populate for this transcription."
+  )
+});
+var languageMap = {
+  afrikaans: "af",
+  arabic: "ar",
+  armenian: "hy",
+  azerbaijani: "az",
+  belarusian: "be",
+  bosnian: "bs",
+  bulgarian: "bg",
+  catalan: "ca",
+  chinese: "zh",
+  croatian: "hr",
+  czech: "cs",
+  danish: "da",
+  dutch: "nl",
+  english: "en",
+  estonian: "et",
+  finnish: "fi",
+  french: "fr",
+  galician: "gl",
+  german: "de",
+  greek: "el",
+  hebrew: "he",
+  hindi: "hi",
+  hungarian: "hu",
+  icelandic: "is",
+  indonesian: "id",
+  italian: "it",
+  japanese: "ja",
+  kannada: "kn",
+  kazakh: "kk",
+  korean: "ko",
+  latvian: "lv",
+  lithuanian: "lt",
+  macedonian: "mk",
+  malay: "ms",
+  marathi: "mr",
+  maori: "mi",
+  nepali: "ne",
+  norwegian: "no",
+  persian: "fa",
+  polish: "pl",
+  portuguese: "pt",
+  romanian: "ro",
+  russian: "ru",
+  serbian: "sr",
+  slovak: "sk",
+  slovenian: "sl",
+  spanish: "es",
+  swahili: "sw",
+  swedish: "sv",
+  tagalog: "tl",
+  tamil: "ta",
+  thai: "th",
+  turkish: "tr",
+  ukrainian: "uk",
+  urdu: "ur",
+  vietnamese: "vi",
+  welsh: "cy"
+};
+var OpenAITranscriptionModel = class {
+  constructor(modelId, config) {
+    this.modelId = modelId;
+    this.config = config;
+    this.specificationVersion = "v1";
+  }
+  get provider() {
+    return this.config.provider;
+  }
+  getArgs({
+    audio,
+    mediaType,
+    providerOptions
+  }) {
+    const warnings = [];
+    const openAIOptions = parseProviderOptions({
+      provider: "openai",
+      providerOptions,
+      schema: OpenAIProviderOptionsSchema
+    });
+    const formData = new FormData();
+    const blob = audio instanceof Uint8Array ? new Blob([audio]) : new Blob([convertBase64ToUint8Array(audio)]);
+    formData.append("model", this.modelId);
+    formData.append("file", new File([blob], "audio", { type: mediaType }));
+    if (openAIOptions) {
+      const transcriptionModelOptions = {
+        include: openAIOptions.include,
+        language: openAIOptions.language,
+        prompt: openAIOptions.prompt,
+        temperature: openAIOptions.temperature,
+        timestamp_granularities: openAIOptions.timestampGranularities
+      };
+      for (const key in transcriptionModelOptions) {
+        const value = transcriptionModelOptions[key];
+        if (value !== void 0) {
+          formData.append(key, value);
+        }
+      }
+    }
+    return {
+      formData,
+      warnings
+    };
+  }
+  async doGenerate(options) {
+    var _a15, _b, _c, _d, _e, _f;
+    const currentDate = (_c = (_b = (_a15 = this.config._internal) == null ? void 0 : _a15.currentDate) == null ? void 0 : _b.call(_a15)) != null ? _c : /* @__PURE__ */ new Date();
+    const { formData, warnings } = this.getArgs(options);
+    const {
+      value: response,
+      responseHeaders,
+      rawValue: rawResponse
+    } = await postFormDataToApi({
+      url: this.config.url({
+        path: "/audio/transcriptions",
+        modelId: this.modelId
+      }),
+      headers: combineHeaders(this.config.headers(), options.headers),
+      formData,
+      failedResponseHandler: openaiFailedResponseHandler,
+      successfulResponseHandler: createJsonResponseHandler(
+        openaiTranscriptionResponseSchema
+      ),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    const language = response.language != null && response.language in languageMap ? languageMap[response.language] : void 0;
+    return {
+      text: response.text,
+      segments: (_e = (_d = response.words) == null ? void 0 : _d.map((word) => ({
+        text: word.word,
+        startSecond: word.start,
+        endSecond: word.end
+      }))) != null ? _e : [],
+      language,
+      durationInSeconds: (_f = response.duration) != null ? _f : void 0,
+      warnings,
+      response: {
+        timestamp: currentDate,
+        modelId: this.modelId,
+        headers: responseHeaders,
+        body: rawResponse
+      }
+    };
+  }
+};
+var openaiTranscriptionResponseSchema = z.object({
+  text: z.string(),
+  language: z.string().nullish(),
+  duration: z.number().nullish(),
+  words: z.array(
+    z.object({
+      word: z.string(),
+      start: z.number(),
+      end: z.number()
+    })
+  ).nullish()
+});
+function convertToOpenAIResponsesMessages({
+  prompt,
+  systemMessageMode
+}) {
+  const messages = [];
+  const warnings = [];
+  for (const { role, content } of prompt) {
+    switch (role) {
+      case "system": {
+        switch (systemMessageMode) {
+          case "system": {
+            messages.push({ role: "system", content });
+            break;
+          }
+          case "developer": {
+            messages.push({ role: "developer", content });
+            break;
+          }
+          case "remove": {
+            warnings.push({
+              type: "other",
+              message: "system messages are removed for this model"
+            });
+            break;
+          }
+          default: {
+            const _exhaustiveCheck = systemMessageMode;
+            throw new Error(
+              `Unsupported system message mode: ${_exhaustiveCheck}`
+            );
+          }
+        }
+        break;
+      }
+      case "user": {
+        messages.push({
+          role: "user",
+          content: content.map((part, index) => {
+            var _a15, _b, _c, _d;
+            switch (part.type) {
+              case "text": {
+                return { type: "input_text", text: part.text };
+              }
+              case "image": {
+                return {
+                  type: "input_image",
+                  image_url: part.image instanceof URL ? part.image.toString() : `data:${(_a15 = part.mimeType) != null ? _a15 : "image/jpeg"};base64,${convertUint8ArrayToBase64(part.image)}`,
+                  // OpenAI specific extension: image detail
+                  detail: (_c = (_b = part.providerMetadata) == null ? void 0 : _b.openai) == null ? void 0 : _c.imageDetail
+                };
+              }
+              case "file": {
+                if (part.data instanceof URL) {
+                  throw new UnsupportedFunctionalityError({
+                    functionality: "File URLs in user messages"
+                  });
+                }
+                switch (part.mimeType) {
+                  case "application/pdf": {
+                    return {
+                      type: "input_file",
+                      filename: (_d = part.filename) != null ? _d : `part-${index}.pdf`,
+                      file_data: `data:application/pdf;base64,${part.data}`
+                    };
+                  }
+                  default: {
+                    throw new UnsupportedFunctionalityError({
+                      functionality: "Only PDF files are supported in user messages"
+                    });
+                  }
+                }
+              }
+            }
+          })
+        });
+        break;
+      }
+      case "assistant": {
+        for (const part of content) {
+          switch (part.type) {
+            case "text": {
+              messages.push({
+                role: "assistant",
+                content: [{ type: "output_text", text: part.text }]
+              });
+              break;
+            }
+            case "tool-call": {
+              messages.push({
+                type: "function_call",
+                call_id: part.toolCallId,
+                name: part.toolName,
+                arguments: JSON.stringify(part.args)
+              });
+              break;
+            }
+          }
+        }
+        break;
+      }
+      case "tool": {
+        for (const part of content) {
+          messages.push({
+            type: "function_call_output",
+            call_id: part.toolCallId,
+            output: JSON.stringify(part.result)
+          });
+        }
+        break;
+      }
+      default: {
+        const _exhaustiveCheck = role;
+        throw new Error(`Unsupported role: ${_exhaustiveCheck}`);
+      }
+    }
+  }
+  return { messages, warnings };
+}
+function mapOpenAIResponseFinishReason({
+  finishReason,
+  hasToolCalls
+}) {
+  switch (finishReason) {
+    case void 0:
+    case null:
+      return hasToolCalls ? "tool-calls" : "stop";
+    case "max_output_tokens":
+      return "length";
+    case "content_filter":
+      return "content-filter";
+    default:
+      return hasToolCalls ? "tool-calls" : "unknown";
+  }
+}
+function prepareResponsesTools({
+  mode,
+  strict
+}) {
+  var _a15;
+  const tools = ((_a15 = mode.tools) == null ? void 0 : _a15.length) ? mode.tools : void 0;
+  const toolWarnings = [];
+  if (tools == null) {
+    return { tools: void 0, tool_choice: void 0, toolWarnings };
+  }
+  const toolChoice = mode.toolChoice;
+  const openaiTools2 = [];
+  for (const tool of tools) {
+    switch (tool.type) {
+      case "function":
+        openaiTools2.push({
+          type: "function",
+          name: tool.name,
+          description: tool.description,
+          parameters: tool.parameters,
+          strict: strict ? true : void 0
+        });
+        break;
+      case "provider-defined":
+        switch (tool.id) {
+          case "openai.web_search_preview":
+            openaiTools2.push({
+              type: "web_search_preview",
+              search_context_size: tool.args.searchContextSize,
+              user_location: tool.args.userLocation
+            });
+            break;
+          default:
+            toolWarnings.push({ type: "unsupported-tool", tool });
+            break;
+        }
+        break;
+      default:
+        toolWarnings.push({ type: "unsupported-tool", tool });
+        break;
+    }
+  }
+  if (toolChoice == null) {
+    return { tools: openaiTools2, tool_choice: void 0, toolWarnings };
+  }
+  const type = toolChoice.type;
+  switch (type) {
+    case "auto":
+    case "none":
+    case "required":
+      return { tools: openaiTools2, tool_choice: type, toolWarnings };
+    case "tool": {
+      if (toolChoice.toolName === "web_search_preview") {
+        return {
+          tools: openaiTools2,
+          tool_choice: {
+            type: "web_search_preview"
+          },
+          toolWarnings
+        };
+      }
+      return {
+        tools: openaiTools2,
+        tool_choice: {
+          type: "function",
+          name: toolChoice.toolName
+        },
+        toolWarnings
+      };
+    }
+    default: {
+      const _exhaustiveCheck = type;
+      throw new UnsupportedFunctionalityError({
+        functionality: `Unsupported tool choice type: ${_exhaustiveCheck}`
+      });
+    }
+  }
+}
+var OpenAIResponsesLanguageModel = class {
+  constructor(modelId, config) {
+    this.specificationVersion = "v1";
+    this.defaultObjectGenerationMode = "json";
+    this.modelId = modelId;
+    this.config = config;
+  }
+  get provider() {
+    return this.config.provider;
+  }
+  getArgs({
+    mode,
+    maxTokens,
+    temperature,
+    stopSequences,
+    topP,
+    topK,
+    presencePenalty,
+    frequencyPenalty,
+    seed,
+    prompt,
+    providerMetadata,
+    responseFormat
+  }) {
+    var _a15, _b, _c;
+    const warnings = [];
+    const modelConfig = getResponsesModelConfig(this.modelId);
+    const type = mode.type;
+    if (topK != null) {
+      warnings.push({
+        type: "unsupported-setting",
+        setting: "topK"
+      });
+    }
+    if (seed != null) {
+      warnings.push({
+        type: "unsupported-setting",
+        setting: "seed"
+      });
+    }
+    if (presencePenalty != null) {
+      warnings.push({
+        type: "unsupported-setting",
+        setting: "presencePenalty"
+      });
+    }
+    if (frequencyPenalty != null) {
+      warnings.push({
+        type: "unsupported-setting",
+        setting: "frequencyPenalty"
+      });
+    }
+    if (stopSequences != null) {
+      warnings.push({
+        type: "unsupported-setting",
+        setting: "stopSequences"
+      });
+    }
+    const { messages, warnings: messageWarnings } = convertToOpenAIResponsesMessages({
+      prompt,
+      systemMessageMode: modelConfig.systemMessageMode
+    });
+    warnings.push(...messageWarnings);
+    const openaiOptions = parseProviderOptions({
+      provider: "openai",
+      providerOptions: providerMetadata,
+      schema: openaiResponsesProviderOptionsSchema
+    });
+    const isStrict = (_a15 = openaiOptions == null ? void 0 : openaiOptions.strictSchemas) != null ? _a15 : true;
+    const baseArgs = {
+      model: this.modelId,
+      input: messages,
+      temperature,
+      top_p: topP,
+      max_output_tokens: maxTokens,
+      ...(responseFormat == null ? void 0 : responseFormat.type) === "json" && {
+        text: {
+          format: responseFormat.schema != null ? {
+            type: "json_schema",
+            strict: isStrict,
+            name: (_b = responseFormat.name) != null ? _b : "response",
+            description: responseFormat.description,
+            schema: responseFormat.schema
+          } : { type: "json_object" }
+        }
+      },
+      // provider options:
+      metadata: openaiOptions == null ? void 0 : openaiOptions.metadata,
+      parallel_tool_calls: openaiOptions == null ? void 0 : openaiOptions.parallelToolCalls,
+      previous_response_id: openaiOptions == null ? void 0 : openaiOptions.previousResponseId,
+      store: openaiOptions == null ? void 0 : openaiOptions.store,
+      user: openaiOptions == null ? void 0 : openaiOptions.user,
+      instructions: openaiOptions == null ? void 0 : openaiOptions.instructions,
+      // model-specific settings:
+      ...modelConfig.isReasoningModel && (openaiOptions == null ? void 0 : openaiOptions.reasoningEffort) != null && {
+        reasoning: { effort: openaiOptions == null ? void 0 : openaiOptions.reasoningEffort }
+      },
+      ...modelConfig.requiredAutoTruncation && {
+        truncation: "auto"
+      }
+    };
+    if (modelConfig.isReasoningModel) {
+      if (baseArgs.temperature != null) {
+        baseArgs.temperature = void 0;
+        warnings.push({
+          type: "unsupported-setting",
+          setting: "temperature",
+          details: "temperature is not supported for reasoning models"
+        });
+      }
+      if (baseArgs.top_p != null) {
+        baseArgs.top_p = void 0;
+        warnings.push({
+          type: "unsupported-setting",
+          setting: "topP",
+          details: "topP is not supported for reasoning models"
+        });
+      }
+    }
+    switch (type) {
+      case "regular": {
+        const { tools, tool_choice, toolWarnings } = prepareResponsesTools({
+          mode,
+          strict: isStrict
+          // TODO support provider options on tools
+        });
+        return {
+          args: {
+            ...baseArgs,
+            tools,
+            tool_choice
+          },
+          warnings: [...warnings, ...toolWarnings]
+        };
+      }
+      case "object-json": {
+        return {
+          args: {
+            ...baseArgs,
+            text: {
+              format: mode.schema != null ? {
+                type: "json_schema",
+                strict: isStrict,
+                name: (_c = mode.name) != null ? _c : "response",
+                description: mode.description,
+                schema: mode.schema
+              } : { type: "json_object" }
+            }
+          },
+          warnings
+        };
+      }
+      case "object-tool": {
+        return {
+          args: {
+            ...baseArgs,
+            tool_choice: { type: "function", name: mode.tool.name },
+            tools: [
+              {
+                type: "function",
+                name: mode.tool.name,
+                description: mode.tool.description,
+                parameters: mode.tool.parameters,
+                strict: isStrict
+              }
+            ]
+          },
+          warnings
+        };
+      }
+      default: {
+        const _exhaustiveCheck = type;
+        throw new Error(`Unsupported type: ${_exhaustiveCheck}`);
+      }
+    }
+  }
+  async doGenerate(options) {
+    var _a15, _b, _c, _d, _e;
+    const { args: body, warnings } = this.getArgs(options);
+    const {
+      responseHeaders,
+      value: response,
+      rawValue: rawResponse
+    } = await postJsonToApi({
+      url: this.config.url({
+        path: "/responses",
+        modelId: this.modelId
+      }),
+      headers: combineHeaders(this.config.headers(), options.headers),
+      body,
+      failedResponseHandler: openaiFailedResponseHandler,
+      successfulResponseHandler: createJsonResponseHandler(
+        z.object({
+          id: z.string(),
+          created_at: z.number(),
+          model: z.string(),
+          output: z.array(
+            z.discriminatedUnion("type", [
+              z.object({
+                type: z.literal("message"),
+                role: z.literal("assistant"),
+                content: z.array(
+                  z.object({
+                    type: z.literal("output_text"),
+                    text: z.string(),
+                    annotations: z.array(
+                      z.object({
+                        type: z.literal("url_citation"),
+                        start_index: z.number(),
+                        end_index: z.number(),
+                        url: z.string(),
+                        title: z.string()
+                      })
+                    )
+                  })
+                )
+              }),
+              z.object({
+                type: z.literal("function_call"),
+                call_id: z.string(),
+                name: z.string(),
+                arguments: z.string()
+              }),
+              z.object({
+                type: z.literal("web_search_call")
+              }),
+              z.object({
+                type: z.literal("computer_call")
+              }),
+              z.object({
+                type: z.literal("reasoning")
+              })
+            ])
+          ),
+          incomplete_details: z.object({ reason: z.string() }).nullable(),
+          usage: usageSchema
+        })
+      ),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    const outputTextElements = response.output.filter((output) => output.type === "message").flatMap((output) => output.content).filter((content) => content.type === "output_text");
+    const toolCalls = response.output.filter((output) => output.type === "function_call").map((output) => ({
+      toolCallType: "function",
+      toolCallId: output.call_id,
+      toolName: output.name,
+      args: output.arguments
+    }));
+    return {
+      text: outputTextElements.map((content) => content.text).join("\n"),
+      sources: outputTextElements.flatMap(
+        (content) => content.annotations.map((annotation) => {
+          var _a22, _b2, _c2;
+          return {
+            sourceType: "url",
+            id: (_c2 = (_b2 = (_a22 = this.config).generateId) == null ? void 0 : _b2.call(_a22)) != null ? _c2 : generateId(),
+            url: annotation.url,
+            title: annotation.title
+          };
+        })
+      ),
+      finishReason: mapOpenAIResponseFinishReason({
+        finishReason: (_a15 = response.incomplete_details) == null ? void 0 : _a15.reason,
+        hasToolCalls: toolCalls.length > 0
+      }),
+      toolCalls: toolCalls.length > 0 ? toolCalls : void 0,
+      usage: {
+        promptTokens: response.usage.input_tokens,
+        completionTokens: response.usage.output_tokens
+      },
+      rawCall: {
+        rawPrompt: void 0,
+        rawSettings: {}
+      },
+      rawResponse: {
+        headers: responseHeaders,
+        body: rawResponse
+      },
+      request: {
+        body: JSON.stringify(body)
+      },
+      response: {
+        id: response.id,
+        timestamp: new Date(response.created_at * 1e3),
+        modelId: response.model
+      },
+      providerMetadata: {
+        openai: {
+          responseId: response.id,
+          cachedPromptTokens: (_c = (_b = response.usage.input_tokens_details) == null ? void 0 : _b.cached_tokens) != null ? _c : null,
+          reasoningTokens: (_e = (_d = response.usage.output_tokens_details) == null ? void 0 : _d.reasoning_tokens) != null ? _e : null
+        }
+      },
+      warnings
+    };
+  }
+  async doStream(options) {
+    const { args: body, warnings } = this.getArgs(options);
+    const { responseHeaders, value: response } = await postJsonToApi({
+      url: this.config.url({
+        path: "/responses",
+        modelId: this.modelId
+      }),
+      headers: combineHeaders(this.config.headers(), options.headers),
+      body: {
+        ...body,
+        stream: true
+      },
+      failedResponseHandler: openaiFailedResponseHandler,
+      successfulResponseHandler: createEventSourceResponseHandler(
+        openaiResponsesChunkSchema
+      ),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    const self = this;
+    let finishReason = "unknown";
+    let promptTokens = NaN;
+    let completionTokens = NaN;
+    let cachedPromptTokens = null;
+    let reasoningTokens = null;
+    let responseId = null;
+    const ongoingToolCalls = {};
+    let hasToolCalls = false;
+    return {
+      stream: response.pipeThrough(
+        new TransformStream({
+          transform(chunk, controller) {
+            var _a15, _b, _c, _d, _e, _f, _g, _h;
+            if (!chunk.success) {
+              finishReason = "error";
+              controller.enqueue({ type: "error", error: chunk.error });
+              return;
+            }
+            const value = chunk.value;
+            if (isResponseOutputItemAddedChunk(value)) {
+              if (value.item.type === "function_call") {
+                ongoingToolCalls[value.output_index] = {
+                  toolName: value.item.name,
+                  toolCallId: value.item.call_id
+                };
+                controller.enqueue({
+                  type: "tool-call-delta",
+                  toolCallType: "function",
+                  toolCallId: value.item.call_id,
+                  toolName: value.item.name,
+                  argsTextDelta: value.item.arguments
+                });
+              }
+            } else if (isResponseFunctionCallArgumentsDeltaChunk(value)) {
+              const toolCall = ongoingToolCalls[value.output_index];
+              if (toolCall != null) {
+                controller.enqueue({
+                  type: "tool-call-delta",
+                  toolCallType: "function",
+                  toolCallId: toolCall.toolCallId,
+                  toolName: toolCall.toolName,
+                  argsTextDelta: value.delta
+                });
+              }
+            } else if (isResponseCreatedChunk(value)) {
+              responseId = value.response.id;
+              controller.enqueue({
+                type: "response-metadata",
+                id: value.response.id,
+                timestamp: new Date(value.response.created_at * 1e3),
+                modelId: value.response.model
+              });
+            } else if (isTextDeltaChunk(value)) {
+              controller.enqueue({
+                type: "text-delta",
+                textDelta: value.delta
+              });
+            } else if (isResponseOutputItemDoneChunk(value) && value.item.type === "function_call") {
+              ongoingToolCalls[value.output_index] = void 0;
+              hasToolCalls = true;
+              controller.enqueue({
+                type: "tool-call",
+                toolCallType: "function",
+                toolCallId: value.item.call_id,
+                toolName: value.item.name,
+                args: value.item.arguments
+              });
+            } else if (isResponseFinishedChunk(value)) {
+              finishReason = mapOpenAIResponseFinishReason({
+                finishReason: (_a15 = value.response.incomplete_details) == null ? void 0 : _a15.reason,
+                hasToolCalls
+              });
+              promptTokens = value.response.usage.input_tokens;
+              completionTokens = value.response.usage.output_tokens;
+              cachedPromptTokens = (_c = (_b = value.response.usage.input_tokens_details) == null ? void 0 : _b.cached_tokens) != null ? _c : cachedPromptTokens;
+              reasoningTokens = (_e = (_d = value.response.usage.output_tokens_details) == null ? void 0 : _d.reasoning_tokens) != null ? _e : reasoningTokens;
+            } else if (isResponseAnnotationAddedChunk(value)) {
+              controller.enqueue({
+                type: "source",
+                source: {
+                  sourceType: "url",
+                  id: (_h = (_g = (_f = self.config).generateId) == null ? void 0 : _g.call(_f)) != null ? _h : generateId(),
+                  url: value.annotation.url,
+                  title: value.annotation.title
+                }
+              });
+            }
+          },
+          flush(controller) {
+            controller.enqueue({
+              type: "finish",
+              finishReason,
+              usage: { promptTokens, completionTokens },
+              ...(cachedPromptTokens != null || reasoningTokens != null) && {
+                providerMetadata: {
+                  openai: {
+                    responseId,
+                    cachedPromptTokens,
+                    reasoningTokens
+                  }
+                }
+              }
+            });
+          }
+        })
+      ),
+      rawCall: {
+        rawPrompt: void 0,
+        rawSettings: {}
+      },
+      rawResponse: { headers: responseHeaders },
+      request: { body: JSON.stringify(body) },
+      warnings
+    };
+  }
+};
+var usageSchema = z.object({
+  input_tokens: z.number(),
+  input_tokens_details: z.object({ cached_tokens: z.number().nullish() }).nullish(),
+  output_tokens: z.number(),
+  output_tokens_details: z.object({ reasoning_tokens: z.number().nullish() }).nullish()
+});
+var textDeltaChunkSchema = z.object({
+  type: z.literal("response.output_text.delta"),
+  delta: z.string()
+});
+var responseFinishedChunkSchema = z.object({
+  type: z.enum(["response.completed", "response.incomplete"]),
+  response: z.object({
+    incomplete_details: z.object({ reason: z.string() }).nullish(),
+    usage: usageSchema
+  })
+});
+var responseCreatedChunkSchema = z.object({
+  type: z.literal("response.created"),
+  response: z.object({
+    id: z.string(),
+    created_at: z.number(),
+    model: z.string()
+  })
+});
+var responseOutputItemDoneSchema = z.object({
+  type: z.literal("response.output_item.done"),
+  output_index: z.number(),
+  item: z.discriminatedUnion("type", [
+    z.object({
+      type: z.literal("message")
+    }),
+    z.object({
+      type: z.literal("function_call"),
+      id: z.string(),
+      call_id: z.string(),
+      name: z.string(),
+      arguments: z.string(),
+      status: z.literal("completed")
+    })
+  ])
+});
+var responseFunctionCallArgumentsDeltaSchema = z.object({
+  type: z.literal("response.function_call_arguments.delta"),
+  item_id: z.string(),
+  output_index: z.number(),
+  delta: z.string()
+});
+var responseOutputItemAddedSchema = z.object({
+  type: z.literal("response.output_item.added"),
+  output_index: z.number(),
+  item: z.discriminatedUnion("type", [
+    z.object({
+      type: z.literal("message")
+    }),
+    z.object({
+      type: z.literal("function_call"),
+      id: z.string(),
+      call_id: z.string(),
+      name: z.string(),
+      arguments: z.string()
+    })
+  ])
+});
+var responseAnnotationAddedSchema = z.object({
+  type: z.literal("response.output_text.annotation.added"),
+  annotation: z.object({
+    type: z.literal("url_citation"),
+    url: z.string(),
+    title: z.string()
+  })
+});
+var openaiResponsesChunkSchema = z.union([
+  textDeltaChunkSchema,
+  responseFinishedChunkSchema,
+  responseCreatedChunkSchema,
+  responseOutputItemDoneSchema,
+  responseFunctionCallArgumentsDeltaSchema,
+  responseOutputItemAddedSchema,
+  responseAnnotationAddedSchema,
+  z.object({ type: z.string() }).passthrough()
+  // fallback for unknown chunks
+]);
+function isTextDeltaChunk(chunk) {
+  return chunk.type === "response.output_text.delta";
+}
+function isResponseOutputItemDoneChunk(chunk) {
+  return chunk.type === "response.output_item.done";
+}
+function isResponseFinishedChunk(chunk) {
+  return chunk.type === "response.completed" || chunk.type === "response.incomplete";
+}
+function isResponseCreatedChunk(chunk) {
+  return chunk.type === "response.created";
+}
+function isResponseFunctionCallArgumentsDeltaChunk(chunk) {
+  return chunk.type === "response.function_call_arguments.delta";
+}
+function isResponseOutputItemAddedChunk(chunk) {
+  return chunk.type === "response.output_item.added";
+}
+function isResponseAnnotationAddedChunk(chunk) {
+  return chunk.type === "response.output_text.annotation.added";
+}
+function getResponsesModelConfig(modelId) {
+  if (modelId.startsWith("o")) {
+    if (modelId.startsWith("o1-mini") || modelId.startsWith("o1-preview")) {
+      return {
+        isReasoningModel: true,
+        systemMessageMode: "remove",
+        requiredAutoTruncation: false
+      };
+    }
+    return {
+      isReasoningModel: true,
+      systemMessageMode: "developer",
+      requiredAutoTruncation: false
+    };
+  }
+  return {
+    isReasoningModel: false,
+    systemMessageMode: "system",
+    requiredAutoTruncation: false
+  };
+}
+var openaiResponsesProviderOptionsSchema = z.object({
+  metadata: z.any().nullish(),
+  parallelToolCalls: z.boolean().nullish(),
+  previousResponseId: z.string().nullish(),
+  store: z.boolean().nullish(),
+  user: z.string().nullish(),
+  reasoningEffort: z.string().nullish(),
+  strictSchemas: z.boolean().nullish(),
+  instructions: z.string().nullish()
+});
+var WebSearchPreviewParameters = z.object({});
+function webSearchPreviewTool({
+  searchContextSize,
+  userLocation
+} = {}) {
+  return {
+    type: "provider-defined",
+    id: "openai.web_search_preview",
+    args: {
+      searchContextSize,
+      userLocation
+    },
+    parameters: WebSearchPreviewParameters
+  };
+}
+var openaiTools = {
+  webSearchPreview: webSearchPreviewTool
+};
+function createOpenAI(options = {}) {
+  var _a15, _b, _c;
+  const baseURL = (_a15 = withoutTrailingSlash(options.baseURL)) != null ? _a15 : "https://api.openai.com/v1";
+  const compatibility = (_b = options.compatibility) != null ? _b : "compatible";
+  const providerName = (_c = options.name) != null ? _c : "openai";
+  const getHeaders = () => ({
+    Authorization: `Bearer ${loadApiKey({
+      apiKey: options.apiKey,
+      environmentVariableName: "OPENAI_API_KEY",
+      description: "OpenAI"
+    })}`,
+    "OpenAI-Organization": options.organization,
+    "OpenAI-Project": options.project,
+    ...options.headers
+  });
+  const createChatModel = (modelId, settings = {}) => new OpenAIChatLanguageModel(modelId, settings, {
+    provider: `${providerName}.chat`,
+    url: ({ path }) => `${baseURL}${path}`,
+    headers: getHeaders,
+    compatibility,
+    fetch: options.fetch
+  });
+  const createCompletionModel = (modelId, settings = {}) => new OpenAICompletionLanguageModel(modelId, settings, {
+    provider: `${providerName}.completion`,
+    url: ({ path }) => `${baseURL}${path}`,
+    headers: getHeaders,
+    compatibility,
+    fetch: options.fetch
+  });
+  const createEmbeddingModel = (modelId, settings = {}) => new OpenAIEmbeddingModel(modelId, settings, {
+    provider: `${providerName}.embedding`,
+    url: ({ path }) => `${baseURL}${path}`,
+    headers: getHeaders,
+    fetch: options.fetch
+  });
+  const createImageModel = (modelId, settings = {}) => new OpenAIImageModel(modelId, settings, {
+    provider: `${providerName}.image`,
+    url: ({ path }) => `${baseURL}${path}`,
+    headers: getHeaders,
+    fetch: options.fetch
+  });
+  const createTranscriptionModel = (modelId) => new OpenAITranscriptionModel(modelId, {
+    provider: `${providerName}.transcription`,
+    url: ({ path }) => `${baseURL}${path}`,
+    headers: getHeaders,
+    fetch: options.fetch
+  });
+  const createLanguageModel = (modelId, settings) => {
+    if (new.target) {
+      throw new Error(
+        "The OpenAI model function cannot be called with the new keyword."
+      );
+    }
+    if (modelId === "gpt-3.5-turbo-instruct") {
+      return createCompletionModel(
+        modelId,
+        settings
+      );
+    }
+    return createChatModel(modelId, settings);
+  };
+  const createResponsesModel = (modelId) => {
+    return new OpenAIResponsesLanguageModel(modelId, {
+      provider: `${providerName}.responses`,
+      url: ({ path }) => `${baseURL}${path}`,
+      headers: getHeaders,
+      fetch: options.fetch
+    });
+  };
+  const provider = function(modelId, settings) {
+    return createLanguageModel(modelId, settings);
+  };
+  provider.languageModel = createLanguageModel;
+  provider.chat = createChatModel;
+  provider.completion = createCompletionModel;
+  provider.responses = createResponsesModel;
+  provider.embedding = createEmbeddingModel;
+  provider.textEmbedding = createEmbeddingModel;
+  provider.textEmbeddingModel = createEmbeddingModel;
+  provider.image = createImageModel;
+  provider.imageModel = createImageModel;
+  provider.transcription = createTranscriptionModel;
+  provider.transcriptionModel = createTranscriptionModel;
+  provider.tools = openaiTools;
+  return provider;
+}
+createOpenAI({
+  compatibility: "strict"
+  // strict for OpenAI API
+});
+
+// src/document/extractors/types.ts
+var STRIP_REGEX = /(\r\n|\n|\r)/gm;
+var openai2 = createOpenAI({ apiKey: process.env.OPENAI_API_KEY });
+var baseLLM = openai2("gpt-4o");
+
+// src/document/extractors/title.ts
+var TitleExtractor = class extends BaseExtractor {
+  /**
+   * MastraLanguageModel instance.
+   * @type {MastraLanguageModel}
+   */
+  llm;
+  /**
+   * Can work for mixture of text and non-text nodes
+   * @type {boolean}
+   * @default false
+   */
+  isTextNodeOnly = false;
+  /**
+   * Number of nodes to extrct titles from.
+   * @type {number}
+   * @default 5
+   */
+  nodes = 5;
+  /**
+   * The prompt template to use for the title extractor.
+   * @type {string}
+   */
+  nodeTemplate;
+  /**
+   * The prompt template to merge title with..
+   * @type {string}
+   */
+  combineTemplate;
+  /**
+   * Constructor for the TitleExtractor class.
+   * @param {MastraLanguageModel} llm MastraLanguageModel instance.
+   * @param {number} nodes Number of nodes to extract titles from.
+   * @param {TitleExtractorPrompt} nodeTemplate The prompt template to use for the title extractor.
+   * @param {string} combineTemplate The prompt template to merge title with..
+   */
+  constructor(options) {
+    super();
+    this.llm = options?.llm ?? baseLLM;
+    this.nodes = options?.nodes ?? 5;
+    this.nodeTemplate = options?.nodeTemplate ? new PromptTemplate({
+      templateVars: ["context"],
+      template: options.nodeTemplate
+    }) : defaultTitleExtractorPromptTemplate;
+    this.combineTemplate = options?.combineTemplate ? new PromptTemplate({
+      templateVars: ["context"],
+      template: options.combineTemplate
+    }) : defaultTitleCombinePromptTemplate;
+  }
+  /**
+   * Extract titles from a list of nodes.
+   * @param {BaseNode[]} nodes Nodes to extract titles from.
+   * @returns {Promise<BaseNode<ExtractTitle>[]>} Titles extracted from the nodes.
+   */
+  async extract(nodes) {
+    const results = new Array(nodes.length);
+    const nodesToExtractTitle = [];
+    const nodeIndexes = [];
+    nodes.forEach((node, idx) => {
+      const text = node.getContent(this.metadataMode);
+      if (!text || text.trim() === "") {
+        results[idx] = { documentTitle: "" };
+      } else {
+        nodesToExtractTitle.push(node);
+        nodeIndexes.push(idx);
+      }
+    });
+    if (nodesToExtractTitle.length) {
+      const filteredNodes = this.filterNodes(nodesToExtractTitle);
+      if (filteredNodes.length) {
+        const nodesByDocument = this.separateNodesByDocument(filteredNodes);
+        const titlesByDocument = await this.extractTitles(nodesByDocument);
+        filteredNodes.forEach((node, i) => {
+          const nodeIndex = nodeIndexes[i];
+          const groupKey = node.sourceNode?.nodeId ?? node.id_;
+          if (typeof nodeIndex === "number") {
+            results[nodeIndex] = {
+              documentTitle: titlesByDocument[groupKey] ?? ""
+            };
+          }
+        });
+      }
+    }
+    return results;
+  }
+  filterNodes(nodes) {
+    return nodes.filter((node) => {
+      if (this.isTextNodeOnly && !(node instanceof TextNode)) {
+        return false;
+      }
+      return true;
+    });
+  }
+  separateNodesByDocument(nodes) {
+    const nodesByDocument = {};
+    for (const node of nodes) {
+      const groupKey = node.sourceNode?.nodeId ?? node.id_;
+      nodesByDocument[groupKey] = nodesByDocument[groupKey] || [];
+      nodesByDocument[groupKey].push(node);
+    }
+    return nodesByDocument;
+  }
+  async extractTitles(nodesByDocument) {
+    const titlesByDocument = {};
+    for (const [key, nodes] of Object.entries(nodesByDocument)) {
+      const titleCandidates = await this.getTitlesCandidates(nodes);
+      const combinedTitles = titleCandidates.join(", ");
+      const completion = await this.llm.doGenerate({
+        inputFormat: "messages",
+        mode: { type: "regular" },
+        prompt: [
+          {
+            role: "user",
+            content: [
+              {
+                type: "text",
+                text: this.combineTemplate.format({
+                  context: combinedTitles
+                })
+              }
+            ]
+          }
+        ]
+      });
+      let title = "";
+      if (typeof completion.text === "string") {
+        title = completion.text.trim();
+      } else {
+        console.warn("Title extraction LLM output was not a string:", completion.text);
+      }
+      titlesByDocument[key] = title;
+    }
+    return titlesByDocument;
+  }
+  async getTitlesCandidates(nodes) {
+    const titleJobs = nodes.map(async (node) => {
+      const completion = await this.llm.doGenerate({
+        inputFormat: "messages",
+        mode: { type: "regular" },
+        prompt: [
+          {
+            role: "user",
+            content: [
+              {
+                type: "text",
+                text: this.nodeTemplate.format({
+                  context: node.getContent(MetadataMode.ALL)
+                })
+              }
+            ]
+          }
+        ]
+      });
+      if (typeof completion.text === "string") {
+        return completion.text.trim();
+      } else {
+        console.warn("Title candidate extraction LLM output was not a string:", completion.text);
+        return "";
+      }
+    });
+    return await Promise.all(titleJobs);
+  }
+};
+var SummaryExtractor = class extends BaseExtractor {
+  /**
+   * MastraLanguageModel instance.
+   * @type {MastraLanguageModel}
+   */
+  llm;
+  /**
+   * List of summaries to extract: 'self', 'prev', 'next'
+   * @type {string[]}
+   */
+  summaries;
+  /**
+   * The prompt template to use for the summary extractor.
+   * @type {string}
+   */
+  promptTemplate;
+  selfSummary;
+  prevSummary;
+  nextSummary;
+  constructor(options) {
+    const summaries = options?.summaries ?? ["self"];
+    if (summaries && !summaries.some((s) => ["self", "prev", "next"].includes(s)))
+      throw new Error("Summaries must be one of 'self', 'prev', 'next'");
+    super();
+    this.llm = options?.llm ?? baseLLM;
+    this.summaries = summaries;
+    this.promptTemplate = options?.promptTemplate ? new PromptTemplate({
+      templateVars: ["context"],
+      template: options.promptTemplate
+    }) : defaultSummaryPrompt;
+    this.selfSummary = summaries?.includes("self") ?? false;
+    this.prevSummary = summaries?.includes("prev") ?? false;
+    this.nextSummary = summaries?.includes("next") ?? false;
+  }
+  /**
+   * Extract summary from a node.
+   * @param {BaseNode} node Node to extract summary from.
+   * @returns {Promise<string>} Summary extracted from the node.
+   */
+  async generateNodeSummary(node) {
+    const text = node.getContent(this.metadataMode);
+    if (!text || text.trim() === "") {
+      return "";
+    }
+    if (this.isTextNodeOnly && !(node instanceof TextNode)) {
+      return "";
+    }
+    const context = node.getContent(this.metadataMode);
+    const prompt = this.promptTemplate.format({
+      context
+    });
+    const result = await this.llm.doGenerate({
+      inputFormat: "messages",
+      mode: { type: "regular" },
+      prompt: [
+        {
+          role: "user",
+          content: [{ type: "text", text: prompt }]
+        }
+      ]
+    });
+    let summary = "";
+    if (typeof result.text === "string") {
+      summary = result.text.trim();
+    } else {
+      console.warn("Summary extraction LLM output was not a string:", result.text);
+    }
+    return summary.replace(STRIP_REGEX, "");
+  }
+  /**
+   * Extract summaries from a list of nodes.
+   * @param {BaseNode[]} nodes Nodes to extract summaries from.
+   * @returns {Promise<ExtractSummary[]>} Summaries extracted from the nodes.
+   */
+  async extract(nodes) {
+    if (!nodes.every((n) => n instanceof TextNode)) throw new Error("Only `TextNode` is allowed for `Summary` extractor");
+    const nodeSummaries = await Promise.all(nodes.map((node) => this.generateNodeSummary(node)));
+    const metadataList = nodes.map(() => ({}));
+    for (let i = 0; i < nodes.length; i++) {
+      if (i > 0 && this.prevSummary && nodeSummaries[i - 1]) {
+        metadataList[i]["prevSectionSummary"] = nodeSummaries[i - 1];
+      }
+      if (i < nodes.length - 1 && this.nextSummary && nodeSummaries[i + 1]) {
+        metadataList[i]["nextSectionSummary"] = nodeSummaries[i + 1];
+      }
+      if (this.selfSummary && nodeSummaries[i]) {
+        metadataList[i]["sectionSummary"] = nodeSummaries[i];
+      }
+    }
+    return metadataList;
+  }
+};
+var QuestionsAnsweredExtractor = class extends BaseExtractor {
+  /**
+   * MastraLanguageModel instance.
+   * @type {MastraLanguageModel}
+   */
+  llm;
+  /**
+   * Number of questions to generate.
+   * @type {number}
+   * @default 5
+   */
+  questions = 5;
+  /**
+   * The prompt template to use for the question extractor.
+   * @type {string}
+   */
+  promptTemplate;
+  /**
+   * Wheter to use metadata for embeddings only
+   * @type {boolean}
+   * @default false
+   */
+  embeddingOnly = false;
+  /**
+   * Constructor for the QuestionsAnsweredExtractor class.
+   * @param {MastraLanguageModel} llm MastraLanguageModel instance.
+   * @param {number} questions Number of questions to generate.
+   * @param {QuestionExtractPrompt['template']} promptTemplate Optional custom prompt template (should include {context}).
+   * @param {boolean} embeddingOnly Whether to use metadata for embeddings only.
+   */
+  constructor(options) {
+    if (options?.questions && options.questions < 1) throw new Error("Questions must be greater than 0");
+    super();
+    this.llm = options?.llm ?? baseLLM;
+    this.questions = options?.questions ?? 5;
+    this.promptTemplate = options?.promptTemplate ? new PromptTemplate({
+      templateVars: ["numQuestions", "context"],
+      template: options.promptTemplate
+    }).partialFormat({
+      numQuestions: "5"
+    }) : defaultQuestionExtractPrompt;
+    this.embeddingOnly = options?.embeddingOnly ?? false;
+  }
+  /**
+   * Extract answered questions from a node.
+   * @param {BaseNode} node Node to extract questions from.
+   * @returns {Promise<Array<ExtractQuestion> | Array<{}>>} Questions extracted from the node.
+   */
+  async extractQuestionsFromNode(node) {
+    const text = node.getContent(this.metadataMode);
+    if (!text || text.trim() === "") {
+      return { questionsThisExcerptCanAnswer: "" };
+    }
+    if (this.isTextNodeOnly && !(node instanceof TextNode)) {
+      return { questionsThisExcerptCanAnswer: "" };
+    }
+    const contextStr = node.getContent(this.metadataMode);
+    const prompt = this.promptTemplate.format({
+      context: contextStr,
+      numQuestions: this.questions.toString()
+    });
+    const questions = await this.llm.doGenerate({
+      inputFormat: "messages",
+      mode: { type: "regular" },
+      prompt: [
+        {
+          role: "user",
+          content: [{ type: "text", text: prompt }]
+        }
+      ]
+    });
+    let result = "";
+    try {
+      if (typeof questions.text === "string") {
+        result = questions.text.replace(STRIP_REGEX, "").trim();
+      } else {
+        console.warn("Question extraction LLM output was not a string:", questions.text);
+      }
+    } catch (err) {
+      console.warn("Question extraction failed:", err);
+    }
+    return {
+      questionsThisExcerptCanAnswer: result
+    };
+  }
+  /**
+   * Extract answered questions from a list of nodes.
+   * @param {BaseNode[]} nodes Nodes to extract questions from.
+   * @returns {Promise<Array<ExtractQuestion> | Array<{}>>} Questions extracted from the nodes.
+   */
+  async extract(nodes) {
+    const results = await Promise.all(nodes.map((node) => this.extractQuestionsFromNode(node)));
+    return results;
+  }
+};
+var KeywordExtractor = class extends BaseExtractor {
+  /**
+   * MastraLanguageModel instance.
+   * @type {MastraLanguageModel}
+   */
+  llm;
+  /**
+   * Number of keywords to extract.
+   * @type {number}
+   * @default 5
+   */
+  keywords = 5;
+  /**
+   * The prompt template to use for the question extractor.
+   * @type {string}
+   */
+  promptTemplate;
+  /**
+   * Constructor for the KeywordExtractor class.
+   * @param {MastraLanguageModel} llm MastraLanguageModel instance.
+   * @param {number} keywords Number of keywords to extract.
+   * @param {string} [promptTemplate] Optional custom prompt template (must include {context})
+   * @throws {Error} If keywords is less than 1.
+   */
+  constructor(options) {
+    if (options?.keywords && options.keywords < 1) throw new Error("Keywords must be greater than 0");
+    super();
+    this.llm = options?.llm ?? baseLLM;
+    this.keywords = options?.keywords ?? 5;
+    this.promptTemplate = options?.promptTemplate ? new PromptTemplate({
+      templateVars: ["context", "maxKeywords"],
+      template: options.promptTemplate
+    }) : defaultKeywordExtractPrompt;
+  }
+  /**
+   *
+   * @param node Node to extract keywords from.
+   * @returns Keywords extracted from the node.
+   */
+  /**
+   * Extract keywords from a node. Returns an object with a comma-separated string of keywords, or an empty string if extraction fails.
+   * Adds error handling for malformed/empty LLM output.
+   */
+  async extractKeywordsFromNodes(node) {
+    const text = node.getContent(this.metadataMode);
+    if (!text || text.trim() === "") {
+      return { excerptKeywords: "" };
+    }
+    if (this.isTextNodeOnly && !(node instanceof TextNode)) {
+      return { excerptKeywords: "" };
+    }
+    let keywords = "";
+    try {
+      const completion = await this.llm.doGenerate({
+        inputFormat: "messages",
+        mode: { type: "regular" },
+        prompt: [
+          {
+            role: "user",
+            content: [
+              {
+                type: "text",
+                text: this.promptTemplate.format({
+                  context: node.getContent(MetadataMode.ALL),
+                  maxKeywords: this.keywords.toString()
+                })
+              }
+            ]
+          }
+        ]
+      });
+      if (typeof completion.text === "string") {
+        keywords = completion.text.trim();
+      } else {
+        console.warn("Keyword extraction LLM output was not a string:", completion.text);
+      }
+    } catch (err) {
+      console.warn("Keyword extraction failed:", err);
+    }
+    return { excerptKeywords: keywords };
+  }
+  /**
+   *
+   * @param nodes Nodes to extract keywords from.
+   * @returns Keywords extracted from the nodes.
+   */
+  /**
+   * Extract keywords from an array of nodes. Always returns an array (may be empty).
+   * @param nodes Nodes to extract keywords from.
+   * @returns Array of keyword extraction results.
+   */
+  async extract(nodes) {
+    if (!Array.isArray(nodes) || nodes.length === 0) return [];
+    const results = await Promise.all(nodes.map((node) => this.extractKeywordsFromNodes(node)));
+    return results;
+  }
+};
 
 // src/document/types.ts
 var Language = /* @__PURE__ */ ((Language2) => {
@@ -508,7 +4474,7 @@ var HTMLSectionTransformer = class {
   headersToSplitOn;
   options;
   constructor(headersToSplitOn, options = {}) {
-    this.headersToSplitOn = Object.fromEntries(headersToSplitOn.map(([tag, name]) => [tag.toLowerCase(), name]));
+    this.headersToSplitOn = Object.fromEntries(headersToSplitOn.map(([tag, name14]) => [tag.toLowerCase(), name14]));
     this.options = options;
   }
   splitText(text) {
@@ -1102,7 +5068,7 @@ var MarkdownHeaderTransformer = class {
         continue;
       }
       let headerMatched = false;
-      for (const [sep, name] of this.headersToSplitOn) {
+      for (const [sep, name14] of this.headersToSplitOn) {
         if (strippedLine.startsWith(sep) && (strippedLine.length === sep.length || strippedLine[sep.length] === " ")) {
           headerMatched = true;
           if (currentContent.length > 0) {
@@ -1112,7 +5078,7 @@ var MarkdownHeaderTransformer = class {
             });
             currentContent = [];
           }
-          if (name !== null) {
+          if (name14 !== null) {
             const currentHeaderLevel = (sep.match(/#/g) || []).length;
             while (headerStack.length > 0 && headerStack?.[headerStack.length - 1].level >= currentHeaderLevel) {
               const poppedHeader = headerStack.pop();
@@ -1122,11 +5088,11 @@ var MarkdownHeaderTransformer = class {
             }
             const header = {
               level: currentHeaderLevel,
-              name,
+              name: name14,
               data: strippedLine.slice(sep.length).trim()
             };
             headerStack.push(header);
-            initialMetadata[name] = header.data;
+            initialMetadata[name14] = header.data;
           }
           linesWithMetadata.push({
             content: line,
@@ -1304,16 +5270,16 @@ var MDocument = class _MDocument {
     if (typeof title !== "undefined") {
       transformations.push(new TitleExtractor(typeof title === "boolean" ? {} : title));
       this.chunks = this.chunks.map(
-        (doc, i) => new Document({
+        (doc) => doc?.metadata?.docId ? new Document({
           ...doc,
           relationships: {
             [NodeRelationship.SOURCE]: {
-              nodeId: `doc-${i}`,
+              nodeId: doc.metadata.docId,
               nodeType: ObjectType.DOCUMENT,
               metadata: doc.metadata
             }
           }
-        })
+        }) : doc
       );
     }
     const pipeline = new IngestionPipeline({