@elizaos/plugin-openai 1.6.0 → 2.0.0-alpha.10

package/dist/cjs/index.node.cjs

@@ -26,384 +26,173 @@ var __export = (target, all) => {
     });
 };
 
-// src/index.node.ts
+// index.node.ts
 var exports_index_node = {};
 __export(exports_index_node, {
   openaiPlugin: () => openaiPlugin,
-  default: () => src_default
+  default: () => typescript_default
 });
 module.exports = __toCommonJS(exports_index_node);
 
-// src/index.ts
-var import_core13 = require("@elizaos/core");
+// index.ts
+var import_core14 = require("@elizaos/core");
 
-// src/init.ts
+// init.ts
 var import_core2 = require("@elizaos/core");
 
-// src/utils/config.ts
+// 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);
+}
 function getSetting(runtime, key, defaultValue) {
   const value = runtime.getSetting(key);
   if (value !== undefined && value !== null) {
     return String(value);
   }
-  return process.env[key] ?? defaultValue;
+  return getEnvValue(key) ?? defaultValue;
+}
+function getNumericSetting(runtime, key, defaultValue) {
+  const value = getSetting(runtime, key);
+  if (value === undefined) {
+    return defaultValue;
+  }
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed)) {
+    throw new Error(`Setting '${key}' must be a valid integer, got: ${value}`);
+  }
+  return parsed;
+}
+function getBooleanSetting(runtime, key, defaultValue) {
+  const value = getSetting(runtime, key);
+  if (value === undefined) {
+    return defaultValue;
+  }
+  const normalized = value.toLowerCase();
+  return normalized === "true" || normalized === "1" || normalized === "yes";
 }
 function isBrowser() {
-  return typeof globalThis !== "undefined" && "document" in globalThis && typeof globalThis.document !== "undefined";
+  return typeof globalThis !== "undefined" && typeof globalThis.document !== "undefined";
 }
 function isProxyMode(runtime) {
   return isBrowser() && !!getSetting(runtime, "OPENAI_BROWSER_BASE_URL");
 }
+function getApiKey(runtime) {
+  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);
+}
 function getAuthHeader(runtime, forEmbedding = false) {
-  if (isBrowser())
+  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] Default base URL: ${baseURL}`);
+  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");
+  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 specific embedding base URL: ${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.");
+  import_core.logger.debug("[OpenAI] Falling back to general base URL for embeddings");
   return getBaseURL(runtime);
 }
-function getApiKey(runtime) {
-  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 (present)");
-    return embeddingApiKey;
-  }
-  import_core.logger.debug("[OpenAI] Falling back to general API key for embeddings.");
-  return getApiKey(runtime);
-}
 function getSmallModel(runtime) {
-  return getSetting(runtime, "OPENAI_SMALL_MODEL") ?? getSetting(runtime, "SMALL_MODEL", "gpt-4o-mini");
+  return getSetting(runtime, "OPENAI_SMALL_MODEL") ?? getSetting(runtime, "SMALL_MODEL") ?? "gpt-5-mini";
 }
 function getLargeModel(runtime) {
-  return getSetting(runtime, "OPENAI_LARGE_MODEL") ?? getSetting(runtime, "LARGE_MODEL", "gpt-4o");
+  return getSetting(runtime, "OPENAI_LARGE_MODEL") ?? getSetting(runtime, "LARGE_MODEL") ?? "gpt-5";
+}
+function getEmbeddingModel(runtime) {
+  return getSetting(runtime, "OPENAI_EMBEDDING_MODEL") ?? "text-embedding-3-small";
 }
 function getImageDescriptionModel(runtime) {
-  return getSetting(runtime, "OPENAI_IMAGE_DESCRIPTION_MODEL", "gpt-5-nano");
+  return getSetting(runtime, "OPENAI_IMAGE_DESCRIPTION_MODEL") ?? "gpt-5-mini";
 }
-function getExperimentalTelemetry(runtime) {
-  const setting = getSetting(runtime, "OPENAI_EXPERIMENTAL_TELEMETRY", "false");
-  const normalizedSetting = String(setting).toLowerCase();
-  const result = normalizedSetting === "true";
-  import_core.logger.debug(`[OpenAI] Experimental telemetry in function: "${setting}" (type: ${typeof setting}, normalized: "${normalizedSetting}", result: ${result})`);
-  return result;
+function getTranscriptionModel(runtime) {
+  return getSetting(runtime, "OPENAI_TRANSCRIPTION_MODEL") ?? "gpt-5-mini-transcribe";
 }
-
-// src/init.ts
-function initializeOpenAI(_config, runtime) {
-  (async () => {
-    try {
-      if (!getApiKey(runtime) && !isBrowser()) {
-        import_core2.logger.warn("OPENAI_API_KEY is not set in environment - OpenAI functionality will be limited");
-        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.statusText}`);
-          import_core2.logger.warn("OpenAI functionality will be limited until a valid API key is provided");
-        } else {
-          import_core2.logger.log("OpenAI API key validated successfully");
-        }
-      } catch (fetchError) {
-        const message = fetchError instanceof Error ? fetchError.message : String(fetchError);
-        import_core2.logger.warn(`Error validating OpenAI API key: ${message}`);
-        import_core2.logger.warn("OpenAI functionality will be limited until a valid API key is provided");
-      }
-    } catch (error) {
-      const message = error?.errors?.map((e) => e.message).join(", ") || (error instanceof Error ? error.message : String(error));
-      import_core2.logger.warn(`OpenAI plugin configuration issue: ${message} - You need to configure the OPENAI_API_KEY in your environment variables`);
-    }
-  })();
+function getTTSModel(runtime) {
+  return getSetting(runtime, "OPENAI_TTS_MODEL") ?? "tts-1";
 }
-
-// src/models/text.ts
-var import_core4 = require("@elizaos/core");
-var import_ai = require("ai");
-
-// src/providers/openai.ts
-var import_openai = require("@ai-sdk/openai");
-function createOpenAIClient(runtime) {
-  const baseURL = getBaseURL(runtime);
-  const apiKey = getApiKey(runtime) ?? (isProxyMode(runtime) ? "sk-proxy" : undefined);
-  return import_openai.createOpenAI({ apiKey: apiKey ?? "", baseURL });
+function getTTSVoice(runtime) {
+  return getSetting(runtime, "OPENAI_TTS_VOICE") ?? "nova";
 }
-
-// src/utils/events.ts
-var import_core3 = require("@elizaos/core");
-function emitModelUsageEvent(runtime, type, prompt, usage) {
-  const promptTokens = ("promptTokens" in usage ? usage.promptTokens : undefined) ?? ("inputTokens" in usage ? usage.inputTokens : undefined) ?? 0;
-  const completionTokens = ("completionTokens" in usage ? usage.completionTokens : undefined) ?? ("outputTokens" in usage ? usage.outputTokens : undefined) ?? 0;
-  const totalTokens = ("totalTokens" in usage ? usage.totalTokens : undefined) ?? promptTokens + completionTokens;
-  const truncatedPrompt = typeof prompt === "string" ? prompt.length > 200 ? `${prompt.slice(0, 200)}…` : prompt : "";
-  runtime.emitEvent(import_core3.EventType.MODEL_USED, {
-    runtime,
-    source: "openai",
-    provider: "openai",
-    type,
-    prompt: truncatedPrompt,
-    tokens: {
-      prompt: promptTokens,
-      completion: completionTokens,
-      total: totalTokens
-    }
-  });
+function getTTSInstructions(runtime) {
+  return getSetting(runtime, "OPENAI_TTS_INSTRUCTIONS") ?? "";
 }
-
-// src/models/text.ts
-async function generateTextByModelType(runtime, params, modelType, getModelFn) {
-  const openai = createOpenAIClient(runtime);
-  const modelName = getModelFn(runtime);
-  import_core4.logger.debug(`[OpenAI] ${modelType} model: ${modelName}`);
-  const generateParams = {
-    model: openai.languageModel(modelName),
-    prompt: params.prompt,
-    system: runtime.character.system ?? undefined,
-    temperature: params.temperature ?? 0.7,
-    maxOutputTokens: params.maxTokens ?? 8192,
-    frequencyPenalty: params.frequencyPenalty ?? 0.7,
-    presencePenalty: params.presencePenalty ?? 0.7,
-    stopSequences: params.stopSequences ?? [],
-    experimental_telemetry: { isEnabled: getExperimentalTelemetry(runtime) }
-  };
-  if (params.stream) {
-    const result = import_ai.streamText(generateParams);
-    return {
-      textStream: result.textStream,
-      text: result.text,
-      usage: result.usage.then((u) => u ? {
-        promptTokens: u.inputTokens ?? 0,
-        completionTokens: u.outputTokens ?? 0,
-        totalTokens: (u.inputTokens ?? 0) + (u.outputTokens ?? 0)
-      } : undefined),
-      finishReason: result.finishReason
-    };
-  }
-  const { text, usage } = await import_ai.generateText(generateParams);
-  if (usage)
-    emitModelUsageEvent(runtime, modelType, params.prompt, usage);
-  return text;
+function getImageModel(runtime) {
+  return getSetting(runtime, "OPENAI_IMAGE_MODEL") ?? "dall-e-3";
 }
-async function handleTextSmall(runtime, params) {
-  return generateTextByModelType(runtime, params, import_core4.ModelType.TEXT_SMALL, getSmallModel);
+function getExperimentalTelemetry(runtime) {
+  return getBooleanSetting(runtime, "OPENAI_EXPERIMENTAL_TELEMETRY", false);
 }
-async function handleTextLarge(runtime, params) {
-  return generateTextByModelType(runtime, params, import_core4.ModelType.TEXT_LARGE, getLargeModel);
+function getEmbeddingDimensions(runtime) {
+  return getNumericSetting(runtime, "OPENAI_EMBEDDING_DIMENSIONS", 1536);
 }
-// src/models/embedding.ts
-var import_core5 = require("@elizaos/core");
-async function handleTextEmbedding(runtime, params) {
-  const embeddingModelName = getSetting(runtime, "OPENAI_EMBEDDING_MODEL", "text-embedding-3-small");
-  const embeddingDimension = Number.parseInt(getSetting(runtime, "OPENAI_EMBEDDING_DIMENSIONS", "1536") || "1536", 10);
-  if (!Object.values(import_core5.VECTOR_DIMS).includes(embeddingDimension)) {
-    const errorMsg = `Invalid embedding dimension: ${embeddingDimension}. Must be one of: ${Object.values(import_core5.VECTOR_DIMS).join(", ")}`;
-    import_core5.logger.error(errorMsg);
-    throw new Error(errorMsg);
-  }
-  if (params === null) {
-    import_core5.logger.debug("Creating test embedding for initialization");
-    const testVector = Array(embeddingDimension).fill(0);
-    testVector[0] = 0.1;
-    return testVector;
-  }
-  let text;
-  if (typeof params === "string") {
-    text = params;
-  } else if (typeof params === "object" && params.text) {
-    text = params.text;
-  } else {
-    const errorMsg = "Invalid input format for embedding";
-    import_core5.logger.warn(errorMsg);
-    const fallbackVector = Array(embeddingDimension).fill(0);
-    fallbackVector[0] = 0.2;
-    return fallbackVector;
-  }
-  if (!text.trim()) {
-    const errorMsg = "Empty text for embedding";
-    import_core5.logger.warn(errorMsg);
-    const fallbackVector = Array(embeddingDimension).fill(0);
-    fallbackVector[0] = 0.3;
-    return fallbackVector;
-  }
-  const embeddingBaseURL = getEmbeddingBaseURL(runtime);
-  try {
-    const response = await fetch(`${embeddingBaseURL}/embeddings`, {
-      method: "POST",
-      headers: {
-        ...getAuthHeader(runtime, true),
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({
-        model: embeddingModelName,
-        input: text
-      })
-    });
-    if (!response.ok) {
-      import_core5.logger.error(`OpenAI API error: ${response.status} - ${response.statusText}`);
-      throw new Error(`OpenAI API error: ${response.status} - ${response.statusText}`);
-    }
-    const data = await response.json();
-    if (!data?.data?.[0]?.embedding) {
-      import_core5.logger.error("API returned invalid structure");
-      throw new Error("API returned invalid structure");
-    }
-    const embedding = data.data[0].embedding;
-    if (!Array.isArray(embedding) || embedding.length !== embeddingDimension) {
-      const errorMsg = `Embedding length ${embedding?.length ?? 0} does not match configured dimension ${embeddingDimension}`;
-      import_core5.logger.error(errorMsg);
-      const fallbackVector = Array(embeddingDimension).fill(0);
-      fallbackVector[0] = 0.4;
-      return fallbackVector;
-    }
-    if (data.usage) {
-      const usage = {
-        inputTokens: data.usage.prompt_tokens,
-        outputTokens: 0,
-        totalTokens: data.usage.total_tokens
-      };
-      emitModelUsageEvent(runtime, import_core5.ModelType.TEXT_EMBEDDING, text, usage);
-    }
-    import_core5.logger.log(`Got valid embedding with length ${embedding.length}`);
-    return embedding;
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    import_core5.logger.error(`Error generating embedding: ${message}`);
-    throw error instanceof Error ? error : new Error(message);
-  }
+function getImageDescriptionMaxTokens(runtime) {
+  return getNumericSetting(runtime, "OPENAI_IMAGE_DESCRIPTION_MAX_TOKENS", 8192);
 }
-// src/models/image.ts
-var import_core6 = require("@elizaos/core");
-async function handleImageGeneration(runtime, params) {
-  const n = params.count || 1;
-  const size = params.size || "1024x1024";
-  const prompt = params.prompt;
-  const modelName = getSetting(runtime, "OPENAI_IMAGE_MODEL", "gpt-image-1");
-  import_core6.logger.log(`[OpenAI] Using IMAGE model: ${modelName}`);
-  const baseURL = getBaseURL(runtime);
-  try {
-    const response = await fetch(`${baseURL}/images/generations`, {
-      method: "POST",
-      headers: {
-        ...getAuthHeader(runtime),
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({
-        model: modelName,
-        prompt,
-        n,
-        size
-      })
-    });
-    if (!response.ok) {
-      throw new Error(`Failed to generate image: ${response.statusText}`);
-    }
-    const data = await response.json();
-    const typedData = data;
-    return typedData.data;
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw error;
-  }
+function getResearchModel(runtime) {
+  return getSetting(runtime, "OPENAI_RESEARCH_MODEL") ?? "o3-deep-research";
 }
-async function handleImageDescription(runtime, params) {
-  let imageUrl;
-  let promptText;
-  const modelName = getImageDescriptionModel(runtime);
-  import_core6.logger.log(`[OpenAI] Using IMAGE_DESCRIPTION model: ${modelName}`);
-  const maxTokens = Number.parseInt(getSetting(runtime, "OPENAI_IMAGE_DESCRIPTION_MAX_TOKENS", "8192") || "8192", 10);
-  const DEFAULT_PROMPT = "Please analyze this image and provide a title and detailed description.";
-  if (typeof params === "string") {
-    imageUrl = params;
-    promptText = DEFAULT_PROMPT;
-  } else {
-    imageUrl = params.imageUrl;
-    promptText = params.prompt || DEFAULT_PROMPT;
+function getResearchTimeout(runtime) {
+  return getNumericSetting(runtime, "OPENAI_RESEARCH_TIMEOUT", 3600000);
+}
+
+// init.ts
+globalThis.AI_SDK_LOG_WARNINGS ??= false;
+function initializeOpenAI(_config, runtime) {
+  validateOpenAIConfiguration(runtime);
+}
+async function validateOpenAIConfiguration(runtime) {
+  if (isBrowser()) {
+    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;
   }
-  const messages = [
-    {
-      role: "user",
-      content: [
-        { type: "text", text: promptText },
-        { type: "image_url", image_url: { url: imageUrl } }
-      ]
-    }
-  ];
-  const baseURL = getBaseURL(runtime);
   try {
-    const requestBody = {
-      model: modelName,
-      messages,
-      max_tokens: maxTokens
-    };
-    const response = await fetch(`${baseURL}/chat/completions`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        ...getAuthHeader(runtime)
-      },
-      body: JSON.stringify(requestBody)
+    const baseURL = getBaseURL(runtime);
+    const response = await fetch(`${baseURL}/models`, {
+      headers: getAuthHeader(runtime)
     });
     if (!response.ok) {
-      throw new Error(`OpenAI API error: ${response.status}`);
-    }
-    const result = await response.json();
-    const typedResult = result;
-    const content = typedResult.choices?.[0]?.message?.content;
-    if (typedResult.usage) {
-      emitModelUsageEvent(runtime, import_core6.ModelType.IMAGE_DESCRIPTION, typeof params === "string" ? params : params.prompt || "", {
-        inputTokens: typedResult.usage.prompt_tokens,
-        outputTokens: typedResult.usage.completion_tokens,
-        totalTokens: typedResult.usage.total_tokens
-      });
+      import_core2.logger.warn(`[OpenAI] API key validation failed: ${response.status} ${response.statusText}. ` + "Please verify your OPENAI_API_KEY is correct.");
+      return;
     }
-    if (!content) {
-      return {
-        title: "Failed to analyze image",
-        description: "No response from API"
-      };
-    }
-    const titleMatch = content.match(/title[:\s]+(.+?)(?:\n|$)/i);
-    const title = titleMatch?.[1]?.trim();
-    if (!title) {
-      import_core6.logger.warn("Could not extract title from image description response");
-    }
-    const finalTitle = title || "Image Analysis";
-    const description = content.replace(/title[:\s]+(.+?)(?:\n|$)/i, "").trim();
-    const processedResult = { title: finalTitle, description };
-    return processedResult;
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    import_core6.logger.error(`Error analyzing image: ${message}`);
-    return {
-      title: "Failed to analyze image",
-      description: `Error: ${message}`
-    };
+    import_core2.logger.warn(`[OpenAI] API validation error: ${message}. OpenAI functionality may be limited.`);
   }
 }
-// src/models/audio.ts
-var import_core8 = require("@elizaos/core");
 
-// src/utils/audio.ts
-var import_core7 = require("@elizaos/core");
+// models/audio.ts
+var import_core4 = require("@elizaos/core");
+
+// utils/audio.ts
+var import_core3 = require("@elizaos/core");
 var MAGIC_BYTES = {
   WAV: {
     HEADER: [82, 73, 70, 70],
@@ -415,21 +204,26 @@ var MAGIC_BYTES = {
   FTYP: [102, 116, 121, 112],
   WEBM_EBML: [26, 69, 223, 163]
 };
-function matchBytes(buffer, offset, bytes) {
-  for (let i = 0;i < bytes.length; i++) {
-    if (buffer[offset + i] !== bytes[i])
+var MIN_DETECTION_BUFFER_SIZE = 12;
+function matchBytes(buffer, offset, expected) {
+  for (let i = 0;i < expected.length; i++) {
+    const expectedByte = expected[i];
+    if (expectedByte === undefined || buffer[offset + i] !== expectedByte) {
       return false;
+    }
   }
   return true;
 }
 function detectAudioMimeType(buffer) {
-  if (buffer.length < 12) {
+  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";
   }
-  if (matchBytes(buffer, 0, MAGIC_BYTES.MP3_ID3) || buffer[0] === 255 && (buffer[1] & 224) === 224) {
+  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)) {
@@ -444,284 +238,910 @@ function detectAudioMimeType(buffer) {
   if (matchBytes(buffer, 0, MAGIC_BYTES.WEBM_EBML)) {
     return "audio/webm";
   }
-  import_core7.logger.warn("Could not detect audio format from buffer, using generic binary type");
+  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";
+  }
+}
+function getFilenameForMimeType(mimeType) {
+  const ext = getExtensionForMimeType(mimeType);
+  return `recording.${ext}`;
+}
 
-// src/models/audio.ts
-async function fetchTextToSpeech(runtime, options) {
-  const defaultModel = getSetting(runtime, "OPENAI_TTS_MODEL", "gpt-4o-mini-tts");
-  const defaultVoice = getSetting(runtime, "OPENAI_TTS_VOICE", "nova");
-  const defaultInstructions = getSetting(runtime, "OPENAI_TTS_INSTRUCTIONS", "");
-  const baseURL = getBaseURL(runtime);
-  const model = options.model || defaultModel;
-  const voice = options.voice || defaultVoice;
-  const instructions = options.instructions ?? defaultInstructions;
-  const format = options.format || "mp3";
-  try {
-    const res = await fetch(`${baseURL}/audio/speech`, {
-      method: "POST",
-      headers: {
-        ...getAuthHeader(runtime),
-        "Content-Type": "application/json",
-        ...format === "mp3" ? { Accept: "audio/mpeg" } : {}
-      },
-      body: JSON.stringify({
-        model,
-        voice,
-        input: options.text,
-        format,
-        ...instructions && { instructions }
-      })
-    });
-    if (!res.ok) {
-      const err = await res.text();
-      throw new Error(`OpenAI TTS error ${res.status}: ${err}`);
-    }
-    return await res.arrayBuffer();
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    throw new Error(`Failed to fetch speech from OpenAI TTS: ${message}`);
+// models/audio.ts
+function isBlobOrFile(value) {
+  return value instanceof Blob || value instanceof File;
+}
+function isBuffer(value) {
+  return Buffer.isBuffer(value);
+}
+function isLocalTranscriptionParams(value) {
+  return typeof value === "object" && value !== null && "audio" in value && (isBlobOrFile(value.audio) || isBuffer(value.audio));
+}
+function isCoreTranscriptionParams(value) {
+  return typeof value === "object" && value !== null && "audioUrl" in value && typeof value.audioUrl === "string";
+}
+async function fetchAudioFromUrl(url) {
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch audio from URL: ${response.status}`);
   }
+  return response.blob();
 }
 async function handleTranscription(runtime, input) {
-  let modelName = getSetting(runtime, "OPENAI_TRANSCRIPTION_MODEL", "gpt-4o-mini-transcribe");
-  import_core8.logger.log(`[OpenAI] Using TRANSCRIPTION model: ${modelName}`);
-  const baseURL = getBaseURL(runtime);
+  let modelName = getTranscriptionModel(runtime);
   let blob;
-  let extraParams = null;
-  if (input instanceof Blob || input instanceof File) {
+  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 (Buffer.isBuffer(input)) {
-    const detectedMimeType = detectAudioMimeType(input);
-    import_core8.logger.debug(`Auto-detected audio MIME type: ${detectedMimeType}`);
-    const uint8Array = new Uint8Array(input);
-    blob = new Blob([uint8Array], { type: detectedMimeType });
-  } else if (typeof input === "object" && input !== null && input.audio != null) {
-    const params = input;
-    if (!(params.audio instanceof Blob) && !(params.audio instanceof File) && !Buffer.isBuffer(params.audio)) {
-      throw new Error("TRANSCRIPTION param 'audio' must be a Blob/File/Buffer.");
+  } 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 (Buffer.isBuffer(params.audio)) {
-      let mimeType = params.mimeType;
-      if (!mimeType) {
-        mimeType = detectAudioMimeType(params.audio);
-        import_core8.logger.debug(`Auto-detected audio MIME type: ${mimeType}`);
-      } else {
-        import_core8.logger.debug(`Using provided MIME type: ${mimeType}`);
-      }
-      const uint8Array = new Uint8Array(params.audio);
-      blob = new Blob([uint8Array], { type: mimeType });
+    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 = params.audio;
-    }
-    extraParams = params;
-    if (typeof params.model === "string" && params.model) {
-      modelName = params.model;
+      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 a Blob/File/Buffer or an object { audio: Blob/File/Buffer, mimeType?, language?, response_format?, timestampGranularities?, prompt?, temperature?, model? }");
+    throw new Error("TRANSCRIPTION expects Blob, File, Buffer, URL string, or TranscriptionParams object");
   }
-  const mime = blob.type || "audio/webm";
-  const filename = blob.name || (mime.includes("mp3") || mime.includes("mpeg") ? "recording.mp3" : mime.includes("ogg") ? "recording.ogg" : mime.includes("wav") ? "recording.wav" : mime.includes("webm") ? "recording.webm" : "recording.bin");
+  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", String(modelName));
-  if (extraParams) {
-    if (typeof extraParams.language === "string") {
-      formData.append("language", String(extraParams.language));
+  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);
     }
-    if (typeof extraParams.response_format === "string") {
-      formData.append("response_format", String(extraParams.response_format));
+  }
+  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 (typeof extraParams.prompt === "string") {
-      formData.append("prompt", String(extraParams.prompt));
+    if ("model" in input && input.model) {
+      model = input.model;
     }
-    if (typeof extraParams.temperature === "number") {
-      formData.append("temperature", String(extraParams.temperature));
+    if ("instructions" in input && input.instructions) {
+      instructions = input.instructions;
     }
-    if (Array.isArray(extraParams.timestampGranularities)) {
-      for (const g of extraParams.timestampGranularities) {
-        formData.append("timestamp_granularities[]", String(g));
-      }
+  }
+  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");
+
+// utils/events.ts
+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)}…`;
+}
+function normalizeUsage(usage) {
+  if ("promptTokens" in usage) {
+    const promptTokensDetails = "promptTokensDetails" in usage ? usage.promptTokensDetails : undefined;
+    const cachedPromptTokens = usage.cachedPromptTokens ?? promptTokensDetails?.cachedTokens;
+    return {
+      promptTokens: usage.promptTokens ?? 0,
+      completionTokens: usage.completionTokens ?? 0,
+      totalTokens: usage.totalTokens ?? (usage.promptTokens ?? 0) + (usage.completionTokens ?? 0),
+      cachedPromptTokens
+    };
+  }
+  if ("inputTokens" in usage || "outputTokens" in usage) {
+    const input = usage.inputTokens ?? 0;
+    const output = usage.outputTokens ?? 0;
+    const total = usage.totalTokens ?? input + output;
+    return {
+      promptTokens: input,
+      completionTokens: output,
+      totalTokens: total,
+      cachedPromptTokens: usage.cachedInputTokens
+    };
+  }
+  return {
+    promptTokens: 0,
+    completionTokens: 0,
+    totalTokens: 0
+  };
+}
+function emitModelUsageEvent(runtime, type, prompt, usage) {
+  const normalized = normalizeUsage(usage);
+  const payload = {
+    runtime,
+    source: "openai",
+    provider: "openai",
+    type,
+    prompt: truncatePrompt(prompt),
+    tokens: {
+      prompt: normalized.promptTokens,
+      completion: normalized.completionTokens,
+      total: normalized.totalTokens,
+      ...normalized.cachedPromptTokens !== undefined ? { cached: normalized.cachedPromptTokens } : {}
     }
+  };
+  runtime.emitEvent(import_core5.EventType.MODEL_USED, payload);
+}
+
+// models/embedding.ts
+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(", ")}`);
   }
-  try {
-    const response = await fetch(`${baseURL}/audio/transcriptions`, {
-      method: "POST",
-      headers: {
-        ...getAuthHeader(runtime)
-      },
-      body: formData
+  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");
+}
+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 = 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 || !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
     });
-    if (!response.ok) {
-      throw new Error(`Failed to transcribe audio: ${response.status} ${response.statusText}`);
-    }
-    const data = await response.json();
-    return data.text || "";
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    import_core8.logger.error(`TRANSCRIPTION error: ${message}`);
-    throw error;
   }
+  import_core6.logger.debug(`[OpenAI] Generated embedding with ${embedding.length} dimensions`);
+  return embedding;
 }
-async function handleTextToSpeech(runtime, input) {
-  const options = typeof input === "string" ? { text: input } : input;
-  const resolvedModel = options.model || getSetting(runtime, "OPENAI_TTS_MODEL", "gpt-4o-mini-tts");
-  import_core8.logger.log(`[OpenAI] Using TEXT_TO_SPEECH model: ${resolvedModel}`);
-  try {
-    return await fetchTextToSpeech(runtime, options);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    import_core8.logger.error(`Error in TEXT_TO_SPEECH: ${message}`);
-    throw error;
+// 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.";
+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
+  }));
 }
-// src/models/object.ts
-var import_core10 = require("@elizaos/core");
-var import_ai3 = require("ai");
-
-// src/utils/json.ts
+function parseTitleFromResponse(content) {
+  const titleMatch = content.match(/title[:\s]+(.+?)(?:\n|$)/i);
+  return titleMatch?.[1]?.trim() ?? "Image Analysis";
+}
+function parseDescriptionFromResponse(content) {
+  return content.replace(/title[:\s]+(.+?)(?:\n|$)/i, "").trim();
+}
+async function handleImageDescription(runtime, params) {
+  const modelName = getImageDescriptionModel(runtime);
+  const 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");
 var import_ai2 = require("ai");
+
+// providers/openai.ts
+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
+  });
+}
+// 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
+};
 function getJsonRepairFunction() {
   return async ({ text, error }) => {
-    try {
-      if (error instanceof import_ai2.JSONParseError) {
-        const cleanedText = text.replace(/```json\n|\n```|```/g, "");
-        JSON.parse(cleanedText);
-        return cleanedText;
-      }
+    if (!(error instanceof import_ai.JSONParseError)) {
       return null;
-    } catch (jsonError) {
-      const message = jsonError instanceof Error ? jsonError.message : String(jsonError);
-      import_core9.logger.warn(`Failed to repair JSON text: ${message}`);
+    }
+    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;
     }
   };
 }
 
-// src/models/object.ts
+// models/object.ts
 async function generateObjectByModelType(runtime, params, modelType, getModelFn) {
   const openai = createOpenAIClient(runtime);
   const modelName = getModelFn(runtime);
-  import_core10.logger.log(`[OpenAI] Using ${modelType} model: ${modelName}`);
-  const temperature = params.temperature ?? 0;
-  const schemaPresent = !!params.schema;
-  if (schemaPresent) {
-    import_core10.logger.warn(`Schema provided but ignored: OpenAI object generation currently uses output=no-schema. The schema parameter has no effect.`);
+  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");
   }
-  try {
-    const { object, usage } = await import_ai3.generateObject({
-      model: openai.languageModel(modelName),
-      output: "no-schema",
-      prompt: params.prompt,
-      temperature,
-      experimental_repairText: getJsonRepairFunction()
-    });
-    if (usage) {
-      emitModelUsageEvent(runtime, modelType, params.prompt, usage);
-    }
-    return object;
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    import_core10.logger.error(`[generateObject] Error: ${message}`);
-    throw error;
+  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_core10.ModelType.OBJECT_SMALL, getSmallModel);
+  return generateObjectByModelType(runtime, params, import_core9.ModelType.OBJECT_SMALL, getSmallModel);
 }
 async function handleObjectLarge(runtime, params) {
-  return generateObjectByModelType(runtime, params, import_core10.ModelType.OBJECT_LARGE, getLargeModel);
+  return generateObjectByModelType(runtime, params, import_core9.ModelType.OBJECT_LARGE, getLargeModel);
 }
-// src/models/tokenizer.ts
-var import_core12 = require("@elizaos/core");
-
-// src/utils/tokenization.ts
+// 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}`);
+  }
+}
+function convertOutputItem(item) {
+  switch (item.type) {
+    case "web_search_call":
+      return {
+        id: item.id ?? "",
+        type: "web_search_call",
+        status: item.status ?? "completed",
+        action: {
+          type: item.action?.type ?? "search",
+          query: item.action?.query,
+          url: item.action?.url
+        }
+      };
+    case "file_search_call":
+      return {
+        id: item.id ?? "",
+        type: "file_search_call",
+        status: item.status ?? "completed",
+        query: item.query ?? "",
+        results: item.results?.map((r) => ({
+          fileId: r.file_id,
+          fileName: r.file_name,
+          score: r.score
+        }))
+      };
+    case "code_interpreter_call":
+      return {
+        id: item.id ?? "",
+        type: "code_interpreter_call",
+        status: item.status ?? "completed",
+        code: item.code ?? "",
+        output: item.output
+      };
+    case "mcp_tool_call":
+      return {
+        id: item.id ?? "",
+        type: "mcp_tool_call",
+        status: item.status ?? "completed",
+        serverLabel: item.server_label ?? "",
+        toolName: item.tool_name ?? "",
+        arguments: item.arguments ?? {},
+        result: item.result
+      };
+    case "message":
+      return {
+        type: "message",
+        content: item.content?.map((c) => ({
+          type: "output_text",
+          text: c.text,
+          annotations: c.annotations?.map((a) => ({
+            url: a.url,
+            title: a.title,
+            startIndex: a.start_index,
+            endIndex: a.end_index
+          })) ?? []
+        })) ?? []
+      };
+    default:
+      return null;
+  }
+}
+function extractTextAndAnnotations(response) {
+  if (response.output_text) {
+    const annotations2 = [];
+    if (response.output) {
+      for (const item of response.output) {
+        if (item.type === "message" && item.content) {
+          for (const content of item.content) {
+            if (content.annotations) {
+              for (const ann of content.annotations) {
+                annotations2.push({
+                  url: ann.url,
+                  title: ann.title,
+                  startIndex: ann.start_index,
+                  endIndex: ann.end_index
+                });
+              }
+            }
+          }
+        }
+      }
+    }
+    return { text: response.output_text, annotations: annotations2 };
+  }
+  let text = "";
+  const annotations = [];
+  if (response.output) {
+    for (const item of response.output) {
+      if (item.type === "message" && item.content) {
+        for (const content of item.content) {
+          text += content.text;
+          if (content.annotations) {
+            for (const ann of content.annotations) {
+              annotations.push({
+                url: ann.url,
+                title: ann.title,
+                startIndex: ann.start_index,
+                endIndex: ann.end_index
+              });
+            }
+          }
+        }
+      }
+    }
+  }
+  return { text, annotations };
+}
+async function handleResearch(runtime, params) {
+  const apiKey = getApiKey(runtime);
+  if (!apiKey) {
+    throw new Error("OPENAI_API_KEY is required for deep research. Set it in your environment variables or runtime settings.");
+  }
+  const baseURL = getBaseURL(runtime);
+  const modelName = params.model ?? getResearchModel(runtime);
+  const timeout = getResearchTimeout(runtime);
+  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");
+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
+  };
+}
+function resolvePromptCacheOptions(params) {
+  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;
+}
+async function handleTextSmall(runtime, params) {
+  return generateTextByModelType(runtime, params, import_core11.ModelType.TEXT_SMALL, getSmallModel);
+}
+async function handleTextLarge(runtime, params) {
+  return generateTextByModelType(runtime, params, import_core11.ModelType.TEXT_LARGE, getLargeModel);
+}
+// models/tokenizer.ts
+var import_core13 = require("@elizaos/core");
+
+// utils/tokenization.ts
+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 (error) {
+  } catch {
     return import_js_tiktoken.getEncoding(fallbackEncoding);
   }
 }
-async function tokenizeText(runtime, model, prompt) {
-  const modelName = model === import_core11.ModelType.TEXT_SMALL ? getSmallModel(runtime) : getLargeModel(runtime);
-  const tokens = resolveTokenizerEncoding(modelName).encode(prompt);
-  return tokens;
+function getModelName(runtime, modelType) {
+  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);
 }
-async function detokenizeText(runtime, model, tokens) {
-  const modelName = model === import_core11.ModelType.TEXT_SMALL ? getSmallModel(runtime) : getLargeModel(runtime);
-  return resolveTokenizerEncoding(modelName).decode(tokens);
+function detokenizeText(runtime, modelType, tokens) {
+  const modelName = getModelName(runtime, modelType);
+  const encoder = resolveTokenizerEncoding(modelName);
+  return encoder.decode(tokens);
 }
 
-// src/models/tokenizer.ts
-async function handleTokenizerEncode(runtime, { prompt, modelType = import_core12.ModelType.TEXT_LARGE }) {
-  return await tokenizeText(runtime, modelType, prompt);
+// 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);
+}
+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);
 }
-async function handleTokenizerDecode(runtime, { tokens, modelType = import_core12.ModelType.TEXT_LARGE }) {
-  return await detokenizeText(runtime, modelType, tokens);
+// index.ts
+function getProcessEnv() {
+  if (typeof process === "undefined") {
+    return {};
+  }
+  return process.env;
 }
-// src/index.ts
+var env = getProcessEnv();
 var openaiPlugin = {
   name: "openai",
-  description: "OpenAI plugin",
+  description: "OpenAI API integration for text, image, audio, and embedding models",
   config: {
-    OPENAI_API_KEY: process.env.OPENAI_API_KEY,
-    OPENAI_BASE_URL: process.env.OPENAI_BASE_URL,
-    OPENAI_SMALL_MODEL: process.env.OPENAI_SMALL_MODEL,
-    OPENAI_LARGE_MODEL: process.env.OPENAI_LARGE_MODEL,
-    SMALL_MODEL: process.env.SMALL_MODEL,
-    LARGE_MODEL: process.env.LARGE_MODEL,
-    OPENAI_EMBEDDING_MODEL: process.env.OPENAI_EMBEDDING_MODEL,
-    OPENAI_EMBEDDING_API_KEY: process.env.OPENAI_EMBEDDING_API_KEY,
-    OPENAI_EMBEDDING_URL: process.env.OPENAI_EMBEDDING_URL,
-    OPENAI_EMBEDDING_DIMENSIONS: process.env.OPENAI_EMBEDDING_DIMENSIONS,
-    OPENAI_IMAGE_DESCRIPTION_MODEL: process.env.OPENAI_IMAGE_DESCRIPTION_MODEL,
-    OPENAI_IMAGE_DESCRIPTION_MAX_TOKENS: process.env.OPENAI_IMAGE_DESCRIPTION_MAX_TOKENS,
-    OPENAI_EXPERIMENTAL_TELEMETRY: process.env.OPENAI_EXPERIMENTAL_TELEMETRY
+    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);
+  async init(config, runtime) {
+    initializeOpenAI(config, runtime);
   },
   models: {
-    [import_core13.ModelType.TEXT_EMBEDDING]: async (runtime, params) => {
+    [import_core14.ModelType.TEXT_EMBEDDING]: async (runtime, params) => {
       return handleTextEmbedding(runtime, params);
     },
-    [import_core13.ModelType.TEXT_TOKENIZER_ENCODE]: async (runtime, params) => {
+    [import_core14.ModelType.TEXT_TOKENIZER_ENCODE]: async (runtime, params) => {
       return handleTokenizerEncode(runtime, params);
     },
-    [import_core13.ModelType.TEXT_TOKENIZER_DECODE]: async (runtime, params) => {
+    [import_core14.ModelType.TEXT_TOKENIZER_DECODE]: async (runtime, params) => {
       return handleTokenizerDecode(runtime, params);
     },
-    [import_core13.ModelType.TEXT_SMALL]: async (runtime, params) => {
+    [import_core14.ModelType.TEXT_SMALL]: async (runtime, params) => {
       return handleTextSmall(runtime, params);
     },
-    [import_core13.ModelType.TEXT_LARGE]: async (runtime, params) => {
+    [import_core14.ModelType.TEXT_LARGE]: async (runtime, params) => {
       return handleTextLarge(runtime, params);
     },
-    [import_core13.ModelType.IMAGE]: async (runtime, params) => {
+    [import_core14.ModelType.IMAGE]: async (runtime, params) => {
       return handleImageGeneration(runtime, params);
     },
-    [import_core13.ModelType.IMAGE_DESCRIPTION]: async (runtime, params) => {
+    [import_core14.ModelType.IMAGE_DESCRIPTION]: async (runtime, params) => {
       return handleImageDescription(runtime, params);
     },
-    [import_core13.ModelType.TRANSCRIPTION]: async (runtime, input) => {
+    [import_core14.ModelType.TRANSCRIPTION]: async (runtime, input) => {
       return handleTranscription(runtime, input);
     },
-    [import_core13.ModelType.TEXT_TO_SPEECH]: async (runtime, input) => {
+    [import_core14.ModelType.TEXT_TO_SPEECH]: async (runtime, input) => {
       return handleTextToSpeech(runtime, input);
     },
-    [import_core13.ModelType.OBJECT_SMALL]: async (runtime, params) => {
+    [import_core14.ModelType.OBJECT_SMALL]: async (runtime, params) => {
       return handleObjectSmall(runtime, params);
     },
-    [import_core13.ModelType.OBJECT_LARGE]: async (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: [
@@ -729,217 +1149,166 @@ var openaiPlugin = {
       name: "openai_plugin_tests",
       tests: [
         {
-          name: "openai_test_url_and_api_key_validation",
+          name: "openai_test_api_connectivity",
           fn: async (runtime) => {
             const baseURL = getBaseURL(runtime);
             const response = await fetch(`${baseURL}/models`, {
               headers: getAuthHeader(runtime)
             });
-            const data = await response.json();
-            import_core13.logger.log({ data: data?.data?.length ?? "N/A" }, "Models Available");
             if (!response.ok) {
-              throw new Error(`Failed to validate OpenAI API key: ${response.statusText}`);
+              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) => {
-            try {
-              const embedding = await runtime.useModel(import_core13.ModelType.TEXT_EMBEDDING, {
-                text: "Hello, world!"
-              });
-              import_core13.logger.log({ embedding }, "embedding");
-            } catch (error) {
-              const message = error instanceof Error ? error.message : String(error);
-              import_core13.logger.error(`Error in test_text_embedding: ${message}`);
-              throw error;
+            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_large",
+          name: "openai_test_text_small",
           fn: async (runtime) => {
-            try {
-              const text = await runtime.useModel(import_core13.ModelType.TEXT_LARGE, {
-                prompt: "What is the nature of reality in 10 words?"
-              });
-              if (text.length === 0) {
-                throw new Error("Failed to generate text");
-              }
-              import_core13.logger.log({ text }, "generated with test_text_large");
-            } catch (error) {
-              const message = error instanceof Error ? error.message : String(error);
-              import_core13.logger.error(`Error in test_text_large: ${message}`);
-              throw error;
+            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_small",
+          name: "openai_test_text_large",
           fn: async (runtime) => {
-            try {
-              const text = await runtime.useModel(import_core13.ModelType.TEXT_SMALL, {
-                prompt: "What is the nature of reality in 10 words?"
-              });
-              if (text.length === 0) {
-                throw new Error("Failed to generate text");
-              }
-              import_core13.logger.log({ text }, "generated with test_text_small");
-            } catch (error) {
-              const message = error instanceof Error ? error.message : String(error);
-              import_core13.logger.error(`Error in test_text_small: ${message}`);
-              throw error;
+            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_image_generation",
+          name: "openai_test_tokenizer_roundtrip",
           fn: async (runtime) => {
-            import_core13.logger.log("openai_test_image_generation");
-            try {
-              const image = await runtime.useModel(import_core13.ModelType.IMAGE, {
-                prompt: "A beautiful sunset over a calm ocean",
-                count: 1,
-                size: "1024x1024"
-              });
-              import_core13.logger.log({ image }, "generated with test_image_generation");
-            } catch (error) {
-              const message = error instanceof Error ? error.message : String(error);
-              import_core13.logger.error(`Error in test_image_generation: ${message}`);
-              throw error;
+            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: "image-description",
+          name: "openai_test_streaming",
           fn: async (runtime) => {
-            try {
-              import_core13.logger.log("openai_test_image_description");
-              try {
-                const result = await runtime.useModel(import_core13.ModelType.IMAGE_DESCRIPTION, "https://upload.wikimedia.org/wikipedia/commons/thumb/1/1c/Vitalik_Buterin_TechCrunch_London_2015_%28cropped%29.jpg/537px-Vitalik_Buterin_TechCrunch_London_2015_%28cropped%29.jpg");
-                if (result && typeof result === "object" && "title" in result && "description" in result) {
-                  import_core13.logger.log({ result }, "Image description");
-                } else {
-                  import_core13.logger.error("Invalid image description result format:", result);
-                }
-              } catch (e) {
-                const message = e instanceof Error ? e.message : String(e);
-                import_core13.logger.error(`Error in image description test: ${message}`);
+            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);
               }
-            } catch (e) {
-              const message = e instanceof Error ? e.message : String(e);
-              import_core13.logger.error(`Error in openai_test_image_description: ${message}`);
+            });
+            if (typeof result !== "string" || result.length === 0) {
+              throw new Error("Streaming should return non-empty result");
             }
-          }
-        },
-        {
-          name: "openai_test_transcription",
-          fn: async (runtime) => {
-            import_core13.logger.log("openai_test_transcription");
-            try {
-              const response = await fetch("https://upload.wikimedia.org/wikipedia/en/4/40/Chris_Benoit_Voice_Message.ogg");
-              const arrayBuffer = await response.arrayBuffer();
-              const transcription = await runtime.useModel(import_core13.ModelType.TRANSCRIPTION, Buffer.from(new Uint8Array(arrayBuffer)));
-              import_core13.logger.log({ transcription }, "generated with test_transcription");
-            } catch (error) {
-              const message = error instanceof Error ? error.message : String(error);
-              import_core13.logger.error(`Error in test_transcription: ${message}`);
-              throw error;
+            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_text_tokenizer_encode",
+          name: "openai_test_image_description",
           fn: async (runtime) => {
-            const prompt = "Hello tokenizer encode!";
-            const tokens = await runtime.useModel(import_core13.ModelType.TEXT_TOKENIZER_ENCODE, { prompt, modelType: import_core13.ModelType.TEXT_SMALL });
-            if (!Array.isArray(tokens) || tokens.length === 0) {
-              throw new Error("Failed to tokenize text: expected non-empty array of tokens");
+            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_core13.logger.log({ tokens }, "Tokenized output");
+            import_core14.logger.info(`[OpenAI Test] Image described: "${result.title}"`);
           }
         },
         {
-          name: "openai_test_text_tokenizer_decode",
+          name: "openai_test_transcription",
           fn: async (runtime) => {
-            const prompt = "Hello tokenizer decode!";
-            const tokens = await runtime.useModel(import_core13.ModelType.TEXT_TOKENIZER_ENCODE, { prompt, modelType: import_core13.ModelType.TEXT_SMALL });
-            const decodedText = await runtime.useModel(import_core13.ModelType.TEXT_TOKENIZER_DECODE, {
-              tokens,
-              modelType: import_core13.ModelType.TEXT_SMALL
-            });
-            if (decodedText !== prompt) {
-              throw new Error(`Decoded text does not match original. Expected "${prompt}", got "${decodedText}"`);
+            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_core13.logger.log({ decodedText }, "Decoded text");
+            import_core14.logger.info(`[OpenAI Test] Transcription: "${transcription.substring(0, 50)}..."`);
           }
         },
         {
           name: "openai_test_text_to_speech",
           fn: async (runtime) => {
-            try {
-              const response = await runtime.useModel(import_core13.ModelType.TEXT_TO_SPEECH, {
-                text: "Hello, this is a test for text-to-speech."
-              });
-              if (!response) {
-                throw new Error("Failed to generate speech");
-              }
-              import_core13.logger.log("Generated speech successfully");
-            } catch (error) {
-              const message = error instanceof Error ? error.message : String(error);
-              import_core13.logger.error(`Error in openai_test_text_to_speech: ${message}`);
-              throw error;
+            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_text_generation_large",
+          name: "openai_test_object_generation",
           fn: async (runtime) => {
-            try {
-              const result = await runtime.useModel(import_core13.ModelType.TEXT_LARGE, {
-                prompt: "Say hello in 5 words."
-              });
-              if (!result || result.length === 0) {
-                throw new Error("Text generation returned empty result");
-              }
-              import_core13.logger.log({ result }, "Text generation test completed");
-            } catch (error) {
-              const message = error instanceof Error ? error.message : String(error);
-              import_core13.logger.error(`Error in openai_test_text_generation_large: ${message}`);
-              throw error;
+            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_streaming",
+          name: "openai_test_research",
           fn: async (runtime) => {
-            try {
-              const chunks = [];
-              const result = await runtime.useModel(import_core13.ModelType.TEXT_LARGE, {
-                prompt: "Count from 1 to 5.",
-                onStreamChunk: (chunk) => {
-                  chunks.push(chunk);
-                }
-              });
-              if (!result || result.length === 0) {
-                throw new Error("Streaming returned empty result");
-              }
-              if (chunks.length === 0) {
-                throw new Error("No streaming chunks received");
-              }
-              import_core13.logger.log({ chunks: chunks.length, result: result.substring(0, 50) }, "Streaming test completed");
-            } catch (error) {
-              const message = error instanceof Error ? error.message : String(error);
-              import_core13.logger.error(`Error in openai_test_streaming: ${message}`);
-              throw error;
+            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 src_default = openaiPlugin;
+var typescript_default = openaiPlugin;
 
-//# debugId=F03D6434951BC08A64756E2164756E21
+//# debugId=063EB1323839B08A64756E2164756E21