@elizaos/plugin-openai 2.0.0-alpha.9 → 2.0.3-beta.2

package/dist/node/index.node.js

@@ -1,1286 +0,0 @@
-// index.ts
-import { logger as logger11, ModelType as ModelType7 } 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 getApiKey(runtime) {
-  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-mini";
-}
-function getLargeModel(runtime) {
-  return getSetting(runtime, "OPENAI_LARGE_MODEL") ?? getSetting(runtime, "LARGE_MODEL") ?? "gpt-5";
-}
-function getEmbeddingModel(runtime) {
-  return getSetting(runtime, "OPENAI_EMBEDDING_MODEL") ?? "text-embedding-3-small";
-}
-function getImageDescriptionModel(runtime) {
-  return getSetting(runtime, "OPENAI_IMAGE_DESCRIPTION_MODEL") ?? "gpt-5-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 } 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 response = await fetch(`${baseURL}/audio/transcriptions`, {
-    method: "POST",
-    headers: getAuthHeader(runtime),
-    body: formData
-  });
-  if (!response.ok) {
-    const errorText = await response.text().catch(() => "Unknown error");
-    throw new Error(`OpenAI transcription failed: ${response.status} ${response.statusText} - ${errorText}`);
-  }
-  const data = await response.json();
-  return data.text;
-}
-async function handleTextToSpeech(runtime, input) {
-  let text;
-  let voice;
-  let format = "mp3";
-  let model;
-  let instructions;
-  if (typeof input === "string") {
-    text = input;
-    voice = undefined;
-  } else {
-    text = input.text;
-    voice = input.voice;
-    if ("format" in input && input.format) {
-      format = input.format;
-    }
-    if ("model" in input && input.model) {
-      model = input.model;
-    }
-    if ("instructions" in input && input.instructions) {
-      instructions = input.instructions;
-    }
-  }
-  model = model ?? getTTSModel(runtime);
-  voice = voice ?? getTTSVoice(runtime);
-  instructions = instructions ?? getTTSInstructions(runtime);
-  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 response = await fetch(`${baseURL}/audio/speech`, {
-    method: "POST",
-    headers: {
-      ...getAuthHeader(runtime),
-      "Content-Type": "application/json",
-      ...format === "mp3" ? { Accept: "audio/mpeg" } : {}
-    },
-    body: JSON.stringify(requestBody)
-  });
-  if (!response.ok) {
-    const errorText = await response.text().catch(() => "Unknown error");
-    throw new Error(`OpenAI TTS failed: ${response.status} ${response.statusText} - ${errorText}`);
-  }
-  return response.arrayBuffer();
-}
-// models/embedding.ts
-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
-var MAX_EMBEDDING_TOKENS = 8000;
-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");
-}
-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 = MAX_EMBEDDING_TOKENS * 4;
-  if (trimmedText.length > maxChars) {
-    logger5.warn(`[OpenAI] Embedding input too long (~${Math.ceil(trimmedText.length / 4)} tokens), truncating to ~${MAX_EMBEDDING_TOKENS} tokens`);
-    trimmedText = trimmedText.slice(0, maxChars);
-  }
-  const baseURL = getEmbeddingBaseURL(runtime);
-  const url = `${baseURL}/embeddings`;
-  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 || !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 } 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 || params.prompt.trim().length === 0) {
-    throw new Error("IMAGE generation requires a non-empty prompt");
-  }
-  if (count < 1 || count > 10) {
-    throw new Error("IMAGE count must be between 1 and 10");
-  }
-  const baseURL = getBaseURL(runtime);
-  const requestBody = {
-    model: modelName,
-    prompt: params.prompt,
-    n: count,
-    size
-  };
-  if (extendedParams.quality) {
-    requestBody.quality = extendedParams.quality;
-  }
-  if (extendedParams.style) {
-    requestBody.style = extendedParams.style;
-  }
-  const response = await fetch(`${baseURL}/images/generations`, {
-    method: "POST",
-    headers: {
-      ...getAuthHeader(runtime),
-      "Content-Type": "application/json"
-    },
-    body: JSON.stringify(requestBody)
-  });
-  if (!response.ok) {
-    const errorText = await response.text().catch(() => "Unknown error");
-    throw new Error(`OpenAI image generation failed: ${response.status} ${response.statusText} - ${errorText}`);
-  }
-  const data = await response.json();
-  if (!data.data || data.data.length === 0) {
-    throw new Error("OpenAI API returned no images");
-  }
-  return data.data.map((item) => ({
-    url: item.url,
-    revisedPrompt: item.revised_prompt
-  }));
-}
-function parseTitleFromResponse(content) {
-  const titleMatch = content.match(/title[:\s]+(.+?)(?:\n|$)/i);
-  return titleMatch?.[1]?.trim() ?? "Image Analysis";
-}
-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 response = await fetch(`${baseURL}/chat/completions`, {
-    method: "POST",
-    headers: {
-      ...getAuthHeader(runtime),
-      "Content-Type": "application/json"
-    },
-    body: JSON.stringify(requestBody)
-  });
-  if (!response.ok) {
-    const errorText = await response.text().catch(() => "Unknown error");
-    throw new Error(`OpenAI image description failed: ${response.status} ${response.statusText} - ${errorText}`);
-  }
-  const data = await response.json();
-  if (data.usage) {
-    emitModelUsageEvent(runtime, 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/object.ts
-import { logger as logger8, ModelType as ModelType3 } from "@elizaos/core";
-import { generateObject } 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
-  });
-}
-// utils/json.ts
-import { logger as logger7 } from "@elizaos/core";
-import { JSONParseError } from "ai";
-var JSON_CLEANUP_PATTERNS = {
-  MARKDOWN_JSON: /```json\n|\n```|```/g,
-  WHITESPACE: /^\s+|\s+$/g
-};
-function getJsonRepairFunction() {
-  return async ({ text, error }) => {
-    if (!(error instanceof JSONParseError)) {
-      return null;
-    }
-    try {
-      const cleanedText = text.replace(JSON_CLEANUP_PATTERNS.MARKDOWN_JSON, "");
-      JSON.parse(cleanedText);
-      logger7.debug("[JSON Repair] Successfully repaired JSON by removing markdown wrappers");
-      return cleanedText;
-    } catch {
-      logger7.warn("[JSON Repair] Unable to repair JSON text");
-      return null;
-    }
-  };
-}
-
-// models/object.ts
-async function generateObjectByModelType(runtime, params, modelType, getModelFn) {
-  const openai = createOpenAIClient(runtime);
-  const modelName = getModelFn(runtime);
-  logger8.debug(`[OpenAI] Using ${modelType} model: ${modelName}`);
-  if (!params.prompt || params.prompt.trim().length === 0) {
-    throw new Error("Object generation requires a non-empty prompt");
-  }
-  if (params.schema) {
-    logger8.debug("[OpenAI] Schema provided but using no-schema mode. " + "Structure is determined by prompt instructions.");
-  }
-  const model = openai.chat(modelName);
-  const { object, usage } = await generateObject({
-    model,
-    output: "no-schema",
-    prompt: params.prompt,
-    experimental_repairText: getJsonRepairFunction()
-  });
-  if (usage) {
-    emitModelUsageEvent(runtime, modelType, params.prompt, usage);
-  }
-  if (typeof object !== "object" || object === null) {
-    throw new Error(`Object generation returned ${typeof object}, expected object`);
-  }
-  return object;
-}
-async function handleObjectSmall(runtime, params) {
-  return generateObjectByModelType(runtime, params, ModelType3.OBJECT_SMALL, getSmallModel);
-}
-async function handleObjectLarge(runtime, params) {
-  return generateObjectByModelType(runtime, params, ModelType3.OBJECT_LARGE, getLargeModel);
-}
-// models/research.ts
-import { logger as logger9 } 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);
-  logger9.debug(`[OpenAI] Starting deep research with model: ${modelName}`);
-  logger9.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) {
-    logger9.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 };
-  }
-  logger9.debug(`[OpenAI] Research request body: ${JSON.stringify(requestBody, null, 2)}`);
-  const response = await fetch(`${baseURL}/responses`, {
-    method: "POST",
-    headers: {
-      Authorization: `Bearer ${apiKey}`,
-      "Content-Type": "application/json"
-    },
-    body: JSON.stringify(requestBody),
-    signal: AbortSignal.timeout(timeout)
-  });
-  if (!response.ok) {
-    const errorText = await response.text();
-    logger9.error(`[OpenAI] Research request failed: ${response.status} ${errorText}`);
-    throw new Error(`Deep research request failed: ${response.status} ${response.statusText}`);
-  }
-  const data = await response.json();
-  if (data.error) {
-    logger9.error(`[OpenAI] Research API error: ${data.error.message}`);
-    throw new Error(`Deep research error: ${data.error.message}`);
-  }
-  logger9.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
-  };
-  logger9.info(`[OpenAI] Research completed. Text length: ${text.length}, Annotations: ${annotations.length}, Output items: ${outputItems.length}`);
-  return result;
-}
-// models/text.ts
-import { logger as logger10, ModelType as ModelType4 } from "@elizaos/core";
-import { generateText, streamText } from "ai";
-function convertUsage(usage) {
-  if (!usage) {
-    return;
-  }
-  const promptTokens = usage.inputTokens ?? 0;
-  const completionTokens = usage.outputTokens ?? 0;
-  const usageWithCache = usage;
-  return {
-    promptTokens,
-    completionTokens,
-    totalTokens: promptTokens + completionTokens,
-    cachedPromptTokens: usageWithCache.cachedInputTokens
-  };
-}
-function resolvePromptCacheOptions(params) {
-  const withOpenAIOptions = params;
-  return {
-    promptCacheKey: withOpenAIOptions.providerOptions?.openai?.promptCacheKey,
-    promptCacheRetention: withOpenAIOptions.providerOptions?.openai?.promptCacheRetention
-  };
-}
-async function generateTextByModelType(runtime, params, modelType, getModelFn) {
-  const openai = createOpenAIClient(runtime);
-  const modelName = getModelFn(runtime);
-  logger10.debug(`[OpenAI] Using ${modelType} model: ${modelName}`);
-  const promptCacheOptions = resolvePromptCacheOptions(params);
-  const systemPrompt = runtime.character.system ?? undefined;
-  const model = openai.chat(modelName);
-  const generateParams = {
-    model,
-    prompt: params.prompt,
-    system: systemPrompt,
-    maxOutputTokens: params.maxTokens ?? 8192,
-    experimental_telemetry: { isEnabled: getExperimentalTelemetry(runtime) },
-    ...promptCacheOptions.promptCacheKey || promptCacheOptions.promptCacheRetention ? {
-      providerOptions: {
-        openai: {
-          ...promptCacheOptions.promptCacheKey ? { promptCacheKey: promptCacheOptions.promptCacheKey } : {},
-          ...promptCacheOptions.promptCacheRetention ? { promptCacheRetention: promptCacheOptions.promptCacheRetention } : {}
-        }
-      }
-    } : {}
-  };
-  if (params.stream) {
-    const result = streamText(generateParams);
-    return {
-      textStream: result.textStream,
-      text: Promise.resolve(result.text),
-      usage: Promise.resolve(result.usage).then(convertUsage),
-      finishReason: Promise.resolve(result.finishReason).then((r) => r)
-    };
-  }
-  const { text, usage } = await generateText(generateParams);
-  if (usage) {
-    emitModelUsageEvent(runtime, modelType, params.prompt, usage);
-  }
-  return text;
-}
-async function handleTextSmall(runtime, params) {
-  return generateTextByModelType(runtime, params, ModelType4.TEXT_SMALL, getSmallModel);
-}
-async function handleTextLarge(runtime, params) {
-  return generateTextByModelType(runtime, params, ModelType4.TEXT_LARGE, getLargeModel);
-}
-// models/tokenizer.ts
-import { ModelType as ModelType6 } from "@elizaos/core";
-
-// utils/tokenization.ts
-import { ModelType as ModelType5 } 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 === ModelType5.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 ?? ModelType6.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 ?? ModelType6.TEXT_LARGE;
-  return detokenizeText(runtime, modelType, params.tokens);
-}
-// index.ts
-function getProcessEnv() {
-  if (typeof process === "undefined") {
-    return {};
-  }
-  return process.env;
-}
-var env = getProcessEnv();
-var openaiPlugin = {
-  name: "openai",
-  description: "OpenAI API integration for text, image, audio, and embedding models",
-  config: {
-    OPENAI_API_KEY: env.OPENAI_API_KEY ?? null,
-    OPENAI_BASE_URL: env.OPENAI_BASE_URL ?? null,
-    OPENAI_SMALL_MODEL: env.OPENAI_SMALL_MODEL ?? null,
-    OPENAI_LARGE_MODEL: env.OPENAI_LARGE_MODEL ?? null,
-    SMALL_MODEL: env.SMALL_MODEL ?? null,
-    LARGE_MODEL: env.LARGE_MODEL ?? null,
-    OPENAI_EMBEDDING_MODEL: env.OPENAI_EMBEDDING_MODEL ?? null,
-    OPENAI_EMBEDDING_API_KEY: env.OPENAI_EMBEDDING_API_KEY ?? null,
-    OPENAI_EMBEDDING_URL: env.OPENAI_EMBEDDING_URL ?? null,
-    OPENAI_EMBEDDING_DIMENSIONS: env.OPENAI_EMBEDDING_DIMENSIONS ?? null,
-    OPENAI_IMAGE_DESCRIPTION_MODEL: env.OPENAI_IMAGE_DESCRIPTION_MODEL ?? null,
-    OPENAI_IMAGE_DESCRIPTION_MAX_TOKENS: env.OPENAI_IMAGE_DESCRIPTION_MAX_TOKENS ?? null,
-    OPENAI_EXPERIMENTAL_TELEMETRY: env.OPENAI_EXPERIMENTAL_TELEMETRY ?? null,
-    OPENAI_RESEARCH_MODEL: env.OPENAI_RESEARCH_MODEL ?? null,
-    OPENAI_RESEARCH_TIMEOUT: env.OPENAI_RESEARCH_TIMEOUT ?? null
-  },
-  async init(config, runtime) {
-    initializeOpenAI(config, runtime);
-  },
-  models: {
-    [ModelType7.TEXT_EMBEDDING]: async (runtime, params) => {
-      return handleTextEmbedding(runtime, params);
-    },
-    [ModelType7.TEXT_TOKENIZER_ENCODE]: async (runtime, params) => {
-      return handleTokenizerEncode(runtime, params);
-    },
-    [ModelType7.TEXT_TOKENIZER_DECODE]: async (runtime, params) => {
-      return handleTokenizerDecode(runtime, params);
-    },
-    [ModelType7.TEXT_SMALL]: async (runtime, params) => {
-      return handleTextSmall(runtime, params);
-    },
-    [ModelType7.TEXT_LARGE]: async (runtime, params) => {
-      return handleTextLarge(runtime, params);
-    },
-    [ModelType7.IMAGE]: async (runtime, params) => {
-      return handleImageGeneration(runtime, params);
-    },
-    [ModelType7.IMAGE_DESCRIPTION]: async (runtime, params) => {
-      return handleImageDescription(runtime, params);
-    },
-    [ModelType7.TRANSCRIPTION]: async (runtime, input) => {
-      return handleTranscription(runtime, input);
-    },
-    [ModelType7.TEXT_TO_SPEECH]: async (runtime, input) => {
-      return handleTextToSpeech(runtime, input);
-    },
-    [ModelType7.OBJECT_SMALL]: async (runtime, params) => {
-      return handleObjectSmall(runtime, params);
-    },
-    [ModelType7.OBJECT_LARGE]: async (runtime, params) => {
-      return handleObjectLarge(runtime, params);
-    },
-    [ModelType7.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();
-            logger11.info(`[OpenAI Test] API connected. ${data.data?.length ?? 0} models available.`);
-          }
-        },
-        {
-          name: "openai_test_text_embedding",
-          fn: async (runtime) => {
-            const embedding = await runtime.useModel(ModelType7.TEXT_EMBEDDING, {
-              text: "Hello, world!"
-            });
-            if (!Array.isArray(embedding) || embedding.length === 0) {
-              throw new Error("Embedding should return a non-empty array");
-            }
-            logger11.info(`[OpenAI Test] Generated embedding with ${embedding.length} dimensions`);
-          }
-        },
-        {
-          name: "openai_test_text_small",
-          fn: async (runtime) => {
-            const text = await runtime.useModel(ModelType7.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");
-            }
-            logger11.info(`[OpenAI Test] TEXT_SMALL generated: "${text.substring(0, 50)}..."`);
-          }
-        },
-        {
-          name: "openai_test_text_large",
-          fn: async (runtime) => {
-            const text = await runtime.useModel(ModelType7.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");
-            }
-            logger11.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(ModelType7.TEXT_TOKENIZER_ENCODE, {
-              prompt: originalText,
-              modelType: ModelType7.TEXT_SMALL
-            });
-            if (!Array.isArray(tokens) || tokens.length === 0) {
-              throw new Error("Tokenization should return non-empty token array");
-            }
-            const decodedText = await runtime.useModel(ModelType7.TEXT_TOKENIZER_DECODE, {
-              tokens,
-              modelType: ModelType7.TEXT_SMALL
-            });
-            if (decodedText !== originalText) {
-              throw new Error(`Tokenizer roundtrip failed: expected "${originalText}", got "${decodedText}"`);
-            }
-            logger11.info(`[OpenAI Test] Tokenizer roundtrip successful (${tokens.length} tokens)`);
-          }
-        },
-        {
-          name: "openai_test_streaming",
-          fn: async (runtime) => {
-            const chunks = [];
-            const result = await runtime.useModel(ModelType7.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");
-            }
-            logger11.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(ModelType7.IMAGE_DESCRIPTION, testImageUrl);
-            if (!result || typeof result !== "object" || !("title" in result) || !("description" in result)) {
-              throw new Error("Image description should return { title, description }");
-            }
-            logger11.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(ModelType7.TRANSCRIPTION, audioBuffer);
-            if (typeof transcription !== "string") {
-              throw new Error("Transcription should return a string");
-            }
-            logger11.info(`[OpenAI Test] Transcription: "${transcription.substring(0, 50)}..."`);
-          }
-        },
-        {
-          name: "openai_test_text_to_speech",
-          fn: async (runtime) => {
-            const audioData = await runtime.useModel(ModelType7.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");
-            }
-            logger11.info(`[OpenAI Test] TTS generated ${audioData.byteLength} bytes of audio`);
-          }
-        },
-        {
-          name: "openai_test_object_generation",
-          fn: async (runtime) => {
-            const result = await runtime.useModel(ModelType7.OBJECT_SMALL, {
-              prompt: "Return a JSON object with exactly these fields: name (string), age (number), active (boolean)"
-            });
-            if (!result || typeof result !== "object") {
-              throw new Error("Object generation should return an object");
-            }
-            logger11.info(`[OpenAI Test] Object generated: ${JSON.stringify(result).substring(0, 100)}`);
-          }
-        },
-        {
-          name: "openai_test_research",
-          fn: async (runtime) => {
-            const result = await runtime.useModel(ModelType7.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");
-            }
-            logger11.info(`[OpenAI Test] Research completed. Text length: ${result.text.length}, Annotations: ${result.annotations?.length ?? 0}`);
-          }
-        }
-      ]
-    }
-  ]
-};
-var typescript_default = openaiPlugin;
-export {
-  openaiPlugin,
-  typescript_default as default
-};
-
-//# debugId=A63C30D83B0EE8CA64756E2164756E21