@elizaos/plugin-openai 1.0.0-beta.49 → 1.0.0-beta.51

package/dist/index.js

@@ -1,29 +1,21 @@
 // src/index.ts
 import { createOpenAI } from "@ai-sdk/openai";
-import { getProviderBaseURL } from "@elizaos/core";
 import {
   EventType,
   logger,
   ModelType,
-  VECTOR_DIMS,
   safeReplacer,
-  ServiceType
+  ServiceType,
+  VECTOR_DIMS
 } from "@elizaos/core";
-import {
-  generateObject,
-  generateText,
-  JSONParseError
-} from "ai";
-import { encodingForModel } from "js-tiktoken";
-import { fetch, FormData } from "undici";
 
-// ../../node_modules/@opentelemetry/api/build/esm/platform/node/globalThis.js
+// node_modules/@opentelemetry/api/build/esm/platform/node/globalThis.js
 var _globalThis = typeof globalThis === "object" ? globalThis : global;
 
-// ../../node_modules/@opentelemetry/api/build/esm/version.js
+// node_modules/@opentelemetry/api/build/esm/version.js
 var VERSION = "1.9.0";
 
-// ../../node_modules/@opentelemetry/api/build/esm/internal/semver.js
+// node_modules/@opentelemetry/api/build/esm/internal/semver.js
 var re = /^(\d+)\.(\d+)\.(\d+)(-(.+))?$/;
 function _makeCompatibilityCheck(ownVersion) {
   var acceptedVersions = /* @__PURE__ */ new Set([ownVersion]);
@@ -90,7 +82,7 @@ function _makeCompatibilityCheck(ownVersion) {
 }
 var isCompatible = _makeCompatibilityCheck(VERSION);
 
-// ../../node_modules/@opentelemetry/api/build/esm/internal/global-utils.js
+// node_modules/@opentelemetry/api/build/esm/internal/global-utils.js
 var major = VERSION.split(".")[0];
 var GLOBAL_OPENTELEMETRY_API_KEY = Symbol.for("opentelemetry.js.api." + major);
 var _global = _globalThis;
@@ -132,7 +124,7 @@ function unregisterGlobal(type, diag) {
   }
 }
 
-// ../../node_modules/@opentelemetry/api/build/esm/diag/ComponentLogger.js
+// node_modules/@opentelemetry/api/build/esm/diag/ComponentLogger.js
 var __read = function(o, n) {
   var m = typeof Symbol === "function" && o[Symbol.iterator];
   if (!m) return o;
@@ -212,7 +204,7 @@ function logProxy(funcName, namespace, args) {
   return logger2[funcName].apply(logger2, __spreadArray([], __read(args), false));
 }
 
-// ../../node_modules/@opentelemetry/api/build/esm/diag/types.js
+// node_modules/@opentelemetry/api/build/esm/diag/types.js
 var DiagLogLevel;
 (function(DiagLogLevel2) {
   DiagLogLevel2[DiagLogLevel2["NONE"] = 0] = "NONE";
@@ -224,7 +216,7 @@ var DiagLogLevel;
   DiagLogLevel2[DiagLogLevel2["ALL"] = 9999] = "ALL";
 })(DiagLogLevel || (DiagLogLevel = {}));
 
-// ../../node_modules/@opentelemetry/api/build/esm/diag/internal/logLevelLogger.js
+// node_modules/@opentelemetry/api/build/esm/diag/internal/logLevelLogger.js
 function createLogLevelDiagLogger(maxLevel, logger2) {
   if (maxLevel < DiagLogLevel.NONE) {
     maxLevel = DiagLogLevel.NONE;
@@ -249,7 +241,7 @@ function createLogLevelDiagLogger(maxLevel, logger2) {
   };
 }
 
-// ../../node_modules/@opentelemetry/api/build/esm/api/diag.js
+// node_modules/@opentelemetry/api/build/esm/api/diag.js
 var __read2 = function(o, n) {
   var m = typeof Symbol === "function" && o[Symbol.iterator];
   if (!m) return o;
@@ -341,7 +333,7 @@ var DiagAPI = (
   }()
 );
 
-// ../../node_modules/@opentelemetry/api/build/esm/context/context.js
+// node_modules/@opentelemetry/api/build/esm/context/context.js
 var BaseContext = (
   /** @class */
   /* @__PURE__ */ function() {
@@ -367,7 +359,7 @@ var BaseContext = (
 );
 var ROOT_CONTEXT = new BaseContext();
 
-// ../../node_modules/@opentelemetry/api/build/esm/context/NoopContextManager.js
+// node_modules/@opentelemetry/api/build/esm/context/NoopContextManager.js
 var __read3 = function(o, n) {
   var m = typeof Symbol === "function" && o[Symbol.iterator];
   if (!m) return o;
@@ -422,7 +414,7 @@ var NoopContextManager = (
   }()
 );
 
-// ../../node_modules/@opentelemetry/api/build/esm/api/context.js
+// node_modules/@opentelemetry/api/build/esm/api/context.js
 var __read4 = function(o, n) {
   var m = typeof Symbol === "function" && o[Symbol.iterator];
   if (!m) return o;
@@ -490,7 +482,7 @@ var ContextAPI = (
   }()
 );
 
-// ../../node_modules/@opentelemetry/api/build/esm/trace/status.js
+// node_modules/@opentelemetry/api/build/esm/trace/status.js
 var SpanStatusCode;
 (function(SpanStatusCode2) {
   SpanStatusCode2[SpanStatusCode2["UNSET"] = 0] = "UNSET";
@@ -498,26 +490,41 @@ var SpanStatusCode;
   SpanStatusCode2[SpanStatusCode2["ERROR"] = 2] = "ERROR";
 })(SpanStatusCode || (SpanStatusCode = {}));
 
-// ../../node_modules/@opentelemetry/api/build/esm/context-api.js
+// node_modules/@opentelemetry/api/build/esm/context-api.js
 var context = ContextAPI.getInstance();
 
 // src/index.ts
+import {
+  generateObject,
+  generateText,
+  JSONParseError
+} from "ai";
+import { encodingForModel } from "js-tiktoken";
+import { fetch, FormData } from "undici";
 function getTracer(runtime) {
   const availableServices = Array.from(runtime.getAllServices().keys());
-  logger.debug(`[getTracer] Available services: ${JSON.stringify(availableServices)}`);
-  logger.debug(`[getTracer] Attempting to get service with key: ${ServiceType.INSTRUMENTATION}`);
+  logger.debug(
+    `[getTracer] Available services: ${JSON.stringify(availableServices)}`
+  );
+  logger.debug(
+    `[getTracer] Attempting to get service with key: ${ServiceType.INSTRUMENTATION}`
+  );
   const instrumentationService = runtime.getService(
     ServiceType.INSTRUMENTATION
   );
   if (!instrumentationService) {
-    logger.warn(`[getTracer] Service ${ServiceType.INSTRUMENTATION} not found in runtime.`);
+    logger.warn(
+      `[getTracer] Service ${ServiceType.INSTRUMENTATION} not found in runtime.`
+    );
     return null;
   }
   if (!instrumentationService.isEnabled()) {
     logger.debug("[getTracer] Instrumentation service found but is disabled.");
     return null;
   }
-  logger.debug("[getTracer] Successfully retrieved enabled instrumentation service.");
+  logger.debug(
+    "[getTracer] Successfully retrieved enabled instrumentation service."
+  );
   return instrumentationService.getTracer("eliza.llm.openai");
 }
 async function startLlmSpan(runtime, spanName, attributes, fn) {
@@ -541,28 +548,37 @@ async function startLlmSpan(runtime, spanName, attributes, fn) {
     return fn(dummySpan);
   }
   const activeContext = context.active();
-  return tracer.startActiveSpan(spanName, { attributes }, activeContext, async (span) => {
-    try {
-      const result = await fn(span);
-      span.setStatus({ code: SpanStatusCode.OK });
-      span.end();
-      return result;
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      span.recordException(error);
-      span.setStatus({ code: SpanStatusCode.ERROR, message });
-      span.end();
-      throw error;
+  return tracer.startActiveSpan(
+    spanName,
+    { attributes },
+    activeContext,
+    async (span) => {
+      try {
+        const result = await fn(span);
+        span.setStatus({ code: SpanStatusCode.OK });
+        span.end();
+        return result;
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        span.recordException(error);
+        span.setStatus({ code: SpanStatusCode.ERROR, message });
+        span.end();
+        throw error;
+      }
     }
-  });
+  );
 }
 function getSetting(runtime, key, defaultValue) {
   return runtime.getSetting(key) ?? process.env[key] ?? defaultValue;
 }
 function getBaseURL(runtime) {
-  const defaultBaseURL = getSetting(runtime, "OPENAI_BASE_URL", "https://api.openai.com/v1");
-  logger.debug(`[OpenAI] Default base URL: ${defaultBaseURL}`);
-  return getProviderBaseURL(runtime, "openai", defaultBaseURL);
+  const baseURL = getSetting(
+    runtime,
+    "OPENAI_BASE_URL",
+    "https://api.openai.com/v1"
+  );
+  logger.debug(`[OpenAI] Default base URL: ${baseURL}`);
+  return baseURL;
 }
 function getEmbeddingBaseURL(runtime) {
   const embeddingURL = getSetting(runtime, "OPENAI_EMBEDDING_URL");
@@ -612,99 +628,113 @@ async function generateObjectByModelType(runtime, params, modelType, getModelFn)
     "llm.request.temperature": temperature,
     "llm.request.schema_present": schemaPresent
   };
-  return startLlmSpan(runtime, "LLM.generateObject", attributes, async (span) => {
-    span.addEvent("llm.prompt", { "prompt.content": params.prompt });
-    if (schemaPresent) {
-      span.addEvent("llm.request.schema", {
-        schema: JSON.stringify(params.schema, safeReplacer())
-      });
-      logger.info(
-        `Using ${modelType} without schema validation (schema provided but output=no-schema)`
-      );
-    }
-    try {
-      const { object, usage } = await generateObject({
-        model: openai.languageModel(modelName),
-        output: "no-schema",
-        prompt: params.prompt,
-        temperature,
-        experimental_repairText: getJsonRepairFunction()
-      });
-      span.addEvent("llm.response.processed", {
-        "response.object": JSON.stringify(object, safeReplacer())
-      });
-      if (usage) {
-        span.setAttributes({
-          "llm.usage.prompt_tokens": usage.promptTokens,
-          "llm.usage.completion_tokens": usage.completionTokens,
-          "llm.usage.total_tokens": usage.totalTokens
+  return startLlmSpan(
+    runtime,
+    "LLM.generateObject",
+    attributes,
+    async (span) => {
+      span.addEvent("llm.prompt", { "prompt.content": params.prompt });
+      if (schemaPresent) {
+        span.addEvent("llm.request.schema", {
+          schema: JSON.stringify(params.schema, safeReplacer())
         });
-        emitModelUsageEvent(runtime, modelType, params.prompt, usage);
+        logger.info(
+          `Using ${modelType} without schema validation (schema provided but output=no-schema)`
+        );
       }
-      return object;
-    } catch (error) {
-      if (error instanceof JSONParseError) {
-        logger.error(`[generateObject] Failed to parse JSON: ${error.message}`);
-        span.recordException(error);
-        span.addEvent("llm.error.json_parse", {
-          "error.message": error.message,
-          "error.text": error.text
+      try {
+        const { object, usage } = await generateObject({
+          model: openai.languageModel(modelName),
+          output: "no-schema",
+          prompt: params.prompt,
+          temperature,
+          experimental_repairText: getJsonRepairFunction()
         });
-        span.addEvent("llm.repair.attempt");
-        const repairFunction = getJsonRepairFunction();
-        const repairedJsonString = await repairFunction({
-          text: error.text,
-          error
+        span.addEvent("llm.response.processed", {
+          "response.object": JSON.stringify(object, safeReplacer())
         });
-        if (repairedJsonString) {
-          try {
-            const repairedObject = JSON.parse(repairedJsonString);
-            span.addEvent("llm.repair.success", {
-              repaired_object: JSON.stringify(repairedObject, safeReplacer())
-            });
-            logger.info("[generateObject] Successfully repaired JSON.");
-            span.setStatus({
-              code: SpanStatusCode.ERROR,
-              message: "JSON parsing failed but was repaired"
-            });
-            return repairedObject;
-          } catch (repairParseError) {
-            const message = repairParseError instanceof Error ? repairParseError.message : String(repairParseError);
-            logger.error(`[generateObject] Failed to parse repaired JSON: ${message}`);
-            const exception = repairParseError instanceof Error ? repairParseError : new Error(message);
-            span.recordException(exception);
-            span.addEvent("llm.repair.parse_error", {
-              "error.message": message
-            });
+        if (usage) {
+          span.setAttributes({
+            "llm.usage.prompt_tokens": usage.promptTokens,
+            "llm.usage.completion_tokens": usage.completionTokens,
+            "llm.usage.total_tokens": usage.totalTokens
+          });
+          emitModelUsageEvent(
+            runtime,
+            modelType,
+            params.prompt,
+            usage
+          );
+        }
+        return object;
+      } catch (error) {
+        if (error instanceof JSONParseError) {
+          logger.error(
+            `[generateObject] Failed to parse JSON: ${error.message}`
+          );
+          span.recordException(error);
+          span.addEvent("llm.error.json_parse", {
+            "error.message": error.message,
+            "error.text": error.text
+          });
+          span.addEvent("llm.repair.attempt");
+          const repairFunction = getJsonRepairFunction();
+          const repairedJsonString = await repairFunction({
+            text: error.text,
+            error
+          });
+          if (repairedJsonString) {
+            try {
+              const repairedObject = JSON.parse(repairedJsonString);
+              span.addEvent("llm.repair.success", {
+                repaired_object: JSON.stringify(repairedObject, safeReplacer())
+              });
+              logger.info("[generateObject] Successfully repaired JSON.");
+              span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: "JSON parsing failed but was repaired"
+              });
+              return repairedObject;
+            } catch (repairParseError) {
+              const message = repairParseError instanceof Error ? repairParseError.message : String(repairParseError);
+              logger.error(
+                `[generateObject] Failed to parse repaired JSON: ${message}`
+              );
+              const exception = repairParseError instanceof Error ? repairParseError : new Error(message);
+              span.recordException(exception);
+              span.addEvent("llm.repair.parse_error", {
+                "error.message": message
+              });
+              span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: `JSON repair failed: ${message}`
+              });
+              throw repairParseError;
+            }
+          } else {
+            const errMsg = error instanceof Error ? error.message : String(error);
+            logger.error("[generateObject] JSON repair failed.");
+            span.addEvent("llm.repair.failed");
             span.setStatus({
               code: SpanStatusCode.ERROR,
-              message: `JSON repair failed: ${message}`
+              message: `JSON repair failed: ${errMsg}`
             });
-            throw repairParseError;
+            throw error;
           }
         } else {
-          const errMsg = error instanceof Error ? error.message : String(error);
-          logger.error("[generateObject] JSON repair failed.");
-          span.addEvent("llm.repair.failed");
+          const message = error instanceof Error ? error.message : String(error);
+          logger.error(`[generateObject] Unknown error: ${message}`);
+          const exception = error instanceof Error ? error : new Error(message);
+          span.recordException(exception);
           span.setStatus({
             code: SpanStatusCode.ERROR,
-            message: `JSON repair failed: ${errMsg}`
+            message
           });
           throw error;
         }
-      } else {
-        const message = error instanceof Error ? error.message : String(error);
-        logger.error(`[generateObject] Unknown error: ${message}`);
-        const exception = error instanceof Error ? error : new Error(message);
-        span.recordException(exception);
-        span.setStatus({
-          code: SpanStatusCode.ERROR,
-          message
-        });
-        throw error;
       }
     }
-  });
+  );
 }
 function getJsonRepairFunction() {
   return async ({ text, error }) => {
@@ -792,15 +822,21 @@ var openaiPlugin = {
           headers: { Authorization: `Bearer ${getApiKey(runtime)}` }
         });
         if (!response.ok) {
-          logger.warn(`OpenAI API key validation failed: ${response.statusText}`);
-          logger.warn("OpenAI functionality will be limited until a valid API key is provided");
+          logger.warn(
+            `OpenAI API key validation failed: ${response.statusText}`
+          );
+          logger.warn(
+            "OpenAI functionality will be limited until a valid API key is provided"
+          );
         } else {
           logger.log("OpenAI API key validated successfully");
         }
       } catch (fetchError) {
         const message = fetchError instanceof Error ? fetchError.message : String(fetchError);
         logger.warn(`Error validating OpenAI API key: ${message}`);
-        logger.warn("OpenAI functionality will be limited until a valid API key is provided");
+        logger.warn(
+          "OpenAI functionality will be limited until a valid API key is provided"
+        );
       }
     } catch (error) {
       const message = error?.errors?.map((e) => e.message).join(", ") || (error instanceof Error ? error.message : String(error));
@@ -858,83 +894,98 @@ var openaiPlugin = {
         "llm.request.embedding.dimensions": embeddingDimension,
         "input.text.length": text.length
       };
-      return startLlmSpan(runtime, "LLM.embedding", attributes, async (span) => {
-        span.addEvent("llm.prompt", { "prompt.content": text });
-        const embeddingBaseURL = getEmbeddingBaseURL(runtime);
-        const apiKey = getApiKey(runtime);
-        if (!apiKey) {
-          span.setStatus({
-            code: SpanStatusCode.ERROR,
-            message: "OpenAI API key not configured"
-          });
-          throw new Error("OpenAI API key not configured");
-        }
-        try {
-          const response = await fetch(`${embeddingBaseURL}/embeddings`, {
-            method: "POST",
-            headers: {
-              Authorization: `Bearer ${apiKey}`,
-              "Content-Type": "application/json"
-            },
-            body: JSON.stringify({
-              model: embeddingModelName,
-              input: text
-            })
-          });
-          const responseClone = response.clone();
-          const rawResponseBody = await responseClone.text();
-          span.addEvent("llm.response.raw", {
-            "response.body": rawResponseBody
-          });
-          if (!response.ok) {
-            logger.error(`OpenAI API error: ${response.status} - ${response.statusText}`);
-            span.setAttributes({ "error.api.status": response.status });
+      return startLlmSpan(
+        runtime,
+        "LLM.embedding",
+        attributes,
+        async (span) => {
+          span.addEvent("llm.prompt", { "prompt.content": text });
+          const embeddingBaseURL = getEmbeddingBaseURL(runtime);
+          const apiKey = getApiKey(runtime);
+          if (!apiKey) {
             span.setStatus({
               code: SpanStatusCode.ERROR,
-              message: `OpenAI API error: ${response.status} - ${response.statusText}. Response: ${rawResponseBody}`
+              message: "OpenAI API key not configured"
             });
-            const errorVector = Array(embeddingDimension).fill(0);
-            errorVector[0] = 0.4;
-            return errorVector;
+            throw new Error("OpenAI API key not configured");
           }
-          const data = await response.json();
-          if (!data?.data?.[0]?.embedding) {
-            logger.error("API returned invalid structure");
-            span.setStatus({
-              code: SpanStatusCode.ERROR,
-              message: "API returned invalid structure"
+          try {
+            const response = await fetch(`${embeddingBaseURL}/embeddings`, {
+              method: "POST",
+              headers: {
+                Authorization: `Bearer ${apiKey}`,
+                "Content-Type": "application/json"
+              },
+              body: JSON.stringify({
+                model: embeddingModelName,
+                input: text
+              })
             });
+            const responseClone = response.clone();
+            const rawResponseBody = await responseClone.text();
+            span.addEvent("llm.response.raw", {
+              "response.body": rawResponseBody
+            });
+            if (!response.ok) {
+              logger.error(
+                `OpenAI API error: ${response.status} - ${response.statusText}`
+              );
+              span.setAttributes({ "error.api.status": response.status });
+              span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: `OpenAI API error: ${response.status} - ${response.statusText}. Response: ${rawResponseBody}`
+              });
+              const errorVector = Array(embeddingDimension).fill(0);
+              errorVector[0] = 0.4;
+              return errorVector;
+            }
+            const data = await response.json();
+            if (!data?.data?.[0]?.embedding) {
+              logger.error("API returned invalid structure");
+              span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: "API returned invalid structure"
+              });
+              const errorVector = Array(embeddingDimension).fill(0);
+              errorVector[0] = 0.5;
+              return errorVector;
+            }
+            const embedding = data.data[0].embedding;
+            span.setAttribute(
+              "llm.response.embedding.vector_length",
+              embedding.length
+            );
+            if (data.usage) {
+              span.setAttributes({
+                "llm.usage.prompt_tokens": data.usage.prompt_tokens,
+                "llm.usage.total_tokens": data.usage.total_tokens
+              });
+              const usage = {
+                promptTokens: data.usage.prompt_tokens,
+                completionTokens: 0,
+                totalTokens: data.usage.total_tokens
+              };
+              emitModelUsageEvent(
+                runtime,
+                ModelType.TEXT_EMBEDDING,
+                text,
+                usage
+              );
+            }
+            logger.log(`Got valid embedding with length ${embedding.length}`);
+            return embedding;
+          } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            logger.error(`Error generating embedding: ${message}`);
+            const exception = error instanceof Error ? error : new Error(message);
+            span.recordException(exception);
+            span.setStatus({ code: SpanStatusCode.ERROR, message });
             const errorVector = Array(embeddingDimension).fill(0);
-            errorVector[0] = 0.5;
+            errorVector[0] = 0.6;
             return errorVector;
           }
-          const embedding = data.data[0].embedding;
-          span.setAttribute("llm.response.embedding.vector_length", embedding.length);
-          if (data.usage) {
-            span.setAttributes({
-              "llm.usage.prompt_tokens": data.usage.prompt_tokens,
-              "llm.usage.total_tokens": data.usage.total_tokens
-            });
-            const usage = {
-              promptTokens: data.usage.prompt_tokens,
-              completionTokens: 0,
-              totalTokens: data.usage.total_tokens
-            };
-            emitModelUsageEvent(runtime, ModelType.TEXT_EMBEDDING, text, usage);
-          }
-          logger.log(`Got valid embedding with length ${embedding.length}`);
-          return embedding;
-        } catch (error) {
-          const message = error instanceof Error ? error.message : String(error);
-          logger.error(`Error generating embedding: ${message}`);
-          const exception = error instanceof Error ? error : new Error(message);
-          span.recordException(exception);
-          span.setStatus({ code: SpanStatusCode.ERROR, message });
-          const errorVector = Array(embeddingDimension).fill(0);
-          errorVector[0] = 0.6;
-          return errorVector;
         }
-      });
+      );
     },
     [ModelType.TEXT_TOKENIZER_ENCODE]: async (_runtime, { prompt, modelType = ModelType.TEXT_LARGE }) => {
       return await tokenizeText(modelType ?? ModelType.TEXT_LARGE, prompt);
@@ -961,32 +1012,40 @@ var openaiPlugin = {
         "llm.request.presence_penalty": presence_penalty,
         "llm.request.stop_sequences": JSON.stringify(stopSequences)
       };
-      return startLlmSpan(runtime, "LLM.generateText", attributes, async (span) => {
-        span.addEvent("llm.prompt", { "prompt.content": prompt });
-        const { text: openaiResponse, usage } = await generateText({
-          model: openai.languageModel(modelName),
-          prompt,
-          system: runtime.character.system ?? void 0,
-          temperature,
-          maxTokens: max_response_length,
-          frequencyPenalty: frequency_penalty,
-          presencePenalty: presence_penalty,
-          stopSequences
-        });
-        span.setAttribute("llm.response.processed.length", openaiResponse.length);
-        span.addEvent("llm.response.processed", {
-          "response.content": openaiResponse.substring(0, 200) + (openaiResponse.length > 200 ? "..." : "")
-        });
-        if (usage) {
-          span.setAttributes({
-            "llm.usage.prompt_tokens": usage.promptTokens,
-            "llm.usage.completion_tokens": usage.completionTokens,
-            "llm.usage.total_tokens": usage.totalTokens
+      return startLlmSpan(
+        runtime,
+        "LLM.generateText",
+        attributes,
+        async (span) => {
+          span.addEvent("llm.prompt", { "prompt.content": prompt });
+          const { text: openaiResponse, usage } = await generateText({
+            model: openai.languageModel(modelName),
+            prompt,
+            system: runtime.character.system ?? void 0,
+            temperature,
+            maxTokens: max_response_length,
+            frequencyPenalty: frequency_penalty,
+            presencePenalty: presence_penalty,
+            stopSequences
+          });
+          span.setAttribute(
+            "llm.response.processed.length",
+            openaiResponse.length
+          );
+          span.addEvent("llm.response.processed", {
+            "response.content": openaiResponse.substring(0, 200) + (openaiResponse.length > 200 ? "..." : "")
           });
-          emitModelUsageEvent(runtime, ModelType.TEXT_SMALL, prompt, usage);
+          if (usage) {
+            span.setAttributes({
+              "llm.usage.prompt_tokens": usage.promptTokens,
+              "llm.usage.completion_tokens": usage.completionTokens,
+              "llm.usage.total_tokens": usage.totalTokens
+            });
+            emitModelUsageEvent(runtime, ModelType.TEXT_SMALL, prompt, usage);
+          }
+          return openaiResponse;
         }
-        return openaiResponse;
-      });
+      );
     },
     [ModelType.TEXT_LARGE]: async (runtime, {
       prompt,
@@ -1010,32 +1069,40 @@ var openaiPlugin = {
         "llm.request.presence_penalty": presencePenalty,
         "llm.request.stop_sequences": JSON.stringify(stopSequences)
       };
-      return startLlmSpan(runtime, "LLM.generateText", attributes, async (span) => {
-        span.addEvent("llm.prompt", { "prompt.content": prompt });
-        const { text: openaiResponse, usage } = await generateText({
-          model: openai.languageModel(modelName),
-          prompt,
-          system: runtime.character.system ?? void 0,
-          temperature,
-          maxTokens,
-          frequencyPenalty,
-          presencePenalty,
-          stopSequences
-        });
-        span.setAttribute("llm.response.processed.length", openaiResponse.length);
-        span.addEvent("llm.response.processed", {
-          "response.content": openaiResponse.substring(0, 200) + (openaiResponse.length > 200 ? "..." : "")
-        });
-        if (usage) {
-          span.setAttributes({
-            "llm.usage.prompt_tokens": usage.promptTokens,
-            "llm.usage.completion_tokens": usage.completionTokens,
-            "llm.usage.total_tokens": usage.totalTokens
+      return startLlmSpan(
+        runtime,
+        "LLM.generateText",
+        attributes,
+        async (span) => {
+          span.addEvent("llm.prompt", { "prompt.content": prompt });
+          const { text: openaiResponse, usage } = await generateText({
+            model: openai.languageModel(modelName),
+            prompt,
+            system: runtime.character.system ?? void 0,
+            temperature,
+            maxTokens,
+            frequencyPenalty,
+            presencePenalty,
+            stopSequences
+          });
+          span.setAttribute(
+            "llm.response.processed.length",
+            openaiResponse.length
+          );
+          span.addEvent("llm.response.processed", {
+            "response.content": openaiResponse.substring(0, 200) + (openaiResponse.length > 200 ? "..." : "")
           });
-          emitModelUsageEvent(runtime, ModelType.TEXT_LARGE, prompt, usage);
+          if (usage) {
+            span.setAttributes({
+              "llm.usage.prompt_tokens": usage.promptTokens,
+              "llm.usage.completion_tokens": usage.completionTokens,
+              "llm.usage.total_tokens": usage.totalTokens
+            });
+            emitModelUsageEvent(runtime, ModelType.TEXT_LARGE, prompt, usage);
+          }
+          return openaiResponse;
         }
-        return openaiResponse;
-      });
+      );
     },
     [ModelType.IMAGE]: async (runtime, params) => {
       const n = params.n || 1;
@@ -1049,57 +1116,64 @@ var openaiPlugin = {
         "llm.request.image.size": size,
         "llm.request.image.count": n
       };
-      return startLlmSpan(runtime, "LLM.imageGeneration", attributes, async (span) => {
-        span.addEvent("llm.prompt", { "prompt.content": prompt });
-        const baseURL = getBaseURL(runtime);
-        const apiKey = getApiKey(runtime);
-        if (!apiKey) {
-          span.setStatus({
-            code: SpanStatusCode.ERROR,
-            message: "OpenAI API key not configured"
-          });
-          throw new Error("OpenAI API key not configured");
-        }
-        try {
-          const response = await fetch(`${baseURL}/images/generations`, {
-            method: "POST",
-            headers: {
-              Authorization: `Bearer ${apiKey}`,
-              "Content-Type": "application/json"
-            },
-            body: JSON.stringify({
-              prompt,
-              n,
-              size
-            })
-          });
-          const responseClone = response.clone();
-          const rawResponseBody = await responseClone.text();
-          span.addEvent("llm.response.raw", {
-            "response.body": rawResponseBody
-          });
-          if (!response.ok) {
-            span.setAttributes({ "error.api.status": response.status });
+      return startLlmSpan(
+        runtime,
+        "LLM.imageGeneration",
+        attributes,
+        async (span) => {
+          span.addEvent("llm.prompt", { "prompt.content": prompt });
+          const baseURL = getBaseURL(runtime);
+          const apiKey = getApiKey(runtime);
+          if (!apiKey) {
             span.setStatus({
               code: SpanStatusCode.ERROR,
-              message: `Failed to generate image: ${response.statusText}. Response: ${rawResponseBody}`
+              message: "OpenAI API key not configured"
             });
-            throw new Error(`Failed to generate image: ${response.statusText}`);
+            throw new Error("OpenAI API key not configured");
+          }
+          try {
+            const response = await fetch(`${baseURL}/images/generations`, {
+              method: "POST",
+              headers: {
+                Authorization: `Bearer ${apiKey}`,
+                "Content-Type": "application/json"
+              },
+              body: JSON.stringify({
+                prompt,
+                n,
+                size
+              })
+            });
+            const responseClone = response.clone();
+            const rawResponseBody = await responseClone.text();
+            span.addEvent("llm.response.raw", {
+              "response.body": rawResponseBody
+            });
+            if (!response.ok) {
+              span.setAttributes({ "error.api.status": response.status });
+              span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: `Failed to generate image: ${response.statusText}. Response: ${rawResponseBody}`
+              });
+              throw new Error(
+                `Failed to generate image: ${response.statusText}`
+              );
+            }
+            const data = await response.json();
+            const typedData = data;
+            span.addEvent("llm.response.processed", {
+              "response.urls": JSON.stringify(typedData.data)
+            });
+            return typedData.data;
+          } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            const exception = error instanceof Error ? error : new Error(message);
+            span.recordException(exception);
+            span.setStatus({ code: SpanStatusCode.ERROR, message });
+            throw error;
           }
-          const data = await response.json();
-          const typedData = data;
-          span.addEvent("llm.response.processed", {
-            "response.urls": JSON.stringify(typedData.data)
-          });
-          return typedData.data;
-        } catch (error) {
-          const message = error instanceof Error ? error.message : String(error);
-          const exception = error instanceof Error ? error : new Error(message);
-          span.recordException(exception);
-          span.setStatus({ code: SpanStatusCode.ERROR, message });
-          throw error;
         }
-      });
+      );
     },
     [ModelType.IMAGE_DESCRIPTION]: async (runtime, params) => {
       let imageUrl;
@@ -1130,102 +1204,113 @@ var openaiPlugin = {
           ]
         }
       ];
-      return startLlmSpan(runtime, "LLM.imageDescription", attributes, async (span) => {
-        span.addEvent("llm.prompt", {
-          "prompt.content": JSON.stringify(messages, safeReplacer())
-        });
-        const baseURL = getBaseURL(runtime);
-        const apiKey = getApiKey(runtime);
-        if (!apiKey) {
-          logger.error("OpenAI API key not set");
-          span.setStatus({
-            code: SpanStatusCode.ERROR,
-            message: "OpenAI API key not configured"
-          });
-          return {
-            title: "Failed to analyze image",
-            description: "API key not configured"
-          };
-        }
-        try {
-          const response = await fetch(`${baseURL}/chat/completions`, {
-            method: "POST",
-            headers: {
-              "Content-Type": "application/json",
-              Authorization: `Bearer ${apiKey}`
-            },
-            body: JSON.stringify({
-              model: modelName,
-              messages,
-              max_tokens: maxTokens
-            })
-          });
-          const responseClone = response.clone();
-          const rawResponseBody = await responseClone.text();
-          span.addEvent("llm.response.raw", {
-            "response.body": rawResponseBody
+      return startLlmSpan(
+        runtime,
+        "LLM.imageDescription",
+        attributes,
+        async (span) => {
+          span.addEvent("llm.prompt", {
+            "prompt.content": JSON.stringify(messages, safeReplacer())
           });
-          if (!response.ok) {
-            span.setAttributes({ "error.api.status": response.status });
+          const baseURL = getBaseURL(runtime);
+          const apiKey = getApiKey(runtime);
+          if (!apiKey) {
+            logger.error("OpenAI API key not set");
             span.setStatus({
               code: SpanStatusCode.ERROR,
-              message: `OpenAI API error: ${response.status}. Response: ${rawResponseBody}`
+              message: "OpenAI API key not configured"
             });
-            throw new Error(`OpenAI API error: ${response.status}`);
+            return {
+              title: "Failed to analyze image",
+              description: "API key not configured"
+            };
           }
-          const result = await response.json();
-          const typedResult = result;
-          const content = typedResult.choices?.[0]?.message?.content;
-          if (typedResult.usage) {
-            span.setAttributes({
-              "llm.usage.prompt_tokens": typedResult.usage.prompt_tokens,
-              "llm.usage.completion_tokens": typedResult.usage.completion_tokens,
-              "llm.usage.total_tokens": typedResult.usage.total_tokens
+          try {
+            const response = await fetch(`${baseURL}/chat/completions`, {
+              method: "POST",
+              headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${apiKey}`
+              },
+              body: JSON.stringify({
+                model: modelName,
+                messages,
+                max_tokens: maxTokens
+              })
             });
-            emitModelUsageEvent(
-              runtime,
-              ModelType.IMAGE_DESCRIPTION,
-              typeof params === "string" ? params : params.prompt || "",
-              {
-                promptTokens: typedResult.usage.prompt_tokens,
-                completionTokens: typedResult.usage.completion_tokens,
-                totalTokens: typedResult.usage.total_tokens
-              }
-            );
-          }
-          if (typedResult.choices?.[0]?.finish_reason) {
-            span.setAttribute("llm.response.finish_reason", typedResult.choices[0].finish_reason);
-          }
-          if (!content) {
-            span.setStatus({
-              code: SpanStatusCode.ERROR,
-              message: "No content in API response"
+            const responseClone = response.clone();
+            const rawResponseBody = await responseClone.text();
+            span.addEvent("llm.response.raw", {
+              "response.body": rawResponseBody
+            });
+            if (!response.ok) {
+              span.setAttributes({ "error.api.status": response.status });
+              span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: `OpenAI API error: ${response.status}. Response: ${rawResponseBody}`
+              });
+              throw new Error(`OpenAI API error: ${response.status}`);
+            }
+            const result = await response.json();
+            const typedResult = result;
+            const content = typedResult.choices?.[0]?.message?.content;
+            if (typedResult.usage) {
+              span.setAttributes({
+                "llm.usage.prompt_tokens": typedResult.usage.prompt_tokens,
+                "llm.usage.completion_tokens": typedResult.usage.completion_tokens,
+                "llm.usage.total_tokens": typedResult.usage.total_tokens
+              });
+              emitModelUsageEvent(
+                runtime,
+                ModelType.IMAGE_DESCRIPTION,
+                typeof params === "string" ? params : params.prompt || "",
+                {
+                  promptTokens: typedResult.usage.prompt_tokens,
+                  completionTokens: typedResult.usage.completion_tokens,
+                  totalTokens: typedResult.usage.total_tokens
+                }
+              );
+            }
+            if (typedResult.choices?.[0]?.finish_reason) {
+              span.setAttribute(
+                "llm.response.finish_reason",
+                typedResult.choices[0].finish_reason
+              );
+            }
+            if (!content) {
+              span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: "No content in API response"
+              });
+              return {
+                title: "Failed to analyze image",
+                description: "No response from API"
+              };
+            }
+            const titleMatch = content.match(/title[:\s]+(.+?)(?:\n|$)/i);
+            const title = titleMatch?.[1]?.trim() || "Image Analysis";
+            const description = content.replace(/title[:\s]+(.+?)(?:\n|$)/i, "").trim();
+            const processedResult = { title, description };
+            span.addEvent("llm.response.processed", {
+              "response.object": JSON.stringify(
+                processedResult,
+                safeReplacer()
+              )
             });
+            return processedResult;
+          } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            logger.error(`Error analyzing image: ${message}`);
+            const exception = error instanceof Error ? error : new Error(message);
+            span.recordException(exception);
+            span.setStatus({ code: SpanStatusCode.ERROR, message });
             return {
               title: "Failed to analyze image",
-              description: "No response from API"
+              description: `Error: ${message}`
             };
           }
-          const titleMatch = content.match(/title[:\s]+(.+?)(?:\n|$)/i);
-          const title = titleMatch?.[1]?.trim() || "Image Analysis";
-          const description = content.replace(/title[:\s]+(.+?)(?:\n|$)/i, "").trim();
-          const processedResult = { title, description };
-          span.addEvent("llm.response.processed", {
-            "response.object": JSON.stringify(processedResult, safeReplacer())
-          });
-          return processedResult;
-        } catch (error) {
-          const message = error instanceof Error ? error.message : String(error);
-          logger.error(`Error analyzing image: ${message}`);
-          const exception = error instanceof Error ? error : new Error(message);
-          span.recordException(exception);
-          span.setStatus({ code: SpanStatusCode.ERROR, message });
-          return {
-            title: "Failed to analyze image",
-            description: `Error: ${message}`
-          };
         }
-      });
+      );
     },
     [ModelType.TRANSCRIPTION]: async (runtime, audioBuffer) => {
       logger.log("audioBuffer", audioBuffer);
@@ -1237,69 +1322,87 @@ var openaiPlugin = {
         "llm.request.model": modelName,
         "llm.request.audio.input_size_bytes": audioBuffer?.length || 0
       };
-      return startLlmSpan(runtime, "LLM.transcription", attributes, async (span) => {
-        span.addEvent("llm.prompt", {
-          "prompt.info": "Audio buffer for transcription"
-        });
-        const baseURL = getBaseURL(runtime);
-        const apiKey = getApiKey(runtime);
-        if (!apiKey) {
-          span.setStatus({
-            code: SpanStatusCode.ERROR,
-            message: "OpenAI API key not configured"
-          });
-          throw new Error("OpenAI API key not configured - Cannot make request");
-        }
-        if (!audioBuffer || audioBuffer.length === 0) {
-          span.setStatus({
-            code: SpanStatusCode.ERROR,
-            message: "Audio buffer is empty or invalid"
-          });
-          throw new Error("Audio buffer is empty or invalid for transcription");
-        }
-        const formData = new FormData();
-        formData.append("file", new Blob([audioBuffer]), "recording.mp3");
-        formData.append("model", "whisper-1");
-        try {
-          const response = await fetch(`${baseURL}/audio/transcriptions`, {
-            method: "POST",
-            headers: {
-              Authorization: `Bearer ${apiKey}`
-            },
-            body: formData
-          });
-          const responseClone = response.clone();
-          const rawResponseBody = await responseClone.text();
-          span.addEvent("llm.response.raw", {
-            "response.body": rawResponseBody
+      return startLlmSpan(
+        runtime,
+        "LLM.transcription",
+        attributes,
+        async (span) => {
+          span.addEvent("llm.prompt", {
+            "prompt.info": "Audio buffer for transcription"
           });
-          logger.log("response", response);
-          if (!response.ok) {
-            span.setAttributes({ "error.api.status": response.status });
+          const baseURL = getBaseURL(runtime);
+          const apiKey = getApiKey(runtime);
+          if (!apiKey) {
             span.setStatus({
               code: SpanStatusCode.ERROR,
-              message: `Failed to transcribe audio: ${response.statusText}. Response: ${rawResponseBody}`
+              message: "OpenAI API key not configured"
             });
-            throw new Error(`Failed to transcribe audio: ${response.statusText}`);
+            throw new Error(
+              "OpenAI API key not configured - Cannot make request"
+            );
+          }
+          if (!audioBuffer || audioBuffer.length === 0) {
+            span.setStatus({
+              code: SpanStatusCode.ERROR,
+              message: "Audio buffer is empty or invalid"
+            });
+            throw new Error(
+              "Audio buffer is empty or invalid for transcription"
+            );
+          }
+          const formData = new FormData();
+          formData.append("file", new Blob([audioBuffer]), "recording.mp3");
+          formData.append("model", "whisper-1");
+          try {
+            const response = await fetch(`${baseURL}/audio/transcriptions`, {
+              method: "POST",
+              headers: {
+                Authorization: `Bearer ${apiKey}`
+              },
+              body: formData
+            });
+            const responseClone = response.clone();
+            const rawResponseBody = await responseClone.text();
+            span.addEvent("llm.response.raw", {
+              "response.body": rawResponseBody
+            });
+            logger.log("response", response);
+            if (!response.ok) {
+              span.setAttributes({ "error.api.status": response.status });
+              span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: `Failed to transcribe audio: ${response.statusText}. Response: ${rawResponseBody}`
+              });
+              throw new Error(
+                `Failed to transcribe audio: ${response.statusText}`
+              );
+            }
+            const data = await response.json();
+            const processedText = data.text;
+            span.setAttribute(
+              "llm.response.processed.length",
+              processedText.length
+            );
+            span.addEvent("llm.response.processed", {
+              "response.text": processedText
+            });
+            return processedText;
+          } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            const exception = error instanceof Error ? error : new Error(message);
+            span.recordException(exception);
+            span.setStatus({ code: SpanStatusCode.ERROR, message });
+            throw error;
           }
-          const data = await response.json();
-          const processedText = data.text;
-          span.setAttribute("llm.response.processed.length", processedText.length);
-          span.addEvent("llm.response.processed", {
-            "response.text": processedText
-          });
-          return processedText;
-        } catch (error) {
-          const message = error instanceof Error ? error.message : String(error);
-          const exception = error instanceof Error ? error : new Error(message);
-          span.recordException(exception);
-          span.setStatus({ code: SpanStatusCode.ERROR, message });
-          throw error;
         }
-      });
+      );
     },
     [ModelType.TEXT_TO_SPEECH]: async (runtime, text) => {
-      const ttsModelName = getSetting(runtime, "OPENAI_TTS_MODEL", "gpt-4o-mini-tts");
+      const ttsModelName = getSetting(
+        runtime,
+        "OPENAI_TTS_MODEL",
+        "gpt-4o-mini-tts"
+      );
       const attributes = {
         "llm.vendor": "OpenAI",
         "llm.request.type": "tts",
@@ -1325,10 +1428,20 @@ var openaiPlugin = {
       });
     },
     [ModelType.OBJECT_SMALL]: async (runtime, params) => {
-      return generateObjectByModelType(runtime, params, ModelType.OBJECT_SMALL, getSmallModel);
+      return generateObjectByModelType(
+        runtime,
+        params,
+        ModelType.OBJECT_SMALL,
+        getSmallModel
+      );
     },
     [ModelType.OBJECT_LARGE]: async (runtime, params) => {
-      return generateObjectByModelType(runtime, params, ModelType.OBJECT_LARGE, getLargeModel);
+      return generateObjectByModelType(
+        runtime,
+        params,
+        ModelType.OBJECT_LARGE,
+        getLargeModel
+      );
     }
   },
   tests: [
@@ -1345,9 +1458,14 @@ var openaiPlugin = {
               }
             });
             const data = await response.json();
-            logger.log("Models Available:", data?.data?.length ?? "N/A");
+            logger.log(
+              "Models Available:",
+              data?.data?.length ?? "N/A"
+            );
             if (!response.ok) {
-              throw new Error(`Failed to validate OpenAI API key: ${response.statusText}`);
+              throw new Error(
+                `Failed to validate OpenAI API key: ${response.statusText}`
+              );
             }
           }
         },
@@ -1355,9 +1473,12 @@ var openaiPlugin = {
           name: "openai_test_text_embedding",
           fn: async (runtime) => {
             try {
-              const embedding = await runtime.useModel(ModelType.TEXT_EMBEDDING, {
-                text: "Hello, world!"
-              });
+              const embedding = await runtime.useModel(
+                ModelType.TEXT_EMBEDDING,
+                {
+                  text: "Hello, world!"
+                }
+              );
               logger.log("embedding", embedding);
             } catch (error) {
               const message = error instanceof Error ? error.message : String(error);
@@ -1433,7 +1554,10 @@ var openaiPlugin = {
                 if (result && typeof result === "object" && "title" in result && "description" in result) {
                   logger.log("Image description:", result);
                 } else {
-                  logger.error("Invalid image description result format:", result);
+                  logger.error(
+                    "Invalid image description result format:",
+                    result
+                  );
                 }
               } catch (e) {
                 const message = e instanceof Error ? e.message : String(e);
@@ -1441,7 +1565,9 @@ var openaiPlugin = {
               }
             } catch (e) {
               const message = e instanceof Error ? e.message : String(e);
-              logger.error(`Error in openai_test_image_description: ${message}`);
+              logger.error(
+                `Error in openai_test_image_description: ${message}`
+              );
             }
           }
         },
@@ -1470,9 +1596,14 @@ var openaiPlugin = {
           name: "openai_test_text_tokenizer_encode",
           fn: async (runtime) => {
             const prompt = "Hello tokenizer encode!";
-            const tokens = await runtime.useModel(ModelType.TEXT_TOKENIZER_ENCODE, { prompt });
+            const tokens = await runtime.useModel(
+              ModelType.TEXT_TOKENIZER_ENCODE,
+              { prompt }
+            );
             if (!Array.isArray(tokens) || tokens.length === 0) {
-              throw new Error("Failed to tokenize text: expected non-empty array of tokens");
+              throw new Error(
+                "Failed to tokenize text: expected non-empty array of tokens"
+              );
             }
             logger.log("Tokenized output:", tokens);
           }
@@ -1481,8 +1612,14 @@ var openaiPlugin = {
           name: "openai_test_text_tokenizer_decode",
           fn: async (runtime) => {
             const prompt = "Hello tokenizer decode!";
-            const tokens = await runtime.useModel(ModelType.TEXT_TOKENIZER_ENCODE, { prompt });
-            const decodedText = await runtime.useModel(ModelType.TEXT_TOKENIZER_DECODE, { tokens });
+            const tokens = await runtime.useModel(
+              ModelType.TEXT_TOKENIZER_ENCODE,
+              { prompt }
+            );
+            const decodedText = await runtime.useModel(
+              ModelType.TEXT_TOKENIZER_DECODE,
+              { tokens }
+            );
             if (decodedText !== prompt) {
               throw new Error(
                 `Decoded text does not match original. Expected "${prompt}", got "${decodedText}"`