@elizaos/plugin-openai 2.0.3-beta.2 → 2.0.3-beta.3

package/dist/node/index.node.js

@@ -0,0 +1,2057 @@
+// index.ts
+import { logger as logger9, ModelType as ModelType5 } from "@elizaos/core";
+
+// init.ts
+import { logger as logger2 } from "@elizaos/core";
+
+// utils/config.ts
+import { logger } from "@elizaos/core";
+function getEnvValue(key) {
+  if (typeof process === "undefined" || !process.env) {
+    return;
+  }
+  const value = process.env[key];
+  return value === undefined ? undefined : String(value);
+}
+function getSetting(runtime, key, defaultValue) {
+  const value = runtime.getSetting(key);
+  if (value !== undefined && value !== null) {
+    return String(value);
+  }
+  return getEnvValue(key) ?? defaultValue;
+}
+function getNumericSetting(runtime, key, defaultValue) {
+  const value = getSetting(runtime, key);
+  if (value === undefined) {
+    return defaultValue;
+  }
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed)) {
+    throw new Error(`Setting '${key}' must be a valid integer, got: ${value}`);
+  }
+  return parsed;
+}
+function getBooleanSetting(runtime, key, defaultValue) {
+  const value = getSetting(runtime, key);
+  if (value === undefined) {
+    return defaultValue;
+  }
+  const normalized = value.toLowerCase();
+  return normalized === "true" || normalized === "1" || normalized === "yes";
+}
+function isBrowser() {
+  return typeof globalThis !== "undefined" && typeof globalThis.document !== "undefined";
+}
+function isProxyMode(runtime) {
+  return isBrowser() && !!getSetting(runtime, "OPENAI_BROWSER_BASE_URL");
+}
+function isCerebrasMode(runtime) {
+  const explicitProvider = getSetting(runtime, "ELIZA_PROVIDER");
+  if (explicitProvider && explicitProvider.toLowerCase() === "cerebras") {
+    return true;
+  }
+  const baseURL = getSetting(runtime, "OPENAI_BASE_URL");
+  if (baseURL && /(^|\.)cerebras\.ai(\/|$)/i.test(baseURL)) {
+    return true;
+  }
+  const cerebrasKey = getSetting(runtime, "CEREBRAS_API_KEY");
+  if (cerebrasKey && !getSetting(runtime, "OPENAI_API_KEY") && !getSetting(runtime, "OPENAI_BASE_URL")) {
+    return true;
+  }
+  return false;
+}
+function isEvoLinkMode(runtime) {
+  const explicitProvider = getSetting(runtime, "ELIZA_PROVIDER");
+  if (explicitProvider && explicitProvider.toLowerCase() === "evolink") {
+    return true;
+  }
+  const baseURL = getSetting(runtime, "OPENAI_BASE_URL");
+  if (baseURL && /(^|\.)evolink\.ai(\/|$)/i.test(baseURL)) {
+    return true;
+  }
+  const evolinkKey = getSetting(runtime, "EVOLINK_API_KEY");
+  if (evolinkKey && !getSetting(runtime, "OPENAI_API_KEY") && !getSetting(runtime, "OPENAI_BASE_URL")) {
+    return true;
+  }
+  return false;
+}
+function getApiKey(runtime) {
+  if (isCerebrasMode(runtime)) {
+    const cerebrasKey = getSetting(runtime, "CEREBRAS_API_KEY");
+    if (cerebrasKey) {
+      return cerebrasKey;
+    }
+  }
+  if (isEvoLinkMode(runtime)) {
+    const evolinkKey = getSetting(runtime, "EVOLINK_API_KEY");
+    if (evolinkKey) {
+      return evolinkKey;
+    }
+  }
+  return getSetting(runtime, "OPENAI_API_KEY");
+}
+function getEmbeddingApiKey(runtime) {
+  const embeddingApiKey = getSetting(runtime, "OPENAI_EMBEDDING_API_KEY");
+  if (embeddingApiKey) {
+    logger.debug("[OpenAI] Using specific embedding API key");
+    return embeddingApiKey;
+  }
+  logger.debug("[OpenAI] Falling back to general API key for embeddings");
+  return getApiKey(runtime);
+}
+function getAuthHeader(runtime, forEmbedding = false) {
+  if (isBrowser() && !getBooleanSetting(runtime, "OPENAI_ALLOW_BROWSER_API_KEY", false)) {
+    return {};
+  }
+  const key = forEmbedding ? getEmbeddingApiKey(runtime) : getApiKey(runtime);
+  return key ? { Authorization: `Bearer ${key}` } : {};
+}
+function authHeaderForKey(runtime, key) {
+  if (isBrowser() && !getBooleanSetting(runtime, "OPENAI_ALLOW_BROWSER_API_KEY", false)) {
+    return {};
+  }
+  return key ? { Authorization: `Bearer ${key}` } : {};
+}
+function getMockBaseURL() {
+  const base = getEnvValue("ELIZA_MOCK_OPENAI_BASE")?.trim();
+  return base ? base : undefined;
+}
+function getBaseURL(runtime) {
+  const browserURL = getSetting(runtime, "OPENAI_BROWSER_BASE_URL");
+  const mockBaseURL = getMockBaseURL();
+  const cerebrasBaseURL = isCerebrasMode(runtime) && !getSetting(runtime, "OPENAI_BASE_URL") ? getSetting(runtime, "CEREBRAS_BASE_URL") ?? "https://api.cerebras.ai/v1" : undefined;
+  const evolinkBaseURL = isEvoLinkMode(runtime) && !getSetting(runtime, "OPENAI_BASE_URL") ? getSetting(runtime, "EVOLINK_BASE_URL") ?? "https://direct.evolink.ai/v1" : undefined;
+  const baseURL = isBrowser() && browserURL ? browserURL : mockBaseURL ?? getSetting(runtime, "OPENAI_BASE_URL") ?? cerebrasBaseURL ?? evolinkBaseURL ?? "https://api.openai.com/v1";
+  logger.debug(`[OpenAI] Base URL: ${baseURL}`);
+  return baseURL;
+}
+function getEmbeddingBaseURL(runtime) {
+  const embeddingURL = isBrowser() ? getSetting(runtime, "OPENAI_BROWSER_EMBEDDING_URL") ?? getSetting(runtime, "OPENAI_BROWSER_BASE_URL") : getSetting(runtime, "OPENAI_EMBEDDING_URL");
+  if (embeddingURL) {
+    logger.debug(`[OpenAI] Using embedding base URL: ${embeddingURL}`);
+    return embeddingURL;
+  }
+  logger.debug("[OpenAI] Falling back to general base URL for embeddings");
+  return getBaseURL(runtime);
+}
+function getImageDescriptionApiKey(runtime) {
+  const imageDescriptionApiKey = getSetting(runtime, "OPENAI_IMAGE_DESCRIPTION_API_KEY");
+  if (imageDescriptionApiKey) {
+    return imageDescriptionApiKey;
+  }
+  const imageDescriptionURL = getSetting(runtime, "OPENAI_IMAGE_DESCRIPTION_BASE_URL");
+  if (imageDescriptionURL && /(^|\.)openai\.com(\/|$)/i.test(imageDescriptionURL)) {
+    return getSetting(runtime, "OPENAI_API_KEY");
+  }
+  return getApiKey(runtime);
+}
+function getImageDescriptionAuthHeader(runtime) {
+  return authHeaderForKey(runtime, getImageDescriptionApiKey(runtime));
+}
+function getImageDescriptionBaseURL(runtime) {
+  const imageDescriptionURL = getSetting(runtime, "OPENAI_IMAGE_DESCRIPTION_BASE_URL");
+  if (imageDescriptionURL) {
+    logger.debug(`[OpenAI] Using image-description base URL: ${imageDescriptionURL}`);
+    return imageDescriptionURL;
+  }
+  return getBaseURL(runtime);
+}
+function getCerebrasModel(runtime) {
+  return isCerebrasMode(runtime) ? getSetting(runtime, "CEREBRAS_MODEL") : undefined;
+}
+function getEvoLinkModel(runtime) {
+  return isEvoLinkMode(runtime) ? getSetting(runtime, "EVOLINK_MODEL") ?? "gpt-5.2" : undefined;
+}
+function getSmallModel(runtime) {
+  return getSetting(runtime, "OPENAI_SMALL_MODEL") ?? getCerebrasModel(runtime) ?? getEvoLinkModel(runtime) ?? getSetting(runtime, "SMALL_MODEL") ?? "gpt-5.4-mini";
+}
+function getNanoModel(runtime) {
+  return getSetting(runtime, "OPENAI_NANO_MODEL") ?? getCerebrasModel(runtime) ?? getEvoLinkModel(runtime) ?? getSetting(runtime, "NANO_MODEL") ?? getSmallModel(runtime);
+}
+function getMediumModel(runtime) {
+  return getSetting(runtime, "OPENAI_MEDIUM_MODEL") ?? getCerebrasModel(runtime) ?? getEvoLinkModel(runtime) ?? getSetting(runtime, "MEDIUM_MODEL") ?? getSmallModel(runtime);
+}
+function getLargeModel(runtime) {
+  return getSetting(runtime, "OPENAI_LARGE_MODEL") ?? getCerebrasModel(runtime) ?? getEvoLinkModel(runtime) ?? getSetting(runtime, "LARGE_MODEL") ?? "gpt-5";
+}
+function getMegaModel(runtime) {
+  return getSetting(runtime, "OPENAI_MEGA_MODEL") ?? getSetting(runtime, "MEGA_MODEL") ?? getLargeModel(runtime);
+}
+function getResponseHandlerModel(runtime) {
+  return getSetting(runtime, "OPENAI_RESPONSE_HANDLER_MODEL") ?? getSetting(runtime, "OPENAI_SHOULD_RESPOND_MODEL") ?? getCerebrasModel(runtime) ?? getEvoLinkModel(runtime) ?? getSetting(runtime, "RESPONSE_HANDLER_MODEL") ?? getSetting(runtime, "SHOULD_RESPOND_MODEL") ?? getSmallModel(runtime);
+}
+function getActionPlannerModel(runtime) {
+  return getSetting(runtime, "OPENAI_ACTION_PLANNER_MODEL") ?? getSetting(runtime, "OPENAI_PLANNER_MODEL") ?? getCerebrasModel(runtime) ?? getEvoLinkModel(runtime) ?? getSetting(runtime, "ACTION_PLANNER_MODEL") ?? getSetting(runtime, "PLANNER_MODEL") ?? getMediumModel(runtime);
+}
+function getEmbeddingModel(runtime) {
+  return getSetting(runtime, "OPENAI_EMBEDDING_MODEL") ?? "text-embedding-3-small";
+}
+function getImageDescriptionModel(runtime) {
+  return getSetting(runtime, "OPENAI_IMAGE_DESCRIPTION_MODEL") ?? "gpt-5-mini";
+}
+function getTranscriptionModel(runtime) {
+  return getSetting(runtime, "OPENAI_TRANSCRIPTION_MODEL") ?? "gpt-5-mini-transcribe";
+}
+function getTTSModel(runtime) {
+  return getSetting(runtime, "OPENAI_TTS_MODEL") ?? "gpt-5-mini-tts";
+}
+function getTTSVoice(runtime) {
+  return getSetting(runtime, "OPENAI_TTS_VOICE") ?? "nova";
+}
+function getTTSInstructions(runtime) {
+  return getSetting(runtime, "OPENAI_TTS_INSTRUCTIONS") ?? "";
+}
+function getImageModel(runtime) {
+  return getSetting(runtime, "OPENAI_IMAGE_MODEL") ?? "dall-e-3";
+}
+function getExperimentalTelemetry(runtime) {
+  return getBooleanSetting(runtime, "OPENAI_EXPERIMENTAL_TELEMETRY", false);
+}
+function getEmbeddingDimensions(runtime) {
+  return getNumericSetting(runtime, "OPENAI_EMBEDDING_DIMENSIONS", 1536);
+}
+function getImageDescriptionMaxTokens(runtime) {
+  return getNumericSetting(runtime, "OPENAI_IMAGE_DESCRIPTION_MAX_TOKENS", 8192);
+}
+function getResearchModel(runtime) {
+  return getSetting(runtime, "OPENAI_RESEARCH_MODEL") ?? "o3-deep-research";
+}
+function getResearchTimeout(runtime) {
+  return getNumericSetting(runtime, "OPENAI_RESEARCH_TIMEOUT", 3600000);
+}
+
+// init.ts
+globalThis.AI_SDK_LOG_WARNINGS ??= false;
+function initializeOpenAI(_config, runtime) {
+  validateOpenAIConfiguration(runtime);
+}
+async function validateOpenAIConfiguration(runtime) {
+  if (isBrowser()) {
+    logger2.debug("[OpenAI] Skipping API validation in browser environment");
+    return;
+  }
+  const apiKey = getApiKey(runtime);
+  if (!apiKey) {
+    logger2.warn("[OpenAI] OPENAI_API_KEY is not configured. " + "OpenAI functionality will fail until a valid API key is provided.");
+    return;
+  }
+  try {
+    const baseURL = getBaseURL(runtime);
+    const response = await fetch(`${baseURL}/models`, {
+      headers: getAuthHeader(runtime)
+    });
+    if (!response.ok) {
+      logger2.warn(`[OpenAI] API key validation failed: ${response.status} ${response.statusText}. ` + "Please verify your OPENAI_API_KEY is correct.");
+      return;
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logger2.warn(`[OpenAI] API validation error: ${message}. OpenAI functionality may be limited.`);
+  }
+}
+
+// models/audio.ts
+import { logger as logger4, recordLlmCall } from "@elizaos/core";
+
+// utils/audio.ts
+import { logger as logger3 } from "@elizaos/core";
+var MAGIC_BYTES = {
+  WAV: {
+    HEADER: [82, 73, 70, 70],
+    IDENTIFIER: [87, 65, 86, 69]
+  },
+  MP3_ID3: [73, 68, 51],
+  OGG: [79, 103, 103, 83],
+  FLAC: [102, 76, 97, 67],
+  FTYP: [102, 116, 121, 112],
+  WEBM_EBML: [26, 69, 223, 163]
+};
+var MIN_DETECTION_BUFFER_SIZE = 12;
+function matchBytes(buffer, offset, expected) {
+  for (let i = 0;i < expected.length; i++) {
+    const expectedByte = expected[i];
+    if (expectedByte === undefined || buffer[offset + i] !== expectedByte) {
+      return false;
+    }
+  }
+  return true;
+}
+function detectAudioMimeType(buffer) {
+  if (buffer.length < MIN_DETECTION_BUFFER_SIZE) {
+    return "application/octet-stream";
+  }
+  if (matchBytes(buffer, 0, MAGIC_BYTES.WAV.HEADER) && matchBytes(buffer, 8, MAGIC_BYTES.WAV.IDENTIFIER)) {
+    return "audio/wav";
+  }
+  const firstByte = buffer[0];
+  const secondByte = buffer[1];
+  if (matchBytes(buffer, 0, MAGIC_BYTES.MP3_ID3) || firstByte === 255 && secondByte !== undefined && (secondByte & 224) === 224) {
+    return "audio/mpeg";
+  }
+  if (matchBytes(buffer, 0, MAGIC_BYTES.OGG)) {
+    return "audio/ogg";
+  }
+  if (matchBytes(buffer, 0, MAGIC_BYTES.FLAC)) {
+    return "audio/flac";
+  }
+  if (matchBytes(buffer, 4, MAGIC_BYTES.FTYP)) {
+    return "audio/mp4";
+  }
+  if (matchBytes(buffer, 0, MAGIC_BYTES.WEBM_EBML)) {
+    return "audio/webm";
+  }
+  logger3.warn("Could not detect audio format from buffer, using generic binary type");
+  return "application/octet-stream";
+}
+function getExtensionForMimeType(mimeType) {
+  switch (mimeType) {
+    case "audio/wav":
+      return "wav";
+    case "audio/mpeg":
+      return "mp3";
+    case "audio/ogg":
+      return "ogg";
+    case "audio/flac":
+      return "flac";
+    case "audio/mp4":
+      return "m4a";
+    case "audio/webm":
+      return "webm";
+    case "application/octet-stream":
+      return "bin";
+  }
+}
+function getFilenameForMimeType(mimeType) {
+  const ext = getExtensionForMimeType(mimeType);
+  return `recording.${ext}`;
+}
+
+// models/audio.ts
+function isBlobOrFile(value) {
+  return value instanceof Blob || value instanceof File;
+}
+function isBuffer(value) {
+  return Buffer.isBuffer(value);
+}
+function isLocalTranscriptionParams(value) {
+  return typeof value === "object" && value !== null && "audio" in value && (isBlobOrFile(value.audio) || isBuffer(value.audio));
+}
+function isCoreTranscriptionParams(value) {
+  return typeof value === "object" && value !== null && "audioUrl" in value && typeof value.audioUrl === "string";
+}
+async function fetchAudioFromUrl(url) {
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch audio from URL: ${response.status}`);
+  }
+  return response.blob();
+}
+async function handleTranscription(runtime, input) {
+  let modelName = getTranscriptionModel(runtime);
+  let blob;
+  let extraParams = {};
+  if (typeof input === "string") {
+    logger4.debug(`[OpenAI] Fetching audio from URL: ${input}`);
+    blob = await fetchAudioFromUrl(input);
+  } else if (isBlobOrFile(input)) {
+    blob = input;
+  } else if (isBuffer(input)) {
+    const mimeType2 = detectAudioMimeType(input);
+    logger4.debug(`[OpenAI] Auto-detected audio MIME type: ${mimeType2}`);
+    blob = new Blob([new Uint8Array(input)], { type: mimeType2 });
+  } else if (isLocalTranscriptionParams(input)) {
+    extraParams = input;
+    if (input.model) {
+      modelName = input.model;
+    }
+    if (isBuffer(input.audio)) {
+      const mimeType2 = input.mimeType ?? detectAudioMimeType(input.audio);
+      logger4.debug(`[OpenAI] Using MIME type: ${mimeType2}`);
+      blob = new Blob([new Uint8Array(input.audio)], { type: mimeType2 });
+    } else {
+      blob = input.audio;
+    }
+  } else if (isCoreTranscriptionParams(input)) {
+    logger4.debug(`[OpenAI] Fetching audio from URL: ${input.audioUrl}`);
+    blob = await fetchAudioFromUrl(input.audioUrl);
+    extraParams = { prompt: input.prompt };
+  } else {
+    throw new Error("TRANSCRIPTION expects Blob, File, Buffer, URL string, or TranscriptionParams object");
+  }
+  logger4.debug(`[OpenAI] Using TRANSCRIPTION model: ${modelName}`);
+  const mimeType = blob.type || "audio/webm";
+  const filename = blob.name || getFilenameForMimeType(mimeType.startsWith("audio/") ? mimeType : "audio/webm");
+  const formData = new FormData;
+  formData.append("file", blob, filename);
+  formData.append("model", modelName);
+  if (extraParams.language) {
+    formData.append("language", extraParams.language);
+  }
+  if (extraParams.responseFormat) {
+    formData.append("response_format", extraParams.responseFormat);
+  }
+  if (extraParams.prompt) {
+    formData.append("prompt", extraParams.prompt);
+  }
+  if (extraParams.temperature !== undefined) {
+    formData.append("temperature", String(extraParams.temperature));
+  }
+  if (extraParams.timestampGranularities) {
+    for (const granularity of extraParams.timestampGranularities) {
+      formData.append("timestamp_granularities[]", granularity);
+    }
+  }
+  const baseURL = getBaseURL(runtime);
+  const details = {
+    model: modelName,
+    systemPrompt: extraParams.prompt ?? "",
+    userPrompt: [
+      `audio transcription request: filename=${filename}`,
+      `mimeType=${mimeType}`,
+      extraParams.language ? `language=${extraParams.language}` : "",
+      extraParams.responseFormat ? `responseFormat=${extraParams.responseFormat}` : ""
+    ].filter(Boolean).join(" "),
+    temperature: extraParams.temperature ?? 0,
+    maxTokens: 0,
+    purpose: "external_llm",
+    actionType: "openai.audio.transcriptions.create"
+  };
+  const data = await recordLlmCall(runtime, details, async () => {
+    const response = await fetch(`${baseURL}/audio/transcriptions`, {
+      method: "POST",
+      headers: getAuthHeader(runtime),
+      body: formData
+    });
+    if (!response.ok) {
+      const errorText = await response.text().catch(() => "Unknown error");
+      throw new Error(`OpenAI transcription failed: ${response.status} ${response.statusText} - ${errorText}`);
+    }
+    const result = await response.json();
+    details.response = result.text;
+    return result;
+  });
+  return data.text;
+}
+async function handleTextToSpeech(runtime, input) {
+  let text;
+  let voice;
+  let format = "mp3";
+  let model;
+  let instructions;
+  if (typeof input === "string") {
+    text = input;
+    voice = undefined;
+  } else {
+    text = input.text;
+    voice = input.voice;
+    if ("format" in input && input.format) {
+      format = input.format;
+    }
+    if ("model" in input && input.model) {
+      model = input.model;
+    }
+    if ("instructions" in input && input.instructions) {
+      instructions = input.instructions;
+    }
+  }
+  model = model ?? getTTSModel(runtime);
+  voice = voice ?? getTTSVoice(runtime);
+  instructions = instructions ?? getTTSInstructions(runtime);
+  logger4.debug(`[OpenAI] Using TEXT_TO_SPEECH model: ${model}`);
+  if (!text || text.trim().length === 0) {
+    throw new Error("TEXT_TO_SPEECH requires non-empty text");
+  }
+  if (text.length > 4096) {
+    throw new Error("TEXT_TO_SPEECH text exceeds 4096 character limit");
+  }
+  const validVoices = ["alloy", "echo", "fable", "onyx", "nova", "shimmer"];
+  if (voice && !validVoices.includes(voice)) {
+    throw new Error(`Invalid voice: ${voice}. Must be one of: ${validVoices.join(", ")}`);
+  }
+  const baseURL = getBaseURL(runtime);
+  const requestBody = {
+    model,
+    voice,
+    input: text,
+    response_format: format
+  };
+  if (instructions && instructions.length > 0) {
+    requestBody.instructions = instructions;
+  }
+  const details = {
+    model,
+    systemPrompt: instructions,
+    userPrompt: text,
+    temperature: 0,
+    maxTokens: 0,
+    purpose: "external_llm",
+    actionType: "openai.audio.speech.create"
+  };
+  return recordLlmCall(runtime, details, async () => {
+    const response = await fetch(`${baseURL}/audio/speech`, {
+      method: "POST",
+      headers: {
+        ...getAuthHeader(runtime),
+        "Content-Type": "application/json",
+        ...format === "mp3" ? { Accept: "audio/mpeg" } : {}
+      },
+      body: JSON.stringify(requestBody)
+    });
+    if (!response.ok) {
+      const errorText = await response.text().catch(() => "Unknown error");
+      throw new Error(`OpenAI TTS failed: ${response.status} ${response.statusText} - ${errorText}`);
+    }
+    const audioBuffer = await response.arrayBuffer();
+    details.response = `[audio bytes=${audioBuffer.byteLength} format=${format}]`;
+    return audioBuffer;
+  });
+}
+// models/embedding.ts
+import { logger as logger5, ModelType, VECTOR_DIMS } from "@elizaos/core";
+
+// utils/events.ts
+import { EventType } from "@elizaos/core";
+var MAX_PROMPT_LENGTH = 200;
+function truncatePrompt(prompt) {
+  if (prompt.length <= MAX_PROMPT_LENGTH) {
+    return prompt;
+  }
+  return `${prompt.slice(0, MAX_PROMPT_LENGTH)}…`;
+}
+function normalizeUsage(usage) {
+  if ("promptTokens" in usage) {
+    const promptTokensDetails = "promptTokensDetails" in usage ? usage.promptTokensDetails : undefined;
+    const cachedPromptTokens = usage.cachedPromptTokens ?? promptTokensDetails?.cachedTokens;
+    return {
+      promptTokens: usage.promptTokens ?? 0,
+      completionTokens: usage.completionTokens ?? 0,
+      totalTokens: usage.totalTokens ?? (usage.promptTokens ?? 0) + (usage.completionTokens ?? 0),
+      cachedPromptTokens
+    };
+  }
+  if ("inputTokens" in usage || "outputTokens" in usage) {
+    const input = usage.inputTokens ?? 0;
+    const output = usage.outputTokens ?? 0;
+    const total = usage.totalTokens ?? input + output;
+    return {
+      promptTokens: input,
+      completionTokens: output,
+      totalTokens: total,
+      cachedPromptTokens: usage.cachedInputTokens
+    };
+  }
+  return {
+    promptTokens: 0,
+    completionTokens: 0,
+    totalTokens: 0
+  };
+}
+function emitModelUsageEvent(runtime, type, prompt, usage) {
+  const normalized = normalizeUsage(usage);
+  const payload = {
+    runtime,
+    source: "openai",
+    provider: "openai",
+    type,
+    prompt: truncatePrompt(prompt),
+    tokens: {
+      prompt: normalized.promptTokens,
+      completion: normalized.completionTokens,
+      total: normalized.totalTokens,
+      ...normalized.cachedPromptTokens !== undefined ? { cached: normalized.cachedPromptTokens } : {}
+    }
+  };
+  runtime.emitEvent(EventType.MODEL_USED, payload);
+}
+
+// models/embedding.ts
+function validateDimension(dimension) {
+  const validDimensions = Object.values(VECTOR_DIMS);
+  if (!validDimensions.includes(dimension)) {
+    throw new Error(`Invalid embedding dimension: ${dimension}. Must be one of: ${validDimensions.join(", ")}`);
+  }
+  return dimension;
+}
+function extractText(params) {
+  if (params === null) {
+    return null;
+  }
+  if (typeof params === "string") {
+    return params;
+  }
+  if (typeof params === "object" && typeof params.text === "string") {
+    return params.text;
+  }
+  throw new Error("Invalid embedding params: expected string, { text: string }, or null");
+}
+function hasExplicitEmbeddingEndpoint(runtime) {
+  const key = isBrowser() ? "OPENAI_BROWSER_EMBEDDING_URL" : "OPENAI_EMBEDDING_URL";
+  const value = getSetting(runtime, key);
+  return typeof value === "string" && value.trim().length > 0;
+}
+function hasExplicitEmbeddingDimensions(runtime) {
+  const value = getSetting(runtime, "OPENAI_EMBEDDING_DIMENSIONS");
+  return typeof value === "string" && value.trim().length > 0;
+}
+function shouldUseLocalEmbeddingFallback(runtime) {
+  return isCerebrasMode(runtime) && !hasExplicitEmbeddingEndpoint(runtime);
+}
+function hashFeature(feature) {
+  let hash = 2166136261;
+  for (let i = 0;i < feature.length; i += 1) {
+    hash ^= feature.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return hash >>> 0;
+}
+function createDeterministicEmbedding(text, dimension) {
+  const vector = new Array(dimension).fill(0);
+  const normalized = text.toLowerCase();
+  const tokens = normalized.match(/[a-z0-9]+(?:[_-][a-z0-9]+)*/g) ?? [normalized];
+  const addFeature = (feature, weight) => {
+    const hash = hashFeature(feature);
+    const idx = hash % dimension;
+    const sign = (hash & 1) === 0 ? 1 : -1;
+    vector[idx] += sign * weight;
+    const secondHash = hashFeature(`b:${feature}`);
+    const secondIdx = secondHash % dimension;
+    const secondSign = (secondHash & 1) === 0 ? 1 : -1;
+    vector[secondIdx] += secondSign * weight * 0.5;
+  };
+  tokens.forEach((token, index) => {
+    addFeature(token, 1);
+    if (index > 0) {
+      addFeature(`${tokens[index - 1]} ${token}`, 0.35);
+    }
+  });
+  addFeature(normalized.slice(0, 512), 0.15);
+  const norm = Math.sqrt(vector.reduce((sum, value) => sum + value * value, 0));
+  if (norm === 0) {
+    vector[0] = 1;
+    return vector;
+  }
+  return vector.map((value) => value / norm);
+}
+async function handleTextEmbedding(runtime, params) {
+  const embeddingModel = getEmbeddingModel(runtime);
+  const embeddingDimension = validateDimension(getEmbeddingDimensions(runtime));
+  const text = extractText(params);
+  if (text === null) {
+    logger5.debug("[OpenAI] Creating test embedding for initialization");
+    const testVector = new Array(embeddingDimension).fill(0);
+    testVector[0] = 0.1;
+    return testVector;
+  }
+  let trimmedText = text.trim();
+  if (trimmedText.length === 0) {
+    throw new Error("Cannot generate embedding for empty text");
+  }
+  const maxChars = 8000 * 4;
+  if (trimmedText.length > maxChars) {
+    logger5.warn(`[OpenAI] Embedding input too long (~${Math.ceil(trimmedText.length / 4)} tokens), truncating to ~8000 tokens`);
+    trimmedText = trimmedText.slice(0, maxChars);
+  }
+  if (shouldUseLocalEmbeddingFallback(runtime)) {
+    logger5.debug("[OpenAI] Using deterministic local embedding fallback for Cerebras mode");
+    return createDeterministicEmbedding(trimmedText, embeddingDimension);
+  }
+  const baseURL = getEmbeddingBaseURL(runtime);
+  const url = `${baseURL}/embeddings`;
+  logger5.debug(`[OpenAI] Generating embedding with model: ${embeddingModel}`);
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      ...getAuthHeader(runtime, true),
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      model: embeddingModel,
+      input: trimmedText,
+      ...hasExplicitEmbeddingDimensions(runtime) ? { dimensions: embeddingDimension } : {}
+    })
+  });
+  if (!response.ok) {
+    const errorText = await response.text().catch(() => "Unknown error");
+    throw new Error(`OpenAI embedding API error: ${response.status} ${response.statusText} - ${errorText}`);
+  }
+  const data = await response.json();
+  const firstResult = Array.isArray(data.data) ? data.data[0] : undefined;
+  if (!firstResult?.embedding) {
+    throw new Error("OpenAI API returned invalid embedding response structure");
+  }
+  const embedding = firstResult.embedding;
+  if (embedding.length !== embeddingDimension) {
+    throw new Error(`Embedding dimension mismatch: got ${embedding.length}, expected ${embeddingDimension}. ` + `Check OPENAI_EMBEDDING_DIMENSIONS setting.`);
+  }
+  if (data.usage) {
+    emitModelUsageEvent(runtime, ModelType.TEXT_EMBEDDING, trimmedText, {
+      promptTokens: data.usage.prompt_tokens,
+      completionTokens: 0,
+      totalTokens: data.usage.total_tokens
+    });
+  }
+  logger5.debug(`[OpenAI] Generated embedding with ${embedding.length} dimensions`);
+  return embedding;
+}
+// models/image.ts
+import { logger as logger6, ModelType as ModelType2, recordLlmCall as recordLlmCall2 } from "@elizaos/core";
+var DEFAULT_IMAGE_DESCRIPTION_PROMPT = "Please analyze this image and provide a title and detailed description.";
+async function handleImageGeneration(runtime, params) {
+  const modelName = getImageModel(runtime);
+  const count = params.count ?? 1;
+  const size = params.size ?? "1024x1024";
+  const extendedParams = params;
+  logger6.debug(`[OpenAI] Using IMAGE model: ${modelName}`);
+  if (typeof params.prompt !== "string" || params.prompt.trim().length === 0) {
+    throw new Error("IMAGE generation requires a non-empty prompt");
+  }
+  if (count < 1 || count > 10) {
+    throw new Error("IMAGE count must be between 1 and 10");
+  }
+  const baseURL = getBaseURL(runtime);
+  const requestBody = {
+    model: modelName,
+    prompt: params.prompt,
+    n: count,
+    size
+  };
+  if (extendedParams.quality) {
+    requestBody.quality = extendedParams.quality;
+  }
+  if (extendedParams.style) {
+    requestBody.style = extendedParams.style;
+  }
+  const details = {
+    model: modelName,
+    systemPrompt: "",
+    userPrompt: params.prompt,
+    temperature: 0,
+    maxTokens: 0,
+    purpose: "external_llm",
+    actionType: "openai.images.generate"
+  };
+  const data = await recordLlmCall2(runtime, details, async () => {
+    const response = await fetch(`${baseURL}/images/generations`, {
+      method: "POST",
+      headers: {
+        ...getAuthHeader(runtime),
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(requestBody)
+    });
+    if (!response.ok) {
+      const errorText = await response.text().catch(() => "Unknown error");
+      throw new Error(`OpenAI image generation failed: ${response.status} ${response.statusText} - ${errorText}`);
+    }
+    const responseData = await response.json();
+    details.response = JSON.stringify(responseData.data);
+    return responseData;
+  });
+  if (data.data.length === 0) {
+    throw new Error("OpenAI API returned no images");
+  }
+  return data.data.map((item) => ({
+    url: item.url,
+    revisedPrompt: item.revised_prompt
+  }));
+}
+function parseTitleFromResponse(content) {
+  const titleMatch = content.match(/title[:\s]+(.+?)(?:\n|$)/i);
+  return titleMatch?.[1]?.trim() ?? "Image Analysis";
+}
+function parseDescriptionFromResponse(content) {
+  return content.replace(/title[:\s]+(.+?)(?:\n|$)/i, "").trim();
+}
+async function handleImageDescription(runtime, params) {
+  const modelName = getImageDescriptionModel(runtime);
+  const paramsWithMaxTokens = params;
+  const maxTokens = typeof params === "object" && typeof paramsWithMaxTokens.maxTokens === "number" ? paramsWithMaxTokens.maxTokens : getImageDescriptionMaxTokens(runtime);
+  logger6.debug(`[OpenAI] Using IMAGE_DESCRIPTION model: ${modelName}`);
+  let imageUrl;
+  let promptText;
+  if (typeof params === "string") {
+    imageUrl = params;
+    promptText = DEFAULT_IMAGE_DESCRIPTION_PROMPT;
+  } else {
+    imageUrl = params.imageUrl;
+    promptText = params.prompt ?? DEFAULT_IMAGE_DESCRIPTION_PROMPT;
+  }
+  if (!imageUrl || imageUrl.trim().length === 0) {
+    throw new Error("IMAGE_DESCRIPTION requires a valid image URL");
+  }
+  const baseURL = getImageDescriptionBaseURL(runtime);
+  const requestBody = {
+    model: modelName,
+    messages: [
+      {
+        role: "user",
+        content: [
+          { type: "text", text: promptText },
+          { type: "image_url", image_url: { url: imageUrl } }
+        ]
+      }
+    ],
+    max_tokens: maxTokens
+  };
+  const details = {
+    model: modelName,
+    systemPrompt: "",
+    userPrompt: promptText,
+    temperature: 0,
+    maxTokens,
+    purpose: "external_llm",
+    actionType: "openai.chat.completions.create"
+  };
+  const data = await recordLlmCall2(runtime, details, async () => {
+    const response = await fetch(`${baseURL}/chat/completions`, {
+      method: "POST",
+      headers: {
+        ...getImageDescriptionAuthHeader(runtime),
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(requestBody)
+    });
+    if (!response.ok) {
+      const errorText = await response.text().catch(() => "Unknown error");
+      throw new Error(`OpenAI image description failed: ${response.status} ${response.statusText} - ${errorText}`);
+    }
+    const responseData = await response.json();
+    const responseContent = responseData.choices[0]?.message.content;
+    if (!responseContent) {
+      throw new Error("OpenAI API returned empty image description");
+    }
+    details.response = responseContent;
+    if (responseData.usage) {
+      details.promptTokens = responseData.usage.prompt_tokens;
+      details.completionTokens = responseData.usage.completion_tokens;
+    }
+    return responseData;
+  });
+  if (data.usage) {
+    emitModelUsageEvent(runtime, ModelType2.IMAGE_DESCRIPTION, typeof params === "string" ? params : params.prompt ?? "", {
+      promptTokens: data.usage.prompt_tokens,
+      completionTokens: data.usage.completion_tokens,
+      totalTokens: data.usage.total_tokens
+    });
+  }
+  const firstChoice = data.choices[0];
+  const content = firstChoice?.message.content;
+  if (!content) {
+    throw new Error("OpenAI API returned empty image description");
+  }
+  return {
+    title: parseTitleFromResponse(content),
+    description: parseDescriptionFromResponse(content)
+  };
+}
+// models/research.ts
+import { logger as logger7, recordLlmCall as recordLlmCall3 } from "@elizaos/core";
+function convertToolToApi(tool) {
+  switch (tool.type) {
+    case "web_search_preview":
+      return { type: "web_search_preview" };
+    case "file_search":
+      return {
+        type: "file_search",
+        vector_store_ids: tool.vectorStoreIds
+      };
+    case "code_interpreter":
+      return {
+        type: "code_interpreter",
+        container: tool.container ?? { type: "auto" }
+      };
+    case "mcp":
+      return {
+        type: "mcp",
+        server_label: tool.serverLabel,
+        server_url: tool.serverUrl,
+        require_approval: tool.requireApproval ?? "never"
+      };
+    default:
+      throw new Error(`Unknown research tool type: ${tool.type}`);
+  }
+}
+function convertOutputItem(item) {
+  switch (item.type) {
+    case "web_search_call":
+      return {
+        id: item.id ?? "",
+        type: "web_search_call",
+        status: item.status ?? "completed",
+        action: {
+          type: item.action?.type ?? "search",
+          query: item.action?.query,
+          url: item.action?.url
+        }
+      };
+    case "file_search_call":
+      return {
+        id: item.id ?? "",
+        type: "file_search_call",
+        status: item.status ?? "completed",
+        query: item.query ?? "",
+        results: item.results?.map((r) => ({
+          fileId: r.file_id,
+          fileName: r.file_name,
+          score: r.score
+        }))
+      };
+    case "code_interpreter_call":
+      return {
+        id: item.id ?? "",
+        type: "code_interpreter_call",
+        status: item.status ?? "completed",
+        code: item.code ?? "",
+        output: item.output
+      };
+    case "mcp_tool_call":
+      return {
+        id: item.id ?? "",
+        type: "mcp_tool_call",
+        status: item.status ?? "completed",
+        serverLabel: item.server_label ?? "",
+        toolName: item.tool_name ?? "",
+        arguments: item.arguments ?? {},
+        result: item.result
+      };
+    case "message":
+      return {
+        type: "message",
+        content: item.content?.map((c) => ({
+          type: "output_text",
+          text: c.text,
+          annotations: c.annotations?.map((a) => ({
+            url: a.url,
+            title: a.title,
+            startIndex: a.start_index,
+            endIndex: a.end_index
+          })) ?? []
+        })) ?? []
+      };
+    default:
+      return null;
+  }
+}
+function extractTextAndAnnotations(response) {
+  if (response.output_text) {
+    const annotations2 = [];
+    if (response.output) {
+      for (const item of response.output) {
+        if (item.type === "message" && item.content) {
+          for (const content of item.content) {
+            if (content.annotations) {
+              for (const ann of content.annotations) {
+                annotations2.push({
+                  url: ann.url,
+                  title: ann.title,
+                  startIndex: ann.start_index,
+                  endIndex: ann.end_index
+                });
+              }
+            }
+          }
+        }
+      }
+    }
+    return { text: response.output_text, annotations: annotations2 };
+  }
+  let text = "";
+  const annotations = [];
+  if (response.output) {
+    for (const item of response.output) {
+      if (item.type === "message" && item.content) {
+        for (const content of item.content) {
+          text += content.text;
+          if (content.annotations) {
+            for (const ann of content.annotations) {
+              annotations.push({
+                url: ann.url,
+                title: ann.title,
+                startIndex: ann.start_index,
+                endIndex: ann.end_index
+              });
+            }
+          }
+        }
+      }
+    }
+  }
+  return { text, annotations };
+}
+async function handleResearch(runtime, params) {
+  const apiKey = getApiKey(runtime);
+  if (!apiKey) {
+    throw new Error("OPENAI_API_KEY is required for deep research. Set it in your environment variables or runtime settings.");
+  }
+  const baseURL = getBaseURL(runtime);
+  const modelName = params.model ?? getResearchModel(runtime);
+  const timeout = getResearchTimeout(runtime);
+  logger7.debug(`[OpenAI] Starting deep research with model: ${modelName}`);
+  logger7.debug(`[OpenAI] Research input: ${params.input.substring(0, 100)}...`);
+  const dataSourceTools = params.tools?.filter((t) => t.type === "web_search_preview" || t.type === "file_search" || t.type === "mcp");
+  if (!dataSourceTools || dataSourceTools.length === 0) {
+    logger7.debug("[OpenAI] No data source tools specified, defaulting to web_search_preview");
+    params.tools = [{ type: "web_search_preview" }, ...params.tools ?? []];
+  }
+  const requestBody = {
+    model: modelName,
+    input: params.input
+  };
+  if (params.instructions) {
+    requestBody.instructions = params.instructions;
+  }
+  if (params.background !== undefined) {
+    requestBody.background = params.background;
+  }
+  if (params.tools && params.tools.length > 0) {
+    requestBody.tools = params.tools.map(convertToolToApi);
+  }
+  if (params.maxToolCalls !== undefined) {
+    requestBody.max_tool_calls = params.maxToolCalls;
+  }
+  if (params.reasoningSummary) {
+    requestBody.reasoning = { summary: params.reasoningSummary };
+  }
+  logger7.debug(`[OpenAI] Research request body: ${JSON.stringify(requestBody, null, 2)}`);
+  const details = {
+    model: modelName,
+    systemPrompt: params.instructions ?? "",
+    userPrompt: params.input,
+    temperature: 0,
+    maxTokens: 0,
+    purpose: "external_llm",
+    actionType: "openai.responses.create"
+  };
+  const data = await recordLlmCall3(runtime, details, async () => {
+    const response = await fetch(`${baseURL}/responses`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(requestBody),
+      signal: AbortSignal.timeout(timeout)
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      logger7.error(`[OpenAI] Research request failed: ${response.status} ${errorText}`);
+      throw new Error(`Deep research request failed: ${response.status} ${response.statusText}`);
+    }
+    const responseData = await response.json();
+    details.response = responseData.output_text ?? "";
+    return responseData;
+  });
+  if (data.error) {
+    logger7.error(`[OpenAI] Research API error: ${data.error.message}`);
+    throw new Error(`Deep research error: ${data.error.message}`);
+  }
+  logger7.debug(`[OpenAI] Research response received. Status: ${data.status ?? "completed"}`);
+  const { text, annotations } = extractTextAndAnnotations(data);
+  const outputItems = [];
+  if (data.output) {
+    for (const item of data.output) {
+      const converted = convertOutputItem(item);
+      if (converted) {
+        outputItems.push(converted);
+      }
+    }
+  }
+  const result = {
+    id: data.id,
+    text,
+    annotations,
+    outputItems,
+    status: data.status
+  };
+  logger7.info(`[OpenAI] Research completed. Text length: ${text.length}, Annotations: ${annotations.length}, Output items: ${outputItems.length}`);
+  return result;
+}
+// models/text.ts
+import {
+  buildCanonicalSystemPrompt,
+  dropDuplicateLeadingSystemMessage,
+  logger as logger8,
+  ModelType as ModelType3,
+  normalizeSchemaForCerebras,
+  recordLlmCall as recordLlmCall4,
+  resolveEffectiveSystemPrompt,
+  sanitizeFunctionNameForCerebras
+} from "@elizaos/core";
+import {
+  generateText,
+  jsonSchema,
+  Output,
+  streamText
+} from "ai";
+
+// providers/openai.ts
+import { createOpenAI } from "@ai-sdk/openai";
+var PROXY_API_KEY = "sk-proxy";
+function createOpenAIClient(runtime) {
+  const baseURL = getBaseURL(runtime);
+  const apiKey = getApiKey(runtime);
+  if (!apiKey && isProxyMode(runtime)) {
+    return createOpenAI({
+      apiKey: PROXY_API_KEY,
+      baseURL
+    });
+  }
+  if (!apiKey) {
+    throw new Error("OPENAI_API_KEY is required. Set it in your environment variables or runtime settings.");
+  }
+  return createOpenAI({
+    apiKey,
+    baseURL
+  });
+}
+// models/text.ts
+var TEXT_NANO_MODEL_TYPE = ModelType3.TEXT_NANO;
+var TEXT_MEDIUM_MODEL_TYPE = ModelType3.TEXT_MEDIUM;
+var TEXT_MEGA_MODEL_TYPE = ModelType3.TEXT_MEGA;
+var RESPONSE_HANDLER_MODEL_TYPE = ModelType3.RESPONSE_HANDLER;
+var ACTION_PLANNER_MODEL_TYPE = ModelType3.ACTION_PLANNER;
+function resolveRequestedModelName(params, runtime, getModelFn) {
+  return typeof params.model === "string" && params.model.trim().length > 0 ? params.model.trim() : getModelFn(runtime);
+}
+function buildUserContent(params) {
+  const content = [{ type: "text", text: params.prompt ?? "" }];
+  for (const attachment of params.attachments ?? []) {
+    content.push({
+      type: "file",
+      data: attachment.data,
+      mediaType: attachment.mediaType,
+      ...attachment.filename ? { filename: attachment.filename } : {}
+    });
+  }
+  return content;
+}
+function convertUsage(usage) {
+  if (!usage) {
+    return;
+  }
+  const promptTokens = usage.inputTokens ?? 0;
+  const completionTokens = usage.outputTokens ?? 0;
+  const usageWithCache = usage;
+  const cachedInput = firstNumber(usageWithCache.cacheReadInputTokens, usageWithCache.cachedInputTokens, usageWithCache.inputTokenDetails?.cacheReadTokens, usageWithCache.inputTokenDetails?.cachedInputTokens, usageWithCache.input_tokens_details?.cache_read_input_tokens, usageWithCache.input_tokens_details?.cached_tokens, usageWithCache.prompt_tokens_details?.cached_tokens) ?? undefined;
+  const cacheCreationInput = firstNumber(usageWithCache.cacheCreationInputTokens, usageWithCache.cacheWriteInputTokens, usageWithCache.inputTokenDetails?.cacheCreationInputTokens, usageWithCache.inputTokenDetails?.cacheCreationTokens, usageWithCache.inputTokenDetails?.cacheWriteTokens, usageWithCache.input_tokens_details?.cache_creation_input_tokens);
+  return {
+    promptTokens,
+    completionTokens,
+    totalTokens: promptTokens + completionTokens,
+    cachedPromptTokens: cachedInput,
+    cacheReadInputTokens: cachedInput,
+    cacheCreationInputTokens: cacheCreationInput
+  };
+}
+function firstNumber(...values) {
+  for (const value of values) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+      return value;
+    }
+    if (typeof value === "string" && value.trim().length > 0) {
+      const parsed = Number(value);
+      if (Number.isFinite(parsed)) {
+        return parsed;
+      }
+    }
+  }
+  return;
+}
+function resolvePromptCacheOptions(params) {
+  const withOpenAIOptions = params;
+  return {
+    promptCacheKey: withOpenAIOptions.providerOptions?.openai?.promptCacheKey,
+    promptCacheRetention: withOpenAIOptions.providerOptions?.openai?.promptCacheRetention
+  };
+}
+var VALID_REASONING_EFFORTS = ["minimal", "low", "medium", "high"];
+function isReasoningModel(modelName) {
+  if (!modelName)
+    return false;
+  const m = modelName.toLowerCase();
+  return m.includes("gpt-oss") || m.includes("o1") || m.includes("o3") || m.includes("o4") || m.includes("deepseek-r1") || m.includes("thinking") || m.includes("reasoning") || m.includes("qwq");
+}
+function resolveReasoningEffort(runtime, modelName) {
+  const raw = runtime.getSetting("OPENAI_REASONING_EFFORT");
+  const normalized = typeof raw === "string" ? raw.trim().toLowerCase() : "";
+  if (normalized) {
+    if (VALID_REASONING_EFFORTS.includes(normalized)) {
+      return normalized;
+    }
+    logger8.warn(`[OpenAI] OPENAI_REASONING_EFFORT=${raw} is not a valid reasoning effort; ignoring. Expected one of: ${VALID_REASONING_EFFORTS.join(", ")}.`);
+  }
+  if (isCerebrasMode(runtime) && isReasoningModel(modelName)) {
+    return "low";
+  }
+  return;
+}
+function resolveProviderOptions(params, runtime, modelName) {
+  const withOpenAIOptions = params;
+  const rawProviderOptions = withOpenAIOptions.providerOptions;
+  const promptCacheOptions = resolvePromptCacheOptions(params);
+  const reasoningEffort = resolveReasoningEffort(runtime, modelName);
+  if (!rawProviderOptions && !promptCacheOptions.promptCacheKey && !promptCacheOptions.promptCacheRetention && !reasoningEffort) {
+    return;
+  }
+  const skipCacheRetention = isCerebrasMode(runtime);
+  const { agentName: _agentName, openai: rawOpenAIOptions, ...rest } = rawProviderOptions ?? {};
+  const sanitizedRawOpenAIOptions = (() => {
+    if (!rawOpenAIOptions || typeof rawOpenAIOptions !== "object")
+      return rawOpenAIOptions;
+    if (!skipCacheRetention)
+      return rawOpenAIOptions;
+    const { promptCacheRetention: _drop, ...rest2 } = rawOpenAIOptions;
+    return rest2;
+  })();
+  const openaiOptions = {
+    ...sanitizedRawOpenAIOptions ?? {},
+    ...promptCacheOptions.promptCacheKey ? { promptCacheKey: promptCacheOptions.promptCacheKey } : {},
+    ...!skipCacheRetention && promptCacheOptions.promptCacheRetention ? { promptCacheRetention: promptCacheOptions.promptCacheRetention } : {},
+    ...sanitizedRawOpenAIOptions?.reasoningEffort === undefined && reasoningEffort ? { reasoningEffort } : {}
+  };
+  const providerOptions = {
+    ...rest,
+    ...Object.keys(openaiOptions).length > 0 ? { openai: openaiOptions } : {}
+  };
+  return Object.keys(providerOptions).length > 0 ? providerOptions : undefined;
+}
+function buildStructuredOutput(responseSchema) {
+  if (responseSchema && typeof responseSchema === "object" && "responseFormat" in responseSchema && "parseCompleteOutput" in responseSchema) {
+    return responseSchema;
+  }
+  const schemaOptions = responseSchema && typeof responseSchema === "object" && "schema" in responseSchema ? responseSchema : { schema: responseSchema };
+  return Output.object({
+    schema: jsonSchema(sanitizeJsonSchema(schemaOptions.schema, true)),
+    ...schemaOptions.name ? { name: schemaOptions.name } : {},
+    ...schemaOptions.description ? { description: schemaOptions.description } : {}
+  });
+}
+function normalizeNativeTools(tools, options = {}) {
+  if (!tools) {
+    return;
+  }
+  if (!Array.isArray(tools)) {
+    return tools;
+  }
+  const toolSet = {};
+  for (const rawTool of tools) {
+    const tool = asRecord(rawTool);
+    const functionTool = asRecord(tool.function);
+    const name = firstString(tool.name, functionTool.name);
+    if (!name) {
+      throw new Error("[OpenAI] Native tool definition is missing a name.");
+    }
+    const description = firstString(tool.description, functionTool.description);
+    const rawSchema = tool.parameters ?? functionTool.parameters ?? { type: "object" };
+    let inputSchema = sanitizeJsonSchema(rawSchema, true);
+    if (options.cerebrasMode) {
+      inputSchema = normalizeSchemaForCerebras(inputSchema, true);
+    }
+    const registeredName = options.cerebrasMode ? sanitizeFunctionNameForCerebras(name) : name;
+    toolSet[registeredName] = {
+      ...description ? { description } : {},
+      inputSchema: jsonSchema(inputSchema)
+    };
+  }
+  return Object.keys(toolSet).length > 0 ? toolSet : undefined;
+}
+function normalizeNativeMessages(messages) {
+  if (!Array.isArray(messages)) {
+    return;
+  }
+  return messages.map((message) => normalizeNativeMessage(message));
+}
+function normalizeNativeMessage(message) {
+  const raw = asRecord(message);
+  const providerOptions = asOptionalRecord(raw.providerOptions);
+  if (raw.role === "system") {
+    return {
+      role: "system",
+      content: stringifyMessageContent(raw.content),
+      ...providerOptions ? { providerOptions } : {}
+    };
+  }
+  if (raw.role === "assistant") {
+    return {
+      role: "assistant",
+      content: normalizeAssistantContent(raw),
+      ...providerOptions ? { providerOptions } : {}
+    };
+  }
+  if (raw.role === "tool") {
+    return {
+      role: "tool",
+      content: normalizeToolContent(raw),
+      ...providerOptions ? { providerOptions } : {}
+    };
+  }
+  return {
+    role: "user",
+    content: normalizeUserContent(raw.content),
+    ...providerOptions ? { providerOptions } : {}
+  };
+}
+function stripReasoningParts(content) {
+  return content.filter((part) => {
+    if (!part || typeof part !== "object")
+      return true;
+    const type = part.type;
+    return type !== "reasoning" && type !== "thinking";
+  });
+}
+function normalizeAssistantContent(message) {
+  const toolCalls = Array.isArray(message.toolCalls) ? message.toolCalls : [];
+  if (toolCalls.length === 0) {
+    if (Array.isArray(message.content)) {
+      return stripReasoningParts(message.content);
+    }
+    if (typeof message.content === "string") {
+      return message.content;
+    }
+    return "";
+  }
+  const parts = [];
+  if (typeof message.content === "string" && message.content.length > 0) {
+    parts.push({ type: "text", text: message.content });
+  } else if (Array.isArray(message.content)) {
+    parts.push(...stripReasoningParts(message.content));
+  }
+  for (const toolCall of toolCalls) {
+    const rawCall = asRecord(toolCall);
+    const rawFunction = asRecord(rawCall.function);
+    const toolCallId = firstString(rawCall.toolCallId, rawCall.id);
+    const toolName = firstString(rawCall.toolName, rawCall.name, rawFunction.name);
+    if (!toolCallId || !toolName) {
+      continue;
+    }
+    parts.push({
+      type: "tool-call",
+      toolCallId,
+      toolName,
+      input: parseToolCallInput(rawCall, rawFunction)
+    });
+  }
+  return parts;
+}
+function normalizeToolContent(message) {
+  if (Array.isArray(message.content)) {
+    return message.content;
+  }
+  const toolCallId = firstString(message.toolCallId, message.id) ?? "tool-call";
+  const toolName = firstString(message.toolName, message.name) ?? "tool";
+  const parsed = parseJsonIfPossible(message.content);
+  return [
+    {
+      type: "tool-result",
+      toolCallId,
+      toolName,
+      output: typeof parsed === "string" ? { type: "text", value: parsed } : { type: "json", value: parsed }
+    }
+  ];
+}
+function normalizeUserContent(content) {
+  if (Array.isArray(content)) {
+    return content;
+  }
+  return stringifyMessageContent(content);
+}
+function stringifyMessageContent(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  if (content == null) {
+    return "";
+  }
+  return typeof content === "object" ? JSON.stringify(content) : String(content);
+}
+function parseToolCallInput(rawCall, rawFunction) {
+  if ("input" in rawCall) {
+    return rawCall.input;
+  }
+  return parseJsonIfPossible(rawCall.arguments ?? rawFunction.arguments ?? {});
+}
+function parseJsonIfPossible(value) {
+  if (typeof value !== "string") {
+    return value ?? "";
+  }
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+function normalizeToolChoice(toolChoice) {
+  if (!toolChoice) {
+    return;
+  }
+  if (typeof toolChoice === "string" && (toolChoice === "auto" || toolChoice === "none" || toolChoice === "required")) {
+    return toolChoice;
+  }
+  const choice = asRecord(toolChoice);
+  if (choice.type === "tool") {
+    if (typeof choice.toolName === "string" && choice.toolName.length > 0) {
+      return toolChoice;
+    }
+    const toolName = firstString(choice.toolName, choice.name);
+    if (toolName) {
+      return { type: "tool", toolName };
+    }
+  }
+  if (choice.type === "function") {
+    const fn = asRecord(choice.function);
+    const toolName = firstString(fn.name);
+    if (toolName) {
+      return { type: "tool", toolName };
+    }
+  }
+  const namedTool = firstString(choice.name);
+  if (namedTool) {
+    return { type: "tool", toolName: namedTool };
+  }
+  return toolChoice;
+}
+function hasIllegalStrictRoot(node) {
+  if (node.type !== "object")
+    return true;
+  if (Array.isArray(node.oneOf) && node.oneOf.length > 0)
+    return true;
+  if (Array.isArray(node.anyOf) && node.anyOf.length > 0)
+    return true;
+  if (Array.isArray(node.enum))
+    return true;
+  if (node.not !== undefined)
+    return true;
+  return false;
+}
+function sanitizeJsonSchema(schema, isRoot = false) {
+  if (!schema || typeof schema !== "object" || Array.isArray(schema)) {
+    return { type: "object" };
+  }
+  const record = schema;
+  let sanitized = { ...record };
+  if (typeof sanitized.type !== "string") {
+    const inferredType = inferJsonSchemaType(sanitized, isRoot);
+    if (inferredType) {
+      sanitized.type = inferredType;
+    }
+  }
+  if (isRoot && hasIllegalStrictRoot(sanitized)) {
+    sanitized = {
+      type: "object",
+      properties: { value: { ...record } },
+      required: ["value"],
+      additionalProperties: false
+    };
+  }
+  if (sanitized.properties && typeof sanitized.properties === "object" && !Array.isArray(sanitized.properties)) {
+    const properties = {};
+    for (const [key, value] of Object.entries(sanitized.properties)) {
+      properties[key] = sanitizeJsonSchema(value);
+    }
+    sanitized.properties = properties;
+    const propertyKeys = Object.keys(properties);
+    const existingRequired = Array.isArray(sanitized.required) ? sanitized.required.filter((key) => typeof key === "string") : [];
+    sanitized.required = [...new Set([...existingRequired, ...propertyKeys])];
+  }
+  if (sanitized.type === "object" && sanitized.additionalProperties !== false) {
+    sanitized.additionalProperties = false;
+  }
+  if (sanitized.items) {
+    sanitized.items = Array.isArray(sanitized.items) ? sanitized.items.map((item) => sanitizeJsonSchema(item)) : sanitizeJsonSchema(sanitized.items);
+  }
+  for (const unionKey of ["anyOf", "oneOf", "allOf"]) {
+    const value = sanitized[unionKey];
+    if (Array.isArray(value)) {
+      sanitized[unionKey] = value.map((item) => sanitizeJsonSchema(item));
+    }
+  }
+  return sanitized;
+}
+function inferJsonSchemaType(schema, isRoot) {
+  if ("properties" in schema || "required" in schema || "additionalProperties" in schema || isRoot) {
+    return "object";
+  }
+  if ("items" in schema) {
+    return "array";
+  }
+  if (Array.isArray(schema.enum) && schema.enum.length > 0) {
+    const types = new Set(schema.enum.map((value) => typeof value));
+    if (types.size === 1) {
+      const [type] = [...types];
+      if (type === "string" || type === "number" || type === "boolean") {
+        return type;
+      }
+    }
+  }
+  return;
+}
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function asOptionalRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : undefined;
+}
+function firstString(...values) {
+  for (const value of values) {
+    if (typeof value === "string" && value.length > 0) {
+      return value;
+    }
+  }
+  return;
+}
+function usesNativeTextResult(params) {
+  return Boolean(params.messages || params.tools || params.toolChoice || params.responseSchema);
+}
+function buildNativeTextResult(result, modelName) {
+  return {
+    text: result.text,
+    toolCalls: result.toolCalls ?? [],
+    finishReason: result.finishReason,
+    usage: convertUsage(result.usage),
+    providerMetadata: mergeProviderModelName(result.providerMetadata, modelName)
+  };
+}
+function handledPromise(value) {
+  const promise = Promise.resolve(value);
+  promise.catch(() => {});
+  return promise;
+}
+function handledMappedPromise(value, mapper) {
+  return handledPromise(handledPromise(value).then(mapper));
+}
+function mergeProviderModelName(providerMetadata, modelName) {
+  if (!modelName) {
+    return providerMetadata;
+  }
+  if (providerMetadata && typeof providerMetadata === "object" && !Array.isArray(providerMetadata)) {
+    return {
+      ...providerMetadata,
+      modelName
+    };
+  }
+  return { modelName };
+}
+function createLlmCallDetails(modelName, params, systemPrompt, actionType, modelType, providerOptions, generateParams) {
+  const originalParams = params;
+  const nativeParams = generateParams;
+  const nativePrompt = nativeParams && "prompt" in nativeParams ? nativeParams.prompt : undefined;
+  const nativeMessages = nativeParams && "messages" in nativeParams && Array.isArray(nativeParams.messages) ? nativeParams.messages : undefined;
+  const nativeSystem = typeof nativeParams?.system === "string" ? nativeParams.system : systemPrompt;
+  return {
+    model: modelName,
+    modelType,
+    provider: "vercel-ai-sdk",
+    systemPrompt: nativeSystem ?? "",
+    userPrompt: typeof nativePrompt === "string" ? nativePrompt : typeof params.prompt === "string" ? params.prompt : "",
+    prompt: typeof nativePrompt === "string" ? nativePrompt : undefined,
+    messages: nativeMessages,
+    tools: nativeParams?.tools ?? originalParams.tools,
+    toolChoice: nativeParams?.toolChoice ?? originalParams.toolChoice,
+    output: nativeParams?.output !== undefined ? buildTrajectoryOutputDescriptor(originalParams.responseSchema, nativeParams.output) : undefined,
+    responseSchema: originalParams.responseSchema,
+    providerOptions: providerOptions ?? nativeParams?.providerOptions ?? originalParams.providerOptions,
+    temperature: params.temperature ?? 0,
+    maxTokens: typeof nativeParams?.maxOutputTokens === "number" ? nativeParams.maxOutputTokens : params.omitMaxTokens ? 0 : params.maxTokens ?? 8192,
+    maxTokensOmitted: params.omitMaxTokens && typeof nativeParams?.maxOutputTokens !== "number" ? true : undefined,
+    purpose: "external_llm",
+    actionType
+  };
+}
+function buildTrajectoryOutputDescriptor(responseSchema, output) {
+  if (responseSchema !== undefined) {
+    return {
+      type: "object",
+      schema: responseSchema
+    };
+  }
+  return toTrajectoryJsonSafe(output);
+}
+function toTrajectoryJsonSafe(value) {
+  try {
+    return JSON.parse(JSON.stringify(value, (_key, nested) => {
+      if (typeof nested === "function")
+        return;
+      if (typeof nested === "bigint")
+        return nested.toString();
+      return nested;
+    }));
+  } catch {
+    return String(value);
+  }
+}
+function applyUsageToDetails(details, usage) {
+  if (!usage) {
+    return;
+  }
+  details.promptTokens = usage.inputTokens ?? 0;
+  details.completionTokens = usage.outputTokens ?? 0;
+}
+async function generateTextByModelType(runtime, params, modelType, getModelFn) {
+  const paramsWithAttachments = params;
+  const openai = createOpenAIClient(runtime);
+  const modelName = resolveRequestedModelName(paramsWithAttachments, runtime, getModelFn);
+  logger8.debug(`[OpenAI] Using ${modelType} model: ${modelName}`);
+  const providerOptions = resolveProviderOptions(params, runtime, modelName);
+  const hasAttachments = (paramsWithAttachments.attachments?.length ?? 0) > 0;
+  const userContent = hasAttachments ? buildUserContent(paramsWithAttachments) : undefined;
+  const shouldReturnNativeResult = usesNativeTextResult(paramsWithAttachments);
+  const systemPrompt = resolveEffectiveSystemPrompt({
+    params: paramsWithAttachments,
+    fallback: buildCanonicalSystemPrompt({ character: runtime.character })
+  });
+  const agentName = paramsWithAttachments.providerOptions?.agentName;
+  const telemetryConfig = {
+    isEnabled: getExperimentalTelemetry(runtime),
+    functionId: agentName ? `agent:${agentName}` : undefined,
+    metadata: agentName ? { agentName } : undefined
+  };
+  const model = openai.chat(modelName);
+  const cerebrasMode = isCerebrasMode(runtime);
+  const normalizedTools = normalizeNativeTools(paramsWithAttachments.tools, {
+    cerebrasMode
+  });
+  const normalizedToolChoice = normalizeToolChoice(paramsWithAttachments.toolChoice);
+  const normalizedMessages = normalizeNativeMessages(paramsWithAttachments.messages);
+  const wireMessages = dropDuplicateLeadingSystemMessage(normalizedMessages, systemPrompt);
+  const effectiveMessages = wireMessages && wireMessages.length > 0 ? wireMessages : normalizedMessages;
+  const promptText = typeof params.prompt === "string" && params.prompt.length > 0 ? params.prompt : "";
+  const promptOrMessages = effectiveMessages && effectiveMessages.length > 0 ? { messages: effectiveMessages } : userContent ? { messages: [{ role: "user", content: userContent }] } : { prompt: promptText };
+  const callerResponseFormat = paramsWithAttachments.responseFormat;
+  const responseFormatType = typeof callerResponseFormat === "string" ? callerResponseFormat : callerResponseFormat && typeof callerResponseFormat === "object" && ("type" in callerResponseFormat) ? callerResponseFormat.type : undefined;
+  const wireResponseFormat = responseFormatType === "json_object" ? { type: "json" } : responseFormatType === "text" ? { type: "text" } : undefined;
+  const generateParams = {
+    model,
+    ...promptOrMessages,
+    system: systemPrompt,
+    allowSystemInMessages: true,
+    ...params.omitMaxTokens ? {} : { maxOutputTokens: params.maxTokens ?? 8192 },
+    experimental_telemetry: telemetryConfig,
+    ...normalizedTools ? { tools: normalizedTools } : {},
+    ...normalizedToolChoice ? { toolChoice: normalizedToolChoice } : {},
+    ...paramsWithAttachments.responseSchema && !isCerebrasMode(runtime) ? { output: buildStructuredOutput(paramsWithAttachments.responseSchema) } : {},
+    ...wireResponseFormat ? { responseFormat: wireResponseFormat } : {},
+    ...providerOptions ? { providerOptions } : {}
+  };
+  if (params.stream) {
+    const details2 = createLlmCallDetails(modelName, params, systemPrompt, "ai.streamText", modelType, providerOptions, generateParams);
+    details2.response = "";
+    const result2 = await recordLlmCall4(runtime, details2, () => streamText(generateParams));
+    return {
+      textStream: async function* textStreamWithCallback() {
+        for await (const chunk of result2.textStream) {
+          params.onStreamChunk?.(chunk);
+          yield chunk;
+        }
+      }(),
+      text: handledPromise(result2.text),
+      ...shouldReturnNativeResult ? { toolCalls: handledPromise(result2.toolCalls) } : {},
+      usage: handledMappedPromise(result2.usage, convertUsage),
+      finishReason: handledMappedPromise(result2.finishReason, (r) => r)
+    };
+  }
+  const details = createLlmCallDetails(modelName, params, systemPrompt, "ai.generateText", modelType, providerOptions, generateParams);
+  const result = await recordLlmCall4(runtime, details, async () => {
+    const result2 = await generateText(generateParams);
+    details.response = result2.text;
+    details.toolCalls = result2.toolCalls;
+    details.finishReason = result2.finishReason;
+    details.providerMetadata = result2.providerMetadata;
+    applyUsageToDetails(details, result2.usage);
+    return result2;
+  });
+  if (result.usage) {
+    emitModelUsageEvent(runtime, modelType, params.prompt ?? "", result.usage);
+  }
+  if (shouldReturnNativeResult) {
+    return buildNativeTextResult(result, modelName);
+  }
+  return result.text;
+}
+async function handleTextSmall(runtime, params) {
+  return generateTextByModelType(runtime, params, ModelType3.TEXT_SMALL, getSmallModel);
+}
+async function handleTextNano(runtime, params) {
+  return generateTextByModelType(runtime, params, TEXT_NANO_MODEL_TYPE, getNanoModel);
+}
+async function handleTextMedium(runtime, params) {
+  return generateTextByModelType(runtime, params, TEXT_MEDIUM_MODEL_TYPE, getMediumModel);
+}
+async function handleTextLarge(runtime, params) {
+  return generateTextByModelType(runtime, params, ModelType3.TEXT_LARGE, getLargeModel);
+}
+async function handleTextMega(runtime, params) {
+  return generateTextByModelType(runtime, params, TEXT_MEGA_MODEL_TYPE, getMegaModel);
+}
+async function handleResponseHandler(runtime, params) {
+  return generateTextByModelType(runtime, params, RESPONSE_HANDLER_MODEL_TYPE, getResponseHandlerModel);
+}
+async function handleActionPlanner(runtime, params) {
+  return generateTextByModelType(runtime, params, ACTION_PLANNER_MODEL_TYPE, getActionPlannerModel);
+}
+// utils/tokenization.ts
+import { ModelType as ModelType4 } from "@elizaos/core";
+import {
+  encodingForModel,
+  getEncoding
+} from "js-tiktoken";
+function resolveTokenizerEncoding(modelName) {
+  const normalized = modelName.toLowerCase();
+  const fallbackEncoding = normalized.includes("4o") ? "o200k_base" : "cl100k_base";
+  try {
+    return encodingForModel(modelName);
+  } catch {
+    return getEncoding(fallbackEncoding);
+  }
+}
+function getModelName(runtime, modelType) {
+  if (modelType === ModelType4.TEXT_SMALL) {
+    return getSmallModel(runtime);
+  }
+  return getLargeModel(runtime);
+}
+function tokenizeText(runtime, modelType, text) {
+  const modelName = getModelName(runtime, modelType);
+  const encoder = resolveTokenizerEncoding(modelName);
+  return encoder.encode(text);
+}
+function detokenizeText(runtime, modelType, tokens) {
+  const modelName = getModelName(runtime, modelType);
+  const encoder = resolveTokenizerEncoding(modelName);
+  return encoder.decode(tokens);
+}
+
+// models/tokenizer.ts
+async function handleTokenizerEncode(runtime, params) {
+  if (!params.prompt) {
+    throw new Error("Tokenization requires a non-empty prompt");
+  }
+  const modelType = params.modelType;
+  return tokenizeText(runtime, modelType, params.prompt);
+}
+async function handleTokenizerDecode(runtime, params) {
+  if (!params.tokens || !Array.isArray(params.tokens)) {
+    throw new Error("Detokenization requires a valid tokens array");
+  }
+  if (params.tokens.length === 0) {
+    return "";
+  }
+  for (let i = 0;i < params.tokens.length; i++) {
+    const token = params.tokens[i];
+    if (typeof token !== "number" || !Number.isFinite(token)) {
+      throw new Error(`Invalid token at index ${i}: expected number`);
+    }
+  }
+  const modelType = params.modelType;
+  return detokenizeText(runtime, modelType, params.tokens);
+}
+// index.ts
+function getProcessEnv() {
+  if (typeof process === "undefined") {
+    return {};
+  }
+  return process.env;
+}
+var env = getProcessEnv();
+var TEXT_NANO_MODEL_TYPE2 = ModelType5.TEXT_NANO;
+var TEXT_MEDIUM_MODEL_TYPE2 = ModelType5.TEXT_MEDIUM;
+var TEXT_MEGA_MODEL_TYPE2 = ModelType5.TEXT_MEGA;
+var RESPONSE_HANDLER_MODEL_TYPE2 = ModelType5.RESPONSE_HANDLER;
+var ACTION_PLANNER_MODEL_TYPE2 = ModelType5.ACTION_PLANNER;
+function hasExplicitCapabilityOverride(runtime, overrideKeys) {
+  return overrideKeys.some((key) => {
+    const value = getSetting(runtime, key);
+    return typeof value === "string" && value.trim().length > 0;
+  });
+}
+var mediaModelOverrideKeys = {
+  [ModelType5.IMAGE_DESCRIPTION]: ["OPENAI_IMAGE_DESCRIPTION_BASE_URL"]
+};
+var mediaModels = {
+  [ModelType5.IMAGE]: async (runtime, params) => {
+    return handleImageGeneration(runtime, params);
+  },
+  [ModelType5.IMAGE_DESCRIPTION]: async (runtime, params) => {
+    return handleImageDescription(runtime, params);
+  },
+  [ModelType5.TRANSCRIPTION]: async (runtime, input) => {
+    return handleTranscription(runtime, input);
+  },
+  [ModelType5.TEXT_TO_SPEECH]: async (runtime, input) => {
+    return handleTextToSpeech(runtime, input);
+  }
+};
+function registerMediaModels(runtime) {
+  const cerebras = isCerebrasMode(runtime);
+  for (const [modelType, handler] of Object.entries(mediaModels)) {
+    if (cerebras && !hasExplicitCapabilityOverride(runtime, mediaModelOverrideKeys[modelType] ?? [])) {
+      logger9.info(`[OpenAI] Not registering ${modelType}: the Cerebras endpoint does not serve it`);
+      continue;
+    }
+    runtime.registerModel(modelType, handler, openaiPlugin.name, openaiPlugin.priority);
+  }
+}
+var openaiPlugin = {
+  name: "openai",
+  description: "OpenAI API integration for text, image, audio, and embedding models",
+  autoEnable: {
+    envKeys: ["OPENAI_API_KEY", "CEREBRAS_API_KEY", "EVOLINK_API_KEY"]
+  },
+  config: {
+    OPENAI_API_KEY: env.OPENAI_API_KEY ?? null,
+    OPENAI_BASE_URL: env.OPENAI_BASE_URL ?? null,
+    EVOLINK_API_KEY: env.EVOLINK_API_KEY ?? null,
+    EVOLINK_BASE_URL: env.EVOLINK_BASE_URL ?? null,
+    EVOLINK_MODEL: env.EVOLINK_MODEL ?? null,
+    OPENAI_NANO_MODEL: env.OPENAI_NANO_MODEL ?? null,
+    OPENAI_MEDIUM_MODEL: env.OPENAI_MEDIUM_MODEL ?? null,
+    OPENAI_SMALL_MODEL: env.OPENAI_SMALL_MODEL ?? null,
+    OPENAI_LARGE_MODEL: env.OPENAI_LARGE_MODEL ?? null,
+    OPENAI_MEGA_MODEL: env.OPENAI_MEGA_MODEL ?? null,
+    OPENAI_RESPONSE_HANDLER_MODEL: env.OPENAI_RESPONSE_HANDLER_MODEL ?? null,
+    OPENAI_SHOULD_RESPOND_MODEL: env.OPENAI_SHOULD_RESPOND_MODEL ?? null,
+    OPENAI_ACTION_PLANNER_MODEL: env.OPENAI_ACTION_PLANNER_MODEL ?? null,
+    OPENAI_PLANNER_MODEL: env.OPENAI_PLANNER_MODEL ?? null,
+    NANO_MODEL: env.NANO_MODEL ?? null,
+    MEDIUM_MODEL: env.MEDIUM_MODEL ?? null,
+    SMALL_MODEL: env.SMALL_MODEL ?? null,
+    LARGE_MODEL: env.LARGE_MODEL ?? null,
+    MEGA_MODEL: env.MEGA_MODEL ?? null,
+    RESPONSE_HANDLER_MODEL: env.RESPONSE_HANDLER_MODEL ?? null,
+    SHOULD_RESPOND_MODEL: env.SHOULD_RESPOND_MODEL ?? null,
+    ACTION_PLANNER_MODEL: env.ACTION_PLANNER_MODEL ?? null,
+    PLANNER_MODEL: env.PLANNER_MODEL ?? null,
+    OPENAI_EMBEDDING_MODEL: env.OPENAI_EMBEDDING_MODEL ?? null,
+    OPENAI_EMBEDDING_API_KEY: env.OPENAI_EMBEDDING_API_KEY ?? null,
+    OPENAI_EMBEDDING_URL: env.OPENAI_EMBEDDING_URL ?? null,
+    OPENAI_EMBEDDING_DIMENSIONS: env.OPENAI_EMBEDDING_DIMENSIONS ?? null,
+    OPENAI_IMAGE_DESCRIPTION_API_KEY: env.OPENAI_IMAGE_DESCRIPTION_API_KEY ?? null,
+    OPENAI_IMAGE_DESCRIPTION_BASE_URL: env.OPENAI_IMAGE_DESCRIPTION_BASE_URL ?? null,
+    OPENAI_IMAGE_DESCRIPTION_MODEL: env.OPENAI_IMAGE_DESCRIPTION_MODEL ?? null,
+    OPENAI_IMAGE_DESCRIPTION_MAX_TOKENS: env.OPENAI_IMAGE_DESCRIPTION_MAX_TOKENS ?? null,
+    OPENAI_EXPERIMENTAL_TELEMETRY: env.OPENAI_EXPERIMENTAL_TELEMETRY ?? null,
+    OPENAI_RESEARCH_MODEL: env.OPENAI_RESEARCH_MODEL ?? null,
+    OPENAI_RESEARCH_TIMEOUT: env.OPENAI_RESEARCH_TIMEOUT ?? null
+  },
+  async init(config, runtime) {
+    initializeOpenAI(config, runtime);
+    registerMediaModels(runtime);
+  },
+  models: {
+    [ModelType5.TEXT_EMBEDDING]: async (runtime, params) => {
+      return handleTextEmbedding(runtime, params);
+    },
+    [ModelType5.TEXT_TOKENIZER_ENCODE]: async (runtime, params) => {
+      return handleTokenizerEncode(runtime, params);
+    },
+    [ModelType5.TEXT_TOKENIZER_DECODE]: async (runtime, params) => {
+      return handleTokenizerDecode(runtime, params);
+    },
+    [ModelType5.TEXT_SMALL]: async (runtime, params) => {
+      return handleTextSmall(runtime, params);
+    },
+    [TEXT_NANO_MODEL_TYPE2]: async (runtime, params) => {
+      return handleTextNano(runtime, params);
+    },
+    [TEXT_MEDIUM_MODEL_TYPE2]: async (runtime, params) => {
+      return handleTextMedium(runtime, params);
+    },
+    [ModelType5.TEXT_LARGE]: async (runtime, params) => {
+      return handleTextLarge(runtime, params);
+    },
+    [TEXT_MEGA_MODEL_TYPE2]: async (runtime, params) => {
+      return handleTextMega(runtime, params);
+    },
+    [RESPONSE_HANDLER_MODEL_TYPE2]: async (runtime, params) => {
+      return handleResponseHandler(runtime, params);
+    },
+    [ACTION_PLANNER_MODEL_TYPE2]: async (runtime, params) => {
+      return handleActionPlanner(runtime, params);
+    },
+    [ModelType5.RESEARCH]: async (runtime, params) => {
+      return handleResearch(runtime, params);
+    }
+  },
+  tests: [
+    {
+      name: "openai_plugin_tests",
+      tests: [
+        {
+          name: "openai_test_api_connectivity",
+          fn: async (runtime) => {
+            const baseURL = getBaseURL(runtime);
+            const response = await fetch(`${baseURL}/models`, {
+              headers: getAuthHeader(runtime)
+            });
+            if (!response.ok) {
+              throw new Error(`API connectivity test failed: ${response.status} ${response.statusText}`);
+            }
+            const data = await response.json();
+            logger9.info(`[OpenAI Test] API connected. ${data.data?.length ?? 0} models available.`);
+          }
+        },
+        {
+          name: "openai_test_text_embedding",
+          fn: async (runtime) => {
+            const embedding = await runtime.useModel(ModelType5.TEXT_EMBEDDING, {
+              text: "Hello, world!"
+            });
+            if (!Array.isArray(embedding) || embedding.length === 0) {
+              throw new Error("Embedding should return a non-empty array");
+            }
+            logger9.info(`[OpenAI Test] Generated embedding with ${embedding.length} dimensions`);
+          }
+        },
+        {
+          name: "openai_test_text_small",
+          fn: async (runtime) => {
+            const text = await runtime.useModel(ModelType5.TEXT_SMALL, {
+              prompt: "Say hello in exactly 5 words."
+            });
+            if (typeof text !== "string" || text.length === 0) {
+              throw new Error("TEXT_SMALL should return non-empty string");
+            }
+            logger9.info(`[OpenAI Test] TEXT_SMALL generated: "${text.substring(0, 50)}..."`);
+          }
+        },
+        {
+          name: "openai_test_text_large",
+          fn: async (runtime) => {
+            const text = await runtime.useModel(ModelType5.TEXT_LARGE, {
+              prompt: "Explain quantum computing in 2 sentences."
+            });
+            if (typeof text !== "string" || text.length === 0) {
+              throw new Error("TEXT_LARGE should return non-empty string");
+            }
+            logger9.info(`[OpenAI Test] TEXT_LARGE generated: "${text.substring(0, 50)}..."`);
+          }
+        },
+        {
+          name: "openai_test_tokenizer_roundtrip",
+          fn: async (runtime) => {
+            const originalText = "Hello, tokenizer test!";
+            const tokens = await runtime.useModel(ModelType5.TEXT_TOKENIZER_ENCODE, {
+              prompt: originalText,
+              modelType: ModelType5.TEXT_SMALL
+            });
+            if (!Array.isArray(tokens) || tokens.length === 0) {
+              throw new Error("Tokenization should return non-empty token array");
+            }
+            const decodedText = await runtime.useModel(ModelType5.TEXT_TOKENIZER_DECODE, {
+              tokens,
+              modelType: ModelType5.TEXT_SMALL
+            });
+            if (decodedText !== originalText) {
+              throw new Error(`Tokenizer roundtrip failed: expected "${originalText}", got "${decodedText}"`);
+            }
+            logger9.info(`[OpenAI Test] Tokenizer roundtrip successful (${tokens.length} tokens)`);
+          }
+        },
+        {
+          name: "openai_test_streaming",
+          fn: async (runtime) => {
+            const chunks = [];
+            const result = await runtime.useModel(ModelType5.TEXT_LARGE, {
+              prompt: "Count from 1 to 5, one number per line.",
+              stream: true,
+              onStreamChunk: (chunk) => {
+                chunks.push(chunk);
+              }
+            });
+            if (typeof result !== "string" || result.length === 0) {
+              throw new Error("Streaming should return non-empty result");
+            }
+            if (chunks.length === 0) {
+              throw new Error("No streaming chunks received");
+            }
+            logger9.info(`[OpenAI Test] Streaming test: ${chunks.length} chunks received`);
+          }
+        },
+        {
+          name: "openai_test_image_description",
+          fn: async (runtime) => {
+            const testImageUrl = "https://upload.wikimedia.org/wikipedia/commons/thumb/a/a7/Camponotus_flavomarginatus_ant.jpg/440px-Camponotus_flavomarginatus_ant.jpg";
+            const result = await runtime.useModel(ModelType5.IMAGE_DESCRIPTION, testImageUrl);
+            if (!result || typeof result !== "object" || !("title" in result) || !("description" in result)) {
+              throw new Error("Image description should return { title, description }");
+            }
+            logger9.info(`[OpenAI Test] Image described: "${result.title}"`);
+          }
+        },
+        {
+          name: "openai_test_transcription",
+          fn: async (runtime) => {
+            const audioUrl = "https://upload.wikimedia.org/wikipedia/commons/2/25/En-Open_Source.ogg";
+            const response = await fetch(audioUrl);
+            const arrayBuffer = await response.arrayBuffer();
+            const audioBuffer = Buffer.from(new Uint8Array(arrayBuffer));
+            const transcription = await runtime.useModel(ModelType5.TRANSCRIPTION, audioBuffer);
+            if (typeof transcription !== "string") {
+              throw new Error("Transcription should return a string");
+            }
+            logger9.info(`[OpenAI Test] Transcription: "${transcription.substring(0, 50)}..."`);
+          }
+        },
+        {
+          name: "openai_test_text_to_speech",
+          fn: async (runtime) => {
+            const audioData = await runtime.useModel(ModelType5.TEXT_TO_SPEECH, {
+              text: "Hello, this is a text-to-speech test."
+            });
+            if (!(audioData instanceof ArrayBuffer) || audioData.byteLength === 0) {
+              throw new Error("TTS should return non-empty ArrayBuffer");
+            }
+            logger9.info(`[OpenAI Test] TTS generated ${audioData.byteLength} bytes of audio`);
+          }
+        },
+        {
+          name: "openai_test_structured_output_via_text_large",
+          fn: async (runtime) => {
+            const result = await runtime.useModel(ModelType5.TEXT_LARGE, {
+              prompt: "Return a JSON object with exactly these fields: name (string), age (number), active (boolean)",
+              responseSchema: {
+                type: "object",
+                properties: {
+                  name: { type: "string" },
+                  age: { type: "number" },
+                  active: { type: "boolean" }
+                },
+                required: ["name", "age", "active"]
+              }
+            });
+            if (!result || typeof result !== "object" && typeof result !== "string") {
+              throw new Error("Structured output should return an object or text");
+            }
+            logger9.info(`[OpenAI Test] Structured output: ${JSON.stringify(result).substring(0, 100)}`);
+          }
+        },
+        {
+          name: "openai_test_research",
+          fn: async (runtime) => {
+            const result = await runtime.useModel(ModelType5.RESEARCH, {
+              input: "What is the current date and time?",
+              tools: [{ type: "web_search_preview" }],
+              maxToolCalls: 3
+            });
+            if (!result || typeof result !== "object" || !("text" in result)) {
+              throw new Error("Research should return an object with text property");
+            }
+            if (typeof result.text !== "string" || result.text.length === 0) {
+              throw new Error("Research result text should be a non-empty string");
+            }
+            logger9.info(`[OpenAI Test] Research completed. Text length: ${result.text.length}, Annotations: ${result.annotations.length}`);
+          }
+        }
+      ]
+    }
+  ]
+};
+var plugin_openai_default = openaiPlugin;
+
+// index.node.ts
+var index_node_default = plugin_openai_default;
+export {
+  openaiPlugin,
+  index_node_default as default
+};
+
+//# debugId=BCCE52F3E7079C4E64756E2164756E21