@elizaos/plugin-openai 2.0.0-alpha.8 → 2.0.0-beta.1

package/dist/cjs/index.node.cjs

@@ -2,35 +2,45 @@ var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __moduleCache = /* @__PURE__ */ new WeakMap;
+function __accessProp(key) {
+	return this[key];
+}
 var __toCommonJS = (from) => {
-  var entry = __moduleCache.get(from), desc;
-  if (entry)
-    return entry;
-  entry = __defProp({}, "__esModule", { value: true });
-  if (from && typeof from === "object" || typeof from === "function")
-    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
-      get: () => from[key],
-      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-    }));
-  __moduleCache.set(from, entry);
-  return entry;
+	var entry = (__moduleCache ??= new WeakMap()).get(from),
+		desc;
+	if (entry) return entry;
+	entry = __defProp({}, "__esModule", { value: true });
+	if ((from && typeof from === "object") || typeof from === "function") {
+		for (var key of __getOwnPropNames(from))
+			if (!__hasOwnProp.call(entry, key))
+				__defProp(entry, key, {
+					get: __accessProp.bind(from, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable,
+				});
+	}
+	__moduleCache.set(from, entry);
+	return entry;
 };
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+	this[name] = __returnValue.bind(null, newValue);
+}
 var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: (newValue) => all[name] = () => newValue
-    });
+	for (var name in all)
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true,
+			configurable: true,
+			set: __exportSetter.bind(all, name),
+		});
 };
 
 // index.node.ts
 var exports_index_node = {};
 __export(exports_index_node, {
-  openaiPlugin: () => openaiPlugin,
-  default: () => typescript_default
+	openaiPlugin: () => openaiPlugin,
+	default: () => index_node_default,
 });
 module.exports = __toCommonJS(exports_index_node);
 
@@ -43,149 +53,231 @@ var import_core2 = require("@elizaos/core");
 // utils/config.ts
 var import_core = require("@elizaos/core");
 function getEnvValue(key) {
-  if (typeof process === "undefined" || !process.env) {
-    return;
-  }
-  const value = process.env[key];
-  return value === undefined ? undefined : String(value);
+	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;
+	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;
+	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";
+	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";
+	return (
+		typeof globalThis !== "undefined" &&
+		typeof globalThis.document !== "undefined"
+	);
 }
 function isProxyMode(runtime) {
-  return isBrowser() && !!getSetting(runtime, "OPENAI_BROWSER_BASE_URL");
+	return isBrowser() && !!getSetting(runtime, "OPENAI_BROWSER_BASE_URL");
 }
 function getApiKey(runtime) {
-  return getSetting(runtime, "OPENAI_API_KEY");
+	return getSetting(runtime, "OPENAI_API_KEY");
 }
 function getEmbeddingApiKey(runtime) {
-  const embeddingApiKey = getSetting(runtime, "OPENAI_EMBEDDING_API_KEY");
-  if (embeddingApiKey) {
-    import_core.logger.debug("[OpenAI] Using specific embedding API key");
-    return embeddingApiKey;
-  }
-  import_core.logger.debug("[OpenAI] Falling back to general API key for embeddings");
-  return getApiKey(runtime);
+	const embeddingApiKey = getSetting(runtime, "OPENAI_EMBEDDING_API_KEY");
+	if (embeddingApiKey) {
+		import_core.logger.debug("[OpenAI] Using specific embedding API key");
+		return embeddingApiKey;
+	}
+	import_core.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}` } : {};
+	if (
+		isBrowser() &&
+		!getBooleanSetting(runtime, "OPENAI_ALLOW_BROWSER_API_KEY", false)
+	) {
+		return {};
+	}
+	const key = forEmbedding ? getEmbeddingApiKey(runtime) : getApiKey(runtime);
+	return key ? { Authorization: `Bearer ${key}` } : {};
 }
 function getBaseURL(runtime) {
-  const browserURL = getSetting(runtime, "OPENAI_BROWSER_BASE_URL");
-  const baseURL = isBrowser() && browserURL ? browserURL : getSetting(runtime, "OPENAI_BASE_URL") ?? "https://api.openai.com/v1";
-  import_core.logger.debug(`[OpenAI] Base URL: ${baseURL}`);
-  return baseURL;
+	const browserURL = getSetting(runtime, "OPENAI_BROWSER_BASE_URL");
+	const baseURL =
+		isBrowser() && browserURL
+			? browserURL
+			: (getSetting(runtime, "OPENAI_BASE_URL") ?? "https://api.openai.com/v1");
+	import_core.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) {
-    import_core.logger.debug(`[OpenAI] Using embedding base URL: ${embeddingURL}`);
-    return embeddingURL;
-  }
-  import_core.logger.debug("[OpenAI] Falling back to general base URL for embeddings");
-  return getBaseURL(runtime);
+	const embeddingURL = isBrowser()
+		? (getSetting(runtime, "OPENAI_BROWSER_EMBEDDING_URL") ??
+			getSetting(runtime, "OPENAI_BROWSER_BASE_URL"))
+		: getSetting(runtime, "OPENAI_EMBEDDING_URL");
+	if (embeddingURL) {
+		import_core.logger.debug(
+			`[OpenAI] Using embedding base URL: ${embeddingURL}`,
+		);
+		return embeddingURL;
+	}
+	import_core.logger.debug(
+		"[OpenAI] Falling back to general base URL for embeddings",
+	);
+	return getBaseURL(runtime);
 }
 function getSmallModel(runtime) {
-  return getSetting(runtime, "OPENAI_SMALL_MODEL") ?? getSetting(runtime, "SMALL_MODEL") ?? "gpt-5-mini";
+	return (
+		getSetting(runtime, "OPENAI_SMALL_MODEL") ??
+		getSetting(runtime, "SMALL_MODEL") ??
+		"gpt-5-mini"
+	);
+}
+function getNanoModel(runtime) {
+	return (
+		getSetting(runtime, "OPENAI_NANO_MODEL") ??
+		getSetting(runtime, "NANO_MODEL") ??
+		getSmallModel(runtime)
+	);
+}
+function getMediumModel(runtime) {
+	return (
+		getSetting(runtime, "OPENAI_MEDIUM_MODEL") ??
+		getSetting(runtime, "MEDIUM_MODEL") ??
+		getSmallModel(runtime)
+	);
 }
 function getLargeModel(runtime) {
-  return getSetting(runtime, "OPENAI_LARGE_MODEL") ?? getSetting(runtime, "LARGE_MODEL") ?? "gpt-5";
+	return (
+		getSetting(runtime, "OPENAI_LARGE_MODEL") ??
+		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") ??
+		getSetting(runtime, "RESPONSE_HANDLER_MODEL") ??
+		getSetting(runtime, "SHOULD_RESPOND_MODEL") ??
+		getNanoModel(runtime)
+	);
+}
+function getActionPlannerModel(runtime) {
+	return (
+		getSetting(runtime, "OPENAI_ACTION_PLANNER_MODEL") ??
+		getSetting(runtime, "OPENAI_PLANNER_MODEL") ??
+		getSetting(runtime, "ACTION_PLANNER_MODEL") ??
+		getSetting(runtime, "PLANNER_MODEL") ??
+		getMediumModel(runtime)
+	);
 }
 function getEmbeddingModel(runtime) {
-  return getSetting(runtime, "OPENAI_EMBEDDING_MODEL") ?? "text-embedding-3-small";
+	return (
+		getSetting(runtime, "OPENAI_EMBEDDING_MODEL") ?? "text-embedding-3-small"
+	);
 }
 function getImageDescriptionModel(runtime) {
-  return getSetting(runtime, "OPENAI_IMAGE_DESCRIPTION_MODEL") ?? "gpt-5-mini";
+	return getSetting(runtime, "OPENAI_IMAGE_DESCRIPTION_MODEL") ?? "gpt-5-mini";
 }
 function getTranscriptionModel(runtime) {
-  return getSetting(runtime, "OPENAI_TRANSCRIPTION_MODEL") ?? "gpt-5-mini-transcribe";
+	return (
+		getSetting(runtime, "OPENAI_TRANSCRIPTION_MODEL") ?? "gpt-5-mini-transcribe"
+	);
 }
 function getTTSModel(runtime) {
-  return getSetting(runtime, "OPENAI_TTS_MODEL") ?? "tts-1";
+	return getSetting(runtime, "OPENAI_TTS_MODEL") ?? "tts-1";
 }
 function getTTSVoice(runtime) {
-  return getSetting(runtime, "OPENAI_TTS_VOICE") ?? "nova";
+	return getSetting(runtime, "OPENAI_TTS_VOICE") ?? "nova";
 }
 function getTTSInstructions(runtime) {
-  return getSetting(runtime, "OPENAI_TTS_INSTRUCTIONS") ?? "";
+	return getSetting(runtime, "OPENAI_TTS_INSTRUCTIONS") ?? "";
 }
 function getImageModel(runtime) {
-  return getSetting(runtime, "OPENAI_IMAGE_MODEL") ?? "dall-e-3";
+	return getSetting(runtime, "OPENAI_IMAGE_MODEL") ?? "dall-e-3";
 }
 function getExperimentalTelemetry(runtime) {
-  return getBooleanSetting(runtime, "OPENAI_EXPERIMENTAL_TELEMETRY", false);
+	return getBooleanSetting(runtime, "OPENAI_EXPERIMENTAL_TELEMETRY", false);
 }
 function getEmbeddingDimensions(runtime) {
-  return getNumericSetting(runtime, "OPENAI_EMBEDDING_DIMENSIONS", 1536);
+	return getNumericSetting(runtime, "OPENAI_EMBEDDING_DIMENSIONS", 1536);
 }
 function getImageDescriptionMaxTokens(runtime) {
-  return getNumericSetting(runtime, "OPENAI_IMAGE_DESCRIPTION_MAX_TOKENS", 8192);
+	return getNumericSetting(
+		runtime,
+		"OPENAI_IMAGE_DESCRIPTION_MAX_TOKENS",
+		8192,
+	);
 }
 function getResearchModel(runtime) {
-  return getSetting(runtime, "OPENAI_RESEARCH_MODEL") ?? "o3-deep-research";
+	return getSetting(runtime, "OPENAI_RESEARCH_MODEL") ?? "o3-deep-research";
 }
 function getResearchTimeout(runtime) {
-  return getNumericSetting(runtime, "OPENAI_RESEARCH_TIMEOUT", 3600000);
+	return getNumericSetting(runtime, "OPENAI_RESEARCH_TIMEOUT", 3600000);
 }
 
 // init.ts
 globalThis.AI_SDK_LOG_WARNINGS ??= false;
 function initializeOpenAI(_config, runtime) {
-  validateOpenAIConfiguration(runtime);
+	validateOpenAIConfiguration(runtime);
 }
 async function validateOpenAIConfiguration(runtime) {
-  if (isBrowser()) {
-    import_core2.logger.debug("[OpenAI] Skipping API validation in browser environment");
-    return;
-  }
-  const apiKey = getApiKey(runtime);
-  if (!apiKey) {
-    import_core2.logger.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) {
-      import_core2.logger.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);
-    import_core2.logger.warn(`[OpenAI] API validation error: ${message}. OpenAI functionality may be limited.`);
-  }
+	if (isBrowser()) {
+		import_core2.logger.debug(
+			"[OpenAI] Skipping API validation in browser environment",
+		);
+		return;
+	}
+	const apiKey = getApiKey(runtime);
+	if (!apiKey) {
+		import_core2.logger.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) {
+			import_core2.logger.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);
+		import_core2.logger.warn(
+			`[OpenAI] API validation error: ${message}. OpenAI functionality may be limited.`,
+		);
+	}
 }
 
 // models/audio.ts
@@ -194,224 +286,260 @@ var import_core4 = require("@elizaos/core");
 // utils/audio.ts
 var import_core3 = require("@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]
+	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;
+	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";
-  }
-  import_core3.logger.warn("Could not detect audio format from buffer, using generic binary type");
-  return "application/octet-stream";
+	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";
+	}
+	import_core3.logger.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";
-  }
+	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}`;
+	const ext = getExtensionForMimeType(mimeType);
+	return `recording.${ext}`;
 }
 
 // models/audio.ts
 function isBlobOrFile(value) {
-  return value instanceof Blob || value instanceof File;
+	return value instanceof Blob || value instanceof File;
 }
 function isBuffer(value) {
-  return Buffer.isBuffer(value);
+	return Buffer.isBuffer(value);
 }
 function isLocalTranscriptionParams(value) {
-  return typeof value === "object" && value !== null && "audio" in value && (isBlobOrFile(value.audio) || isBuffer(value.audio));
+	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";
+	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();
+	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") {
-    import_core4.logger.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);
-    import_core4.logger.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);
-      import_core4.logger.debug(`[OpenAI] Using MIME type: ${mimeType2}`);
-      blob = new Blob([new Uint8Array(input.audio)], { type: mimeType2 });
-    } else {
-      blob = input.audio;
-    }
-  } else if (isCoreTranscriptionParams(input)) {
-    import_core4.logger.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");
-  }
-  import_core4.logger.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 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 data = await response.json();
-  return data.text;
+	let modelName = getTranscriptionModel(runtime);
+	let blob;
+	let extraParams = {};
+	if (typeof input === "string") {
+		import_core4.logger.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);
+		import_core4.logger.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);
+			import_core4.logger.debug(`[OpenAI] Using MIME type: ${mimeType2}`);
+			blob = new Blob([new Uint8Array(input.audio)], { type: mimeType2 });
+		} else {
+			blob = input.audio;
+		}
+	} else if (isCoreTranscriptionParams(input)) {
+		import_core4.logger.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",
+		);
+	}
+	import_core4.logger.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 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 data = await response.json();
+	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);
-  import_core4.logger.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 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}`);
-  }
-  return response.arrayBuffer();
+	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);
+	import_core4.logger.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 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}`,
+		);
+	}
+	return response.arrayBuffer();
 }
 // models/embedding.ts
 var import_core6 = require("@elizaos/core");
@@ -420,249 +548,287 @@ var import_core6 = require("@elizaos/core");
 var import_core5 = require("@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)}…`;
+	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
-  };
+	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(import_core5.EventType.MODEL_USED, payload);
+	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(import_core5.EventType.MODEL_USED, payload);
 }
 
 // models/embedding.ts
-var MAX_EMBEDDING_TOKENS = 8000;
 function validateDimension(dimension) {
-  const validDimensions = Object.values(import_core6.VECTOR_DIMS);
-  if (!validDimensions.includes(dimension)) {
-    throw new Error(`Invalid embedding dimension: ${dimension}. Must be one of: ${validDimensions.join(", ")}`);
-  }
-  return dimension;
+	const validDimensions = Object.values(import_core6.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");
+	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",
+	);
 }
 async function handleTextEmbedding(runtime, params) {
-  const embeddingModel = getEmbeddingModel(runtime);
-  const embeddingDimension = validateDimension(getEmbeddingDimensions(runtime));
-  const text = extractText(params);
-  if (text === null) {
-    import_core6.logger.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 = MAX_EMBEDDING_TOKENS * 4;
-  if (trimmedText.length > maxChars) {
-    import_core6.logger.warn(`[OpenAI] Embedding input too long (~${Math.ceil(trimmedText.length / 4)} tokens), truncating to ~${MAX_EMBEDDING_TOKENS} tokens`);
-    trimmedText = trimmedText.slice(0, maxChars);
-  }
-  const baseURL = getEmbeddingBaseURL(runtime);
-  const url = `${baseURL}/embeddings`;
-  import_core6.logger.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
-    })
-  });
-  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 = data?.data?.[0];
-  if (!firstResult || !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, import_core6.ModelType.TEXT_EMBEDDING, trimmedText, {
-      promptTokens: data.usage.prompt_tokens,
-      completionTokens: 0,
-      totalTokens: data.usage.total_tokens
-    });
-  }
-  import_core6.logger.debug(`[OpenAI] Generated embedding with ${embedding.length} dimensions`);
-  return embedding;
+	const embeddingModel = getEmbeddingModel(runtime);
+	const embeddingDimension = validateDimension(getEmbeddingDimensions(runtime));
+	const text = extractText(params);
+	if (text === null) {
+		import_core6.logger.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) {
+		import_core6.logger.warn(
+			`[OpenAI] Embedding input too long (~${Math.ceil(trimmedText.length / 4)} tokens), truncating to ~8000 tokens`,
+		);
+		trimmedText = trimmedText.slice(0, maxChars);
+	}
+	const baseURL = getEmbeddingBaseURL(runtime);
+	const url = `${baseURL}/embeddings`;
+	import_core6.logger.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,
+		}),
+	});
+	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 = data?.data?.[0];
+	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,
+			import_core6.ModelType.TEXT_EMBEDDING,
+			trimmedText,
+			{
+				promptTokens: data.usage.prompt_tokens,
+				completionTokens: 0,
+				totalTokens: data.usage.total_tokens,
+			},
+		);
+	}
+	import_core6.logger.debug(
+		`[OpenAI] Generated embedding with ${embedding.length} dimensions`,
+	);
+	return embedding;
 }
 // models/image.ts
 var import_core7 = require("@elizaos/core");
-var DEFAULT_IMAGE_DESCRIPTION_PROMPT = "Please analyze this image and provide a title and detailed description.";
+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;
-  import_core7.logger.debug(`[OpenAI] Using IMAGE model: ${modelName}`);
-  if (!params.prompt || 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 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 data = await response.json();
-  if (!data.data || data.data.length === 0) {
-    throw new Error("OpenAI API returned no images");
-  }
-  return data.data.map((item) => ({
-    url: item.url,
-    revisedPrompt: item.revised_prompt
-  }));
+	const modelName = getImageModel(runtime);
+	const count = params.count ?? 1;
+	const size = params.size ?? "1024x1024";
+	const extendedParams = params;
+	import_core7.logger.debug(`[OpenAI] Using IMAGE model: ${modelName}`);
+	if (!params.prompt || 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 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 data = await response.json();
+	if (!data.data || 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";
+	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();
+	return content.replace(/title[:\s]+(.+?)(?:\n|$)/i, "").trim();
 }
 async function handleImageDescription(runtime, params) {
-  const modelName = getImageDescriptionModel(runtime);
-  const maxTokens = getImageDescriptionMaxTokens(runtime);
-  import_core7.logger.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 = getBaseURL(runtime);
-  const requestBody = {
-    model: modelName,
-    messages: [
-      {
-        role: "user",
-        content: [
-          { type: "text", text: promptText },
-          { type: "image_url", image_url: { url: imageUrl } }
-        ]
-      }
-    ],
-    max_tokens: maxTokens
-  };
-  const response = await fetch(`${baseURL}/chat/completions`, {
-    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 description failed: ${response.status} ${response.statusText} - ${errorText}`);
-  }
-  const data = await response.json();
-  if (data.usage) {
-    emitModelUsageEvent(runtime, import_core7.ModelType.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)
-  };
+	const modelName = getImageDescriptionModel(runtime);
+	const maxTokens = getImageDescriptionMaxTokens(runtime);
+	import_core7.logger.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 = getBaseURL(runtime);
+	const requestBody = {
+		model: modelName,
+		messages: [
+			{
+				role: "user",
+				content: [
+					{ type: "text", text: promptText },
+					{ type: "image_url", image_url: { url: imageUrl } },
+				],
+			},
+		],
+		max_tokens: maxTokens,
+	};
+	const response = await fetch(`${baseURL}/chat/completions`, {
+		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 description failed: ${response.status} ${response.statusText} - ${errorText}`,
+		);
+	}
+	const data = await response.json();
+	if (data.usage) {
+		emitModelUsageEvent(
+			runtime,
+			import_core7.ModelType.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/object.ts
 var import_core9 = require("@elizaos/core");
@@ -672,353 +838,492 @@ var import_ai2 = require("ai");
 var import_openai = require("@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 import_openai.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 import_openai.createOpenAI({
-    apiKey,
-    baseURL
-  });
+	const baseURL = getBaseURL(runtime);
+	const apiKey = getApiKey(runtime);
+	if (!apiKey && isProxyMode(runtime)) {
+		return import_openai.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 import_openai.createOpenAI({
+		apiKey,
+		baseURL,
+	});
 }
 // utils/json.ts
 var import_core8 = require("@elizaos/core");
 var import_ai = require("ai");
 var JSON_CLEANUP_PATTERNS = {
-  MARKDOWN_JSON: /```json\n|\n```|```/g,
-  WHITESPACE: /^\s+|\s+$/g
+	MARKDOWN_JSON: /```json\n|\n```|```/g,
+	WHITESPACE: /^\s+|\s+$/g,
 };
 function getJsonRepairFunction() {
-  return async ({ text, error }) => {
-    if (!(error instanceof import_ai.JSONParseError)) {
-      return null;
-    }
-    try {
-      const cleanedText = text.replace(JSON_CLEANUP_PATTERNS.MARKDOWN_JSON, "");
-      JSON.parse(cleanedText);
-      import_core8.logger.debug("[JSON Repair] Successfully repaired JSON by removing markdown wrappers");
-      return cleanedText;
-    } catch {
-      import_core8.logger.warn("[JSON Repair] Unable to repair JSON text");
-      return null;
-    }
-  };
+	return async ({ text, error }) => {
+		if (!(error instanceof import_ai.JSONParseError)) {
+			return null;
+		}
+		try {
+			const cleanedText = text.replace(JSON_CLEANUP_PATTERNS.MARKDOWN_JSON, "");
+			JSON.parse(cleanedText);
+			import_core8.logger.debug(
+				"[JSON Repair] Successfully repaired JSON by removing markdown wrappers",
+			);
+			return cleanedText;
+		} catch {
+			import_core8.logger.warn("[JSON Repair] Unable to repair JSON text");
+			return null;
+		}
+	};
 }
 
 // models/object.ts
-async function generateObjectByModelType(runtime, params, modelType, getModelFn) {
-  const openai = createOpenAIClient(runtime);
-  const modelName = getModelFn(runtime);
-  import_core9.logger.debug(`[OpenAI] Using ${modelType} model: ${modelName}`);
-  if (!params.prompt || params.prompt.trim().length === 0) {
-    throw new Error("Object generation requires a non-empty prompt");
-  }
-  if (params.schema) {
-    import_core9.logger.debug("[OpenAI] Schema provided but using no-schema mode. " + "Structure is determined by prompt instructions.");
-  }
-  const model = openai.chat(modelName);
-  const { object, usage } = await import_ai2.generateObject({
-    model,
-    output: "no-schema",
-    prompt: params.prompt,
-    experimental_repairText: getJsonRepairFunction()
-  });
-  if (usage) {
-    emitModelUsageEvent(runtime, modelType, params.prompt, usage);
-  }
-  if (typeof object !== "object" || object === null) {
-    throw new Error(`Object generation returned ${typeof object}, expected object`);
-  }
-  return object;
+async function generateObjectByModelType(
+	runtime,
+	params,
+	modelType,
+	getModelFn,
+) {
+	const openai = createOpenAIClient(runtime);
+	const modelName = getModelFn(runtime);
+	import_core9.logger.debug(`[OpenAI] Using ${modelType} model: ${modelName}`);
+	if (!params.prompt || params.prompt.trim().length === 0) {
+		throw new Error("Object generation requires a non-empty prompt");
+	}
+	if (params.schema) {
+		import_core9.logger.debug(
+			"[OpenAI] Schema provided but using no-schema mode. " +
+				"Structure is determined by prompt instructions.",
+		);
+	}
+	const model = openai.chat(modelName);
+	const { object, usage } = await import_ai2.generateObject({
+		model,
+		output: "no-schema",
+		prompt: params.prompt,
+		experimental_repairText: getJsonRepairFunction(),
+	});
+	if (usage) {
+		emitModelUsageEvent(runtime, modelType, params.prompt, usage);
+	}
+	if (typeof object !== "object" || object === null) {
+		throw new Error(
+			`Object generation returned ${typeof object}, expected object`,
+		);
+	}
+	return object;
 }
 async function handleObjectSmall(runtime, params) {
-  return generateObjectByModelType(runtime, params, import_core9.ModelType.OBJECT_SMALL, getSmallModel);
+	return generateObjectByModelType(
+		runtime,
+		params,
+		import_core9.ModelType.OBJECT_SMALL,
+		getSmallModel,
+	);
 }
 async function handleObjectLarge(runtime, params) {
-  return generateObjectByModelType(runtime, params, import_core9.ModelType.OBJECT_LARGE, getLargeModel);
+	return generateObjectByModelType(
+		runtime,
+		params,
+		import_core9.ModelType.OBJECT_LARGE,
+		getLargeModel,
+	);
 }
 // models/research.ts
 var import_core10 = require("@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}`);
-  }
+	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;
-  }
+	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 };
+	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);
-  import_core10.logger.debug(`[OpenAI] Starting deep research with model: ${modelName}`);
-  import_core10.logger.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) {
-    import_core10.logger.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 };
-  }
-  import_core10.logger.debug(`[OpenAI] Research request body: ${JSON.stringify(requestBody, null, 2)}`);
-  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();
-    import_core10.logger.error(`[OpenAI] Research request failed: ${response.status} ${errorText}`);
-    throw new Error(`Deep research request failed: ${response.status} ${response.statusText}`);
-  }
-  const data = await response.json();
-  if (data.error) {
-    import_core10.logger.error(`[OpenAI] Research API error: ${data.error.message}`);
-    throw new Error(`Deep research error: ${data.error.message}`);
-  }
-  import_core10.logger.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
-  };
-  import_core10.logger.info(`[OpenAI] Research completed. Text length: ${text.length}, Annotations: ${annotations.length}, Output items: ${outputItems.length}`);
-  return result;
+	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);
+	import_core10.logger.debug(
+		`[OpenAI] Starting deep research with model: ${modelName}`,
+	);
+	import_core10.logger.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) {
+		import_core10.logger.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 };
+	}
+	import_core10.logger.debug(
+		`[OpenAI] Research request body: ${JSON.stringify(requestBody, null, 2)}`,
+	);
+	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();
+		import_core10.logger.error(
+			`[OpenAI] Research request failed: ${response.status} ${errorText}`,
+		);
+		throw new Error(
+			`Deep research request failed: ${response.status} ${response.statusText}`,
+		);
+	}
+	const data = await response.json();
+	if (data.error) {
+		import_core10.logger.error(
+			`[OpenAI] Research API error: ${data.error.message}`,
+		);
+		throw new Error(`Deep research error: ${data.error.message}`);
+	}
+	import_core10.logger.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,
+	};
+	import_core10.logger.info(
+		`[OpenAI] Research completed. Text length: ${text.length}, Annotations: ${annotations.length}, Output items: ${outputItems.length}`,
+	);
+	return result;
 }
 // models/text.ts
 var import_core11 = require("@elizaos/core");
 var import_ai3 = require("ai");
+var TEXT_NANO_MODEL_TYPE = import_core11.ModelType.TEXT_NANO ?? "TEXT_NANO";
+var TEXT_MEDIUM_MODEL_TYPE =
+	import_core11.ModelType.TEXT_MEDIUM ?? "TEXT_MEDIUM";
+var TEXT_MEGA_MODEL_TYPE = import_core11.ModelType.TEXT_MEGA ?? "TEXT_MEGA";
+var RESPONSE_HANDLER_MODEL_TYPE =
+	import_core11.ModelType.RESPONSE_HANDLER ?? "RESPONSE_HANDLER";
+var ACTION_PLANNER_MODEL_TYPE =
+	import_core11.ModelType.ACTION_PLANNER ?? "ACTION_PLANNER";
+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;
-  return {
-    promptTokens,
-    completionTokens,
-    totalTokens: promptTokens + completionTokens,
-    cachedPromptTokens: usageWithCache.cachedInputTokens
-  };
+	if (!usage) {
+		return;
+	}
+	const promptTokens = usage.inputTokens ?? 0;
+	const completionTokens = usage.outputTokens ?? 0;
+	const usageWithCache = usage;
+	return {
+		promptTokens,
+		completionTokens,
+		totalTokens: promptTokens + completionTokens,
+		cachedPromptTokens: usageWithCache.cachedInputTokens,
+	};
 }
 function resolvePromptCacheOptions(params) {
-  const withOpenAIOptions = params;
-  return {
-    promptCacheKey: withOpenAIOptions.providerOptions?.openai?.promptCacheKey,
-    promptCacheRetention: withOpenAIOptions.providerOptions?.openai?.promptCacheRetention
-  };
+	const withOpenAIOptions = params;
+	return {
+		promptCacheKey: withOpenAIOptions.providerOptions?.openai?.promptCacheKey,
+		promptCacheRetention:
+			withOpenAIOptions.providerOptions?.openai?.promptCacheRetention,
+	};
 }
 async function generateTextByModelType(runtime, params, modelType, getModelFn) {
-  const openai = createOpenAIClient(runtime);
-  const modelName = getModelFn(runtime);
-  import_core11.logger.debug(`[OpenAI] Using ${modelType} model: ${modelName}`);
-  const promptCacheOptions = resolvePromptCacheOptions(params);
-  const systemPrompt = runtime.character.system ?? undefined;
-  const model = openai.chat(modelName);
-  const generateParams = {
-    model,
-    prompt: params.prompt,
-    system: systemPrompt,
-    maxOutputTokens: params.maxTokens ?? 8192,
-    experimental_telemetry: { isEnabled: getExperimentalTelemetry(runtime) },
-    ...promptCacheOptions.promptCacheKey || promptCacheOptions.promptCacheRetention ? {
-      providerOptions: {
-        openai: {
-          ...promptCacheOptions.promptCacheKey ? { promptCacheKey: promptCacheOptions.promptCacheKey } : {},
-          ...promptCacheOptions.promptCacheRetention ? { promptCacheRetention: promptCacheOptions.promptCacheRetention } : {}
-        }
-      }
-    } : {}
-  };
-  if (params.stream) {
-    const result = import_ai3.streamText(generateParams);
-    return {
-      textStream: result.textStream,
-      text: Promise.resolve(result.text),
-      usage: Promise.resolve(result.usage).then(convertUsage),
-      finishReason: Promise.resolve(result.finishReason).then((r) => r)
-    };
-  }
-  const { text, usage } = await import_ai3.generateText(generateParams);
-  if (usage) {
-    emitModelUsageEvent(runtime, modelType, params.prompt, usage);
-  }
-  return text;
+	const paramsWithAttachments = params;
+	const openai = createOpenAIClient(runtime);
+	const modelName = getModelFn(runtime);
+	import_core11.logger.debug(`[OpenAI] Using ${modelType} model: ${modelName}`);
+	const promptCacheOptions = resolvePromptCacheOptions(params);
+	const hasAttachments = (paramsWithAttachments.attachments?.length ?? 0) > 0;
+	const userContent = hasAttachments
+		? buildUserContent(paramsWithAttachments)
+		: undefined;
+	const systemPrompt = runtime.character.system ?? undefined;
+	const model = openai.chat(modelName);
+	const generateParams = {
+		model,
+		...(userContent
+			? { messages: [{ role: "user", content: userContent }] }
+			: { prompt: params.prompt }),
+		system: systemPrompt,
+		maxOutputTokens: params.maxTokens ?? 8192,
+		experimental_telemetry: { isEnabled: getExperimentalTelemetry(runtime) },
+		...(promptCacheOptions.promptCacheKey ||
+		promptCacheOptions.promptCacheRetention
+			? {
+					providerOptions: {
+						openai: {
+							...(promptCacheOptions.promptCacheKey
+								? { promptCacheKey: promptCacheOptions.promptCacheKey }
+								: {}),
+							...(promptCacheOptions.promptCacheRetention
+								? {
+										promptCacheRetention:
+											promptCacheOptions.promptCacheRetention,
+									}
+								: {}),
+						},
+					},
+				}
+			: {}),
+	};
+	if (params.stream) {
+		const result = import_ai3.streamText(generateParams);
+		return {
+			textStream: result.textStream,
+			text: Promise.resolve(result.text),
+			usage: Promise.resolve(result.usage).then(convertUsage),
+			finishReason: Promise.resolve(result.finishReason).then((r) => r),
+		};
+	}
+	const { text, usage } = await import_ai3.generateText(generateParams);
+	if (usage) {
+		emitModelUsageEvent(runtime, modelType, params.prompt, usage);
+	}
+	return text;
 }
 async function handleTextSmall(runtime, params) {
-  return generateTextByModelType(runtime, params, import_core11.ModelType.TEXT_SMALL, getSmallModel);
+	return generateTextByModelType(
+		runtime,
+		params,
+		import_core11.ModelType.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, import_core11.ModelType.TEXT_LARGE, getLargeModel);
+	return generateTextByModelType(
+		runtime,
+		params,
+		import_core11.ModelType.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,
+	);
 }
 // models/tokenizer.ts
 var import_core13 = require("@elizaos/core");
@@ -1027,289 +1332,417 @@ var import_core13 = require("@elizaos/core");
 var import_core12 = require("@elizaos/core");
 var import_js_tiktoken = require("js-tiktoken");
 function resolveTokenizerEncoding(modelName) {
-  const normalized = modelName.toLowerCase();
-  const fallbackEncoding = normalized.includes("4o") ? "o200k_base" : "cl100k_base";
-  try {
-    return import_js_tiktoken.encodingForModel(modelName);
-  } catch {
-    return import_js_tiktoken.getEncoding(fallbackEncoding);
-  }
+	const normalized = modelName.toLowerCase();
+	const fallbackEncoding = normalized.includes("4o")
+		? "o200k_base"
+		: "cl100k_base";
+	try {
+		return import_js_tiktoken.encodingForModel(modelName);
+	} catch {
+		return import_js_tiktoken.getEncoding(fallbackEncoding);
+	}
 }
 function getModelName(runtime, modelType) {
-  if (modelType === import_core12.ModelType.TEXT_SMALL) {
-    return getSmallModel(runtime);
-  }
-  return getLargeModel(runtime);
+	if (modelType === import_core12.ModelType.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);
+	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);
+	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 ?? import_core13.ModelType.TEXT_LARGE;
-  return tokenizeText(runtime, modelType, params.prompt);
+	if (!params.prompt) {
+		throw new Error("Tokenization requires a non-empty prompt");
+	}
+	const modelType = params.modelType ?? import_core13.ModelType.TEXT_LARGE;
+	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 ?? import_core13.ModelType.TEXT_LARGE;
-  return detokenizeText(runtime, modelType, params.tokens);
+	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 ?? import_core13.ModelType.TEXT_LARGE;
+	return detokenizeText(runtime, modelType, params.tokens);
 }
 // index.ts
 function getProcessEnv() {
-  if (typeof process === "undefined") {
-    return {};
-  }
-  return process.env;
+	if (typeof process === "undefined") {
+		return {};
+	}
+	return process.env;
 }
 var env = getProcessEnv();
+var TEXT_NANO_MODEL_TYPE2 = import_core14.ModelType.TEXT_NANO ?? "TEXT_NANO";
+var TEXT_MEDIUM_MODEL_TYPE2 =
+	import_core14.ModelType.TEXT_MEDIUM ?? "TEXT_MEDIUM";
+var TEXT_MEGA_MODEL_TYPE2 = import_core14.ModelType.TEXT_MEGA ?? "TEXT_MEGA";
+var RESPONSE_HANDLER_MODEL_TYPE2 =
+	import_core14.ModelType.RESPONSE_HANDLER ?? "RESPONSE_HANDLER";
+var ACTION_PLANNER_MODEL_TYPE2 =
+	import_core14.ModelType.ACTION_PLANNER ?? "ACTION_PLANNER";
 var openaiPlugin = {
-  name: "openai",
-  description: "OpenAI API integration for text, image, audio, and embedding models",
-  config: {
-    OPENAI_API_KEY: env.OPENAI_API_KEY ?? null,
-    OPENAI_BASE_URL: env.OPENAI_BASE_URL ?? null,
-    OPENAI_SMALL_MODEL: env.OPENAI_SMALL_MODEL ?? null,
-    OPENAI_LARGE_MODEL: env.OPENAI_LARGE_MODEL ?? null,
-    SMALL_MODEL: env.SMALL_MODEL ?? null,
-    LARGE_MODEL: env.LARGE_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_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);
-  },
-  models: {
-    [import_core14.ModelType.TEXT_EMBEDDING]: async (runtime, params) => {
-      return handleTextEmbedding(runtime, params);
-    },
-    [import_core14.ModelType.TEXT_TOKENIZER_ENCODE]: async (runtime, params) => {
-      return handleTokenizerEncode(runtime, params);
-    },
-    [import_core14.ModelType.TEXT_TOKENIZER_DECODE]: async (runtime, params) => {
-      return handleTokenizerDecode(runtime, params);
-    },
-    [import_core14.ModelType.TEXT_SMALL]: async (runtime, params) => {
-      return handleTextSmall(runtime, params);
-    },
-    [import_core14.ModelType.TEXT_LARGE]: async (runtime, params) => {
-      return handleTextLarge(runtime, params);
-    },
-    [import_core14.ModelType.IMAGE]: async (runtime, params) => {
-      return handleImageGeneration(runtime, params);
-    },
-    [import_core14.ModelType.IMAGE_DESCRIPTION]: async (runtime, params) => {
-      return handleImageDescription(runtime, params);
-    },
-    [import_core14.ModelType.TRANSCRIPTION]: async (runtime, input) => {
-      return handleTranscription(runtime, input);
-    },
-    [import_core14.ModelType.TEXT_TO_SPEECH]: async (runtime, input) => {
-      return handleTextToSpeech(runtime, input);
-    },
-    [import_core14.ModelType.OBJECT_SMALL]: async (runtime, params) => {
-      return handleObjectSmall(runtime, params);
-    },
-    [import_core14.ModelType.OBJECT_LARGE]: async (runtime, params) => {
-      return handleObjectLarge(runtime, params);
-    },
-    [import_core14.ModelType.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();
-            import_core14.logger.info(`[OpenAI Test] API connected. ${data.data?.length ?? 0} models available.`);
-          }
-        },
-        {
-          name: "openai_test_text_embedding",
-          fn: async (runtime) => {
-            const embedding = await runtime.useModel(import_core14.ModelType.TEXT_EMBEDDING, {
-              text: "Hello, world!"
-            });
-            if (!Array.isArray(embedding) || embedding.length === 0) {
-              throw new Error("Embedding should return a non-empty array");
-            }
-            import_core14.logger.info(`[OpenAI Test] Generated embedding with ${embedding.length} dimensions`);
-          }
-        },
-        {
-          name: "openai_test_text_small",
-          fn: async (runtime) => {
-            const text = await runtime.useModel(import_core14.ModelType.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");
-            }
-            import_core14.logger.info(`[OpenAI Test] TEXT_SMALL generated: "${text.substring(0, 50)}..."`);
-          }
-        },
-        {
-          name: "openai_test_text_large",
-          fn: async (runtime) => {
-            const text = await runtime.useModel(import_core14.ModelType.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");
-            }
-            import_core14.logger.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(import_core14.ModelType.TEXT_TOKENIZER_ENCODE, {
-              prompt: originalText,
-              modelType: import_core14.ModelType.TEXT_SMALL
-            });
-            if (!Array.isArray(tokens) || tokens.length === 0) {
-              throw new Error("Tokenization should return non-empty token array");
-            }
-            const decodedText = await runtime.useModel(import_core14.ModelType.TEXT_TOKENIZER_DECODE, {
-              tokens,
-              modelType: import_core14.ModelType.TEXT_SMALL
-            });
-            if (decodedText !== originalText) {
-              throw new Error(`Tokenizer roundtrip failed: expected "${originalText}", got "${decodedText}"`);
-            }
-            import_core14.logger.info(`[OpenAI Test] Tokenizer roundtrip successful (${tokens.length} tokens)`);
-          }
-        },
-        {
-          name: "openai_test_streaming",
-          fn: async (runtime) => {
-            const chunks = [];
-            const result = await runtime.useModel(import_core14.ModelType.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");
-            }
-            import_core14.logger.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(import_core14.ModelType.IMAGE_DESCRIPTION, testImageUrl);
-            if (!result || typeof result !== "object" || !("title" in result) || !("description" in result)) {
-              throw new Error("Image description should return { title, description }");
-            }
-            import_core14.logger.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(import_core14.ModelType.TRANSCRIPTION, audioBuffer);
-            if (typeof transcription !== "string") {
-              throw new Error("Transcription should return a string");
-            }
-            import_core14.logger.info(`[OpenAI Test] Transcription: "${transcription.substring(0, 50)}..."`);
-          }
-        },
-        {
-          name: "openai_test_text_to_speech",
-          fn: async (runtime) => {
-            const audioData = await runtime.useModel(import_core14.ModelType.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");
-            }
-            import_core14.logger.info(`[OpenAI Test] TTS generated ${audioData.byteLength} bytes of audio`);
-          }
-        },
-        {
-          name: "openai_test_object_generation",
-          fn: async (runtime) => {
-            const result = await runtime.useModel(import_core14.ModelType.OBJECT_SMALL, {
-              prompt: "Return a JSON object with exactly these fields: name (string), age (number), active (boolean)"
-            });
-            if (!result || typeof result !== "object") {
-              throw new Error("Object generation should return an object");
-            }
-            import_core14.logger.info(`[OpenAI Test] Object generated: ${JSON.stringify(result).substring(0, 100)}`);
-          }
-        },
-        {
-          name: "openai_test_research",
-          fn: async (runtime) => {
-            const result = await runtime.useModel(import_core14.ModelType.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");
-            }
-            import_core14.logger.info(`[OpenAI Test] Research completed. Text length: ${result.text.length}, Annotations: ${result.annotations?.length ?? 0}`);
-          }
-        }
-      ]
-    }
-  ]
+	name: "openai",
+	description:
+		"OpenAI API integration for text, image, audio, and embedding models",
+	config: {
+		OPENAI_API_KEY: env.OPENAI_API_KEY ?? null,
+		OPENAI_BASE_URL: env.OPENAI_BASE_URL ?? 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_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);
+	},
+	models: {
+		[import_core14.ModelType.TEXT_EMBEDDING]: async (runtime, params) => {
+			return handleTextEmbedding(runtime, params);
+		},
+		[import_core14.ModelType.TEXT_TOKENIZER_ENCODE]: async (
+			runtime,
+			params,
+		) => {
+			return handleTokenizerEncode(runtime, params);
+		},
+		[import_core14.ModelType.TEXT_TOKENIZER_DECODE]: async (
+			runtime,
+			params,
+		) => {
+			return handleTokenizerDecode(runtime, params);
+		},
+		[import_core14.ModelType.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);
+		},
+		[import_core14.ModelType.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);
+		},
+		[import_core14.ModelType.IMAGE]: async (runtime, params) => {
+			return handleImageGeneration(runtime, params);
+		},
+		[import_core14.ModelType.IMAGE_DESCRIPTION]: async (runtime, params) => {
+			return handleImageDescription(runtime, params);
+		},
+		[import_core14.ModelType.TRANSCRIPTION]: async (runtime, input) => {
+			return handleTranscription(runtime, input);
+		},
+		[import_core14.ModelType.TEXT_TO_SPEECH]: async (runtime, input) => {
+			return handleTextToSpeech(runtime, input);
+		},
+		[import_core14.ModelType.OBJECT_SMALL]: async (runtime, params) => {
+			return handleObjectSmall(runtime, params);
+		},
+		[import_core14.ModelType.OBJECT_LARGE]: async (runtime, params) => {
+			return handleObjectLarge(runtime, params);
+		},
+		[import_core14.ModelType.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();
+						import_core14.logger.info(
+							`[OpenAI Test] API connected. ${data.data?.length ?? 0} models available.`,
+						);
+					},
+				},
+				{
+					name: "openai_test_text_embedding",
+					fn: async (runtime) => {
+						const embedding = await runtime.useModel(
+							import_core14.ModelType.TEXT_EMBEDDING,
+							{
+								text: "Hello, world!",
+							},
+						);
+						if (!Array.isArray(embedding) || embedding.length === 0) {
+							throw new Error("Embedding should return a non-empty array");
+						}
+						import_core14.logger.info(
+							`[OpenAI Test] Generated embedding with ${embedding.length} dimensions`,
+						);
+					},
+				},
+				{
+					name: "openai_test_text_small",
+					fn: async (runtime) => {
+						const text = await runtime.useModel(
+							import_core14.ModelType.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");
+						}
+						import_core14.logger.info(
+							`[OpenAI Test] TEXT_SMALL generated: "${text.substring(0, 50)}..."`,
+						);
+					},
+				},
+				{
+					name: "openai_test_text_large",
+					fn: async (runtime) => {
+						const text = await runtime.useModel(
+							import_core14.ModelType.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");
+						}
+						import_core14.logger.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(
+							import_core14.ModelType.TEXT_TOKENIZER_ENCODE,
+							{
+								prompt: originalText,
+								modelType: import_core14.ModelType.TEXT_SMALL,
+							},
+						);
+						if (!Array.isArray(tokens) || tokens.length === 0) {
+							throw new Error(
+								"Tokenization should return non-empty token array",
+							);
+						}
+						const decodedText = await runtime.useModel(
+							import_core14.ModelType.TEXT_TOKENIZER_DECODE,
+							{
+								tokens,
+								modelType: import_core14.ModelType.TEXT_SMALL,
+							},
+						);
+						if (decodedText !== originalText) {
+							throw new Error(
+								`Tokenizer roundtrip failed: expected "${originalText}", got "${decodedText}"`,
+							);
+						}
+						import_core14.logger.info(
+							`[OpenAI Test] Tokenizer roundtrip successful (${tokens.length} tokens)`,
+						);
+					},
+				},
+				{
+					name: "openai_test_streaming",
+					fn: async (runtime) => {
+						const chunks = [];
+						const result = await runtime.useModel(
+							import_core14.ModelType.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");
+						}
+						import_core14.logger.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(
+							import_core14.ModelType.IMAGE_DESCRIPTION,
+							testImageUrl,
+						);
+						if (
+							!result ||
+							typeof result !== "object" ||
+							!("title" in result) ||
+							!("description" in result)
+						) {
+							throw new Error(
+								"Image description should return { title, description }",
+							);
+						}
+						import_core14.logger.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(
+							import_core14.ModelType.TRANSCRIPTION,
+							audioBuffer,
+						);
+						if (typeof transcription !== "string") {
+							throw new Error("Transcription should return a string");
+						}
+						import_core14.logger.info(
+							`[OpenAI Test] Transcription: "${transcription.substring(0, 50)}..."`,
+						);
+					},
+				},
+				{
+					name: "openai_test_text_to_speech",
+					fn: async (runtime) => {
+						const audioData = await runtime.useModel(
+							import_core14.ModelType.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");
+						}
+						import_core14.logger.info(
+							`[OpenAI Test] TTS generated ${audioData.byteLength} bytes of audio`,
+						);
+					},
+				},
+				{
+					name: "openai_test_object_generation",
+					fn: async (runtime) => {
+						const result = await runtime.useModel(
+							import_core14.ModelType.OBJECT_SMALL,
+							{
+								prompt:
+									"Return a JSON object with exactly these fields: name (string), age (number), active (boolean)",
+							},
+						);
+						if (!result || typeof result !== "object") {
+							throw new Error("Object generation should return an object");
+						}
+						import_core14.logger.info(
+							`[OpenAI Test] Object generated: ${JSON.stringify(result).substring(0, 100)}`,
+						);
+					},
+				},
+				{
+					name: "openai_test_research",
+					fn: async (runtime) => {
+						const result = await runtime.useModel(
+							import_core14.ModelType.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",
+							);
+						}
+						import_core14.logger.info(
+							`[OpenAI Test] Research completed. Text length: ${result.text.length}, Annotations: ${result.annotations?.length ?? 0}`,
+						);
+					},
+				},
+			],
+		},
+	],
 };
 var typescript_default = openaiPlugin;
 
-//# debugId=23E20BA2231FE80864756E2164756E21
+// index.node.ts
+var index_node_default = typescript_default;
+
+//# debugId=236821D6733C981C64756E2164756E21