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

package/dist/node/index.node.js

@@ -1,5 +1,5 @@
 // index.ts
-import { logger as logger11, ModelType as ModelType7 } from "@elizaos/core";
+import { logger as logger9, ModelType as ModelType6 } from "@elizaos/core";
 
 // init.ts
 import { logger as logger2 } from "@elizaos/core";
@@ -45,7 +45,24 @@ function isBrowser() {
 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) {
@@ -80,11 +97,26 @@ function getEmbeddingBaseURL(runtime) {
   return getBaseURL(runtime);
 }
 function getSmallModel(runtime) {
-  return getSetting(runtime, "OPENAI_SMALL_MODEL") ?? getSetting(runtime, "SMALL_MODEL") ?? "gpt-5-mini";
+  return getSetting(runtime, "OPENAI_SMALL_MODEL") ?? getSetting(runtime, "SMALL_MODEL") ?? "gpt-5.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";
 }
@@ -153,7 +185,7 @@ async function validateOpenAIConfiguration(runtime) {
 }
 
 // models/audio.ts
-import { logger as logger4 } from "@elizaos/core";
+import { logger as logger4, recordLlmCall } from "@elizaos/core";
 
 // utils/audio.ts
 import { logger as logger3 } from "@elizaos/core";
@@ -304,16 +336,34 @@ async function handleTranscription(runtime, input) {
     }
   }
   const baseURL = getBaseURL(runtime);
-  const response = await fetch(`${baseURL}/audio/transcriptions`, {
-    method: "POST",
-    headers: getAuthHeader(runtime),
-    body: formData
+  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;
   });
-  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) {
@@ -362,20 +412,33 @@ async function handleTextToSpeech(runtime, input) {
   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)
+  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;
   });
-  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";
@@ -436,7 +499,6 @@ function emitModelUsageEvent(runtime, type, prompt, usage) {
 }
 
 // models/embedding.ts
-var MAX_EMBEDDING_TOKENS = 8000;
 function validateDimension(dimension) {
   const validDimensions = Object.values(VECTOR_DIMS);
   if (!validDimensions.includes(dimension)) {
@@ -456,6 +518,50 @@ function extractText(params) {
   }
   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));
@@ -470,11 +576,15 @@ async function handleTextEmbedding(runtime, params) {
   if (trimmedText.length === 0) {
     throw new Error("Cannot generate embedding for empty text");
   }
-  const maxChars = MAX_EMBEDDING_TOKENS * 4;
+  const maxChars = 8000 * 4;
   if (trimmedText.length > maxChars) {
-    logger5.warn(`[OpenAI] Embedding input too long (~${Math.ceil(trimmedText.length / 4)} tokens), truncating to ~${MAX_EMBEDDING_TOKENS} tokens`);
+    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}`);
@@ -495,7 +605,7 @@ async function handleTextEmbedding(runtime, params) {
   }
   const data = await response.json();
   const firstResult = data?.data?.[0];
-  if (!firstResult || !firstResult.embedding) {
+  if (!firstResult?.embedding) {
     throw new Error("OpenAI API returned invalid embedding response structure");
   }
   const embedding = firstResult.embedding;
@@ -513,7 +623,7 @@ async function handleTextEmbedding(runtime, params) {
   return embedding;
 }
 // models/image.ts
-import { logger as logger6, ModelType as ModelType2 } from "@elizaos/core";
+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);
@@ -521,7 +631,7 @@ async function handleImageGeneration(runtime, params) {
   const size = params.size ?? "1024x1024";
   const extendedParams = params;
   logger6.debug(`[OpenAI] Using IMAGE model: ${modelName}`);
-  if (!params.prompt || params.prompt.trim().length === 0) {
+  if (params.prompt.trim().length === 0) {
     throw new Error("IMAGE generation requires a non-empty prompt");
   }
   if (count < 1 || count > 10) {
@@ -540,20 +650,33 @@ async function handleImageGeneration(runtime, params) {
   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)
+  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 (!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) {
+  if (data.data.length === 0) {
     throw new Error("OpenAI API returned no images");
   }
   return data.data.map((item) => ({
@@ -598,19 +721,36 @@ async function handleImageDescription(runtime, params) {
     ],
     max_tokens: maxTokens
   };
-  const response = await fetch(`${baseURL}/chat/completions`, {
-    method: "POST",
-    headers: {
-      ...getAuthHeader(runtime),
-      "Content-Type": "application/json"
-    },
-    body: JSON.stringify(requestBody)
+  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 (!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,
@@ -628,88 +768,8 @@ async function handleImageDescription(runtime, params) {
     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";
+import { logger as logger7, recordLlmCall as recordLlmCall3 } from "@elizaos/core";
 function convertToolToApi(tool) {
   switch (tool.type) {
     case "web_search_preview":
@@ -850,11 +910,11 @@ async function handleResearch(runtime, params) {
   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)}...`);
+  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) {
-    logger9.debug("[OpenAI] No data source tools specified, defaulting to web_search_preview");
+    logger7.debug("[OpenAI] No data source tools specified, defaulting to web_search_preview");
     params.tools = [{ type: "web_search_preview" }, ...params.tools ?? []];
   }
   const requestBody = {
@@ -876,27 +936,40 @@ async function handleResearch(runtime, params) {
   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)
+  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 (!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}`);
+    logger7.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"}`);
+  logger7.debug(`[OpenAI] Research response received. Status: ${data.status ?? "completed"}`);
   const { text, annotations } = extractTextAndAnnotations(data);
   const outputItems = [];
   if (data.output) {
@@ -914,12 +987,65 @@ async function handleResearch(runtime, params) {
     outputItems,
     status: data.status
   };
-  logger9.info(`[OpenAI] Research completed. Text length: ${text.length}, Annotations: ${annotations.length}, Output items: ${outputItems.length}`);
+  logger7.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";
+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;
@@ -927,13 +1053,31 @@ function convertUsage(usage) {
   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: usageWithCache.cachedInputTokens
+    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 {
@@ -941,54 +1085,462 @@ function resolvePromptCacheOptions(params) {
     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);
-  logger10.debug(`[OpenAI] Using ${modelType} model: ${modelName}`);
-  const promptCacheOptions = resolvePromptCacheOptions(params);
-  const systemPrompt = runtime.character.system ?? undefined;
+  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,
-    prompt: params.prompt,
+    ...promptOrMessages,
     system: systemPrompt,
+    allowSystemInMessages: true,
     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 } : {}
-        }
-      }
-    } : {}
+    experimental_telemetry: telemetryConfig,
+    ...normalizedTools ? { tools: normalizedTools } : {},
+    ...normalizedToolChoice ? { toolChoice: normalizedToolChoice } : {},
+    ...paramsWithAttachments.responseSchema && !isCerebrasMode(runtime) ? { output: buildStructuredOutput(paramsWithAttachments.responseSchema) } : {},
+    ...providerOptions ? { providerOptions } : {}
   };
   if (params.stream) {
-    const result = streamText(generateParams);
+    const details2 = createLlmCallDetails(modelName, params, systemPrompt, "ai.streamText", modelType, providerOptions, generateParams);
+    details2.response = "";
+    const result2 = await recordLlmCall4(runtime, details2, () => 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)
+      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 { text, usage } = await generateText(generateParams);
-  if (usage) {
-    emitModelUsageEvent(runtime, modelType, params.prompt, usage);
+  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 text;
+  return result.text;
 }
 async function handleTextSmall(runtime, params) {
-  return generateTextByModelType(runtime, params, ModelType4.TEXT_SMALL, getSmallModel);
+  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, ModelType4.TEXT_LARGE, getLargeModel);
+  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 ModelType6 } from "@elizaos/core";
+import { ModelType as ModelType5 } from "@elizaos/core";
 
 // utils/tokenization.ts
-import { ModelType as ModelType5 } from "@elizaos/core";
+import { ModelType as ModelType4 } from "@elizaos/core";
 import {
   encodingForModel,
   getEncoding
@@ -1003,7 +1555,7 @@ function resolveTokenizerEncoding(modelName) {
   }
 }
 function getModelName(runtime, modelType) {
-  if (modelType === ModelType5.TEXT_SMALL) {
+  if (modelType === ModelType4.TEXT_SMALL) {
     return getSmallModel(runtime);
   }
   return getLargeModel(runtime);
@@ -1024,7 +1576,7 @@ async function handleTokenizerEncode(runtime, params) {
   if (!params.prompt) {
     throw new Error("Tokenization requires a non-empty prompt");
   }
-  const modelType = params.modelType ?? ModelType6.TEXT_LARGE;
+  const modelType = params.modelType ?? ModelType5.TEXT_LARGE;
   return tokenizeText(runtime, modelType, params.prompt);
 }
 async function handleTokenizerDecode(runtime, params) {
@@ -1040,7 +1592,7 @@ async function handleTokenizerDecode(runtime, params) {
       throw new Error(`Invalid token at index ${i}: expected number`);
     }
   }
-  const modelType = params.modelType ?? ModelType6.TEXT_LARGE;
+  const modelType = params.modelType ?? ModelType5.TEXT_LARGE;
   return detokenizeText(runtime, modelType, params.tokens);
 }
 // index.ts
@@ -1051,16 +1603,38 @@ function getProcessEnv() {
   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,
@@ -1075,40 +1649,49 @@ var openaiPlugin = {
     initializeOpenAI(config, runtime);
   },
   models: {
-    [ModelType7.TEXT_EMBEDDING]: async (runtime, params) => {
+    [ModelType6.TEXT_EMBEDDING]: async (runtime, params) => {
       return handleTextEmbedding(runtime, params);
     },
-    [ModelType7.TEXT_TOKENIZER_ENCODE]: async (runtime, params) => {
+    [ModelType6.TEXT_TOKENIZER_ENCODE]: async (runtime, params) => {
       return handleTokenizerEncode(runtime, params);
     },
-    [ModelType7.TEXT_TOKENIZER_DECODE]: async (runtime, params) => {
+    [ModelType6.TEXT_TOKENIZER_DECODE]: async (runtime, params) => {
       return handleTokenizerDecode(runtime, params);
     },
-    [ModelType7.TEXT_SMALL]: async (runtime, params) => {
+    [ModelType6.TEXT_SMALL]: async (runtime, params) => {
       return handleTextSmall(runtime, params);
     },
-    [ModelType7.TEXT_LARGE]: async (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);
     },
-    [ModelType7.IMAGE]: async (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);
     },
-    [ModelType7.IMAGE_DESCRIPTION]: async (runtime, params) => {
+    [ModelType6.IMAGE_DESCRIPTION]: async (runtime, params) => {
       return handleImageDescription(runtime, params);
     },
-    [ModelType7.TRANSCRIPTION]: async (runtime, input) => {
+    [ModelType6.TRANSCRIPTION]: async (runtime, input) => {
       return handleTranscription(runtime, input);
     },
-    [ModelType7.TEXT_TO_SPEECH]: async (runtime, input) => {
+    [ModelType6.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) => {
+    [ModelType6.RESEARCH]: async (runtime, params) => {
       return handleResearch(runtime, params);
     }
   },
@@ -1127,71 +1710,71 @@ var openaiPlugin = {
               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.`);
+            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(ModelType7.TEXT_EMBEDDING, {
+            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");
             }
-            logger11.info(`[OpenAI Test] Generated embedding with ${embedding.length} dimensions`);
+            logger9.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, {
+            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");
             }
-            logger11.info(`[OpenAI Test] TEXT_SMALL generated: "${text.substring(0, 50)}..."`);
+            logger9.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, {
+            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");
             }
-            logger11.info(`[OpenAI Test] TEXT_LARGE generated: "${text.substring(0, 50)}..."`);
+            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(ModelType7.TEXT_TOKENIZER_ENCODE, {
+            const tokens = await runtime.useModel(ModelType6.TEXT_TOKENIZER_ENCODE, {
               prompt: originalText,
-              modelType: ModelType7.TEXT_SMALL
+              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(ModelType7.TEXT_TOKENIZER_DECODE, {
+            const decodedText = await runtime.useModel(ModelType6.TEXT_TOKENIZER_DECODE, {
               tokens,
-              modelType: ModelType7.TEXT_SMALL
+              modelType: ModelType6.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)`);
+            logger9.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, {
+            const result = await runtime.useModel(ModelType6.TEXT_LARGE, {
               prompt: "Count from 1 to 5, one number per line.",
               stream: true,
               onStreamChunk: (chunk) => {
@@ -1204,18 +1787,18 @@ var openaiPlugin = {
             if (chunks.length === 0) {
               throw new Error("No streaming chunks received");
             }
-            logger11.info(`[OpenAI Test] Streaming test: ${chunks.length} 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(ModelType7.IMAGE_DESCRIPTION, testImageUrl);
+            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 }");
             }
-            logger11.info(`[OpenAI Test] Image described: "${result.title}"`);
+            logger9.info(`[OpenAI Test] Image described: "${result.title}"`);
           }
         },
         {
@@ -1225,41 +1808,50 @@ var openaiPlugin = {
             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);
+            const transcription = await runtime.useModel(ModelType6.TRANSCRIPTION, audioBuffer);
             if (typeof transcription !== "string") {
               throw new Error("Transcription should return a string");
             }
-            logger11.info(`[OpenAI Test] Transcription: "${transcription.substring(0, 50)}..."`);
+            logger9.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, {
+            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");
             }
-            logger11.info(`[OpenAI Test] TTS generated ${audioData.byteLength} bytes of audio`);
+            logger9.info(`[OpenAI Test] TTS generated ${audioData.byteLength} bytes of audio`);
           }
         },
         {
-          name: "openai_test_object_generation",
+          name: "openai_test_structured_output_via_text_large",
           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)"
+            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") {
-              throw new Error("Object generation should return an object");
+            if (!result || typeof result !== "object" && typeof result !== "string") {
+              throw new Error("Structured output should return an object or text");
             }
-            logger11.info(`[OpenAI Test] Object generated: ${JSON.stringify(result).substring(0, 100)}`);
+            logger9.info(`[OpenAI Test] Structured output: ${JSON.stringify(result).substring(0, 100)}`);
           }
         },
         {
           name: "openai_test_research",
           fn: async (runtime) => {
-            const result = await runtime.useModel(ModelType7.RESEARCH, {
+            const result = await runtime.useModel(ModelType6.RESEARCH, {
               input: "What is the current date and time?",
               tools: [{ type: "web_search_preview" }],
               maxToolCalls: 3
@@ -1270,17 +1862,20 @@ var openaiPlugin = {
             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}`);
+            logger9.info(`[OpenAI Test] Research completed. Text length: ${result.text.length}, Annotations: ${result.annotations?.length ?? 0}`);
           }
         }
       ]
     }
   ]
 };
-var typescript_default = openaiPlugin;
+var plugin_openai_default = openaiPlugin;
+
+// index.node.ts
+var index_node_default = plugin_openai_default;
 export {
   openaiPlugin,
-  typescript_default as default
+  index_node_default as default
 };
 
-//# debugId=A63C30D83B0EE8CA64756E2164756E21
+//# debugId=D3370FEEF676E11164756E2164756E21