@elizaos/plugin-openai 2.0.0-beta.1 → 2.0.11-beta.7

package/dist/node/index.node.js

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