@elizaos/plugin-elizacloud 1.5.18

package/dist/cjs/index.node.cjs

@@ -0,0 +1,796 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/index.node.ts
+var exports_index_node = {};
+__export(exports_index_node, {
+  elizaOSCloudPlugin: () => elizaOSCloudPlugin,
+  default: () => src_default
+});
+module.exports = __toCommonJS(exports_index_node);
+
+// src/index.ts
+var import_core10 = require("@elizaos/core");
+
+// src/init.ts
+var import_core2 = require("@elizaos/core");
+
+// src/utils/config.ts
+var import_core = require("@elizaos/core");
+function getSetting(runtime, key, defaultValue) {
+  return runtime.getSetting(key) ?? process.env[key] ?? defaultValue;
+}
+function isBrowser() {
+  return typeof globalThis !== "undefined" && typeof globalThis.document !== "undefined";
+}
+function isProxyMode(runtime) {
+  return isBrowser() && !!getSetting(runtime, "ELIZAOS_CLOUD_BROWSER_BASE_URL");
+}
+function getAuthHeader(runtime, forEmbedding = false) {
+  if (isBrowser())
+    return {};
+  const key = forEmbedding ? getEmbeddingApiKey(runtime) : getApiKey(runtime);
+  return key ? { Authorization: `Bearer ${key}` } : {};
+}
+function getBaseURL(runtime) {
+  const browserURL = getSetting(runtime, "ELIZAOS_CLOUD_BROWSER_BASE_URL");
+  const baseURL = isBrowser() && browserURL ? browserURL : getSetting(runtime, "ELIZAOS_CLOUD_BASE_URL", "https://www.elizacloud.ai/api/v1");
+  import_core.logger.debug(`[ELIZAOS_CLOUD] Default base URL: ${baseURL}`);
+  return baseURL;
+}
+function getEmbeddingBaseURL(runtime) {
+  const embeddingURL = isBrowser() ? getSetting(runtime, "ELIZAOS_CLOUD_BROWSER_EMBEDDING_URL") || getSetting(runtime, "ELIZAOS_CLOUD_BROWSER_BASE_URL") : getSetting(runtime, "ELIZAOS_CLOUD_EMBEDDING_URL");
+  if (embeddingURL) {
+    import_core.logger.debug(`[ELIZAOS_CLOUD] Using specific embedding base URL: ${embeddingURL}`);
+    return embeddingURL;
+  }
+  import_core.logger.debug("[ELIZAOS_CLOUD] Falling back to general base URL for embeddings.");
+  return getBaseURL(runtime);
+}
+function getApiKey(runtime) {
+  return getSetting(runtime, "ELIZAOS_CLOUD_API_KEY");
+}
+function getEmbeddingApiKey(runtime) {
+  const embeddingApiKey = getSetting(runtime, "ELIZAOS_CLOUD_EMBEDDING_API_KEY");
+  if (embeddingApiKey) {
+    import_core.logger.debug("[ELIZAOS_CLOUD] Using specific embedding API key (present)");
+    return embeddingApiKey;
+  }
+  import_core.logger.debug("[ELIZAOS_CLOUD] Falling back to general API key for embeddings.");
+  return getApiKey(runtime);
+}
+function getSmallModel(runtime) {
+  return getSetting(runtime, "ELIZAOS_CLOUD_SMALL_MODEL") ?? getSetting(runtime, "SMALL_MODEL", "gpt-4o-mini");
+}
+function getLargeModel(runtime) {
+  return getSetting(runtime, "ELIZAOS_CLOUD_LARGE_MODEL") ?? getSetting(runtime, "LARGE_MODEL", "gpt-4o");
+}
+function getImageDescriptionModel(runtime) {
+  return getSetting(runtime, "ELIZAOS_CLOUD_IMAGE_DESCRIPTION_MODEL", "gpt-4o-mini") ?? "gpt-4o-mini";
+}
+function getExperimentalTelemetry(runtime) {
+  const setting = getSetting(runtime, "ELIZAOS_CLOUD_EXPERIMENTAL_TELEMETRY", "false");
+  const normalizedSetting = String(setting).toLowerCase();
+  const result = normalizedSetting === "true";
+  import_core.logger.debug(`[ELIZAOS_CLOUD] Experimental telemetry in function: "${setting}" (type: ${typeof setting}, normalized: "${normalizedSetting}", result: ${result})`);
+  return result;
+}
+
+// src/init.ts
+function initializeOpenAI(_config, runtime) {
+  new Promise(async (resolve) => {
+    resolve();
+    try {
+      if (!getApiKey(runtime) && !isBrowser()) {
+        import_core2.logger.warn("ELIZAOS_CLOUD_API_KEY is not set in environment - ElizaOS Cloud functionality will be limited");
+        import_core2.logger.info("Get your API key from https://www.elizacloud.ai/dashboard/api-keys");
+        return;
+      }
+      try {
+        const baseURL = getBaseURL(runtime);
+        const response = await fetch(`${baseURL}/models`, {
+          headers: { ...getAuthHeader(runtime) }
+        });
+        if (!response.ok) {
+          import_core2.logger.warn(`ElizaOS Cloud API key validation failed: ${response.statusText}`);
+          import_core2.logger.warn("ElizaOS Cloud functionality will be limited until a valid API key is provided");
+          import_core2.logger.info("Get your API key from https://www.elizacloud.ai/dashboard/api-keys");
+        } else {
+          import_core2.logger.log("ElizaOS Cloud API key validated successfully");
+        }
+      } catch (fetchError) {
+        const message = fetchError instanceof Error ? fetchError.message : String(fetchError);
+        import_core2.logger.warn(`Error validating ElizaOS Cloud API key: ${message}`);
+        import_core2.logger.warn("ElizaOS Cloud functionality will be limited until a valid API key is provided");
+      }
+    } catch (error) {
+      const message = error?.errors?.map((e) => e.message).join(", ") || (error instanceof Error ? error.message : String(error));
+      import_core2.logger.warn(`ElizaOS Cloud plugin configuration issue: ${message} - You need to configure the ELIZAOS_CLOUD_API_KEY in your environment variables`);
+      import_core2.logger.info("Get your API key from https://www.elizacloud.ai/dashboard/api-keys");
+    }
+  });
+}
+
+// src/models/text.ts
+var import_core4 = require("@elizaos/core");
+var import_ai = require("ai");
+
+// src/providers/openai.ts
+var import_openai = require("@ai-sdk/openai");
+function createOpenAIClient(runtime) {
+  const baseURL = getBaseURL(runtime);
+  const apiKey = getApiKey(runtime) ?? (isProxyMode(runtime) ? "eliza-proxy" : undefined);
+  return import_openai.createOpenAI({ apiKey: apiKey ?? "", baseURL });
+}
+
+// src/utils/events.ts
+var import_core3 = require("@elizaos/core");
+function emitModelUsageEvent(runtime, type, prompt, usage) {
+  runtime.emitEvent(import_core3.EventType.MODEL_USED, {
+    provider: "openai",
+    type,
+    prompt,
+    tokens: {
+      prompt: usage.inputTokens,
+      completion: usage.outputTokens,
+      total: usage.totalTokens
+    }
+  });
+}
+
+// src/models/text.ts
+async function handleTextSmall(runtime, {
+  prompt,
+  stopSequences = [],
+  maxTokens = 8192,
+  temperature = 0.7,
+  frequencyPenalty = 0.7,
+  presencePenalty = 0.7
+}) {
+  const openai = createOpenAIClient(runtime);
+  const modelName = getSmallModel(runtime);
+  const experimentalTelemetry = getExperimentalTelemetry(runtime);
+  import_core4.logger.log(`[ELIZAOS_CLOUD] Using TEXT_SMALL model: ${modelName}`);
+  import_core4.logger.log(prompt);
+  const { text: openaiResponse, usage } = await import_ai.generateText({
+    model: openai.languageModel(modelName),
+    prompt,
+    system: runtime.character.system ?? undefined,
+    temperature,
+    maxOutputTokens: maxTokens,
+    frequencyPenalty,
+    presencePenalty,
+    stopSequences,
+    experimental_telemetry: {
+      isEnabled: experimentalTelemetry
+    }
+  });
+  if (usage) {
+    emitModelUsageEvent(runtime, import_core4.ModelType.TEXT_SMALL, prompt, usage);
+  }
+  return openaiResponse;
+}
+async function handleTextLarge(runtime, {
+  prompt,
+  stopSequences = [],
+  maxTokens = 8192,
+  temperature = 0.7,
+  frequencyPenalty = 0.7,
+  presencePenalty = 0.7
+}) {
+  const openai = createOpenAIClient(runtime);
+  const modelName = getLargeModel(runtime);
+  const experimentalTelemetry = getExperimentalTelemetry(runtime);
+  import_core4.logger.log(`[ELIZAOS_CLOUD] Using TEXT_LARGE model: ${modelName}`);
+  import_core4.logger.log(prompt);
+  const { text: openaiResponse, usage } = await import_ai.generateText({
+    model: openai.languageModel(modelName),
+    prompt,
+    system: runtime.character.system ?? undefined,
+    temperature,
+    maxOutputTokens: maxTokens,
+    frequencyPenalty,
+    presencePenalty,
+    stopSequences,
+    experimental_telemetry: {
+      isEnabled: experimentalTelemetry
+    }
+  });
+  if (usage) {
+    emitModelUsageEvent(runtime, import_core4.ModelType.TEXT_LARGE, prompt, usage);
+  }
+  return openaiResponse;
+}
+// src/models/object.ts
+var import_core6 = require("@elizaos/core");
+var import_ai3 = require("ai");
+
+// src/utils/helpers.ts
+var import_core5 = require("@elizaos/core");
+var import_ai2 = require("ai");
+function getJsonRepairFunction() {
+  return async ({ text, error }) => {
+    try {
+      if (error instanceof import_ai2.JSONParseError) {
+        const cleanedText = text.replace(/```json\n|\n```|```/g, "");
+        JSON.parse(cleanedText);
+        return cleanedText;
+      }
+      return null;
+    } catch (jsonError) {
+      const message = jsonError instanceof Error ? jsonError.message : String(jsonError);
+      import_core5.logger.warn(`Failed to repair JSON text: ${message}`);
+      return null;
+    }
+  };
+}
+async function webStreamToNodeStream(webStream) {
+  try {
+    const { Readable } = await import("node:stream");
+    const reader = webStream.getReader();
+    return new Readable({
+      async read() {
+        try {
+          const { done, value } = await reader.read();
+          if (done) {
+            this.push(null);
+          } else {
+            this.push(value);
+          }
+        } catch (error) {
+          this.destroy(error);
+        }
+      },
+      destroy(error, callback) {
+        reader.cancel().finally(() => callback(error));
+      }
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    import_core5.logger.error(`Failed to load node:stream module: ${message}`);
+    throw new Error(`Cannot convert stream: node:stream module unavailable. This feature requires a Node.js environment.`);
+  }
+}
+function parseImageDescriptionResponse(responseText) {
+  const titleMatch = responseText.match(/title[:\s]+(.+?)(?:\n|$)/i);
+  const title = titleMatch?.[1]?.trim() || "Image Analysis";
+  const description = responseText.replace(/title[:\s]+(.+?)(?:\n|$)/i, "").trim();
+  return { title, description };
+}
+
+// src/models/object.ts
+async function generateObjectByModelType(runtime, params, modelType, getModelFn) {
+  const openai = createOpenAIClient(runtime);
+  const modelName = getModelFn(runtime);
+  import_core6.logger.log(`[ELIZAOS_CLOUD] Using ${modelType} model: ${modelName}`);
+  const temperature = params.temperature ?? 0;
+  const schemaPresent = !!params.schema;
+  if (schemaPresent) {
+    import_core6.logger.info(`Using ${modelType} without schema validation (schema provided but output=no-schema)`);
+  }
+  try {
+    const { object, usage } = await import_ai3.generateObject({
+      model: openai.languageModel(modelName),
+      output: "no-schema",
+      prompt: params.prompt,
+      temperature,
+      experimental_repairText: getJsonRepairFunction()
+    });
+    if (usage) {
+      emitModelUsageEvent(runtime, modelType, params.prompt, usage);
+    }
+    return object;
+  } catch (error) {
+    if (error instanceof import_ai3.JSONParseError) {
+      import_core6.logger.error(`[generateObject] Failed to parse JSON: ${error.message}`);
+      const repairFunction = getJsonRepairFunction();
+      const repairedJsonString = await repairFunction({
+        text: error.text,
+        error
+      });
+      if (repairedJsonString) {
+        try {
+          const repairedObject = JSON.parse(repairedJsonString);
+          import_core6.logger.info("[generateObject] Successfully repaired JSON.");
+          return repairedObject;
+        } catch (repairParseError) {
+          const message = repairParseError instanceof Error ? repairParseError.message : String(repairParseError);
+          import_core6.logger.error(`[generateObject] Failed to parse repaired JSON: ${message}`);
+          throw repairParseError;
+        }
+      } else {
+        import_core6.logger.error("[generateObject] JSON repair failed.");
+        throw error;
+      }
+    } else {
+      const message = error instanceof Error ? error.message : String(error);
+      import_core6.logger.error(`[generateObject] Unknown error: ${message}`);
+      throw error;
+    }
+  }
+}
+async function handleObjectSmall(runtime, params) {
+  return generateObjectByModelType(runtime, params, import_core6.ModelType.OBJECT_SMALL, getSmallModel);
+}
+async function handleObjectLarge(runtime, params) {
+  return generateObjectByModelType(runtime, params, import_core6.ModelType.OBJECT_LARGE, getLargeModel);
+}
+// src/models/embeddings.ts
+var import_core7 = require("@elizaos/core");
+async function handleTextEmbedding(runtime, params) {
+  const embeddingModelName = getSetting(runtime, "ELIZAOS_CLOUD_EMBEDDING_MODEL", "text-embedding-3-small");
+  const embeddingDimension = Number.parseInt(getSetting(runtime, "ELIZAOS_CLOUD_EMBEDDING_DIMENSIONS", "1536") || "1536", 10);
+  if (!Object.values(import_core7.VECTOR_DIMS).includes(embeddingDimension)) {
+    const errorMsg = `Invalid embedding dimension: ${embeddingDimension}. Must be one of: ${Object.values(import_core7.VECTOR_DIMS).join(", ")}`;
+    import_core7.logger.error(errorMsg);
+    throw new Error(errorMsg);
+  }
+  if (params === null) {
+    import_core7.logger.debug("Creating test embedding for initialization");
+    const testVector = Array(embeddingDimension).fill(0);
+    testVector[0] = 0.1;
+    return testVector;
+  }
+  let text;
+  if (typeof params === "string") {
+    text = params;
+  } else if (typeof params === "object" && params.text) {
+    text = params.text;
+  } else {
+    import_core7.logger.warn("Invalid input format for embedding");
+    const fallbackVector = Array(embeddingDimension).fill(0);
+    fallbackVector[0] = 0.2;
+    return fallbackVector;
+  }
+  if (!text.trim()) {
+    import_core7.logger.warn("Empty text for embedding");
+    const emptyVector = Array(embeddingDimension).fill(0);
+    emptyVector[0] = 0.3;
+    return emptyVector;
+  }
+  const embeddingBaseURL = getEmbeddingBaseURL(runtime);
+  try {
+    const response = await fetch(`${embeddingBaseURL}/embeddings`, {
+      method: "POST",
+      headers: {
+        ...getAuthHeader(runtime, true),
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        model: embeddingModelName,
+        input: text
+      })
+    });
+    if (!response.ok) {
+      import_core7.logger.error(`ElizaOS Cloud API error: ${response.status} - ${response.statusText}`);
+      const errorVector = Array(embeddingDimension).fill(0);
+      errorVector[0] = 0.4;
+      return errorVector;
+    }
+    const data = await response.json();
+    if (!data?.data?.[0]?.embedding) {
+      import_core7.logger.error("API returned invalid structure");
+      const errorVector = Array(embeddingDimension).fill(0);
+      errorVector[0] = 0.5;
+      return errorVector;
+    }
+    const embedding = data.data[0].embedding;
+    if (data.usage) {
+      const usage = {
+        inputTokens: data.usage.prompt_tokens,
+        outputTokens: 0,
+        totalTokens: data.usage.total_tokens
+      };
+      emitModelUsageEvent(runtime, import_core7.ModelType.TEXT_EMBEDDING, text, usage);
+    }
+    import_core7.logger.log(`Got valid embedding with length ${embedding.length}`);
+    return embedding;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    import_core7.logger.error(`Error generating embedding: ${message}`);
+    const errorVector = Array(embeddingDimension).fill(0);
+    errorVector[0] = 0.6;
+    return errorVector;
+  }
+}
+// src/models/image.ts
+var import_core8 = require("@elizaos/core");
+async function handleImageGeneration(runtime, params) {
+  const numImages = params.n || 1;
+  const size = params.size || "1024x1024";
+  const prompt = params.prompt;
+  const modelName = "google/gemini-2.5-flash-image-preview";
+  import_core8.logger.log(`[ELIZAOS_CLOUD] Using IMAGE model: ${modelName}`);
+  const baseURL = getBaseURL(runtime);
+  const aspectRatioMap = {
+    "1024x1024": "1:1",
+    "1792x1024": "16:9",
+    "1024x1792": "9:16"
+  };
+  const aspectRatio = aspectRatioMap[size] || "1:1";
+  try {
+    const response = await fetch(`${baseURL}/generate-image`, {
+      method: "POST",
+      headers: {
+        ...getAuthHeader(runtime),
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        prompt,
+        numImages,
+        aspectRatio
+      })
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`Failed to generate image: ${response.status} ${errorText}`);
+    }
+    const data = await response.json();
+    const typedData = data;
+    return typedData.images.map((img) => ({
+      url: img.url || img.image
+    }));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    import_core8.logger.error(`[ELIZAOS_CLOUD] Image generation error: ${message}`);
+    throw error;
+  }
+}
+async function handleImageDescription(runtime, params) {
+  let imageUrl;
+  let promptText;
+  const modelName = getImageDescriptionModel(runtime);
+  import_core8.logger.log(`[ELIZAOS_CLOUD] Using IMAGE_DESCRIPTION model: ${modelName}`);
+  const maxTokens = Number.parseInt(getSetting(runtime, "ELIZAOS_CLOUD_IMAGE_DESCRIPTION_MAX_TOKENS", "8192") || "8192", 10);
+  if (typeof params === "string") {
+    imageUrl = params;
+    promptText = "Please analyze this image and provide a title and detailed description.";
+  } else {
+    imageUrl = params.imageUrl;
+    promptText = params.prompt || "Please analyze this image and provide a title and detailed description.";
+  }
+  const messages = [
+    {
+      role: "user",
+      content: [
+        { type: "text", text: promptText },
+        { type: "image_url", image_url: { url: imageUrl } }
+      ]
+    }
+  ];
+  const baseURL = getBaseURL(runtime);
+  try {
+    const requestBody = {
+      model: modelName,
+      messages,
+      max_tokens: maxTokens
+    };
+    const response = await fetch(`${baseURL}/chat/completions`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...getAuthHeader(runtime)
+      },
+      body: JSON.stringify(requestBody)
+    });
+    if (!response.ok) {
+      throw new Error(`ElizaOS Cloud API error: ${response.status}`);
+    }
+    const result = await response.json();
+    const typedResult = result;
+    const content = typedResult.choices?.[0]?.message?.content;
+    if (typedResult.usage) {
+      emitModelUsageEvent(runtime, import_core8.ModelType.IMAGE_DESCRIPTION, typeof params === "string" ? params : params.prompt || "", {
+        inputTokens: typedResult.usage.prompt_tokens,
+        outputTokens: typedResult.usage.completion_tokens,
+        totalTokens: typedResult.usage.total_tokens
+      });
+    }
+    if (!content) {
+      return {
+        title: "Failed to analyze image",
+        description: "No response from API"
+      };
+    }
+    const isCustomPrompt = typeof params === "object" && params.prompt && params.prompt !== "Please analyze this image and provide a title and detailed description.";
+    if (isCustomPrompt) {
+      return content;
+    }
+    const processedResult = parseImageDescriptionResponse(content);
+    return processedResult;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    import_core8.logger.error(`Error analyzing image: ${message}`);
+    return {
+      title: "Failed to analyze image",
+      description: `Error: ${message}`
+    };
+  }
+}
+// src/models/speech.ts
+var import_core9 = require("@elizaos/core");
+async function fetchTextToSpeech(runtime, options) {
+  const defaultModel = getSetting(runtime, "ELIZAOS_CLOUD_TTS_MODEL", "gpt-4o-mini-tts");
+  const defaultVoice = getSetting(runtime, "ELIZAOS_CLOUD_TTS_VOICE", "nova");
+  const defaultInstructions = getSetting(runtime, "ELIZAOS_CLOUD_TTS_INSTRUCTIONS", "");
+  const baseURL = getBaseURL(runtime);
+  const model = options.model || defaultModel;
+  const voice = options.voice || defaultVoice;
+  const instructions = options.instructions ?? defaultInstructions;
+  const format = options.format || "mp3";
+  try {
+    const res = await fetch(`${baseURL}/audio/speech`, {
+      method: "POST",
+      headers: {
+        ...getAuthHeader(runtime),
+        "Content-Type": "application/json",
+        ...format === "mp3" ? { Accept: "audio/mpeg" } : {}
+      },
+      body: JSON.stringify({
+        model,
+        voice,
+        input: options.text,
+        format,
+        ...instructions && { instructions }
+      })
+    });
+    if (!res.ok) {
+      const err = await res.text();
+      throw new Error(`ElizaOS Cloud TTS error ${res.status}: ${err}`);
+    }
+    if (!res.body) {
+      throw new Error("ElizaOS Cloud TTS response body is null");
+    }
+    if (!isBrowser()) {
+      return await webStreamToNodeStream(res.body);
+    }
+    return res.body;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(`Failed to fetch speech from ElizaOS Cloud TTS: ${message}`);
+  }
+}
+// src/index.ts
+var elizaOSCloudPlugin = {
+  name: "elizaOSCloud",
+  description: "ElizaOS Cloud plugin - Multi-model AI generation with text, image, and video support",
+  config: {
+    ELIZAOS_CLOUD_API_KEY: process.env.ELIZAOS_CLOUD_API_KEY,
+    ELIZAOS_CLOUD_BASE_URL: process.env.ELIZAOS_CLOUD_BASE_URL,
+    ELIZAOS_CLOUD_SMALL_MODEL: process.env.ELIZAOS_CLOUD_SMALL_MODEL,
+    ELIZAOS_CLOUD_LARGE_MODEL: process.env.ELIZAOS_CLOUD_LARGE_MODEL,
+    SMALL_MODEL: process.env.SMALL_MODEL,
+    LARGE_MODEL: process.env.LARGE_MODEL,
+    ELIZAOS_CLOUD_EMBEDDING_MODEL: process.env.ELIZAOS_CLOUD_EMBEDDING_MODEL,
+    ELIZAOS_CLOUD_EMBEDDING_API_KEY: process.env.ELIZAOS_CLOUD_EMBEDDING_API_KEY,
+    ELIZAOS_CLOUD_EMBEDDING_URL: process.env.ELIZAOS_CLOUD_EMBEDDING_URL,
+    ELIZAOS_CLOUD_EMBEDDING_DIMENSIONS: process.env.ELIZAOS_CLOUD_EMBEDDING_DIMENSIONS,
+    ELIZAOS_CLOUD_IMAGE_DESCRIPTION_MODEL: process.env.ELIZAOS_CLOUD_IMAGE_DESCRIPTION_MODEL,
+    ELIZAOS_CLOUD_IMAGE_DESCRIPTION_MAX_TOKENS: process.env.ELIZAOS_CLOUD_IMAGE_DESCRIPTION_MAX_TOKENS,
+    ELIZAOS_CLOUD_EXPERIMENTAL_TELEMETRY: process.env.ELIZAOS_CLOUD_EXPERIMENTAL_TELEMETRY
+  },
+  async init(config, runtime) {
+    initializeOpenAI(config, runtime);
+  },
+  models: {
+    [import_core10.ModelType.TEXT_EMBEDDING]: handleTextEmbedding,
+    [import_core10.ModelType.TEXT_SMALL]: handleTextSmall,
+    [import_core10.ModelType.TEXT_LARGE]: handleTextLarge,
+    [import_core10.ModelType.IMAGE]: handleImageGeneration,
+    [import_core10.ModelType.IMAGE_DESCRIPTION]: handleImageDescription,
+    [import_core10.ModelType.OBJECT_SMALL]: handleObjectSmall,
+    [import_core10.ModelType.OBJECT_LARGE]: handleObjectLarge
+  },
+  tests: [
+    {
+      name: "ELIZAOS_CLOUD_plugin_tests",
+      tests: [
+        {
+          name: "ELIZAOS_CLOUD_test_url_and_api_key_validation",
+          fn: async (runtime) => {
+            const baseURL = getBaseURL(runtime);
+            const response = await fetch(`${baseURL}/models`, {
+              headers: {
+                Authorization: `Bearer ${getApiKey(runtime)}`
+              }
+            });
+            const data = await response.json();
+            import_core10.logger.log({ data: data?.data?.length ?? "N/A" }, "Models Available");
+            if (!response.ok) {
+              throw new Error(`Failed to validate OpenAI API key: ${response.statusText}`);
+            }
+          }
+        },
+        {
+          name: "ELIZAOS_CLOUD_test_text_embedding",
+          fn: async (runtime) => {
+            try {
+              const embedding = await runtime.useModel(import_core10.ModelType.TEXT_EMBEDDING, {
+                text: "Hello, world!"
+              });
+              import_core10.logger.log({ embedding }, "embedding");
+            } catch (error) {
+              const message = error instanceof Error ? error.message : String(error);
+              import_core10.logger.error(`Error in test_text_embedding: ${message}`);
+              throw error;
+            }
+          }
+        },
+        {
+          name: "ELIZAOS_CLOUD_test_text_large",
+          fn: async (runtime) => {
+            try {
+              const text = await runtime.useModel(import_core10.ModelType.TEXT_LARGE, {
+                prompt: "What is the nature of reality in 10 words?"
+              });
+              if (text.length === 0) {
+                throw new Error("Failed to generate text");
+              }
+              import_core10.logger.log({ text }, "generated with test_text_large");
+            } catch (error) {
+              const message = error instanceof Error ? error.message : String(error);
+              import_core10.logger.error(`Error in test_text_large: ${message}`);
+              throw error;
+            }
+          }
+        },
+        {
+          name: "ELIZAOS_CLOUD_test_text_small",
+          fn: async (runtime) => {
+            try {
+              const text = await runtime.useModel(import_core10.ModelType.TEXT_SMALL, {
+                prompt: "What is the nature of reality in 10 words?"
+              });
+              if (text.length === 0) {
+                throw new Error("Failed to generate text");
+              }
+              import_core10.logger.log({ text }, "generated with test_text_small");
+            } catch (error) {
+              const message = error instanceof Error ? error.message : String(error);
+              import_core10.logger.error(`Error in test_text_small: ${message}`);
+              throw error;
+            }
+          }
+        },
+        {
+          name: "ELIZAOS_CLOUD_test_image_generation",
+          fn: async (runtime) => {
+            import_core10.logger.log("ELIZAOS_CLOUD_test_image_generation");
+            try {
+              const image = await runtime.useModel(import_core10.ModelType.IMAGE, {
+                prompt: "A beautiful sunset over a calm ocean",
+                n: 1,
+                size: "1024x1024"
+              });
+              import_core10.logger.log({ image }, "generated with test_image_generation");
+            } catch (error) {
+              const message = error instanceof Error ? error.message : String(error);
+              import_core10.logger.error(`Error in test_image_generation: ${message}`);
+              throw error;
+            }
+          }
+        },
+        {
+          name: "image-description",
+          fn: async (runtime) => {
+            try {
+              import_core10.logger.log("ELIZAOS_CLOUD_test_image_description");
+              try {
+                const result = await runtime.useModel(import_core10.ModelType.IMAGE_DESCRIPTION, "https://upload.wikimedia.org/wikipedia/commons/thumb/1/1c/Vitalik_Buterin_TechCrunch_London_2015_%28cropped%29.jpg/537px-Vitalik_Buterin_TechCrunch_London_2015_%28cropped%29.jpg");
+                if (result && typeof result === "object" && "title" in result && "description" in result) {
+                  import_core10.logger.log({ result }, "Image description");
+                } else {
+                  import_core10.logger.error("Invalid image description result format:", result);
+                }
+              } catch (e) {
+                const message = e instanceof Error ? e.message : String(e);
+                import_core10.logger.error(`Error in image description test: ${message}`);
+              }
+            } catch (e) {
+              const message = e instanceof Error ? e.message : String(e);
+              import_core10.logger.error(`Error in ELIZAOS_CLOUD_test_image_description: ${message}`);
+            }
+          }
+        },
+        {
+          name: "ELIZAOS_CLOUD_test_transcription",
+          fn: async (runtime) => {
+            import_core10.logger.log("ELIZAOS_CLOUD_test_transcription");
+            try {
+              const response = await fetch("https://upload.wikimedia.org/wikipedia/en/4/40/Chris_Benoit_Voice_Message.ogg");
+              const arrayBuffer = await response.arrayBuffer();
+              const transcription = await runtime.useModel(import_core10.ModelType.TRANSCRIPTION, Buffer.from(new Uint8Array(arrayBuffer)));
+              import_core10.logger.log({ transcription }, "generated with test_transcription");
+            } catch (error) {
+              const message = error instanceof Error ? error.message : String(error);
+              import_core10.logger.error(`Error in test_transcription: ${message}`);
+              throw error;
+            }
+          }
+        },
+        {
+          name: "ELIZAOS_CLOUD_test_text_tokenizer_encode",
+          fn: async (runtime) => {
+            const prompt = "Hello tokenizer encode!";
+            const tokens = await runtime.useModel(import_core10.ModelType.TEXT_TOKENIZER_ENCODE, { prompt });
+            if (!Array.isArray(tokens) || tokens.length === 0) {
+              throw new Error("Failed to tokenize text: expected non-empty array of tokens");
+            }
+            import_core10.logger.log({ tokens }, "Tokenized output");
+          }
+        },
+        {
+          name: "ELIZAOS_CLOUD_test_text_tokenizer_decode",
+          fn: async (runtime) => {
+            const prompt = "Hello tokenizer decode!";
+            const tokens = await runtime.useModel(import_core10.ModelType.TEXT_TOKENIZER_ENCODE, { prompt });
+            const decodedText = await runtime.useModel(import_core10.ModelType.TEXT_TOKENIZER_DECODE, { tokens });
+            if (decodedText !== prompt) {
+              throw new Error(`Decoded text does not match original. Expected "${prompt}", got "${decodedText}"`);
+            }
+            import_core10.logger.log({ decodedText }, "Decoded text");
+          }
+        },
+        {
+          name: "ELIZAOS_CLOUD_test_text_to_speech",
+          fn: async (runtime) => {
+            try {
+              const response = await fetchTextToSpeech(runtime, {
+                text: "Hello, this is a test for text-to-speech."
+              });
+              if (!response) {
+                throw new Error("Failed to generate speech");
+              }
+              import_core10.logger.log("Generated speech successfully");
+            } catch (error) {
+              const message = error instanceof Error ? error.message : String(error);
+              import_core10.logger.error(`Error in ELIZAOS_CLOUD_test_text_to_speech: ${message}`);
+              throw error;
+            }
+          }
+        }
+      ]
+    }
+  ]
+};
+var src_default = elizaOSCloudPlugin;
+
+//# debugId=62AC16B013B01D9364756E2164756E21