@elizaos/plugin-openai 1.5.15 → 1.5.18

package/dist/cjs/index.node.cjs

@@ -1,7 +1,20 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
 var __moduleCache = /* @__PURE__ */ new WeakMap;
 var __toCommonJS = (from) => {
   var entry = __moduleCache.get(from), desc;
@@ -35,15 +48,18 @@ __export(exports_index_node, {
 module.exports = __toCommonJS(exports_index_node);
 
 // src/index.ts
-var import_openai = require("@ai-sdk/openai");
+var import_core13 = require("@elizaos/core");
+
+// src/init.ts
+var import_core2 = require("@elizaos/core");
+
+// src/utils/config.ts
 var import_core = require("@elizaos/core");
-var import_ai = require("ai");
-var import_js_tiktoken = require("js-tiktoken");
 function getSetting(runtime, key, defaultValue) {
   return runtime.getSetting(key) ?? process.env[key] ?? defaultValue;
 }
 function isBrowser() {
-  return typeof globalThis !== "undefined" && typeof globalThis.document !== "undefined";
+  return typeof globalThis !== "undefined" && "document" in globalThis && typeof globalThis.document !== "undefined";
 }
 function isProxyMode(runtime) {
   return isBrowser() && !!getSetting(runtime, "OPENAI_BROWSER_BASE_URL");
@@ -82,13 +98,13 @@ function getEmbeddingApiKey(runtime) {
   return getApiKey(runtime);
 }
 function getSmallModel(runtime) {
-  return getSetting(runtime, "OPENAI_SMALL_MODEL") ?? getSetting(runtime, "SMALL_MODEL", "gpt-5-nano");
+  return getSetting(runtime, "OPENAI_SMALL_MODEL") ?? getSetting(runtime, "SMALL_MODEL", "gpt-4o-mini");
 }
 function getLargeModel(runtime) {
-  return getSetting(runtime, "OPENAI_LARGE_MODEL") ?? getSetting(runtime, "LARGE_MODEL", "gpt-5-mini");
+  return getSetting(runtime, "OPENAI_LARGE_MODEL") ?? getSetting(runtime, "LARGE_MODEL", "gpt-4o");
 }
 function getImageDescriptionModel(runtime) {
-  return getSetting(runtime, "OPENAI_IMAGE_DESCRIPTION_MODEL", "gpt-5-nano") ?? "gpt-5-nano";
+  return getSetting(runtime, "OPENAI_IMAGE_DESCRIPTION_MODEL", "gpt-5-nano");
 }
 function getExperimentalTelemetry(runtime) {
   const setting = getSetting(runtime, "OPENAI_EXPERIMENTAL_TELEMETRY", "false");
@@ -97,98 +113,378 @@ function getExperimentalTelemetry(runtime) {
   import_core.logger.debug(`[OpenAI] Experimental telemetry in function: "${setting}" (type: ${typeof setting}, normalized: "${normalizedSetting}", result: ${result})`);
   return result;
 }
+
+// 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`);
+    }
+  })();
+}
+
+// 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 });
 }
-async function tokenizeText(model, prompt) {
-  const modelName = model === import_core.ModelType.TEXT_SMALL ? process.env.OPENAI_SMALL_MODEL ?? process.env.SMALL_MODEL ?? "gpt-5-nano" : process.env.LARGE_MODEL ?? "gpt-5-mini";
-  const tokens = import_js_tiktoken.encodingForModel(modelName).encode(prompt);
-  return tokens;
-}
-async function detokenizeText(model, tokens) {
-  const modelName = model === import_core.ModelType.TEXT_SMALL ? process.env.OPENAI_SMALL_MODEL ?? process.env.SMALL_MODEL ?? "gpt-5-nano" : process.env.OPENAI_LARGE_MODEL ?? process.env.LARGE_MODEL ?? "gpt-5-mini";
-  return import_js_tiktoken.encodingForModel(modelName).decode(tokens);
+
+// 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;
+  runtime.emitEvent(import_core3.EventType.MODEL_USED, {
+    provider: "openai",
+    type,
+    prompt,
+    tokens: {
+      prompt: promptTokens,
+      completion: completionTokens,
+      total: totalTokens
+    }
+  });
 }
-async function generateObjectByModelType(runtime, params, modelType, getModelFn) {
+
+// src/models/text.ts
+async function generateTextByModelType(runtime, params, modelType, getModelFn) {
   const openai = createOpenAIClient(runtime);
   const modelName = getModelFn(runtime);
-  import_core.logger.log(`[OpenAI] Using ${modelType} model: ${modelName}`);
-  const temperature = params.temperature ?? 0;
-  const schemaPresent = !!params.schema;
-  if (schemaPresent) {
-    import_core.logger.info(`Using ${modelType} without schema validation (schema provided but output=no-schema)`);
+  const experimentalTelemetry = getExperimentalTelemetry(runtime);
+  import_core4.logger.log(`[OpenAI] Using ${modelType} model: ${modelName}`);
+  import_core4.logger.log(params.prompt);
+  const {
+    prompt,
+    stopSequences = [],
+    maxTokens = 8192,
+    temperature = 0.7,
+    frequencyPenalty = 0.7,
+    presencePenalty = 0.7
+  } = params;
+  const { text: openaiResponse, usage } = await import_ai.generateText({
+    model: openai.languageModel(modelName),
+    prompt,
+    system: runtime.character.system ?? undefined,
+    temperature,
+    maxOutputTokens: maxTokens,
+    frequencyPenalty,
+    presencePenalty,
+    stopSequences,
+    experimental_telemetry: {
+      isEnabled: experimentalTelemetry
+    }
+  });
+  if (usage) {
+    emitModelUsageEvent(runtime, modelType, prompt, usage);
+  }
+  return openaiResponse;
+}
+async function handleTextSmall(runtime, params) {
+  return generateTextByModelType(runtime, params, import_core4.ModelType.TEXT_SMALL, getSmallModel);
+}
+async function handleTextLarge(runtime, params) {
+  return generateTextByModelType(runtime, params, import_core4.ModelType.TEXT_LARGE, getLargeModel);
+}
+// 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 { object, usage } = await import_ai.generateObject({
-      model: openai.languageModel(modelName),
-      output: "no-schema",
-      prompt: params.prompt,
-      temperature,
-      experimental_repairText: getJsonRepairFunction()
+    const response = await fetch(`${embeddingBaseURL}/embeddings`, {
+      method: "POST",
+      headers: {
+        ...getAuthHeader(runtime, true),
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        model: embeddingModelName,
+        input: text
+      })
     });
-    if (usage) {
-      emitModelUsageEvent(runtime, modelType, params.prompt, usage);
+    if (!response.ok) {
+      import_core5.logger.error(`OpenAI API error: ${response.status} - ${response.statusText}`);
+      throw new Error(`OpenAI API error: ${response.status} - ${response.statusText}`);
     }
-    return object;
-  } catch (error) {
-    if (error instanceof import_ai.JSONParseError) {
-      import_core.logger.error(`[generateObject] Failed to parse JSON: ${error.message}`);
-      const repairFunction = getJsonRepairFunction();
-      const repairedJsonString = await repairFunction({
-        text: error.text,
-        error
-      });
-      if (repairedJsonString) {
-        try {
-          const repairedObject = JSON.parse(repairedJsonString);
-          import_core.logger.info("[generateObject] Successfully repaired JSON.");
-          return repairedObject;
-        } catch (repairParseError) {
-          const message = repairParseError instanceof Error ? repairParseError.message : String(repairParseError);
-          import_core.logger.error(`[generateObject] Failed to parse repaired JSON: ${message}`);
-          throw repairParseError;
-        }
-      } else {
-        import_core.logger.error("[generateObject] JSON repair failed.");
-        throw error;
-      }
-    } else {
-      const message = error instanceof Error ? error.message : String(error);
-      import_core.logger.error(`[generateObject] Unknown error: ${message}`);
-      throw error;
+    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 getJsonRepairFunction() {
-  return async ({ text, error }) => {
-    try {
-      if (error instanceof import_ai.JSONParseError) {
-        const cleanedText = text.replace(/```json\n|\n```|```/g, "");
-        JSON.parse(cleanedText);
-        return cleanedText;
-      }
-      return null;
-    } catch (jsonError) {
-      const message = jsonError instanceof Error ? jsonError.message : String(jsonError);
-      import_core.logger.warn(`Failed to repair JSON text: ${message}`);
-      return null;
+// src/models/image.ts
+var import_core6 = require("@elizaos/core");
+async function handleImageGeneration(runtime, params) {
+  const n = params.n || 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;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw error;
+  }
 }
-function emitModelUsageEvent(runtime, type, prompt, usage) {
-  runtime.emitEvent(import_core.EventType.MODEL_USED, {
-    provider: "openai",
-    type,
-    prompt,
-    tokens: {
-      prompt: usage.inputTokens,
-      completion: usage.outputTokens,
-      total: usage.totalTokens
+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;
+  }
+  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)
+    });
+    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
+      });
+    }
+    if (!content) {
+      return {
+        title: "Failed to analyze image",
+        description: "No response from API"
+      };
+    }
+    const isCustomPrompt = typeof params === "object" && Boolean(params.prompt) && params.prompt !== DEFAULT_PROMPT;
+    if (isCustomPrompt) {
+      return content;
+    }
+    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}`
+    };
+  }
+}
+// src/models/audio.ts
+var import_core8 = require("@elizaos/core");
+
+// src/utils/audio.ts
+var import_core7 = 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]
+};
+function matchBytes(buffer, offset, bytes) {
+  for (let i = 0;i < bytes.length; i++) {
+    if (buffer[offset + i] !== bytes[i])
+      return false;
+  }
+  return true;
+}
+function detectAudioMimeType(buffer) {
+  if (buffer.length < 12) {
+    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) {
+    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_core7.logger.warn("Could not detect audio format from buffer, using generic binary type");
+  return "application/octet-stream";
+}
+async function webStreamToNodeStream(webStream) {
+  try {
+    const { Readable } = await import("node:stream");
+    const reader = webStream.getReader();
+    return new Readable({
+      async read() {
+        try {
+          const { done, value } = await reader.read();
+          if (done) {
+            this.push(null);
+          } else {
+            this.push(value);
+          }
+        } catch (error) {
+          this.destroy(error);
+        }
+      },
+      destroy(error, callback) {
+        reader.cancel().finally(() => callback(error));
+      }
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    import_core7.logger.error(`Failed to load node:stream module: ${message}`);
+    throw new Error(`Cannot convert stream: node:stream module unavailable. This feature requires a Node.js environment.`);
+  }
 }
+
+// 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");
@@ -218,12 +514,203 @@ async function fetchTextToSpeech(runtime, options) {
       const err = await res.text();
       throw new Error(`OpenAI TTS error ${res.status}: ${err}`);
     }
+    if (!res.body) {
+      throw new Error("OpenAI TTS response body is null");
+    }
+    if (!isBrowser()) {
+      return await webStreamToNodeStream(res.body);
+    }
     return res.body;
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     throw new Error(`Failed to fetch speech from OpenAI TTS: ${message}`);
   }
 }
+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 blob;
+  let extraParams = null;
+  if (input instanceof Blob || input instanceof File) {
+    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.");
+    }
+    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 });
+    } else {
+      blob = params.audio;
+    }
+    extraParams = params;
+    if (typeof params.model === "string" && params.model) {
+      modelName = params.model;
+    }
+  } 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? }");
+  }
+  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");
+  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));
+    }
+    if (typeof extraParams.response_format === "string") {
+      formData.append("response_format", String(extraParams.response_format));
+    }
+    if (typeof extraParams.prompt === "string") {
+      formData.append("prompt", String(extraParams.prompt));
+    }
+    if (typeof extraParams.temperature === "number") {
+      formData.append("temperature", String(extraParams.temperature));
+    }
+    if (Array.isArray(extraParams.timestampGranularities)) {
+      for (const g of extraParams.timestampGranularities) {
+        formData.append("timestamp_granularities[]", String(g));
+      }
+    }
+  }
+  try {
+    const response = await fetch(`${baseURL}/audio/transcriptions`, {
+      method: "POST",
+      headers: {
+        ...getAuthHeader(runtime)
+      },
+      body: formData
+    });
+    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;
+  }
+}
+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 {
+    const speechStream = await fetchTextToSpeech(runtime, options);
+    return speechStream;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    import_core8.logger.error(`Error in TEXT_TO_SPEECH: ${message}`);
+    throw error;
+  }
+}
+// src/models/object.ts
+var import_core10 = require("@elizaos/core");
+var import_ai3 = require("ai");
+
+// src/utils/json.ts
+var import_core9 = require("@elizaos/core");
+var import_ai2 = require("ai");
+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;
+      }
+      return null;
+    } catch (jsonError) {
+      const message = jsonError instanceof Error ? jsonError.message : String(jsonError);
+      import_core9.logger.warn(`Failed to repair JSON text: ${message}`);
+      return null;
+    }
+  };
+}
+
+// src/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.`);
+  }
+  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;
+  }
+}
+async function handleObjectSmall(runtime, params) {
+  return generateObjectByModelType(runtime, params, import_core10.ModelType.OBJECT_SMALL, getSmallModel);
+}
+async function handleObjectLarge(runtime, params) {
+  return generateObjectByModelType(runtime, params, import_core10.ModelType.OBJECT_LARGE, getLargeModel);
+}
+// src/models/tokenizer.ts
+var import_core12 = require("@elizaos/core");
+
+// src/utils/tokenization.ts
+var import_core11 = 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) {
+    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;
+}
+async function detokenizeText(runtime, model, tokens) {
+  const modelName = model === import_core11.ModelType.TEXT_SMALL ? getSmallModel(runtime) : getLargeModel(runtime);
+  return resolveTokenizerEncoding(modelName).decode(tokens);
+}
+
+// src/models/tokenizer.ts
+async function handleTokenizerEncode(runtime, { prompt, modelType = import_core12.ModelType.TEXT_LARGE }) {
+  return await tokenizeText(runtime, modelType, prompt);
+}
+async function handleTokenizerDecode(runtime, { tokens, modelType = import_core12.ModelType.TEXT_LARGE }) {
+  return await detokenizeText(runtime, modelType, tokens);
+}
+// src/index.ts
 var openaiPlugin = {
   name: "openai",
   description: "OpenAI plugin",
@@ -243,368 +730,41 @@ var openaiPlugin = {
     OPENAI_EXPERIMENTAL_TELEMETRY: process.env.OPENAI_EXPERIMENTAL_TELEMETRY
   },
   async init(_config, runtime) {
-    new Promise(async (resolve) => {
-      resolve();
-      try {
-        if (!getApiKey(runtime) && !isBrowser()) {
-          import_core.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_core.logger.warn(`OpenAI API key validation failed: ${response.statusText}`);
-            import_core.logger.warn("OpenAI functionality will be limited until a valid API key is provided");
-          } else {
-            import_core.logger.log("OpenAI API key validated successfully");
-          }
-        } catch (fetchError) {
-          const message = fetchError instanceof Error ? fetchError.message : String(fetchError);
-          import_core.logger.warn(`Error validating OpenAI API key: ${message}`);
-          import_core.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_core.logger.warn(`OpenAI plugin configuration issue: ${message} - You need to configure the OPENAI_API_KEY in your environment variables`);
-      }
-    });
+    initializeOpenAI(_config, runtime);
   },
   models: {
-    [import_core.ModelType.TEXT_EMBEDDING]: async (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_core.VECTOR_DIMS).includes(embeddingDimension)) {
-        const errorMsg = `Invalid embedding dimension: ${embeddingDimension}. Must be one of: ${Object.values(import_core.VECTOR_DIMS).join(", ")}`;
-        import_core.logger.error(errorMsg);
-        throw new Error(errorMsg);
-      }
-      if (params === null) {
-        import_core.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 {
-        import_core.logger.warn("Invalid input format for embedding");
-        const fallbackVector = Array(embeddingDimension).fill(0);
-        fallbackVector[0] = 0.2;
-        return fallbackVector;
-      }
-      if (!text.trim()) {
-        import_core.logger.warn("Empty text for embedding");
-        const emptyVector = Array(embeddingDimension).fill(0);
-        emptyVector[0] = 0.3;
-        return emptyVector;
-      }
-      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_core.logger.error(`OpenAI API error: ${response.status} - ${response.statusText}`);
-          const errorVector = Array(embeddingDimension).fill(0);
-          errorVector[0] = 0.4;
-          return errorVector;
-        }
-        const data = await response.json();
-        if (!data?.data?.[0]?.embedding) {
-          import_core.logger.error("API returned invalid structure");
-          const errorVector = Array(embeddingDimension).fill(0);
-          errorVector[0] = 0.5;
-          return errorVector;
-        }
-        const embedding = data.data[0].embedding;
-        if (data.usage) {
-          const usage = {
-            inputTokens: data.usage.prompt_tokens,
-            outputTokens: 0,
-            totalTokens: data.usage.total_tokens
-          };
-          emitModelUsageEvent(runtime, import_core.ModelType.TEXT_EMBEDDING, text, usage);
-        }
-        import_core.logger.log(`Got valid embedding with length ${embedding.length}`);
-        return embedding;
-      } catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        import_core.logger.error(`Error generating embedding: ${message}`);
-        const errorVector = Array(embeddingDimension).fill(0);
-        errorVector[0] = 0.6;
-        return errorVector;
-      }
+    [import_core13.ModelType.TEXT_EMBEDDING]: async (runtime, params) => {
+      return handleTextEmbedding(runtime, params);
     },
-    [import_core.ModelType.TEXT_TOKENIZER_ENCODE]: async (_runtime, { prompt, modelType = import_core.ModelType.TEXT_LARGE }) => {
-      return await tokenizeText(modelType ?? import_core.ModelType.TEXT_LARGE, prompt);
+    [import_core13.ModelType.TEXT_TOKENIZER_ENCODE]: async (runtime, params) => {
+      return handleTokenizerEncode(runtime, params);
     },
-    [import_core.ModelType.TEXT_TOKENIZER_DECODE]: async (_runtime, { tokens, modelType = import_core.ModelType.TEXT_LARGE }) => {
-      return await detokenizeText(modelType ?? import_core.ModelType.TEXT_LARGE, tokens);
+    [import_core13.ModelType.TEXT_TOKENIZER_DECODE]: async (runtime, params) => {
+      return handleTokenizerDecode(runtime, params);
     },
-    [import_core.ModelType.TEXT_SMALL]: async (runtime, {
-      prompt,
-      stopSequences = [],
-      maxTokens = 8192,
-      temperature = 0.7,
-      frequencyPenalty = 0.7,
-      presencePenalty = 0.7
-    }) => {
-      const openai = createOpenAIClient(runtime);
-      const modelName = getSmallModel(runtime);
-      const experimentalTelemetry = getExperimentalTelemetry(runtime);
-      import_core.logger.log(`[OpenAI] Using TEXT_SMALL model: ${modelName}`);
-      import_core.logger.log(prompt);
-      const { text: openaiResponse, usage } = await import_ai.generateText({
-        model: openai.languageModel(modelName),
-        prompt,
-        system: runtime.character.system ?? undefined,
-        temperature,
-        maxOutputTokens: maxTokens,
-        frequencyPenalty,
-        presencePenalty,
-        stopSequences,
-        experimental_telemetry: {
-          isEnabled: experimentalTelemetry
-        }
-      });
-      if (usage) {
-        emitModelUsageEvent(runtime, import_core.ModelType.TEXT_SMALL, prompt, usage);
-      }
-      return openaiResponse;
+    [import_core13.ModelType.TEXT_SMALL]: async (runtime, params) => {
+      return handleTextSmall(runtime, params);
     },
-    [import_core.ModelType.TEXT_LARGE]: async (runtime, {
-      prompt,
-      stopSequences = [],
-      maxTokens = 8192,
-      temperature = 0.7,
-      frequencyPenalty = 0.7,
-      presencePenalty = 0.7
-    }) => {
-      const openai = createOpenAIClient(runtime);
-      const modelName = getLargeModel(runtime);
-      const experimentalTelemetry = getExperimentalTelemetry(runtime);
-      import_core.logger.log(`[OpenAI] Using TEXT_LARGE model: ${modelName}`);
-      import_core.logger.log(prompt);
-      const { text: openaiResponse, usage } = await import_ai.generateText({
-        model: openai.languageModel(modelName),
-        prompt,
-        system: runtime.character.system ?? undefined,
-        temperature,
-        maxOutputTokens: maxTokens,
-        frequencyPenalty,
-        presencePenalty,
-        stopSequences,
-        experimental_telemetry: {
-          isEnabled: experimentalTelemetry
-        }
-      });
-      if (usage) {
-        emitModelUsageEvent(runtime, import_core.ModelType.TEXT_LARGE, prompt, usage);
-      }
-      return openaiResponse;
+    [import_core13.ModelType.TEXT_LARGE]: async (runtime, params) => {
+      return handleTextLarge(runtime, params);
     },
-    [import_core.ModelType.IMAGE]: async (runtime, params) => {
-      const n = params.n || 1;
-      const size = params.size || "1024x1024";
-      const prompt = params.prompt;
-      const modelName = "gpt-image-1";
-      import_core.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;
-      }
+    [import_core13.ModelType.IMAGE]: async (runtime, params) => {
+      return handleImageGeneration(runtime, params);
     },
-    [import_core.ModelType.IMAGE_DESCRIPTION]: async (runtime, params) => {
-      let imageUrl;
-      let promptText;
-      const modelName = getImageDescriptionModel(runtime);
-      import_core.logger.log(`[OpenAI] Using IMAGE_DESCRIPTION model: ${modelName}`);
-      const maxTokens = Number.parseInt(getSetting(runtime, "OPENAI_IMAGE_DESCRIPTION_MAX_TOKENS", "8192") || "8192", 10);
-      if (typeof params === "string") {
-        imageUrl = params;
-        promptText = "Please analyze this image and provide a title and detailed description.";
-      } else {
-        imageUrl = params.imageUrl;
-        promptText = params.prompt || "Please analyze this image and provide a title and detailed description.";
-      }
-      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)
-        });
-        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_core.ModelType.IMAGE_DESCRIPTION, typeof params === "string" ? params : params.prompt || "", {
-            inputTokens: typedResult.usage.prompt_tokens,
-            outputTokens: typedResult.usage.completion_tokens,
-            totalTokens: typedResult.usage.total_tokens
-          });
-        }
-        if (!content) {
-          return {
-            title: "Failed to analyze image",
-            description: "No response from API"
-          };
-        }
-        const isCustomPrompt = typeof params === "object" && params.prompt && params.prompt !== "Please analyze this image and provide a title and detailed description.";
-        if (isCustomPrompt) {
-          return content;
-        }
-        const titleMatch = content.match(/title[:\s]+(.+?)(?:\n|$)/i);
-        const title = titleMatch?.[1]?.trim() || "Image Analysis";
-        const description = content.replace(/title[:\s]+(.+?)(?:\n|$)/i, "").trim();
-        const processedResult = { title, description };
-        return processedResult;
-      } catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        import_core.logger.error(`Error analyzing image: ${message}`);
-        return {
-          title: "Failed to analyze image",
-          description: `Error: ${message}`
-        };
-      }
+    [import_core13.ModelType.IMAGE_DESCRIPTION]: async (runtime, params) => {
+      return handleImageDescription(runtime, params);
     },
-    [import_core.ModelType.TRANSCRIPTION]: async (runtime, input) => {
-      let modelName = getSetting(runtime, "OPENAI_TRANSCRIPTION_MODEL", "gpt-4o-mini-transcribe");
-      import_core.logger.log(`[OpenAI] Using TRANSCRIPTION model: ${modelName}`);
-      const baseURL = getBaseURL(runtime);
-      let blob;
-      let extraParams = null;
-      if (input instanceof Blob || input instanceof File) {
-        blob = input;
-      } else if (typeof input === "object" && input !== null && input.audio != null) {
-        const params = input;
-        if (!(params.audio instanceof Blob) && !(params.audio instanceof File)) {
-          throw new Error("TRANSCRIPTION param 'audio' must be a Blob/File. Wrap buffers as: new Blob([buffer], { type: 'audio/mpeg' })");
-        }
-        blob = params.audio;
-        extraParams = params;
-        if (typeof params.model === "string" && params.model) {
-          modelName = params.model;
-        }
-      } else {
-        throw new Error("TRANSCRIPTION expects a Blob/File or an object { audio: Blob/File, language?, response_format?, timestampGranularities?, prompt?, temperature?, model? }");
-      }
-      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");
-      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));
-        }
-        if (typeof extraParams.response_format === "string") {
-          formData.append("response_format", String(extraParams.response_format));
-        }
-        if (typeof extraParams.prompt === "string") {
-          formData.append("prompt", String(extraParams.prompt));
-        }
-        if (typeof extraParams.temperature === "number") {
-          formData.append("temperature", String(extraParams.temperature));
-        }
-        if (Array.isArray(extraParams.timestampGranularities)) {
-          for (const g of extraParams.timestampGranularities) {
-            formData.append("timestamp_granularities[]", String(g));
-          }
-        }
-      }
-      try {
-        const response = await fetch(`${baseURL}/audio/transcriptions`, {
-          method: "POST",
-          headers: {
-            ...getAuthHeader(runtime)
-          },
-          body: formData
-        });
-        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_core.logger.error(`TRANSCRIPTION error: ${message}`);
-        throw error;
-      }
+    [import_core13.ModelType.TRANSCRIPTION]: async (runtime, input) => {
+      return handleTranscription(runtime, input);
     },
-    [import_core.ModelType.TEXT_TO_SPEECH]: async (runtime, input) => {
-      const options = typeof input === "string" ? { text: input } : input;
-      const resolvedModel = options.model || getSetting(runtime, "OPENAI_TTS_MODEL", "gpt-4o-mini-tts");
-      import_core.logger.log(`[OpenAI] Using TEXT_TO_SPEECH model: ${resolvedModel}`);
-      try {
-        const speechStream = await fetchTextToSpeech(runtime, options);
-        return speechStream;
-      } catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        import_core.logger.error(`Error in TEXT_TO_SPEECH: ${message}`);
-        throw error;
-      }
+    [import_core13.ModelType.TEXT_TO_SPEECH]: async (runtime, input) => {
+      return handleTextToSpeech(runtime, input);
     },
-    [import_core.ModelType.OBJECT_SMALL]: async (runtime, params) => {
-      return generateObjectByModelType(runtime, params, import_core.ModelType.OBJECT_SMALL, getSmallModel);
+    [import_core13.ModelType.OBJECT_SMALL]: async (runtime, params) => {
+      return handleObjectSmall(runtime, params);
     },
-    [import_core.ModelType.OBJECT_LARGE]: async (runtime, params) => {
-      return generateObjectByModelType(runtime, params, import_core.ModelType.OBJECT_LARGE, getLargeModel);
+    [import_core13.ModelType.OBJECT_LARGE]: async (runtime, params) => {
+      return handleObjectLarge(runtime, params);
     }
   },
   tests: [
@@ -616,12 +776,10 @@ var openaiPlugin = {
           fn: async (runtime) => {
             const baseURL = getBaseURL(runtime);
             const response = await fetch(`${baseURL}/models`, {
-              headers: {
-                Authorization: `Bearer ${getApiKey(runtime)}`
-              }
+              headers: getAuthHeader(runtime)
             });
             const data = await response.json();
-            import_core.logger.log({ data: data?.data?.length ?? "N/A" }, "Models Available");
+            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}`);
             }
@@ -631,13 +789,13 @@ var openaiPlugin = {
           name: "openai_test_text_embedding",
           fn: async (runtime) => {
             try {
-              const embedding = await runtime.useModel(import_core.ModelType.TEXT_EMBEDDING, {
+              const embedding = await runtime.useModel(import_core13.ModelType.TEXT_EMBEDDING, {
                 text: "Hello, world!"
               });
-              import_core.logger.log({ embedding }, "embedding");
+              import_core13.logger.log({ embedding }, "embedding");
             } catch (error) {
               const message = error instanceof Error ? error.message : String(error);
-              import_core.logger.error(`Error in test_text_embedding: ${message}`);
+              import_core13.logger.error(`Error in test_text_embedding: ${message}`);
               throw error;
             }
           }
@@ -646,16 +804,16 @@ var openaiPlugin = {
           name: "openai_test_text_large",
           fn: async (runtime) => {
             try {
-              const text = await runtime.useModel(import_core.ModelType.TEXT_LARGE, {
+              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_core.logger.log({ text }, "generated with test_text_large");
+              import_core13.logger.log({ text }, "generated with test_text_large");
             } catch (error) {
               const message = error instanceof Error ? error.message : String(error);
-              import_core.logger.error(`Error in test_text_large: ${message}`);
+              import_core13.logger.error(`Error in test_text_large: ${message}`);
               throw error;
             }
           }
@@ -664,16 +822,16 @@ var openaiPlugin = {
           name: "openai_test_text_small",
           fn: async (runtime) => {
             try {
-              const text = await runtime.useModel(import_core.ModelType.TEXT_SMALL, {
+              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_core.logger.log({ text }, "generated with test_text_small");
+              import_core13.logger.log({ text }, "generated with test_text_small");
             } catch (error) {
               const message = error instanceof Error ? error.message : String(error);
-              import_core.logger.error(`Error in test_text_small: ${message}`);
+              import_core13.logger.error(`Error in test_text_small: ${message}`);
               throw error;
             }
           }
@@ -681,17 +839,17 @@ var openaiPlugin = {
         {
           name: "openai_test_image_generation",
           fn: async (runtime) => {
-            import_core.logger.log("openai_test_image_generation");
+            import_core13.logger.log("openai_test_image_generation");
             try {
-              const image = await runtime.useModel(import_core.ModelType.IMAGE, {
+              const image = await runtime.useModel(import_core13.ModelType.IMAGE, {
                 prompt: "A beautiful sunset over a calm ocean",
                 n: 1,
                 size: "1024x1024"
               });
-              import_core.logger.log({ image }, "generated with test_image_generation");
+              import_core13.logger.log({ image }, "generated with test_image_generation");
             } catch (error) {
               const message = error instanceof Error ? error.message : String(error);
-              import_core.logger.error(`Error in test_image_generation: ${message}`);
+              import_core13.logger.error(`Error in test_image_generation: ${message}`);
               throw error;
             }
           }
@@ -700,36 +858,36 @@ var openaiPlugin = {
           name: "image-description",
           fn: async (runtime) => {
             try {
-              import_core.logger.log("openai_test_image_description");
+              import_core13.logger.log("openai_test_image_description");
               try {
-                const result = await runtime.useModel(import_core.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");
+                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_core.logger.log({ result }, "Image description");
+                  import_core13.logger.log({ result }, "Image description");
                 } else {
-                  import_core.logger.error("Invalid image description result format:", result);
+                  import_core13.logger.error("Invalid image description result format:", result);
                 }
               } catch (e) {
                 const message = e instanceof Error ? e.message : String(e);
-                import_core.logger.error(`Error in image description test: ${message}`);
+                import_core13.logger.error(`Error in image description test: ${message}`);
               }
             } catch (e) {
               const message = e instanceof Error ? e.message : String(e);
-              import_core.logger.error(`Error in openai_test_image_description: ${message}`);
+              import_core13.logger.error(`Error in openai_test_image_description: ${message}`);
             }
           }
         },
         {
           name: "openai_test_transcription",
           fn: async (runtime) => {
-            import_core.logger.log("openai_test_transcription");
+            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_core.ModelType.TRANSCRIPTION, Buffer.from(new Uint8Array(arrayBuffer)));
-              import_core.logger.log({ transcription }, "generated with test_transcription");
+              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_core.logger.error(`Error in test_transcription: ${message}`);
+              import_core13.logger.error(`Error in test_transcription: ${message}`);
               throw error;
             }
           }
@@ -738,39 +896,41 @@ var openaiPlugin = {
           name: "openai_test_text_tokenizer_encode",
           fn: async (runtime) => {
             const prompt = "Hello tokenizer encode!";
-            const tokens = await runtime.useModel(import_core.ModelType.TEXT_TOKENIZER_ENCODE, { prompt });
+            const tokens = await runtime.useModel(import_core13.ModelType.TEXT_TOKENIZER_ENCODE, { prompt });
             if (!Array.isArray(tokens) || tokens.length === 0) {
               throw new Error("Failed to tokenize text: expected non-empty array of tokens");
             }
-            import_core.logger.log({ tokens }, "Tokenized output");
+            import_core13.logger.log({ tokens }, "Tokenized output");
           }
         },
         {
           name: "openai_test_text_tokenizer_decode",
           fn: async (runtime) => {
             const prompt = "Hello tokenizer decode!";
-            const tokens = await runtime.useModel(import_core.ModelType.TEXT_TOKENIZER_ENCODE, { prompt });
-            const decodedText = await runtime.useModel(import_core.ModelType.TEXT_TOKENIZER_DECODE, { tokens });
+            const tokens = await runtime.useModel(import_core13.ModelType.TEXT_TOKENIZER_ENCODE, { prompt });
+            const decodedText = await runtime.useModel(import_core13.ModelType.TEXT_TOKENIZER_DECODE, {
+              tokens
+            });
             if (decodedText !== prompt) {
               throw new Error(`Decoded text does not match original. Expected "${prompt}", got "${decodedText}"`);
             }
-            import_core.logger.log({ decodedText }, "Decoded text");
+            import_core13.logger.log({ decodedText }, "Decoded text");
           }
         },
         {
           name: "openai_test_text_to_speech",
           fn: async (runtime) => {
             try {
-              const response = await fetchTextToSpeech(runtime, {
+              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_core.logger.log("Generated speech successfully");
+              import_core13.logger.log("Generated speech successfully");
             } catch (error) {
               const message = error instanceof Error ? error.message : String(error);
-              import_core.logger.error(`Error in openai_test_text_to_speech: ${message}`);
+              import_core13.logger.error(`Error in openai_test_text_to_speech: ${message}`);
               throw error;
             }
           }
@@ -781,4 +941,4 @@ var openaiPlugin = {
 };
 var src_default = openaiPlugin;
 
-//# debugId=BF1EBFE59A12C26D64756E2164756E21
+//# debugId=9B5BF59394995A3864756E2164756E21