@elizaos/plugin-elizacloud 2.0.0-alpha.4 → 2.0.0-alpha.537

package/dist/node/index.node.js

@@ -2,13 +2,14 @@ import { createRequire } from "node:module";
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // index.ts
-import { logger as logger16, ModelType as ModelType5 } from "@elizaos/core";
+import { logger as logger19, ModelType as ModelType6 } from "@elizaos/core";
 
 // actions/check-credits.ts
 var DAILY_COST_PER_CONTAINER = 0.67;
 var checkCloudCreditsAction = {
   name: "CHECK_CLOUD_CREDITS",
   description: "Check ElizaCloud credit balance, container costs, and estimated remaining runtime.",
+  descriptionCompressed: "Check ElizaCloud credits, container costs, remaining runtime.",
   similes: ["check credits", "check balance", "how much credit", "cloud billing"],
   tags: ["cloud", "billing"],
   parameters: [
@@ -19,8 +20,29 @@ var checkCloudCreditsAction = {
       schema: { type: "boolean" }
     }
   ],
-  async validate(runtime) {
-    return !!runtime.getService("CLOUD_AUTH")?.isAuthenticated();
+  validate: async (runtime, message, state, options) => {
+    const __avTextRaw = typeof message?.content?.text === "string" ? message.content.text : "";
+    const __avText = __avTextRaw.toLowerCase();
+    const __avKeywords = ["check", "cloud", "credits"];
+    const __avKeywordOk = __avKeywords.length > 0 && __avKeywords.some((kw) => kw.length > 0 && __avText.includes(kw));
+    const __avRegex = /\b(?:check|cloud|credits)\b/i;
+    const __avRegexOk = Boolean(__avText.match(__avRegex));
+    const __avSource = String(message?.content?.source ?? "");
+    const __avExpectedSource = "";
+    const __avSourceOk = __avExpectedSource ? __avSource === __avExpectedSource : Boolean(__avSource || state || runtime?.agentId || runtime?.getService);
+    const __avOptions = options && typeof options === "object" ? options : {};
+    const __avInputOk = __avText.trim().length > 0 || Object.keys(__avOptions).length > 0 || Boolean(message?.content && typeof message.content === "object");
+    if (!(__avKeywordOk && __avRegexOk && __avSourceOk && __avInputOk)) {
+      return false;
+    }
+    const __avLegacyValidate = async (runtime2) => {
+      return !!runtime2.getService("CLOUD_AUTH")?.isAuthenticated();
+    };
+    try {
+      return Boolean(await __avLegacyValidate(runtime));
+    } catch {
+      return false;
+    }
   },
   async handler(runtime, message, _state, options, callback) {
     const auth = runtime.getService("CLOUD_AUTH");
@@ -62,16 +84,36 @@ var checkCloudCreditsAction = {
   }
 };
 
+// actions/confirmation.ts
+function mergedOptions(options) {
+  const direct = options ?? {};
+  const parameters = direct.parameters && typeof direct.parameters === "object" ? direct.parameters : {};
+  return { ...direct, ...parameters };
+}
+function isConfirmed(options) {
+  const raw = mergedOptions(options).confirmed;
+  return raw === true || raw === "true";
+}
+function confirmationRequired(preview, data) {
+  return {
+    success: false,
+    text: preview,
+    data: { requiresConfirmation: true, preview, ...data }
+  };
+}
+
 // actions/freeze-agent.ts
 function getContainerId(message, options) {
-  if (options?.containerId)
-    return String(options.containerId);
+  const params = mergedOptions(options);
+  if (params.containerId)
+    return String(params.containerId);
   const meta = message.metadata?.actionParams;
   return meta?.containerId ? String(meta.containerId) : null;
 }
 var freezeCloudAgentAction = {
   name: "FREEZE_CLOUD_AGENT",
   description: "Freeze a cloud agent: snapshot state, disconnect bridge, stop container.",
+  descriptionCompressed: "Freeze cloud agent: snapshot, disconnect, stop container.",
   similes: ["freeze agent", "hibernate agent", "pause agent", "stop cloud agent"],
   tags: ["cloud", "container", "backup"],
   parameters: [
@@ -80,10 +122,37 @@ var freezeCloudAgentAction = {
       description: "ID of the container to freeze",
       required: true,
       schema: { type: "string" }
+    },
+    {
+      name: "confirmed",
+      description: "Must be true to freeze the cloud agent after preview.",
+      required: false,
+      schema: { type: "boolean", default: false }
     }
   ],
-  async validate(runtime) {
-    return !!runtime.getService("CLOUD_AUTH")?.isAuthenticated();
+  validate: async (runtime, message, state, options) => {
+    const __avTextRaw = typeof message?.content?.text === "string" ? message.content.text : "";
+    const __avText = __avTextRaw.toLowerCase();
+    const __avKeywords = ["freeze", "cloud"];
+    const __avKeywordOk = __avKeywords.length > 0 && __avKeywords.some((kw) => kw.length > 0 && __avText.includes(kw));
+    const __avRegex = /\b(?:freeze|cloud)\b/i;
+    const __avRegexOk = Boolean(__avText.match(__avRegex));
+    const __avSource = String(message?.content?.source ?? "");
+    const __avExpectedSource = "";
+    const __avSourceOk = __avExpectedSource ? __avSource === __avExpectedSource : Boolean(__avSource || state || runtime?.agentId || runtime?.getService);
+    const __avOptions = options && typeof options === "object" ? options : {};
+    const __avInputOk = __avText.trim().length > 0 || Object.keys(__avOptions).length > 0 || Boolean(message?.content && typeof message.content === "object");
+    if (!(__avKeywordOk && __avRegexOk && __avSourceOk && __avInputOk)) {
+      return false;
+    }
+    const __avLegacyValidate = async (runtime2) => {
+      return !!runtime2.getService("CLOUD_AUTH")?.isAuthenticated();
+    };
+    try {
+      return Boolean(await __avLegacyValidate(runtime));
+    } catch {
+      return false;
+    }
   },
   async handler(runtime, message, _state, options, callback) {
     const containers = runtime.getService("CLOUD_CONTAINER");
@@ -99,6 +168,20 @@ var freezeCloudAgentAction = {
         error: `Container not running (status: ${container.status})`
       };
     }
+    const preview = [
+      "Confirmation required before freezing Eliza Cloud agent:",
+      `Container: ${container.name}`,
+      `ID: ${containerId}`,
+      "Effects: create snapshot, disconnect bridge, stop container."
+    ].join(`
+`);
+    if (!isConfirmed(options)) {
+      await callback?.({ text: preview, actions: ["FREEZE_CLOUD_AGENT"] });
+      return confirmationRequired(preview, {
+        containerId,
+        containerName: container.name
+      });
+    }
     const notify = async (text) => {
       if (callback)
         await callback({ text, actions: ["FREEZE_CLOUD_AGENT"] });
@@ -129,6 +212,10 @@ var freezeCloudAgentAction = {
 import { logger } from "@elizaos/core";
 
 // types/cloud.ts
+import {
+  CloudApiError,
+  InsufficientCreditsError
+} from "@elizaos/cloud-sdk";
 var DEFAULT_CLOUD_CONFIG = {
   enabled: false,
   baseUrl: "https://www.elizacloud.ai/api/v1",
@@ -152,36 +239,32 @@ var DEFAULT_CLOUD_CONFIG = {
   }
 };
 
-class CloudApiError extends Error {
-  statusCode;
-  errorBody;
-  constructor(statusCode, body) {
-    super(body.error);
-    this.name = "CloudApiError";
-    this.statusCode = statusCode;
-    this.errorBody = body;
-  }
-}
-
-class InsufficientCreditsError extends CloudApiError {
-  requiredCredits;
-  constructor(body) {
-    super(402, body);
-    this.name = "InsufficientCreditsError";
-    this.requiredCredits = body.requiredCredits ?? 0;
-  }
-}
-
 // utils/forwarded-settings.ts
 var FORWARDED_SETTINGS = [
   "OPENAI_API_KEY",
   "ANTHROPIC_API_KEY",
   "GROQ_API_KEY",
   "ELIZAOS_CLOUD_API_KEY",
+  "NANO_MODEL",
+  "MEDIUM_MODEL",
   "SMALL_MODEL",
   "LARGE_MODEL",
+  "MEGA_MODEL",
+  "RESPONSE_HANDLER_MODEL",
+  "ACTION_PLANNER_MODEL",
+  "SHOULD_RESPOND_MODEL",
+  "PLANNER_MODEL",
+  "RESPONSE_MODEL",
   "ELIZAOS_CLOUD_SMALL_MODEL",
-  "ELIZAOS_CLOUD_LARGE_MODEL"
+  "ELIZAOS_CLOUD_NANO_MODEL",
+  "ELIZAOS_CLOUD_MEDIUM_MODEL",
+  "ELIZAOS_CLOUD_LARGE_MODEL",
+  "ELIZAOS_CLOUD_MEGA_MODEL",
+  "ELIZAOS_CLOUD_RESPONSE_HANDLER_MODEL",
+  "ELIZAOS_CLOUD_ACTION_PLANNER_MODEL",
+  "ELIZAOS_CLOUD_SHOULD_RESPOND_MODEL",
+  "ELIZAOS_CLOUD_PLANNER_MODEL",
+  "ELIZAOS_CLOUD_RESPONSE_MODEL"
 ];
 function collectEnvVars(runtime) {
   const vars = {};
@@ -195,8 +278,9 @@ function collectEnvVars(runtime) {
 
 // actions/provision-agent.ts
 function extractParams(message, options) {
-  if (options && Object.keys(options).length > 0)
-    return options;
+  const params = mergedOptions(options);
+  if (Object.keys(params).length > 0)
+    return params;
   const meta = message.metadata;
   if (meta?.actionParams)
     return meta.actionParams;
@@ -208,6 +292,7 @@ function extractParams(message, options) {
 var provisionCloudAgentAction = {
   name: "PROVISION_CLOUD_AGENT",
   description: "Deploy an ElizaOS agent to ElizaCloud. Provisions a container, waits for deployment, connects the bridge, and starts auto-backup.",
+  descriptionCompressed: "Deploy agent to ElizaCloud. Provisions container, connects bridge, starts backup.",
   similes: [
     "deploy agent to cloud",
     "launch cloud agent",
@@ -245,11 +330,38 @@ var provisionCloudAgentAction = {
       description: "Enable periodic auto-backup (default: true)",
       required: false,
       schema: { type: "boolean" }
+    },
+    {
+      name: "confirmed",
+      description: "Must be true to provision the cloud agent after preview.",
+      required: false,
+      schema: { type: "boolean", default: false }
     }
   ],
-  async validate(runtime) {
-    const auth = runtime.getService("CLOUD_AUTH");
-    return !!auth?.isAuthenticated();
+  validate: async (runtime, message, state, options) => {
+    const __avTextRaw = typeof message?.content?.text === "string" ? message.content.text : "";
+    const __avText = __avTextRaw.toLowerCase();
+    const __avKeywords = ["provision", "cloud"];
+    const __avKeywordOk = __avKeywords.length > 0 && __avKeywords.some((kw) => kw.length > 0 && __avText.includes(kw));
+    const __avRegex = /\b(?:provision|cloud)\b/i;
+    const __avRegexOk = Boolean(__avText.match(__avRegex));
+    const __avSource = String(message?.content?.source ?? "");
+    const __avExpectedSource = "";
+    const __avSourceOk = __avExpectedSource ? __avSource === __avExpectedSource : Boolean(__avSource || state || runtime?.agentId || runtime?.getService);
+    const __avOptions = options && typeof options === "object" ? options : {};
+    const __avInputOk = __avText.trim().length > 0 || Object.keys(__avOptions).length > 0 || Boolean(message?.content && typeof message.content === "object");
+    if (!(__avKeywordOk && __avRegexOk && __avSourceOk && __avInputOk)) {
+      return false;
+    }
+    const __avLegacyValidate = async (runtime2) => {
+      const auth = runtime2.getService("CLOUD_AUTH");
+      return !!auth?.isAuthenticated();
+    };
+    try {
+      return Boolean(await __avLegacyValidate(runtime));
+    } catch {
+      return false;
+    }
   },
   async handler(runtime, message, _state, options, callback) {
     const auth = runtime.getService("CLOUD_AUTH");
@@ -269,6 +381,22 @@ var provisionCloudAgentAction = {
         error: "Missing required parameters: name and project_name"
       };
     }
+    const autoBackup = params.auto_backup !== false;
+    const preview = [
+      "Confirmation required before provisioning Eliza Cloud agent:",
+      `Name: ${String(params.name)}`,
+      `Project: ${String(params.project_name)}`,
+      `Auto-backup: ${autoBackup ? "enabled" : "disabled"}`
+    ].join(`
+`);
+    if (!isConfirmed(options)) {
+      await callback?.({ text: preview, actions: ["PROVISION_CLOUD_AGENT"] });
+      return confirmationRequired(preview, {
+        name: String(params.name),
+        project_name: String(params.project_name),
+        auto_backup: autoBackup
+      });
+    }
     const notify = async (text) => {
       if (callback)
         await callback({ text, actions: ["PROVISION_CLOUD_AGENT"] });
@@ -299,7 +427,6 @@ var provisionCloudAgentAction = {
       await bridge.connect(id);
       logger.info(`[PROVISION] Bridge connected to ${id}`);
     }
-    const autoBackup = params.auto_backup !== false;
     if (autoBackup && backup)
       backup.scheduleAutoBackup(id);
     await notify(`Agent "${params.name}" deployed.${autoBackup ? " Auto-backup enabled." : ""}`);
@@ -321,8 +448,9 @@ var provisionCloudAgentAction = {
 
 // actions/resume-agent.ts
 function extractParams2(message, options) {
-  if (options && Object.keys(options).length > 0)
-    return options;
+  const params = mergedOptions(options);
+  if (Object.keys(params).length > 0)
+    return params;
   const meta = message.metadata;
   return meta?.actionParams ?? {};
 }
@@ -339,6 +467,7 @@ async function findLatestProjectSnapshot(backup, containers, projectName) {
 var resumeCloudAgentAction = {
   name: "RESUME_CLOUD_AGENT",
   description: "Resume a frozen cloud agent from snapshot. Re-provisions, restores state, reconnects bridge.",
+  descriptionCompressed: "Resume frozen cloud agent from snapshot.",
   similes: ["resume agent", "unfreeze agent", "restart cloud agent", "restore agent"],
   tags: ["cloud", "container", "restore"],
   parameters: [
@@ -365,10 +494,37 @@ var resumeCloudAgentAction = {
       description: "Additional environment variables",
       required: false,
       schema: { type: "object" }
+    },
+    {
+      name: "confirmed",
+      description: "Must be true to resume the cloud agent after preview.",
+      required: false,
+      schema: { type: "boolean", default: false }
     }
   ],
-  async validate(runtime) {
-    return !!runtime.getService("CLOUD_AUTH")?.isAuthenticated();
+  validate: async (runtime, message, state, options) => {
+    const __avTextRaw = typeof message?.content?.text === "string" ? message.content.text : "";
+    const __avText = __avTextRaw.toLowerCase();
+    const __avKeywords = ["resume", "cloud"];
+    const __avKeywordOk = __avKeywords.length > 0 && __avKeywords.some((kw) => kw.length > 0 && __avText.includes(kw));
+    const __avRegex = /\b(?:resume|cloud)\b/i;
+    const __avRegexOk = Boolean(__avText.match(__avRegex));
+    const __avSource = String(message?.content?.source ?? "");
+    const __avExpectedSource = "";
+    const __avSourceOk = __avExpectedSource ? __avSource === __avExpectedSource : Boolean(__avSource || state || runtime?.agentId || runtime?.getService);
+    const __avOptions = options && typeof options === "object" ? options : {};
+    const __avInputOk = __avText.trim().length > 0 || Object.keys(__avOptions).length > 0 || Boolean(message?.content && typeof message.content === "object");
+    if (!(__avKeywordOk && __avRegexOk && __avSourceOk && __avInputOk)) {
+      return false;
+    }
+    const __avLegacyValidate = async (runtime2) => {
+      return !!runtime2.getService("CLOUD_AUTH")?.isAuthenticated();
+    };
+    try {
+      return Boolean(await __avLegacyValidate(runtime));
+    } catch {
+      return false;
+    }
   },
   async handler(runtime, message, _state, options, callback) {
     const containerSvc = runtime.getService("CLOUD_CONTAINER");
@@ -381,6 +537,22 @@ var resumeCloudAgentAction = {
         error: "Missing required parameters: name and project_name"
       };
     }
+    const explicitSnapshot = typeof params.snapshotId === "string" && params.snapshotId.length > 0 ? params.snapshotId : null;
+    const preview = [
+      "Confirmation required before resuming Eliza Cloud agent:",
+      `Name: ${String(params.name)}`,
+      `Project: ${String(params.project_name)}`,
+      `Snapshot: ${explicitSnapshot ?? "latest available"}`
+    ].join(`
+`);
+    if (!isConfirmed(options)) {
+      await callback?.({ text: preview, actions: ["RESUME_CLOUD_AGENT"] });
+      return confirmationRequired(preview, {
+        name: String(params.name),
+        project_name: String(params.project_name),
+        snapshotId: explicitSnapshot
+      });
+    }
     const notify = async (text) => {
       if (callback)
         await callback({ text, actions: ["RESUME_CLOUD_AGENT"] });
@@ -407,7 +579,7 @@ var resumeCloudAgentAction = {
     const running = await containerSvc.waitForDeployment(id);
     let restoredId = null;
     if (backup) {
-      const explicit = params.snapshotId;
+      const explicit = explicitSnapshot ?? undefined;
       if (explicit) {
         await backup.restoreSnapshot(id, explicit);
         restoredId = explicit;
@@ -441,6 +613,7 @@ var resumeCloudAgentAction = {
 var cloudStatusProvider = {
   name: "elizacloud_status",
   description: "ElizaCloud container and connection status",
+  descriptionCompressed: "ElizaCloud container/connection status.",
   dynamic: true,
   position: 90,
   async get(runtime, _message, _state) {
@@ -487,6 +660,7 @@ var cloudStatusProvider = {
 var containerHealthProvider = {
   name: "elizacloud_health",
   description: "ElizaCloud container health",
+  descriptionCompressed: "ElizaCloud container health.",
   dynamic: true,
   position: 92,
   private: true,
@@ -527,24 +701,36 @@ var containerHealthProvider = {
 
 // cloud-providers/credit-balance.ts
 import { logger as logger2 } from "@elizaos/core";
-var cache = null;
+var TOP_UP_URL = "https://www.elizacloud.ai/dashboard/settings?tab=billing";
+var creditCaches = new WeakMap;
 var TTL = 60000;
 var creditBalanceProvider = {
   name: "elizacloud_credits",
   description: "ElizaCloud credit balance",
+  descriptionCompressed: "ElizaCloud credit balance.",
   dynamic: true,
   position: 91,
   async get(runtime, _message, _state) {
     const auth = runtime.getService("CLOUD_AUTH");
     if (!auth?.isAuthenticated())
       return { text: "" };
-    if (cache && Date.now() - cache.at < TTL)
-      return format(cache.value);
-    const { data } = await auth.getClient().get("/credits/balance");
-    cache = { value: data.balance, at: Date.now() };
-    if (data.balance < 1)
-      logger2.warn(`[CloudCredits] Low balance: $${data.balance.toFixed(2)}`);
-    return format(data.balance);
+    const cached = creditCaches.get(runtime);
+    if (cached && Date.now() - cached.at < TTL)
+      return format(cached.value);
+    let balance;
+    try {
+      const { data } = await auth.getClient().get("/credits/balance");
+      balance = data.balance;
+    } catch (err) {
+      logger2.warn(`[CloudCredits] Failed to fetch balance: ${err instanceof Error ? err.message : err}`);
+      if (cached)
+        return format(cached.value);
+      return { text: "" };
+    }
+    creditCaches.set(runtime, { value: balance, at: Date.now() });
+    if (balance < 1)
+      logger2.warn(`[CloudCredits] Low balance: $${balance.toFixed(2)}`);
+    return format(balance);
   }
 };
 function format(balance) {
@@ -552,15 +738,53 @@ function format(balance) {
   const critical = balance < 0.5;
   let text = `ElizaCloud credits: $${balance.toFixed(2)}`;
   if (critical)
-    text += " (CRITICAL)";
+    text += ` (CRITICAL — top up at ${TOP_UP_URL})`;
   else if (low)
-    text += " (LOW)";
+    text += ` (LOW — top up at ${TOP_UP_URL})`;
   return {
     text,
     values: {
       cloudCredits: balance,
       cloudCreditsLow: low,
-      cloudCreditsCritical: critical
+      cloudCreditsCritical: critical,
+      cloudTopUpUrl: TOP_UP_URL
+    }
+  };
+}
+
+// cloud-providers/model-registry.ts
+var TTL2 = 300000;
+var runtimeCaches = new WeakMap;
+var modelRegistryProvider = {
+  name: "elizacloud_models",
+  description: "Available AI models from ElizaCloud grouped by provider",
+  descriptionCompressed: "Available AI models from ElizaCloud by provider.",
+  dynamic: true,
+  position: 92,
+  async get(runtime, _message, _state) {
+    const registry = runtime.getService("CLOUD_MODEL_REGISTRY");
+    if (!registry)
+      return { text: "" };
+    const cached = runtimeCaches.get(runtime);
+    if (cached && Date.now() - cached.at < TTL2) {
+      return formatModels(cached.value);
+    }
+    const byProvider = await registry.getModelsByProvider();
+    if (Object.keys(byProvider).length === 0) {
+      return { text: "" };
+    }
+    runtimeCaches.set(runtime, { value: byProvider, at: Date.now() });
+    return formatModels(byProvider);
+  }
+};
+function formatModels(byProvider) {
+  const providers = Object.keys(byProvider).sort();
+  const total = Object.values(byProvider).reduce((n, m) => n + m.length, 0);
+  return {
+    text: `ElizaCloud: ${total} models (${providers.join(", ")})`,
+    values: {
+      cloudModelProviders: providers.join(","),
+      cloudModelCount: total
     }
   };
 }
@@ -590,12 +814,6 @@ function isBrowser() {
 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");
@@ -623,22 +841,67 @@ function getEmbeddingApiKey(runtime) {
   return getApiKey(runtime);
 }
 function getSmallModel(runtime) {
-  return getSetting(runtime, "ELIZAOS_CLOUD_SMALL_MODEL") ?? getSetting(runtime, "SMALL_MODEL", "gpt-5-mini");
+  return getSetting(runtime, "ELIZAOS_CLOUD_SMALL_MODEL") ?? getSetting(runtime, "SMALL_MODEL", "openai/gpt-5.4-mini");
+}
+function getNanoModel(runtime) {
+  return getSetting(runtime, "ELIZAOS_CLOUD_NANO_MODEL") ?? getSetting(runtime, "NANO_MODEL") ?? getSmallModel(runtime);
+}
+function getMediumModel(runtime) {
+  return getSetting(runtime, "ELIZAOS_CLOUD_MEDIUM_MODEL") ?? getSetting(runtime, "MEDIUM_MODEL") ?? getSmallModel(runtime);
 }
 function getLargeModel(runtime) {
-  return getSetting(runtime, "ELIZAOS_CLOUD_LARGE_MODEL") ?? getSetting(runtime, "LARGE_MODEL", "gpt-5");
+  return getSetting(runtime, "ELIZAOS_CLOUD_LARGE_MODEL") ?? getSetting(runtime, "LARGE_MODEL", "anthropic/claude-sonnet-4.6");
+}
+function getMegaModel(runtime) {
+  return getSetting(runtime, "ELIZAOS_CLOUD_MEGA_MODEL") ?? getSetting(runtime, "MEGA_MODEL") ?? getLargeModel(runtime);
+}
+function getResponseHandlerModel(runtime) {
+  return getSetting(runtime, "ELIZAOS_CLOUD_RESPONSE_HANDLER_MODEL") ?? getSetting(runtime, "ELIZAOS_CLOUD_SHOULD_RESPOND_MODEL") ?? getSetting(runtime, "RESPONSE_HANDLER_MODEL") ?? getSetting(runtime, "SHOULD_RESPOND_MODEL") ?? getNanoModel(runtime);
+}
+function getActionPlannerModel(runtime) {
+  return getSetting(runtime, "ELIZAOS_CLOUD_ACTION_PLANNER_MODEL") ?? getSetting(runtime, "ELIZAOS_CLOUD_PLANNER_MODEL") ?? getSetting(runtime, "ACTION_PLANNER_MODEL") ?? getSetting(runtime, "PLANNER_MODEL") ?? getMediumModel(runtime);
 }
 function getImageDescriptionModel(runtime) {
-  return getSetting(runtime, "ELIZAOS_CLOUD_IMAGE_DESCRIPTION_MODEL", "gpt-5-mini") ?? "gpt-5-mini";
+  return getSetting(runtime, "ELIZAOS_CLOUD_IMAGE_DESCRIPTION_MODEL", "gpt-5.4-mini");
 }
 function getImageGenerationModel(runtime) {
   return getSetting(runtime, "ELIZAOS_CLOUD_IMAGE_GENERATION_MODEL", "google/gemini-2.5-flash-image") ?? "google/gemini-2.5-flash-image";
 }
+function getResearchModel(runtime) {
+  return getSetting(runtime, "ELIZAOS_CLOUD_RESEARCH_MODEL") ?? getSetting(runtime, "RESEARCH_MODEL", "o3-deep-research");
+}
 function getExperimentalTelemetry(runtime) {
   const setting = getSetting(runtime, "ELIZAOS_CLOUD_EXPERIMENTAL_TELEMETRY", "false");
   return String(setting).toLowerCase() === "true";
 }
 
+// utils/sdk-client.ts
+import { CloudApiClient, ElizaCloudClient } from "@elizaos/cloud-sdk";
+function trimTrailingSlash(value) {
+  return value.replace(/\/+$/, "");
+}
+function apiBaseToSiteBaseUrl(apiBaseUrl) {
+  const trimmed = trimTrailingSlash(apiBaseUrl);
+  return trimmed.endsWith("/api/v1") ? trimmed.slice(0, -"/api/v1".length) : trimmed;
+}
+function apiKeyForRuntime(runtime, embedding = false) {
+  if (isBrowser())
+    return;
+  return embedding ? getEmbeddingApiKey(runtime) : getApiKey(runtime);
+}
+function createCloudApiClient(runtime, embedding = false) {
+  const baseUrl = embedding ? getEmbeddingBaseURL(runtime) : getBaseURL(runtime);
+  return new CloudApiClient(trimTrailingSlash(baseUrl), apiKeyForRuntime(runtime, embedding));
+}
+function createElizaCloudClient(runtime) {
+  const apiBaseUrl = trimTrailingSlash(getBaseURL(runtime));
+  return new ElizaCloudClient({
+    apiBaseUrl,
+    baseUrl: apiBaseToSiteBaseUrl(apiBaseUrl),
+    apiKey: apiKeyForRuntime(runtime)
+  });
+}
+
 // init.ts
 function initializeOpenAI(_config, runtime) {
   (async () => {
@@ -649,20 +912,11 @@ function initializeOpenAI(_config, runtime) {
         return;
       }
       try {
-        const baseURL = getBaseURL(runtime);
-        const response = await fetch(`${baseURL}/models`, {
-          headers: { ...getAuthHeader(runtime) }
-        });
-        if (!response.ok) {
-          logger4.warn(`ElizaOS Cloud API key validation failed: ${response.statusText}`);
-          logger4.warn("ElizaOS Cloud functionality will be limited until a valid API key is provided");
-          logger4.info("Get your API key from https://www.elizacloud.ai/dashboard/api-keys");
-        } else {
-          logger4.log("ElizaOS Cloud API key validated successfully");
-        }
+        await createCloudApiClient(runtime).get("/models");
+        logger4.log("ElizaOS Cloud API key validated successfully");
       } catch (fetchError) {
         const message = fetchError instanceof Error ? fetchError.message : String(fetchError);
-        logger4.warn(`Error validating ElizaOS Cloud API key: ${message}`);
+        logger4.warn(`ElizaOS Cloud API key validation failed: ${message}`);
         logger4.warn("ElizaOS Cloud functionality will be limited until a valid API key is provided");
       }
     } catch (error) {
@@ -677,12 +931,14 @@ function initializeOpenAI(_config, runtime) {
 import { logger as logger5, ModelType, VECTOR_DIMS } from "@elizaos/core";
 
 // utils/events.ts
-import { EventType } from "@elizaos/core";
+import {
+  EventType
+} from "@elizaos/core";
 function emitModelUsageEvent(runtime, type, _prompt, usage) {
   const inputTokens = Number(usage.inputTokens || 0);
   const outputTokens = Number(usage.outputTokens || 0);
   const totalTokens = Number(usage.totalTokens != null ? usage.totalTokens : inputTokens + outputTokens);
-  runtime.emitEvent(EventType.MODEL_USED, {
+  const payload = {
     runtime,
     source: "elizacloud",
     type,
@@ -691,7 +947,8 @@ function emitModelUsageEvent(runtime, type, _prompt, usage) {
       completion: outputTokens,
       total: totalTokens
     }
-  });
+  };
+  runtime.emitEvent(EventType.MODEL_USED, payload);
 }
 
 // models/embeddings.ts
@@ -746,7 +1003,7 @@ async function handleTextEmbedding(runtime, params) {
 }
 async function handleBatchTextEmbedding(runtime, texts) {
   const { embeddingModelName, embeddingDimension } = getEmbeddingConfig(runtime);
-  const embeddingBaseURL = getEmbeddingBaseURL(runtime);
+  const client = createCloudApiClient(runtime, true);
   if (!texts || texts.length === 0) {
     logger5.warn("[BatchEmbeddings] Empty texts array");
     return [];
@@ -771,16 +1028,11 @@ async function handleBatchTextEmbedding(runtime, texts) {
     const batchTexts = batch.map((b) => b.text);
     logger5.info(`[BatchEmbeddings] Processing batch ${Math.floor(batchStart / MAX_BATCH_SIZE) + 1}/${Math.ceil(validTexts.length / MAX_BATCH_SIZE)}: ${batch.length} texts`);
     try {
-      const response = await fetch(`${embeddingBaseURL}/embeddings`, {
-        method: "POST",
-        headers: {
-          ...getAuthHeader(runtime, true),
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({
+      const response = await client.requestRaw("POST", "/embeddings", {
+        json: {
           model: embeddingModelName,
           input: batchTexts
-        })
+        }
       });
       const rateLimitInfo = extractRateLimitInfo(response);
       if (rateLimitInfo.remainingRequests !== undefined && rateLimitInfo.remainingRequests < 50) {
@@ -790,16 +1042,11 @@ async function handleBatchTextEmbedding(runtime, texts) {
         const retryAfter = rateLimitInfo.retryAfter || 30;
         logger5.warn(`[BatchEmbeddings] Rate limited, waiting ${retryAfter}s...`);
         await new Promise((resolve) => setTimeout(resolve, retryAfter * 1000));
-        const retryResponse = await fetch(`${embeddingBaseURL}/embeddings`, {
-          method: "POST",
-          headers: {
-            ...getAuthHeader(runtime, true),
-            "Content-Type": "application/json"
-          },
-          body: JSON.stringify({
+        const retryResponse = await client.requestRaw("POST", "/embeddings", {
+          json: {
             model: embeddingModelName,
             input: batchTexts
-          })
+          }
         });
         if (!retryResponse.ok) {
           logger5.error(`[BatchEmbeddings] Retry failed: ${retryResponse.status}`);
@@ -919,7 +1166,6 @@ async function handleImageGeneration(runtime, params) {
   const prompt = params.prompt;
   const modelName = getImageGenerationModel(runtime);
   logger7.log(`[ELIZAOS_CLOUD] Using IMAGE model: ${modelName}`);
-  const baseURL = getBaseURL(runtime);
   const aspectRatioMap = {
     "1024x1024": "1:1",
     "1792x1024": "16:9",
@@ -927,27 +1173,13 @@ async function handleImageGeneration(runtime, params) {
   };
   const aspectRatio = aspectRatioMap[size] || "1:1";
   try {
-    const requestUrl = `${baseURL}/generate-image`;
     const requestBody = {
       prompt,
       numImages,
       aspectRatio,
       model: modelName
     };
-    const response = await fetch(requestUrl, {
-      method: "POST",
-      headers: {
-        ...getAuthHeader(runtime),
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify(requestBody)
-    });
-    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;
+    const typedData = await createElizaCloudClient(runtime).generateImage(requestBody);
     const result = typedData.images.map((img) => ({
       url: img.url || img.image
     }));
@@ -980,23 +1212,32 @@ async function handleImageDescription(runtime, params) {
       ]
     }
   ];
-  const baseURL = getBaseURL(runtime);
+  const client = createElizaCloudClient(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}`);
+    let response = null;
+    for (let attempt = 0;attempt < 3; attempt++) {
+      response = await client.routes.postApiV1ChatCompletionsRaw({
+        json: requestBody
+      });
+      if (response.status === 429 && attempt < 2) {
+        const wait = (attempt + 1) * 2000;
+        logger7.warn(`[ELIZAOS_CLOUD] Image analysis rate-limited (429), retrying in ${wait / 1000}s...`);
+        await new Promise((r) => setTimeout(r, wait));
+        continue;
+      }
+      break;
+    }
+    if (!response?.ok) {
+      const status = response?.status ?? 0;
+      if (status === 402) {
+        throw new Error("Eliza Cloud credits exhausted — top up at https://www.elizacloud.ai/dashboard/settings?tab=billing");
+      }
+      throw new Error(`ElizaOS Cloud API error: ${status}`);
     }
     const typedResult = await response.json();
     const content = typedResult.choices?.[0]?.message?.content;
@@ -1025,62 +1266,179 @@ async function handleImageDescription(runtime, params) {
 }
 // models/object.ts
 import { logger as logger8, ModelType as ModelType3 } from "@elizaos/core";
-import { generateObject, JSONParseError as JSONParseError2 } from "ai";
 
-// providers/openai.ts
-import { createOpenAI } from "@ai-sdk/openai";
-function createOpenAIClient(runtime) {
-  const baseURL = getBaseURL(runtime);
-  const apiKey = getApiKey(runtime) ?? (isProxyMode(runtime) ? "eliza-proxy" : undefined);
-  return createOpenAI({ apiKey: apiKey ?? "", baseURL });
+// utils/responses-output.ts
+function asRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return null;
+  }
+  return value;
+}
+function normalizeContentItems(value) {
+  if (Array.isArray(value))
+    return value;
+  if (typeof value === "string")
+    return [{ type: "text", text: value }];
+  return value && typeof value === "object" ? [value] : [];
+}
+function extractTextFromContentItem(value) {
+  if (typeof value === "string") {
+    return [value];
+  }
+  const record = asRecord(value);
+  if (!record)
+    return [];
+  const text = typeof record.text === "string" ? record.text : typeof record.output_text === "string" ? record.output_text : typeof record.content === "string" ? record.content : "";
+  const type = typeof record.type === "string" ? record.type : undefined;
+  if (text && (!type || type === "output_text" || type === "text")) {
+    return [text];
+  }
+  return [];
+}
+function extractTextFromOutputItem(value) {
+  const record = asRecord(value);
+  if (!record)
+    return [];
+  const directContent = normalizeContentItems(record.content);
+  if (directContent.length > 0) {
+    return directContent.flatMap(extractTextFromContentItem);
+  }
+  const nestedMessage = asRecord(record.message);
+  if (nestedMessage) {
+    return normalizeContentItems(nestedMessage.content).flatMap(extractTextFromContentItem);
+  }
+  const type = typeof record.type === "string" ? record.type : undefined;
+  const text = typeof record.text === "string" ? record.text : typeof record.output_text === "string" ? record.output_text : "";
+  if (text && (type === "output_text" || type === "text")) {
+    return [text];
+  }
+  return [];
+}
+function extractTextFromChoice(value) {
+  const record = asRecord(value);
+  if (!record)
+    return [];
+  if (typeof record.text === "string" && record.text) {
+    return [record.text];
+  }
+  const message = asRecord(record.message);
+  if (!message) {
+    return [];
+  }
+  return normalizeContentItems(message.content).flatMap(extractTextFromContentItem);
+}
+function extractResponsesOutputText(data) {
+  const record = asRecord(data);
+  if (!record)
+    return "";
+  const segments = [];
+  if (typeof record.output_text === "string" && record.output_text) {
+    segments.push(record.output_text);
+  }
+  if (Array.isArray(record.output)) {
+    segments.push(...record.output.flatMap(extractTextFromOutputItem));
+  }
+  if (Array.isArray(record.choices)) {
+    segments.push(...record.choices.flatMap(extractTextFromChoice));
+  }
+  return segments.join("");
 }
 
 // models/object.ts
+var REASONING_MODEL_PATTERNS = [
+  "o1",
+  "o3",
+  "o4",
+  "deepseek-r1",
+  "deepseek-reasoner",
+  "claude-opus-4.7",
+  "claude-opus-4-7",
+  "gpt-5"
+];
+function isReasoningModel(modelName) {
+  const lower = modelName.toLowerCase();
+  return REASONING_MODEL_PATTERNS.some((pattern) => lower.includes(pattern));
+}
 async function generateObjectByModelType(runtime, params, modelType, getModelFn) {
-  const openai = createOpenAIClient(runtime);
   const modelName = getModelFn(runtime);
   logger8.log(`[ELIZAOS_CLOUD] Using ${modelType} model: ${modelName}`);
-  const temperature = params.temperature ?? 0;
-  try {
-    const model = openai.languageModel(modelName);
-    const { object, usage } = await generateObject({
-      model,
-      output: "no-schema",
-      prompt: params.prompt,
-      temperature,
-      experimental_repairText: getJsonRepairFunction()
+  const reasoning = isReasoningModel(modelName);
+  const input = [];
+  if (runtime.character.system) {
+    input.push({
+      role: "system",
+      content: [{ type: "input_text", text: runtime.character.system }]
     });
-    if (usage) {
-      emitModelUsageEvent(runtime, modelType, params.prompt, usage);
+  }
+  input.push({
+    role: "user",
+    content: [{ type: "input_text", text: params.prompt }]
+  });
+  const requestBody = {
+    model: modelName,
+    input,
+    max_output_tokens: params.maxTokens ?? 8192,
+    text: { format: { type: "json_object" } }
+  };
+  if (!reasoning && typeof params.temperature === "number") {
+    requestBody.temperature = params.temperature;
+  }
+  const response = await createCloudApiClient(runtime).requestRaw("POST", "/responses", {
+    json: requestBody
+  });
+  const responseText = await response.text();
+  let data = {};
+  if (responseText) {
+    try {
+      data = JSON.parse(responseText);
+    } catch (parseErr) {
+      logger8.error(`[generateObject] Failed to parse Eliza Cloud JSON: ${parseErr instanceof Error ? parseErr.message : String(parseErr)}`);
     }
-    return object;
+  }
+  if (!response.ok) {
+    const errorBody = typeof data === "object" && data ? data.error : undefined;
+    const errorMessage = typeof errorBody?.message === "string" && errorBody.message.trim() ? errorBody.message.trim() : `elizaOS Cloud error ${response.status}`;
+    const requestError = new Error(errorMessage);
+    requestError.status = response.status;
+    if (errorBody) {
+      requestError.error = errorBody;
+    }
+    throw requestError;
+  }
+  if (data.usage) {
+    emitModelUsageEvent(runtime, modelType, params.prompt, {
+      inputTokens: data.usage.input_tokens ?? 0,
+      outputTokens: data.usage.output_tokens ?? 0,
+      totalTokens: data.usage.total_tokens ?? 0
+    });
+  }
+  let jsonText = extractResponsesOutputText(data);
+  if (!jsonText.trim()) {
+    throw new Error("Object generation returned empty response");
+  }
+  jsonText = jsonText.replace(/^[\s]*```(?:json)?\s*\n?/i, "").replace(/\n?```\s*$/i, "").trim();
+  try {
+    return JSON.parse(jsonText);
   } catch (error) {
-    if (error instanceof JSONParseError2) {
-      logger8.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);
-          logger8.info("[generateObject] Successfully repaired JSON.");
-          return repairedObject;
-        } catch (repairParseError) {
-          const message = repairParseError instanceof Error ? repairParseError.message : String(repairParseError);
-          logger8.error(`[generateObject] Failed to parse repaired JSON: ${message}`);
-          throw repairParseError;
-        }
-      } else {
-        logger8.error("[generateObject] JSON repair failed.");
-        throw error;
+    const repairFunction = getJsonRepairFunction();
+    const repairedJsonString = await repairFunction({
+      text: jsonText,
+      error
+    });
+    if (repairedJsonString) {
+      try {
+        const repairedObject = JSON.parse(repairedJsonString);
+        logger8.info("[generateObject] Successfully repaired JSON.");
+        return repairedObject;
+      } catch (repairParseError) {
+        const message2 = repairParseError instanceof Error ? repairParseError.message : String(repairParseError);
+        logger8.error(`[generateObject] Failed to parse repaired JSON: ${message2}`);
+        throw repairParseError;
       }
-    } else {
-      const message = error instanceof Error ? error.message : String(error);
-      logger8.error(`[generateObject] Error: ${message}`);
-      throw error;
     }
+    const message = error instanceof Error ? error.message : String(error);
+    logger8.error(`[generateObject] Failed to parse JSON: ${message}`);
+    throw error;
   }
 }
 async function handleObjectSmall(runtime, params) {
@@ -1089,32 +1447,185 @@ async function handleObjectSmall(runtime, params) {
 async function handleObjectLarge(runtime, params) {
   return generateObjectByModelType(runtime, params, ModelType3.OBJECT_LARGE, getLargeModel);
 }
+// models/research.ts
+import { logger as logger9, ModelType as ModelType4 } from "@elizaos/core";
+function normalizeInput(input) {
+  if (typeof input !== "string") {
+    return input;
+  }
+  return [
+    {
+      role: "user",
+      content: [
+        {
+          type: "input_text",
+          text: input
+        }
+      ]
+    }
+  ];
+}
+function buildResearchApiError(status, errorText) {
+  try {
+    const parsed = JSON.parse(errorText);
+    const message = parsed.error?.message;
+    const param = parsed.error?.param;
+    if (param === "tools.0.type" && message?.includes('expected "function"')) {
+      return new Error(`Research API error: ${status} Eliza Cloud /responses rejected deep-research tool types; the provider currently only accepts function tools on this route`);
+    }
+  } catch {}
+  return new Error(`Research API error: ${status} ${errorText}`);
+}
+function parseAnnotations(raw) {
+  return raw.filter((a) => a.url !== undefined).map((a) => ({
+    url: a.url,
+    title: a.title ?? "",
+    startIndex: a.start_index ?? 0,
+    endIndex: a.end_index ?? 0
+  }));
+}
+function parseOutputItems(raw) {
+  const items = [];
+  for (const item of raw) {
+    switch (item.type) {
+      case "web_search_call":
+        items.push({
+          id: item.id ?? "",
+          type: "web_search_call",
+          status: item.status ?? "completed",
+          action: {
+            type: item.action?.type ?? "search",
+            query: item.action?.query,
+            url: item.action?.url
+          }
+        });
+        break;
+      case "file_search_call":
+        items.push({
+          id: item.id ?? "",
+          type: "file_search_call",
+          status: item.status ?? "completed",
+          query: item.query ?? "",
+          results: item.results?.map((r) => ({
+            fileId: r.file_id,
+            fileName: r.file_name,
+            score: r.score
+          }))
+        });
+        break;
+      case "code_interpreter_call":
+        items.push({
+          id: item.id ?? "",
+          type: "code_interpreter_call",
+          status: item.status ?? "completed",
+          code: item.code ?? "",
+          output: item.output
+        });
+        break;
+      case "mcp_tool_call":
+        items.push({
+          id: item.id ?? "",
+          type: "mcp_tool_call",
+          status: item.status ?? "completed",
+          serverLabel: item.server_label ?? "",
+          toolName: item.tool_name ?? "",
+          arguments: item.arguments ?? {},
+          result: item.result
+        });
+        break;
+      case "message": {
+        const content = item.content ?? [];
+        items.push({
+          type: "message",
+          content: content.filter((c) => c.type === "output_text").map((c) => ({
+            type: "output_text",
+            text: c.text ?? "",
+            annotations: parseAnnotations(c.annotations ?? [])
+          }))
+        });
+        break;
+      }
+    }
+  }
+  return items;
+}
+async function handleResearch(runtime, params) {
+  const modelName = params.model ?? getResearchModel(runtime);
+  logger9.log(`[ELIZAOS_CLOUD] Using RESEARCH model: ${modelName}`);
+  const tools = params.tools ?? [{ type: "web_search_preview" }];
+  const requestBody = {
+    model: modelName,
+    input: normalizeInput(params.input),
+    tools
+  };
+  if (params.instructions) {
+    requestBody.instructions = params.instructions;
+  }
+  if (params.background !== undefined) {
+    requestBody.background = params.background;
+  }
+  if (params.maxToolCalls !== undefined) {
+    requestBody.max_tool_calls = params.maxToolCalls;
+  }
+  if (params.reasoningSummary) {
+    requestBody.reasoning = { summary: params.reasoningSummary };
+  }
+  const response = await createCloudApiClient(runtime).requestRaw("POST", "/responses", {
+    json: requestBody
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw buildResearchApiError(response.status, errorText);
+  }
+  const data = await response.json();
+  if (data.usage) {
+    emitModelUsageEvent(runtime, ModelType4.RESEARCH, params.input, {
+      inputTokens: data.usage.input_tokens,
+      outputTokens: data.usage.output_tokens,
+      totalTokens: data.usage.total_tokens
+    });
+  }
+  const outputItems = parseOutputItems(data.output);
+  let text = "";
+  const annotations = [];
+  for (const item of outputItems) {
+    if (item.type === "message") {
+      for (const content of item.content) {
+        if (content.type === "output_text") {
+          text += content.text;
+          annotations.push(...content.annotations);
+        }
+      }
+    }
+  }
+  return {
+    id: data.id,
+    text,
+    annotations,
+    outputItems,
+    status: data.status
+  };
+}
 // models/speech.ts
-import { logger as logger9 } from "@elizaos/core";
+import { logger as logger10 } from "@elizaos/core";
 async function fetchTextToSpeech(runtime, options) {
   const defaultModel = getSetting(runtime, "ELIZAOS_CLOUD_TTS_MODEL", "gpt-5-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 format2 = options.format || "mp3";
+  const modelId = model.startsWith("elevenlabs/") ? model.split("/").slice(1).join("/") : model.startsWith("eleven_") ? model : undefined;
+  const voiceId = voice && voice !== "nova" ? voice : undefined;
   try {
-    const res = await fetch(`${baseURL}/audio/speech`, {
-      method: "POST",
+    const res = await createElizaCloudClient(runtime).routes.postApiV1VoiceTts({
       headers: {
-        ...getAuthHeader(runtime),
-        "Content-Type": "application/json",
         ...format2 === "mp3" ? { Accept: "audio/mpeg" } : {}
       },
-      body: JSON.stringify({
-        model,
-        voice,
-        input: options.text,
-        format: format2,
-        ...instructions && { instructions }
-      })
+      json: {
+        text: options.text,
+        ...voiceId ? { voiceId } : {},
+        ...modelId ? { modelId } : {}
+      }
     });
     if (!res.ok) {
       const err = await res.text();
@@ -1133,151 +1644,214 @@ async function fetchTextToSpeech(runtime, options) {
   }
 }
 // models/text.ts
-import { logger as logger10, ModelType as ModelType4 } from "@elizaos/core";
-import { generateText, streamText } from "ai";
+import { logger as logger11, ModelType as ModelType5 } from "@elizaos/core";
+
+// providers/openai.ts
+import { createOpenAI } from "@ai-sdk/openai";
+function createOpenAIClient(runtime) {
+  const baseURL = getBaseURL(runtime);
+  const apiKey = getApiKey(runtime) ?? (isProxyMode(runtime) ? "eliza-proxy" : undefined);
+  return createOpenAI({
+    apiKey: apiKey ?? "",
+    baseURL
+  });
+}
+
+// models/text.ts
+var TEXT_NANO_MODEL_TYPE = ModelType5.TEXT_NANO ?? "TEXT_NANO";
+var TEXT_MEDIUM_MODEL_TYPE = ModelType5.TEXT_MEDIUM ?? "TEXT_MEDIUM";
+var TEXT_SMALL_MODEL_TYPE = ModelType5.TEXT_SMALL;
+var TEXT_LARGE_MODEL_TYPE = ModelType5.TEXT_LARGE;
+var TEXT_MEGA_MODEL_TYPE = ModelType5.TEXT_MEGA ?? "TEXT_MEGA";
+var RESPONSE_HANDLER_MODEL_TYPE = ModelType5.RESPONSE_HANDLER ?? "RESPONSE_HANDLER";
+var ACTION_PLANNER_MODEL_TYPE = ModelType5.ACTION_PLANNER ?? "ACTION_PLANNER";
+var REASONING_MODEL_PATTERNS2 = [
+  "o1",
+  "o3",
+  "o4",
+  "deepseek-r1",
+  "deepseek-reasoner",
+  "claude-opus-4.7",
+  "claude-opus-4-7",
+  "gpt-5"
+];
+var RESPONSES_ROUTED_PREFIXES = ["openai/", "anthropic/"];
+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 isReasoningModel2(modelName) {
+  const lower = modelName.toLowerCase();
+  return REASONING_MODEL_PATTERNS2.some((pattern) => lower.includes(pattern));
+}
+function supportsStopSequences(modelName) {
+  const lower = modelName.toLowerCase();
+  return !RESPONSES_ROUTED_PREFIXES.some((prefix) => lower.startsWith(prefix));
+}
+function getPurposeForModelType(modelType) {
+  switch (modelType) {
+    case RESPONSE_HANDLER_MODEL_TYPE:
+      return "should_respond";
+    case ACTION_PLANNER_MODEL_TYPE:
+      return "action_planner";
+    default:
+      return "response";
+  }
+}
+function getModelNameForType(runtime, modelType) {
+  switch (modelType) {
+    case TEXT_NANO_MODEL_TYPE:
+      return getNanoModel(runtime);
+    case TEXT_MEDIUM_MODEL_TYPE:
+      return getMediumModel(runtime);
+    case TEXT_SMALL_MODEL_TYPE:
+      return getSmallModel(runtime);
+    case TEXT_LARGE_MODEL_TYPE:
+      return getLargeModel(runtime);
+    case TEXT_MEGA_MODEL_TYPE:
+      return getMegaModel(runtime);
+    case RESPONSE_HANDLER_MODEL_TYPE:
+      return getResponseHandlerModel(runtime);
+    case ACTION_PLANNER_MODEL_TYPE:
+      return getActionPlannerModel(runtime);
+    default:
+      return getLargeModel(runtime);
+  }
+}
 function buildGenerateParams(runtime, modelType, params) {
-  const { prompt, stopSequences = [] } = params;
-  const temperature = params.temperature ?? 0.7;
-  const frequencyPenalty = params.frequencyPenalty ?? 0.7;
-  const presencePenalty = params.presencePenalty ?? 0.7;
+  const paramsWithAttachments = params;
+  const { prompt } = params;
   const maxTokens = params.maxTokens ?? 8192;
   const openai = createOpenAIClient(runtime);
-  const modelName = modelType === ModelType4.TEXT_SMALL ? getSmallModel(runtime) : getLargeModel(runtime);
-  const modelLabel = modelType === ModelType4.TEXT_SMALL ? "TEXT_SMALL" : "TEXT_LARGE";
+  const modelName = getModelNameForType(runtime, modelType);
   const experimentalTelemetry = getExperimentalTelemetry(runtime);
-  const model = openai.languageModel(modelName);
+  const userContent = (paramsWithAttachments.attachments?.length ?? 0) > 0 ? buildUserContent(paramsWithAttachments) : undefined;
+  const model = openai.chat(modelName);
+  const reasoning = isReasoningModel2(modelName);
+  const stopSequences = !reasoning && supportsStopSequences(modelName) && Array.isArray(params.stopSequences) && params.stopSequences.length > 0 ? params.stopSequences : undefined;
   const generateParams = {
     model,
-    prompt,
+    ...userContent ? { messages: [{ role: "user", content: userContent }] } : { prompt },
     system: runtime.character.system ?? undefined,
-    temperature,
+    ...stopSequences ? { stopSequences } : {},
     maxOutputTokens: maxTokens,
-    frequencyPenalty,
-    presencePenalty,
-    stopSequences,
     experimental_telemetry: {
       isEnabled: experimentalTelemetry
     }
   };
-  return { generateParams, modelName, modelLabel, prompt };
-}
-function handleStreamingGeneration(runtime, modelType, generateParams, prompt, modelLabel) {
-  logger10.debug(`[ELIZAOS_CLOUD] Streaming text with ${modelLabel} model`);
-  const streamResult = streamText(generateParams);
-  return {
-    textStream: streamResult.textStream,
-    text: Promise.resolve(streamResult.text),
-    usage: Promise.resolve(streamResult.usage).then((usage) => {
-      if (usage) {
-        emitModelUsageEvent(runtime, modelType, prompt, usage);
-        const inputTokens = usage.inputTokens ?? 0;
-        const outputTokens = usage.outputTokens ?? 0;
-        return {
-          promptTokens: inputTokens,
-          completionTokens: outputTokens,
-          totalTokens: inputTokens + outputTokens
-        };
-      }
-      return;
-    }),
-    finishReason: Promise.resolve(streamResult.finishReason)
-  };
+  return { generateParams, modelName, modelType, prompt };
 }
 async function generateTextWithModel(runtime, modelType, params) {
-  const { generateParams, modelName, modelLabel, prompt } = buildGenerateParams(runtime, modelType, params);
-  logger10.debug(`[ELIZAOS_CLOUD] Generating text with ${modelLabel} model: ${modelName}`);
+  const { modelName, prompt } = buildGenerateParams(runtime, modelType, params);
+  logger11.debug(`[ELIZAOS_CLOUD] Generating text with ${modelType} model: ${modelName}`);
   if (params.stream) {
-    return handleStreamingGeneration(runtime, modelType, generateParams, prompt, modelLabel);
+    logger11.debug("[ELIZAOS_CLOUD] Streaming text disabled for responses compatibility; falling back to buffered response.");
+  }
+  logger11.log(`[ELIZAOS_CLOUD] Using ${modelType} model: ${modelName}`);
+  logger11.log(prompt);
+  const reasoning = isReasoningModel2(modelName);
+  const input = [];
+  if (runtime.character.system) {
+    input.push({
+      role: "system",
+      content: [{ type: "input_text", text: runtime.character.system }]
+    });
+  }
+  input.push({
+    role: "user",
+    content: [{ type: "input_text", text: prompt }]
+  });
+  const requestBody = {
+    model: modelName,
+    input,
+    max_output_tokens: params.maxTokens ?? 8192
+  };
+  if (!reasoning && typeof params.temperature === "number") {
+    requestBody.temperature = params.temperature;
+  }
+  const response = await createCloudApiClient(runtime).requestRaw("POST", "/responses", {
+    headers: {
+      "X-Eliza-Llm-Purpose": getPurposeForModelType(modelType),
+      "X-Eliza-Model-Type": modelType
+    },
+    json: requestBody
+  });
+  const responseText = await response.text();
+  let data = {};
+  if (responseText) {
+    try {
+      data = JSON.parse(responseText);
+    } catch (parseErr) {
+      logger11.error(`[ELIZAOS_CLOUD] Failed to parse responses JSON: ${parseErr instanceof Error ? parseErr.message : String(parseErr)}`);
+    }
+  }
+  if (!response.ok) {
+    const errorBody = typeof data === "object" && data ? data.error : undefined;
+    const errorMessage = typeof errorBody?.message === "string" && errorBody.message.trim() ? errorBody.message.trim() : `elizaOS Cloud error ${response.status}`;
+    const requestError = new Error(errorMessage);
+    requestError.status = response.status;
+    if (errorBody) {
+      requestError.error = errorBody;
+    }
+    throw requestError;
+  }
+  if (data.usage) {
+    emitModelUsageEvent(runtime, modelType, prompt, {
+      inputTokens: data.usage.input_tokens ?? 0,
+      outputTokens: data.usage.output_tokens ?? 0,
+      totalTokens: data.usage.total_tokens ?? 0
+    });
   }
-  logger10.log(`[ELIZAOS_CLOUD] Using ${modelLabel} model: ${modelName}`);
-  logger10.log(prompt);
-  const response = await generateText(generateParams);
-  if (response.usage) {
-    emitModelUsageEvent(runtime, modelType, prompt, response.usage);
+  const text = extractResponsesOutputText(data);
+  if (!text.trim()) {
+    throw new Error("elizaOS Cloud returned no text response");
   }
-  return response.text;
+  return text;
 }
 async function handleTextSmall(runtime, params) {
-  return generateTextWithModel(runtime, ModelType4.TEXT_SMALL, params);
+  return generateTextWithModel(runtime, TEXT_SMALL_MODEL_TYPE, params);
+}
+async function handleTextNano(runtime, params) {
+  return generateTextWithModel(runtime, TEXT_NANO_MODEL_TYPE, params);
+}
+async function handleTextMedium(runtime, params) {
+  return generateTextWithModel(runtime, TEXT_MEDIUM_MODEL_TYPE, params);
 }
 async function handleTextLarge(runtime, params) {
-  return generateTextWithModel(runtime, ModelType4.TEXT_LARGE, params);
+  return generateTextWithModel(runtime, TEXT_LARGE_MODEL_TYPE, params);
+}
+async function handleTextMega(runtime, params) {
+  return generateTextWithModel(runtime, TEXT_MEGA_MODEL_TYPE, params);
+}
+async function handleResponseHandler(runtime, params) {
+  return generateTextWithModel(runtime, RESPONSE_HANDLER_MODEL_TYPE, params);
+}
+async function handleActionPlanner(runtime, params) {
+  return generateTextWithModel(runtime, ACTION_PLANNER_MODEL_TYPE, params);
 }
 // services/cloud-auth.ts
 import { logger as logger12, Service } from "@elizaos/core";
+import {
+  resolveApiSecurityConfig,
+  resolveDesktopApiPort
+} from "@elizaos/shared";
+import { createRemoteJWKSet, jwtVerify } from "jose";
 
 // utils/cloud-api.ts
-import { logger as logger11 } from "@elizaos/core";
-class CloudApiClient {
-  baseUrl;
-  apiKey;
-  constructor(baseUrl, apiKey) {
-    this.baseUrl = baseUrl.replace(/\/+$/, "");
-    this.apiKey = apiKey;
-  }
-  setApiKey(key) {
-    this.apiKey = key;
-  }
-  setBaseUrl(url) {
-    this.baseUrl = url.replace(/\/+$/, "");
-  }
-  getBaseUrl() {
-    return this.baseUrl;
-  }
-  getApiKey() {
-    return this.apiKey;
-  }
-  buildWsUrl(path) {
-    return `${this.baseUrl.replace(/^http/, "ws")}${path}`;
-  }
-  async get(path) {
-    return this.request("GET", path);
-  }
-  async post(path, body) {
-    return this.request("POST", path, body);
-  }
-  async delete(path) {
-    return this.request("DELETE", path);
-  }
-  async postUnauthenticated(path, body) {
-    return this.request("POST", path, body, true);
-  }
-  async request(method, path, body, skipAuth = false) {
-    const url = `${this.baseUrl}${path}`;
-    logger11.debug(`[CloudAPI] ${method} ${url}`);
-    const headers = {
-      "Content-Type": "application/json",
-      Accept: "application/json"
-    };
-    if (!skipAuth && this.apiKey) {
-      headers.Authorization = `Bearer ${this.apiKey}`;
-    }
-    const response = await fetch(url, {
-      method,
-      headers,
-      ...body ? { body: JSON.stringify(body) } : {}
-    });
-    return this.handleResponse(response);
-  }
-  async handleResponse(response) {
-    const contentType = response.headers.get("content-type") ?? "";
-    if (!contentType.includes("application/json")) {
-      if (!response.ok) {
-        throw new CloudApiError(response.status, {
-          success: false,
-          error: `HTTP ${response.status}: ${response.statusText}`
-        });
-      }
-      return { success: true };
-    }
-    const body = await response.json();
-    if (!response.ok) {
-      const err = body;
-      throw response.status === 402 ? new InsufficientCreditsError(err) : new CloudApiError(response.status, err);
-    }
-    return body;
-  }
-}
+import {
+  CloudApiClient as CloudApiClient2,
+  CloudApiError as CloudApiError2,
+  ElizaCloudHttpClient,
+  InsufficientCreditsError as InsufficientCreditsError2
+} from "@elizaos/cloud-sdk";
 
 // services/cloud-auth.ts
 async function deriveDeviceId() {
@@ -1304,15 +1878,14 @@ function detectPlatform() {
   };
   return map[process.platform] ?? "linux";
 }
-
 class CloudAuthService extends Service {
   static serviceType = "CLOUD_AUTH";
-  capabilityDescription = "ElizaCloud device authentication and session management";
+  capabilityDescription = "Eliza Cloud device authentication and SSO session helpers";
   client;
   credentials = null;
   constructor(runtime) {
     super(runtime);
-    this.client = new CloudApiClient(DEFAULT_CLOUD_CONFIG.baseUrl);
+    this.client = new CloudApiClient2(DEFAULT_CLOUD_CONFIG.baseUrl);
   }
   static async start(runtime) {
     const service = new CloudAuthService(runtime);
@@ -1329,31 +1902,43 @@ class CloudAuthService extends Service {
     if (existingKey) {
       const key = String(existingKey);
       this.client.setApiKey(key);
-      const valid = await this.validateApiKey(key);
-      if (valid) {
-        this.credentials = {
-          apiKey: key,
-          userId: String(this.runtime.getSetting("ELIZAOS_CLOUD_USER_ID") ?? ""),
-          organizationId: String(this.runtime.getSetting("ELIZAOS_CLOUD_ORG_ID") ?? ""),
-          authenticatedAt: Date.now()
-        };
-        logger12.info("[CloudAuth] Authenticated with existing API key");
-        return;
-      }
-      logger12.warn("[CloudAuth] Existing API key invalid, attempting device auth");
+      this.credentials = {
+        apiKey: key,
+        userId: String(this.runtime.getSetting("ELIZAOS_CLOUD_USER_ID") ?? ""),
+        organizationId: String(this.runtime.getSetting("ELIZAOS_CLOUD_ORG_ID") ?? this.runtime.getSetting("ELIZA_CLOUD_ORGANIZATION_ID") ?? ""),
+        authenticatedAt: Date.now()
+      };
+      logger12.info("[CloudAuth] Authenticated with saved API key");
+      this.validateApiKey(key).then((valid) => {
+        if (!valid) {
+          logger12.warn("[CloudAuth] Saved API key could not be validated (cloud may be unreachable or key revoked) — model calls will use the key anyway");
+        }
+      }).catch(() => {});
+      return;
     }
     const enabled = this.runtime.getSetting("ELIZAOS_CLOUD_ENABLED");
     if (enabled === "true" || enabled === "1") {
-      await this.authenticateWithDevice();
+      try {
+        await this.authenticateWithDevice();
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        logger12.warn(`[CloudAuth] Device auth failed (cloud may be unreachable): ${msg}`);
+        logger12.info("[CloudAuth] Service will start unauthenticated — cloud features disabled until connectivity is restored");
+      }
     } else {
       logger12.info("[CloudAuth] Cloud not enabled (set ELIZAOS_CLOUD_ENABLED=true)");
     }
   }
   async validateApiKey(key) {
-    const resp = await fetch(`${this.client.getBaseUrl()}/models`, {
-      headers: { Authorization: `Bearer ${key}` }
-    });
-    return resp.ok;
+    try {
+      const validationClient = new CloudApiClient2(this.client.getBaseUrl(), key);
+      await validationClient.get("/models", { timeoutMs: 1e4 });
+      return true;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      logger12.warn(`[CloudAuth] Could not reach cloud API to validate key: ${msg}`);
+      return false;
+    }
   }
   async authenticateWithDevice() {
     const deviceId = await deriveDeviceId();
@@ -1378,6 +1963,25 @@ class CloudAuthService extends Service {
     logger12.info(`[CloudAuth] ${action} (credits: $${response.data.credits.toFixed(2)})`);
     return this.credentials;
   }
+  authenticateWithApiKey(input) {
+    const apiKey = input.apiKey.trim();
+    if (!apiKey) {
+      throw new Error("Eliza Cloud API key is required");
+    }
+    this.client.setApiKey(apiKey);
+    this.credentials = {
+      apiKey,
+      userId: input.userId ?? "",
+      organizationId: input.organizationId ?? "",
+      authenticatedAt: Date.now()
+    };
+    logger12.info("[CloudAuth] Authenticated with API key");
+    return this.credentials;
+  }
+  clearAuth() {
+    this.credentials = null;
+    this.client.setApiKey(undefined);
+  }
   isAuthenticated() {
     return this.credentials !== null;
   }
@@ -1422,7 +2026,7 @@ class CloudBackupService extends Service2 {
   async initialize() {
     const auth = this.runtime.getService("CLOUD_AUTH");
     if (!auth) {
-      logger13.warn("[CloudBackup] CloudAuthService not available");
+      logger13.debug("[CloudBackup] CloudAuthService not available");
       return;
     }
     this.authService = auth;
@@ -1524,10 +2128,72 @@ function formatBytes(bytes) {
   return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
 }
 
-// services/cloud-bridge.ts
+// services/cloud-bootstrap.ts
 import { logger as logger14, Service as Service3 } from "@elizaos/core";
+function readEnv() {
+  if (typeof process === "undefined") {
+    return {};
+  }
+  return process.env;
+}
+function readSetting(runtime, key) {
+  if (runtime && typeof runtime.getSetting === "function") {
+    const value = runtime.getSetting(key);
+    if (typeof value === "string" && value.length > 0) {
+      return value;
+    }
+  }
+  const fromEnv = readEnv()[key];
+  if (typeof fromEnv === "string" && fromEnv.length > 0) {
+    return fromEnv;
+  }
+  return null;
+}
+function trimTrailingSlash2(input) {
+  let end = input.length;
+  while (end > 0 && input.charCodeAt(end - 1) === 47) {
+    end -= 1;
+  }
+  return end === input.length ? input : input.slice(0, end);
+}
+
+class CloudBootstrapServiceImpl extends Service3 {
+  static serviceType = "CLOUD_BOOTSTRAP";
+  capabilityDescription = "Exposes Eliza Cloud bootstrap-token trust anchor (issuer, JWKS URL, revocation list URL, expected container id) to app-core";
+  static async start(runtime) {
+    const service = new CloudBootstrapServiceImpl(runtime);
+    const issuer = readSetting(runtime, "ELIZA_CLOUD_ISSUER");
+    const containerId = readSetting(runtime, "ELIZA_CLOUD_CONTAINER_ID");
+    if (issuer) {
+      logger14.info(`[CloudBootstrap] Trust anchor configured (issuer=${issuer}, containerId=${containerId ?? "<unset>"})`);
+    } else {
+      logger14.debug("[CloudBootstrap] ELIZA_CLOUD_ISSUER unset — bootstrap-token verification will reject until configured");
+    }
+    return service;
+  }
+  async stop() {}
+  getExpectedIssuer() {
+    const issuer = readSetting(this.runtime, "ELIZA_CLOUD_ISSUER");
+    if (!issuer) {
+      throw new Error("ELIZA_CLOUD_ISSUER is not configured — bootstrap-token verification cannot proceed");
+    }
+    return trimTrailingSlash2(issuer);
+  }
+  getJwksUrl() {
+    return `${this.getExpectedIssuer()}/.well-known/jwks.json`;
+  }
+  getRevocationListUrl() {
+    return `${this.getExpectedIssuer()}/.well-known/revocations.json`;
+  }
+  getExpectedContainerId() {
+    return readSetting(this.runtime, "ELIZA_CLOUD_CONTAINER_ID");
+  }
+}
+
+// services/cloud-bridge.ts
+import { logger as logger15, Service as Service4 } from "@elizaos/core";
 import { WebSocket } from "undici";
-class CloudBridgeService extends Service3 {
+class CloudBridgeService extends Service4 {
   static serviceType = "CLOUD_BRIDGE";
   capabilityDescription = "WebSocket bridge to cloud-hosted ElizaOS agents";
   authService;
@@ -1542,22 +2208,22 @@ class CloudBridgeService extends Service3 {
     for (const [containerId] of this.connections) {
       await this.disconnect(containerId);
     }
-    logger14.info("[CloudBridge] Service stopped");
+    logger15.info("[CloudBridge] Service stopped");
   }
   async initialize() {
     const auth = this.runtime.getService("CLOUD_AUTH");
     if (!auth) {
-      logger14.warn("[CloudBridge] CloudAuthService not available");
+      logger15.debug("[CloudBridge] CloudAuthService not available");
       return;
     }
     this.authService = auth;
-    logger14.info("[CloudBridge] Service initialized");
+    logger15.info("[CloudBridge] Service initialized");
   }
   async connect(containerId) {
-    if (this.connections.has(containerId)) {
-      const existing = this.connections.get(containerId);
+    const existing = this.connections.get(containerId);
+    if (existing) {
       if (existing.state === "connected" || existing.state === "connecting") {
-        logger14.debug(`[CloudBridge] Already connected/connecting to ${containerId}`);
+        logger15.debug(`[CloudBridge] Already connected/connecting to ${containerId}`);
         return;
       }
     }
@@ -1580,7 +2246,7 @@ class CloudBridgeService extends Service3 {
       conn.ws.close(1000, "Client disconnect");
     }
     this.connections.delete(containerId);
-    logger14.info(`[CloudBridge] Disconnected from ${containerId}`);
+    logger15.info(`[CloudBridge] Disconnected from ${containerId}`);
   }
   async establishConnection(containerId, reconnectAttempts) {
     const client = this.authService.getClient();
@@ -1604,7 +2270,7 @@ class CloudBridgeService extends Service3 {
       conn.state = "connected";
       conn.connectedAt = Date.now();
       conn.reconnectAttempts = 0;
-      logger14.info(`[CloudBridge] Connected to agent ${containerId}`);
+      logger15.info(`[CloudBridge] Connected to agent ${containerId}`);
       conn.heartbeatTimer = setInterval(() => {
         this.sendHeartbeat(containerId);
       }, this.bridgeConfig.heartbeatIntervalMs);
@@ -1639,26 +2305,26 @@ class CloudBridgeService extends Service3 {
       if (conn.heartbeatTimer)
         clearInterval(conn.heartbeatTimer);
       if (event.code === 1000) {
-        logger14.info(`[CloudBridge] Clean disconnect from ${containerId}`);
+        logger15.info(`[CloudBridge] Clean disconnect from ${containerId}`);
         return;
       }
-      logger14.warn(`[CloudBridge] Connection lost to ${containerId} (code=${event.code}, reason=${event.reason})`);
+      logger15.warn(`[CloudBridge] Connection lost to ${containerId} (code=${event.code}, reason=${event.reason})`);
       this.scheduleReconnect(containerId, conn.reconnectAttempts + 1);
     });
     conn.ws.addEventListener("error", () => {
-      logger14.error(`[CloudBridge] WebSocket error for ${containerId}`);
+      logger15.error(`[CloudBridge] WebSocket error for ${containerId}`);
     });
   }
   scheduleReconnect(containerId, attempt) {
     if (attempt > this.bridgeConfig.maxReconnectAttempts) {
-      logger14.error(`[CloudBridge] Max reconnect attempts (${this.bridgeConfig.maxReconnectAttempts}) reached for ${containerId}`);
+      logger15.error(`[CloudBridge] Max reconnect attempts (${this.bridgeConfig.maxReconnectAttempts}) reached for ${containerId}`);
       this.connections.delete(containerId);
       return;
     }
     const base = this.bridgeConfig.reconnectIntervalMs;
     const delay = Math.min(base * 2 ** Math.min(attempt, 5), 120000);
     const jitter = Math.floor(Math.random() * 1000);
-    logger14.info(`[CloudBridge] Reconnecting to ${containerId} in ${Math.round((delay + jitter) / 1000)}s (attempt ${attempt})`);
+    logger15.info(`[CloudBridge] Reconnecting to ${containerId} in ${Math.round((delay + jitter) / 1000)}s (attempt ${attempt})`);
     const conn = this.connections.get(containerId);
     if (conn) {
       conn.state = "reconnecting";
@@ -1774,8 +2440,8 @@ class CloudBridgeService extends Service3 {
 }
 
 // services/cloud-container.ts
-import { logger as logger15, Service as Service4 } from "@elizaos/core";
-class CloudContainerService extends Service4 {
+import { logger as logger16, Service as Service5 } from "@elizaos/core";
+class CloudContainerService extends Service5 {
   static serviceType = "CLOUD_CONTAINER";
   capabilityDescription = "ElizaCloud container provisioning and lifecycle management";
   authService;
@@ -1798,7 +2464,7 @@ class CloudContainerService extends Service4 {
   async initialize() {
     const auth = this.runtime.getService("CLOUD_AUTH");
     if (!auth) {
-      logger15.warn("[CloudContainer] CloudAuthService not available, container operations will fail");
+      logger16.debug("[CloudContainer] CloudAuthService not available, container operations will fail");
       return;
     }
     this.authService = auth;
@@ -1817,7 +2483,7 @@ class CloudContainerService extends Service4 {
           this.startHealthMonitoring(container.id);
         }
       }
-      logger15.info(`[CloudContainer] Loaded ${containers.length} existing container(s)`);
+      logger16.info(`[CloudContainer] Loaded ${containers.length} existing container(s)`);
     }
   }
   getClient() {
@@ -1848,7 +2514,7 @@ class CloudContainerService extends Service4 {
       healthTimer: null
     });
     this.startPolling(response.data.id);
-    logger15.info(`[CloudContainer] Created container "${request.name}" (id=${response.data.id}, stack=${response.stackName})`);
+    logger16.info(`[CloudContainer] Created container "${request.name}" (id=${response.data.id}, stack=${response.stackName})`);
     return response;
   }
   async listContainers() {
@@ -1876,7 +2542,7 @@ class CloudContainerService extends Service4 {
         clearInterval(tracked.healthTimer);
       this.tracked.delete(containerId);
     }
-    logger15.info(`[CloudContainer] Deleted container ${containerId}`);
+    logger16.info(`[CloudContainer] Deleted container ${containerId}`);
   }
   startPolling(containerId) {
     const tracked = this.tracked.get(containerId);
@@ -1889,21 +2555,21 @@ class CloudContainerService extends Service4 {
     const poll = async () => {
       attempt++;
       if (attempt > maxAttempts) {
-        logger15.error(`[CloudContainer] Polling timed out for container ${containerId} after ${maxAttempts} attempts`);
+        logger16.error(`[CloudContainer] Polling timed out for container ${containerId} after ${maxAttempts} attempts`);
         return;
       }
       const container = await this.getContainer(containerId);
       const status = container.status;
-      logger15.debug(`[CloudContainer] Poll #${attempt} for ${containerId}: status=${status}`);
+      logger16.debug(`[CloudContainer] Poll #${attempt} for ${containerId}: status=${status}`);
       if (status === "running") {
-        logger15.info(`[CloudContainer] Container ${containerId} is now running at ${container.load_balancer_url}`);
+        logger16.info(`[CloudContainer] Container ${containerId} is now running at ${container.load_balancer_url}`);
         this.startHealthMonitoring(containerId);
         return;
       }
       if (status === "failed" || status === "stopped" || status === "suspended") {
-        logger15.warn(`[CloudContainer] Container ${containerId} reached terminal state: ${status}`);
+        logger16.warn(`[CloudContainer] Container ${containerId} reached terminal state: ${status}`);
         if (container.error_message) {
-          logger15.error(`[CloudContainer] Error: ${container.error_message}`);
+          logger16.error(`[CloudContainer] Error: ${container.error_message}`);
         }
         return;
       }
@@ -1939,10 +2605,10 @@ class CloudContainerService extends Service4 {
     tracked.healthTimer = setInterval(() => {
       this.getContainerHealth(containerId).then((health) => {
         if (!health.data.healthy) {
-          logger15.warn(`[CloudContainer] Container ${containerId} unhealthy: ${health.data.status}`);
+          logger16.warn(`[CloudContainer] Container ${containerId} unhealthy: ${health.data.status}`);
         }
       }).catch((err) => {
-        logger15.error(`[CloudContainer] Health check failed for ${containerId}: ${err.message}`);
+        logger16.error(`[CloudContainer] Health check failed for ${containerId}: ${err.message}`);
       });
     }, interval);
   }
@@ -1964,7 +2630,622 @@ class CloudContainerService extends Service4 {
   }
 }
 
+// services/cloud-managed-gateway-relay.ts
+import {
+  ChannelType,
+  ContentType,
+  createMessageMemory,
+  createUniqueUuid,
+  logger as logger17,
+  Service as Service6
+} from "@elizaos/core";
+var POLL_TIMEOUT_MS = 25000;
+var REQUEST_TIMEOUT_MS = POLL_TIMEOUT_MS + 5000;
+var RETRY_DELAY_MS = 2000;
+var IDLE_DELAY_MS = 250;
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isUuidLike(value) {
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value);
+}
+function asTrimmedString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function resolveChannelType(value) {
+  const candidate = asTrimmedString(value)?.toUpperCase();
+  return candidate && candidate in ChannelType ? ChannelType[candidate] : ChannelType.DM;
+}
+function isCloudProvisionedRuntime() {
+  if (typeof process === "undefined") {
+    return false;
+  }
+  return process.env.ELIZA_CLOUD_PROVISIONED === "1";
+}
+function isNodeHost() {
+  return typeof process !== "undefined" && typeof process.versions?.node === "string";
+}
+function normalizeAttachments(value) {
+  if (!Array.isArray(value)) {
+    return;
+  }
+  const attachments = value.map((entry, index) => {
+    if (!isRecord(entry)) {
+      return null;
+    }
+    const url = asTrimmedString(entry.url);
+    if (!url) {
+      return null;
+    }
+    const type = asTrimmedString(entry.type)?.toLowerCase();
+    return {
+      id: asTrimmedString(entry.id) ?? `${index}:${url}`,
+      url,
+      source: asTrimmedString(entry.source),
+      title: asTrimmedString(entry.title),
+      description: asTrimmedString(entry.description),
+      text: asTrimmedString(entry.text),
+      contentType: type === "image" ? ContentType.IMAGE : type === "video" ? ContentType.VIDEO : type === "audio" ? ContentType.AUDIO : type === "document" ? ContentType.DOCUMENT : undefined
+    };
+  }).filter((entry) => entry !== null);
+  return attachments.length > 0 ? attachments : undefined;
+}
+function toJsonRecord(value) {
+  return isRecord(value) ? value : undefined;
+}
+function toJsonMetadataRecord(value) {
+  if (!isRecord(value)) {
+    return;
+  }
+  return JSON.parse(JSON.stringify(value));
+}
+function buildGatewayMessagePayload(runtime, rpc) {
+  const params = toJsonRecord(rpc.params);
+  const sender = toJsonRecord(params?.sender);
+  const source = asTrimmedString(params?.source) ?? "eliza_cloud_gateway";
+  const text = typeof params?.text === "string" ? params.text : "";
+  const senderId = asTrimmedString(sender?.id) ?? `${source}:anonymous`;
+  const senderUserName = asTrimmedString(sender?.username) ?? senderId;
+  const senderName = asTrimmedString(sender?.displayName) ?? asTrimmedString(sender?.name) ?? senderUserName;
+  const roomKey = asTrimmedString(params?.roomId) ?? `${source}:${senderId}:${String(rpc.id ?? Date.now())}:${runtime.agentId}`;
+  if (!text.trim() && !normalizeAttachments(params?.attachments)?.length) {
+    return null;
+  }
+  return {
+    text: text.trim() || " ",
+    roomKey,
+    channelType: resolveChannelType(params?.channelType),
+    source,
+    senderId,
+    senderUserName,
+    senderName,
+    attachments: normalizeAttachments(params?.attachments),
+    senderMetadata: toJsonRecord(sender?.metadata),
+    transportMetadata: toJsonRecord(params?.metadata)
+  };
+}
+function buildWorldKey(source, metadata, roomKey) {
+  const discord = toJsonRecord(metadata?.discord);
+  const guildId = asTrimmedString(discord?.guildId);
+  if (guildId) {
+    return `gateway:${source}:guild:${guildId}`;
+  }
+  const threadId = asTrimmedString(metadata?.threadId);
+  if (threadId) {
+    return `gateway:${source}:thread:${threadId}`;
+  }
+  return `gateway:${source}:room:${roomKey}`;
+}
+
+class SessionMissingError extends Error {
+  constructor() {
+    super("Gateway relay session missing");
+    this.name = "SessionMissingError";
+  }
+}
+
+class CloudManagedGatewayRelayService extends Service6 {
+  static serviceType = "CLOUD_MANAGED_GATEWAY_RELAY";
+  capabilityDescription = "Registers a local Eliza runtime with the cloud managed gateway and handles inbound relay traffic";
+  authService = null;
+  loopPromise = null;
+  currentSessionId = null;
+  stopping = false;
+  activeAbortController = null;
+  relayStatus = "idle";
+  lastSeenAt = null;
+  static async start(runtime) {
+    const service = new CloudManagedGatewayRelayService(runtime);
+    await service.initialize();
+    return service;
+  }
+  async stop() {
+    this.stopping = true;
+    this.relayStatus = "stopped";
+    this.activeAbortController?.abort();
+    if (this.loopPromise) {
+      await this.loopPromise.catch((error) => {
+        logger17.debug(`[CloudManagedGatewayRelay] Ignoring relay loop shutdown error: ${error instanceof Error ? error.message : String(error)}`);
+      });
+    }
+    const sessionId = this.currentSessionId;
+    this.currentSessionId = null;
+    if (sessionId) {
+      await this.disconnectSession(sessionId);
+    }
+  }
+  async initialize() {
+    if (!isNodeHost()) {
+      logger17.debug("[CloudManagedGatewayRelay] Skipping gateway relay outside Node.js runtime");
+      this.relayStatus = "stopped";
+      return;
+    }
+    if (isCloudProvisionedRuntime()) {
+      logger17.debug("[CloudManagedGatewayRelay] Skipping local relay inside provisioned cloud runtime");
+      this.relayStatus = "stopped";
+      return;
+    }
+    if (!this.runtime.messageService) {
+      logger17.debug("[CloudManagedGatewayRelay] Skipping gateway relay without message service");
+      this.relayStatus = "idle";
+      return;
+    }
+    const auth = this.runtime.getService("CLOUD_AUTH");
+    if (!auth) {
+      logger17.debug("[CloudManagedGatewayRelay] CloudAuthService not available");
+      this.relayStatus = "idle";
+      return;
+    }
+    this.authService = auth;
+    if (!this.authService.isAuthenticated()) {
+      logger17.debug("[CloudManagedGatewayRelay] Skipping gateway relay while cloud auth is inactive");
+      this.relayStatus = "idle";
+      return;
+    }
+    this.startRelayLoopIfReady();
+  }
+  getSessionInfo() {
+    const auth = this.authService;
+    const status = this.stopping || this.relayStatus === "stopped" ? "stopped" : auth?.isAuthenticated() === false ? "idle" : this.relayStatus;
+    return {
+      sessionId: this.currentSessionId,
+      organizationId: auth?.getOrganizationId() ?? null,
+      userId: auth?.getUserId() ?? null,
+      agentName: this.getAgentName(),
+      platform: "local-runtime",
+      lastSeenAt: this.lastSeenAt,
+      status
+    };
+  }
+  startRelayLoopIfReady() {
+    if (this.loopPromise && !this.stopping) {
+      return true;
+    }
+    const auth = this.authService ?? this.runtime.getService("CLOUD_AUTH");
+    if (!auth?.isAuthenticated() || !this.runtime.messageService) {
+      this.relayStatus = "idle";
+      return false;
+    }
+    this.authService = auth;
+    this.stopping = false;
+    this.relayStatus = "idle";
+    this.loopPromise = this.runLoop();
+    logger17.info("[CloudManagedGatewayRelay] Local gateway relay loop started");
+    return true;
+  }
+  async runLoop() {
+    while (!this.stopping) {
+      try {
+        if (!this.currentSessionId) {
+          this.currentSessionId = await this.registerSession();
+          this.relayStatus = "registered";
+          this.lastSeenAt = new Date().toISOString();
+          continue;
+        }
+        this.relayStatus = "polling";
+        const request = await this.pollNextRequest(this.currentSessionId);
+        this.lastSeenAt = new Date().toISOString();
+        if (!request) {
+          this.relayStatus = "registered";
+          await sleep(IDLE_DELAY_MS);
+          continue;
+        }
+        const response = await this.handleRequest(request.rpc);
+        await this.submitResponse(this.currentSessionId, request.requestId, response);
+        this.relayStatus = "registered";
+      } catch (error) {
+        if (this.stopping) {
+          return;
+        }
+        if (error instanceof SessionMissingError) {
+          this.currentSessionId = null;
+          this.relayStatus = "idle";
+          await sleep(IDLE_DELAY_MS);
+          continue;
+        }
+        this.relayStatus = "error";
+        logger17.warn(`[CloudManagedGatewayRelay] Relay loop error: ${error instanceof Error ? error.message : String(error)}`);
+        await sleep(RETRY_DELAY_MS);
+      }
+    }
+  }
+  getAgentName() {
+    return this.runtime.character?.name?.trim() || "Eliza";
+  }
+  getClient() {
+    const client = this.authService?.getClient();
+    if (!client) {
+      throw new Error("Cloud API client is unavailable");
+    }
+    return client;
+  }
+  async requestJson(path, options) {
+    const timeoutMs = options.timeoutMs ?? REQUEST_TIMEOUT_MS;
+    const controller = new AbortController;
+    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+    this.activeAbortController = controller;
+    try {
+      const response = await this.getClient().requestRaw(options.method, path, {
+        headers: {
+          Accept: "application/json"
+        },
+        json: options.json,
+        query: options.query,
+        signal: controller.signal
+      });
+      const body = await response.json().catch(() => ({}));
+      return { status: response.status, body };
+    } finally {
+      clearTimeout(timeoutId);
+      if (this.activeAbortController === controller) {
+        this.activeAbortController = null;
+      }
+    }
+  }
+  async registerSession() {
+    const { status, body } = await this.requestJson("/eliza/gateway-relay/sessions", {
+      method: "POST",
+      json: {
+        runtimeAgentId: this.runtime.agentId,
+        agentName: this.getAgentName()
+      }
+    });
+    if (status >= 400 || !body?.success || !body.data?.session?.id) {
+      throw new Error(`Failed to register gateway relay session (status=${status})`);
+    }
+    logger17.info(`[CloudManagedGatewayRelay] Registered local runtime for managed gateway (${body.data.session.id})`);
+    return body.data.session.id;
+  }
+  async disconnectSession(sessionId) {
+    try {
+      await this.requestJson(`/eliza/gateway-relay/sessions/${encodeURIComponent(sessionId)}`, {
+        method: "DELETE",
+        timeoutMs: 1e4
+      });
+    } catch (error) {
+      logger17.debug(`[CloudManagedGatewayRelay] Failed to disconnect relay session ${sessionId}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  async pollNextRequest(sessionId) {
+    const { status, body } = await this.requestJson(`/eliza/gateway-relay/sessions/${encodeURIComponent(sessionId)}/next`, {
+      method: "GET",
+      query: { timeoutMs: POLL_TIMEOUT_MS },
+      timeoutMs: POLL_TIMEOUT_MS + 5000
+    });
+    if (status === 404) {
+      throw new SessionMissingError;
+    }
+    if (status >= 400 || !body?.success) {
+      throw new Error(`Failed to poll gateway relay session ${sessionId} (status=${status})`);
+    }
+    return body.data?.request ?? null;
+  }
+  async submitResponse(sessionId, requestId, response) {
+    const { status, body } = await this.requestJson(`/eliza/gateway-relay/sessions/${encodeURIComponent(sessionId)}/responses`, {
+      method: "POST",
+      json: { requestId, response }
+    });
+    if (status === 404) {
+      throw new SessionMissingError;
+    }
+    if (status >= 400 || body?.success === false) {
+      throw new Error(`Failed to submit gateway relay response (status=${status})`);
+    }
+  }
+  async handleRequest(rpc) {
+    switch (rpc.method) {
+      case "heartbeat":
+        return {
+          jsonrpc: "2.0",
+          id: rpc.id,
+          result: { timestamp: Date.now() }
+        };
+      case "status.get":
+        return {
+          jsonrpc: "2.0",
+          id: rpc.id,
+          result: {
+            status: "running",
+            runtimeAgentId: this.runtime.agentId,
+            agentName: this.getAgentName()
+          }
+        };
+      case "message.send":
+        return this.handleMessageSend(rpc);
+      default:
+        return {
+          jsonrpc: "2.0",
+          id: rpc.id,
+          error: {
+            code: -32601,
+            message: `Unsupported relay method: ${rpc.method}`
+          }
+        };
+    }
+  }
+  async handleMessageSend(rpc) {
+    if (!this.runtime.messageService) {
+      return {
+        jsonrpc: "2.0",
+        id: rpc.id,
+        error: { code: -32603, message: "Message service is not available" }
+      };
+    }
+    const payload = buildGatewayMessagePayload(this.runtime, rpc);
+    if (!payload) {
+      return {
+        jsonrpc: "2.0",
+        id: rpc.id,
+        error: { code: -32602, message: "Invalid message relay payload" }
+      };
+    }
+    const roomId = isUuidLike(payload.roomKey) ? payload.roomKey : createUniqueUuid(this.runtime, payload.roomKey);
+    const worldId = createUniqueUuid(this.runtime, buildWorldKey(payload.source, payload.transportMetadata, payload.roomKey));
+    const entityId = createUniqueUuid(this.runtime, `${payload.source}:${payload.senderId}`);
+    const messageServerId = createUniqueUuid(this.runtime, `eliza-cloud-gateway:${payload.source}`);
+    const messageId = createUniqueUuid(this.runtime, `${payload.source}:${payload.roomKey}:${String(rpc.id ?? Date.now())}:inbound`);
+    const transportMetadata = toJsonMetadataRecord(payload.transportMetadata);
+    await this.runtime.ensureConnection({
+      entityId,
+      roomId,
+      roomName: payload.roomKey,
+      worldId,
+      worldName: payload.source,
+      userName: payload.senderUserName,
+      name: payload.senderName,
+      source: payload.source,
+      channelId: payload.roomKey,
+      type: payload.channelType,
+      messageServerId,
+      metadata: transportMetadata
+    });
+    const message = createMessageMemory({
+      id: messageId,
+      entityId,
+      agentId: this.runtime.agentId,
+      roomId,
+      content: {
+        text: payload.text,
+        source: payload.source,
+        channelType: payload.channelType,
+        ...payload.attachments ? { attachments: payload.attachments } : {}
+      }
+    });
+    message.metadata = {
+      ...message.metadata,
+      entityName: payload.senderName,
+      entityUserName: payload.senderUserName,
+      ...payload.senderMetadata ? { gatewaySender: toJsonMetadataRecord(payload.senderMetadata) } : {},
+      ...payload.transportMetadata ? { gatewayMetadata: transportMetadata } : {}
+    };
+    const callbackTexts = [];
+    const callback = async (content) => {
+      const responseText = typeof content.text === "string" ? content.text : "";
+      if (responseText.trim()) {
+        callbackTexts.push(responseText);
+      }
+      const responseMemory = createMessageMemory({
+        id: createUniqueUuid(this.runtime, `${payload.source}:${payload.roomKey}:${String(rpc.id ?? Date.now())}:response:${callbackTexts.length}`),
+        entityId: this.runtime.agentId,
+        agentId: this.runtime.agentId,
+        roomId,
+        content: {
+          ...content,
+          text: responseText,
+          source: payload.source,
+          channelType: payload.channelType
+        }
+      });
+      await this.runtime.createMemory(responseMemory, "messages");
+      return [responseMemory];
+    };
+    try {
+      const result = await this.runtime.messageService.handleMessage(this.runtime, message, callback);
+      const replyText = callbackTexts[callbackTexts.length - 1] ?? (typeof result.responseContent?.text === "string" ? result.responseContent.text : undefined);
+      return {
+        jsonrpc: "2.0",
+        id: rpc.id,
+        result: {
+          didRespond: result.didRespond,
+          ...replyText ? { text: replyText } : {},
+          runtimeAgentId: this.runtime.agentId
+        }
+      };
+    } catch (error) {
+      return {
+        jsonrpc: "2.0",
+        id: rpc.id,
+        error: {
+          code: -32603,
+          message: error instanceof Error ? error.message : String(error)
+        }
+      };
+    }
+  }
+}
+
+// services/cloud-model-registry.ts
+import { logger as logger18, Service as Service7 } from "@elizaos/core";
+var CACHE_TTL_MS = 30 * 60 * 1000;
+var PROVIDER_PREFIXES = [
+  ["gpt-", "openai"],
+  ["o1", "openai"],
+  ["o3", "openai"],
+  ["o4", "openai"],
+  ["dall-e", "openai"],
+  ["whisper", "openai"],
+  ["tts", "openai"],
+  ["claude-", "anthropic"],
+  ["gemini-", "google"],
+  ["llama", "meta"],
+  ["deepseek", "deepseek"],
+  ["grok", "xai"],
+  ["kimi", "moonshot"]
+];
+function extractProvider(modelId) {
+  if (modelId.includes("/"))
+    return modelId.split("/")[0];
+  const lower = modelId.toLowerCase();
+  for (const [prefix, provider] of PROVIDER_PREFIXES) {
+    if (lower.startsWith(prefix))
+      return provider;
+  }
+  return "unknown";
+}
+function stripProvider(modelId) {
+  if (modelId.includes("/")) {
+    return modelId.split("/").slice(1).join("/");
+  }
+  return modelId;
+}
+
+class CloudModelRegistryService extends Service7 {
+  static serviceType = "CLOUD_MODEL_REGISTRY";
+  capabilityDescription = "Discovers and caches available AI models from ElizaCloud";
+  models = [];
+  byProvider = {};
+  lastFetchedAt = 0;
+  fetchPromise = null;
+  static async start(runtime) {
+    const service = new CloudModelRegistryService(runtime);
+    await service.initialize();
+    return service;
+  }
+  async stop() {
+    this.models = [];
+    this.byProvider = {};
+    this.lastFetchedAt = 0;
+  }
+  async initialize() {
+    const auth = this.runtime.getService("CLOUD_AUTH");
+    if (!auth?.isAuthenticated()) {
+      logger18.info("[CloudModelRegistry] Auth not available, will fetch models on first access");
+      return;
+    }
+    await this.fetchModels();
+    this.validateConfiguredModels();
+  }
+  async fetchModels() {
+    if (this.fetchPromise) {
+      await this.fetchPromise;
+      return;
+    }
+    this.fetchPromise = this.doFetchModels();
+    await this.fetchPromise;
+    this.fetchPromise = null;
+  }
+  async doFetchModels() {
+    const auth = this.runtime.getService("CLOUD_AUTH");
+    if (!auth?.isAuthenticated())
+      return;
+    const client = auth.getClient();
+    const response = await client.get("/models");
+    const entries = response.data ?? [];
+    this.models = entries.map((entry) => ({
+      id: entry.id,
+      provider: extractProvider(entry.id),
+      name: stripProvider(entry.id),
+      createdAt: entry.created
+    }));
+    this.byProvider = {};
+    for (const model of this.models) {
+      if (!this.byProvider[model.provider]) {
+        this.byProvider[model.provider] = [];
+      }
+      this.byProvider[model.provider].push(model);
+    }
+    this.lastFetchedAt = Date.now();
+    logger18.info(`[CloudModelRegistry] Loaded ${this.models.length} models from ${Object.keys(this.byProvider).length} providers`);
+  }
+  validateConfiguredModels() {
+    if (this.models.length === 0)
+      return;
+    const modelIds = new Set(this.models.map((m) => m.id));
+    const nameSet = new Set(this.models.map((m) => m.name));
+    const settingsToCheck = [
+      { key: "ELIZAOS_CLOUD_NANO_MODEL", label: "nano model" },
+      { key: "ELIZAOS_CLOUD_MEDIUM_MODEL", label: "medium model" },
+      { key: "ELIZAOS_CLOUD_SMALL_MODEL", label: "small model" },
+      { key: "ELIZAOS_CLOUD_LARGE_MODEL", label: "large model" },
+      { key: "ELIZAOS_CLOUD_MEGA_MODEL", label: "mega model" },
+      {
+        key: "ELIZAOS_CLOUD_RESPONSE_HANDLER_MODEL",
+        label: "response handler model"
+      },
+      {
+        key: "ELIZAOS_CLOUD_ACTION_PLANNER_MODEL",
+        label: "action planner model"
+      },
+      { key: "ELIZAOS_CLOUD_RESPONSE_MODEL", label: "response model" },
+      { key: "ELIZAOS_CLOUD_RESEARCH_MODEL", label: "research model" },
+      { key: "ELIZAOS_CLOUD_EMBEDDING_MODEL", label: "embedding model" },
+      {
+        key: "ELIZAOS_CLOUD_IMAGE_DESCRIPTION_MODEL",
+        label: "image description model"
+      },
+      {
+        key: "ELIZAOS_CLOUD_IMAGE_GENERATION_MODEL",
+        label: "image generation model"
+      },
+      { key: "ELIZAOS_CLOUD_TTS_MODEL", label: "TTS model" },
+      {
+        key: "ELIZAOS_CLOUD_TRANSCRIPTION_MODEL",
+        label: "transcription model"
+      }
+    ];
+    for (const { key, label } of settingsToCheck) {
+      const value = this.runtime.getSetting(key);
+      if (value && typeof value === "string") {
+        const found = modelIds.has(value) || nameSet.has(value);
+        if (!found) {
+          logger18.warn(`[CloudModelRegistry] Configured ${label} "${value}" not found in available models. ` + "It may still work if the gateway supports it, but check your configuration.");
+        }
+      }
+    }
+  }
+  async getAvailableModels() {
+    if (Date.now() - this.lastFetchedAt > CACHE_TTL_MS) {
+      await this.fetchModels();
+    }
+    return this.models;
+  }
+  async getModelsByProvider() {
+    if (Date.now() - this.lastFetchedAt > CACHE_TTL_MS) {
+      await this.fetchModels();
+    }
+    return this.byProvider;
+  }
+}
+
 // index.ts
+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";
 function getProcessEnv() {
   if (typeof process === "undefined") {
     return {};
@@ -1979,38 +3260,77 @@ var elizaOSCloudPlugin = {
     ELIZAOS_CLOUD_API_KEY: env.ELIZAOS_CLOUD_API_KEY ?? null,
     ELIZAOS_CLOUD_BASE_URL: env.ELIZAOS_CLOUD_BASE_URL ?? null,
     ELIZAOS_CLOUD_ENABLED: env.ELIZAOS_CLOUD_ENABLED ?? null,
+    ELIZAOS_CLOUD_NANO_MODEL: env.ELIZAOS_CLOUD_NANO_MODEL ?? null,
+    ELIZAOS_CLOUD_MEDIUM_MODEL: env.ELIZAOS_CLOUD_MEDIUM_MODEL ?? null,
     ELIZAOS_CLOUD_SMALL_MODEL: env.ELIZAOS_CLOUD_SMALL_MODEL ?? null,
     ELIZAOS_CLOUD_LARGE_MODEL: env.ELIZAOS_CLOUD_LARGE_MODEL ?? null,
+    ELIZAOS_CLOUD_MEGA_MODEL: env.ELIZAOS_CLOUD_MEGA_MODEL ?? null,
+    ELIZAOS_CLOUD_RESPONSE_HANDLER_MODEL: env.ELIZAOS_CLOUD_RESPONSE_HANDLER_MODEL ?? null,
+    ELIZAOS_CLOUD_SHOULD_RESPOND_MODEL: env.ELIZAOS_CLOUD_SHOULD_RESPOND_MODEL ?? null,
+    ELIZAOS_CLOUD_ACTION_PLANNER_MODEL: env.ELIZAOS_CLOUD_ACTION_PLANNER_MODEL ?? null,
+    ELIZAOS_CLOUD_PLANNER_MODEL: env.ELIZAOS_CLOUD_PLANNER_MODEL ?? null,
+    ELIZAOS_CLOUD_RESPONSE_MODEL: env.ELIZAOS_CLOUD_RESPONSE_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,
+    RESPONSE_MODEL: env.RESPONSE_MODEL ?? null,
+    ELIZAOS_CLOUD_RESEARCH_MODEL: env.ELIZAOS_CLOUD_RESEARCH_MODEL ?? null,
+    RESEARCH_MODEL: env.RESEARCH_MODEL ?? null,
     ELIZAOS_CLOUD_EMBEDDING_MODEL: env.ELIZAOS_CLOUD_EMBEDDING_MODEL ?? null,
     ELIZAOS_CLOUD_EMBEDDING_API_KEY: env.ELIZAOS_CLOUD_EMBEDDING_API_KEY ?? null,
     ELIZAOS_CLOUD_EMBEDDING_URL: env.ELIZAOS_CLOUD_EMBEDDING_URL ?? null,
     ELIZAOS_CLOUD_EMBEDDING_DIMENSIONS: env.ELIZAOS_CLOUD_EMBEDDING_DIMENSIONS ?? null,
     ELIZAOS_CLOUD_IMAGE_DESCRIPTION_MODEL: env.ELIZAOS_CLOUD_IMAGE_DESCRIPTION_MODEL ?? null,
     ELIZAOS_CLOUD_IMAGE_DESCRIPTION_MAX_TOKENS: env.ELIZAOS_CLOUD_IMAGE_DESCRIPTION_MAX_TOKENS ?? null,
-    ELIZAOS_CLOUD_EXPERIMENTAL_TELEMETRY: env.ELIZAOS_CLOUD_EXPERIMENTAL_TELEMETRY ?? null,
-    ELIZAOS_CLOUD_IMAGE_GENERATION_MODEL: env.ELIZAOS_CLOUD_IMAGE_GENERATION_MODEL ?? null
+    ELIZAOS_CLOUD_IMAGE_GENERATION_MODEL: env.ELIZAOS_CLOUD_IMAGE_GENERATION_MODEL ?? null,
+    ELIZAOS_CLOUD_TTS_MODEL: env.ELIZAOS_CLOUD_TTS_MODEL ?? null,
+    ELIZAOS_CLOUD_TRANSCRIPTION_MODEL: env.ELIZAOS_CLOUD_TRANSCRIPTION_MODEL ?? null,
+    ELIZAOS_CLOUD_EXPERIMENTAL_TELEMETRY: env.ELIZAOS_CLOUD_EXPERIMENTAL_TELEMETRY ?? null
   },
   async init(config, runtime) {
     initializeOpenAI(config, runtime);
   },
-  services: [CloudAuthService, CloudContainerService, CloudBridgeService, CloudBackupService],
+  services: [
+    CloudAuthService,
+    CloudBootstrapServiceImpl,
+    CloudManagedGatewayRelayService,
+    CloudModelRegistryService,
+    CloudContainerService,
+    CloudBridgeService,
+    CloudBackupService
+  ],
   actions: [
     provisionCloudAgentAction,
     freezeCloudAgentAction,
     resumeCloudAgentAction,
     checkCloudCreditsAction
   ],
-  providers: [cloudStatusProvider, creditBalanceProvider, containerHealthProvider],
+  providers: [
+    cloudStatusProvider,
+    creditBalanceProvider,
+    containerHealthProvider,
+    modelRegistryProvider
+  ],
   models: {
-    [ModelType5.TEXT_EMBEDDING]: handleTextEmbedding,
-    [ModelType5.TEXT_SMALL]: handleTextSmall,
-    [ModelType5.TEXT_LARGE]: handleTextLarge,
-    [ModelType5.IMAGE]: handleImageGeneration,
-    [ModelType5.IMAGE_DESCRIPTION]: handleImageDescription,
-    [ModelType5.OBJECT_SMALL]: handleObjectSmall,
-    [ModelType5.OBJECT_LARGE]: handleObjectLarge
+    [ModelType6.TEXT_EMBEDDING]: handleTextEmbedding,
+    [TEXT_NANO_MODEL_TYPE2]: handleTextNano,
+    [TEXT_MEDIUM_MODEL_TYPE2]: handleTextMedium,
+    [ModelType6.TEXT_SMALL]: handleTextSmall,
+    [ModelType6.TEXT_LARGE]: handleTextLarge,
+    [TEXT_MEGA_MODEL_TYPE2]: handleTextMega,
+    [RESPONSE_HANDLER_MODEL_TYPE2]: handleResponseHandler,
+    [ACTION_PLANNER_MODEL_TYPE2]: handleActionPlanner,
+    [ModelType6.RESEARCH]: handleResearch,
+    [ModelType6.IMAGE]: handleImageGeneration,
+    [ModelType6.IMAGE_DESCRIPTION]: handleImageDescription,
+    [ModelType6.OBJECT_SMALL]: handleObjectSmall,
+    [ModelType6.OBJECT_LARGE]: handleObjectLarge
   },
   tests: [
     {
@@ -2019,118 +3339,109 @@ var elizaOSCloudPlugin = {
         {
           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();
-            logger16.log({
-              data: data?.data?.length ?? "N/A"
+            const data = await createCloudApiClient(runtime).get("/models");
+            logger19.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) => {
-            const embedding = await runtime.useModel(ModelType5.TEXT_EMBEDDING, {
+            const embedding = await runtime.useModel(ModelType6.TEXT_EMBEDDING, {
               text: "Hello, world!"
             });
-            logger16.log({ embedding }, "embedding");
+            logger19.log({ embedding }, "embedding");
           }
         },
         {
           name: "ELIZAOS_CLOUD_test_text_large",
           fn: async (runtime) => {
-            const text = await runtime.useModel(ModelType5.TEXT_LARGE, {
+            const text = await runtime.useModel(ModelType6.TEXT_LARGE, {
               prompt: "What is the nature of reality in 10 words?"
             });
             if (text.length === 0) {
               throw new Error("Failed to generate text");
             }
-            logger16.log({ text }, "generated with test_text_large");
+            logger19.log({ text }, "generated with test_text_large");
           }
         },
         {
           name: "ELIZAOS_CLOUD_test_text_small",
           fn: async (runtime) => {
-            const text = await runtime.useModel(ModelType5.TEXT_SMALL, {
+            const text = await runtime.useModel(ModelType6.TEXT_SMALL, {
               prompt: "What is the nature of reality in 10 words?"
             });
             if (text.length === 0) {
               throw new Error("Failed to generate text");
             }
-            logger16.log({ text }, "generated with test_text_small");
+            logger19.log({ text }, "generated with test_text_small");
           }
         },
         {
           name: "ELIZAOS_CLOUD_test_image_generation",
           fn: async (runtime) => {
-            logger16.log("ELIZAOS_CLOUD_test_image_generation");
-            const image = await runtime.useModel(ModelType5.IMAGE, {
+            logger19.log("ELIZAOS_CLOUD_test_image_generation");
+            const image = await runtime.useModel(ModelType6.IMAGE, {
               prompt: "A beautiful sunset over a calm ocean",
               count: 1,
               size: "1024x1024"
             });
-            logger16.log({ image }, "generated with test_image_generation");
+            logger19.log({ image }, "generated with test_image_generation");
           }
         },
         {
           name: "image-description",
           fn: async (runtime) => {
-            logger16.log("ELIZAOS_CLOUD_test_image_description");
-            const result = await runtime.useModel(ModelType5.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");
+            logger19.log("ELIZAOS_CLOUD_test_image_description");
+            const result = await runtime.useModel(ModelType6.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) {
-              logger16.log({ result }, "Image description");
+              logger19.log({ result }, "Image description");
             } else {
-              logger16.error(`Invalid image description result format: ${JSON.stringify(result)}`);
+              logger19.error(`Invalid image description result format: ${JSON.stringify(result)}`);
             }
           }
         },
         {
           name: "ELIZAOS_CLOUD_test_transcription",
           fn: async (runtime) => {
-            logger16.log("ELIZAOS_CLOUD_test_transcription");
+            logger19.log("ELIZAOS_CLOUD_test_transcription");
             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(ModelType5.TRANSCRIPTION, Buffer.from(new Uint8Array(arrayBuffer)));
-            logger16.log({ transcription }, "generated with test_transcription");
+            const transcription = await runtime.useModel(ModelType6.TRANSCRIPTION, Buffer.from(new Uint8Array(arrayBuffer)));
+            logger19.log({ transcription }, "generated with test_transcription");
           }
         },
         {
           name: "ELIZAOS_CLOUD_test_text_tokenizer_encode",
           fn: async (runtime) => {
             const prompt = "Hello tokenizer encode!";
-            const tokens = await runtime.useModel(ModelType5.TEXT_TOKENIZER_ENCODE, {
+            const tokens = await runtime.useModel(ModelType6.TEXT_TOKENIZER_ENCODE, {
               prompt,
-              modelType: ModelType5.TEXT_SMALL
+              modelType: ModelType6.TEXT_SMALL
             });
             if (!Array.isArray(tokens) || tokens.length === 0) {
               throw new Error("Failed to tokenize text: expected non-empty array of tokens");
             }
-            logger16.log({ tokens }, "Tokenized output");
+            logger19.log({ tokens }, "Tokenized output");
           }
         },
         {
           name: "ELIZAOS_CLOUD_test_text_tokenizer_decode",
           fn: async (runtime) => {
             const prompt = "Hello tokenizer decode!";
-            const tokens = await runtime.useModel(ModelType5.TEXT_TOKENIZER_ENCODE, {
+            const tokens = await runtime.useModel(ModelType6.TEXT_TOKENIZER_ENCODE, {
               prompt,
-              modelType: ModelType5.TEXT_SMALL
+              modelType: ModelType6.TEXT_SMALL
             });
-            const decodedText = await runtime.useModel(ModelType5.TEXT_TOKENIZER_DECODE, {
+            const decodedText = await runtime.useModel(ModelType6.TEXT_TOKENIZER_DECODE, {
               tokens,
-              modelType: ModelType5.TEXT_SMALL
+              modelType: ModelType6.TEXT_SMALL
             });
             if (decodedText !== prompt) {
               throw new Error(`Decoded text does not match original. Expected "${prompt}", got "${decodedText}"`);
             }
-            logger16.log({ decodedText }, "Decoded text");
+            logger19.log({ decodedText }, "Decoded text");
           }
         },
         {
@@ -2142,17 +3453,20 @@ var elizaOSCloudPlugin = {
             if (!response) {
               throw new Error("Failed to generate speech");
             }
-            logger16.log("Generated speech successfully");
+            logger19.log("Generated speech successfully");
           }
         }
       ]
     }
   ]
 };
-var typescript_default = elizaOSCloudPlugin;
+var plugin_elizacloud_default = elizaOSCloudPlugin;
+
+// index.node.ts
+var index_node_default = plugin_elizacloud_default;
 export {
   elizaOSCloudPlugin,
-  typescript_default as default
+  index_node_default as default
 };
 
-//# debugId=2380024BE3C1D9F164756E2164756E21
+//# debugId=6243C8A3ED6780E664756E2164756E21