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

package/dist/cjs/index.node.cjs

@@ -1,41 +1,38 @@
-var __create = Object.create;
-var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __toESM = (mod, isNodeMode, target) => {
-  target = mod != null ? __create(__getProtoOf(mod)) : {};
-  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: () => mod[key],
-        enumerable: true
-      });
-  return to;
-};
-var __moduleCache = /* @__PURE__ */ new WeakMap;
+function __accessProp(key) {
+  return this[key];
+}
 var __toCommonJS = (from) => {
-  var entry = __moduleCache.get(from), desc;
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
   if (entry)
     return entry;
   entry = __defProp({}, "__esModule", { value: true });
-  if (from && typeof from === "object" || typeof from === "function")
-    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
-      get: () => from[key],
-      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-    }));
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
   __moduleCache.set(from, entry);
   return entry;
 };
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
     });
 };
 
@@ -43,24 +40,20 @@ var __export = (target, all) => {
 var exports_index_node = {};
 __export(exports_index_node, {
   elizaOSCloudPlugin: () => elizaOSCloudPlugin,
-  default: () => typescript_default
+  default: () => index_node_default
 });
 module.exports = __toCommonJS(exports_index_node);
 
 // index.ts
-var import_core19 = require("@elizaos/core");
+var import_core20 = require("@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.",
-  similes: [
-    "check credits",
-    "check balance",
-    "how much credit",
-    "cloud billing"
-  ],
+  descriptionCompressed: "Check ElizaCloud credits, container costs, remaining runtime.",
+  similes: ["check credits", "check balance", "how much credit", "cloud billing"],
   tags: ["cloud", "billing"],
   parameters: [
     {
@@ -70,8 +63,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");
@@ -113,22 +127,37 @@ 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.",
-  similes: [
-    "freeze agent",
-    "hibernate agent",
-    "pause agent",
-    "stop cloud agent"
-  ],
+  descriptionCompressed: "Freeze cloud agent: snapshot, disconnect, stop container.",
+  similes: ["freeze agent", "hibernate agent", "pause agent", "stop cloud agent"],
   tags: ["cloud", "container", "backup"],
   parameters: [
     {
@@ -136,10 +165,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");
@@ -155,6 +211,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"] });
@@ -185,6 +255,7 @@ var freezeCloudAgentAction = {
 var import_core = require("@elizaos/core");
 
 // types/cloud.ts
+var import_cloud_sdk = require("@elizaos/cloud-sdk");
 var DEFAULT_CLOUD_CONFIG = {
   enabled: false,
   baseUrl: "https://www.elizacloud.ai/api/v1",
@@ -208,36 +279,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 = {};
@@ -251,8 +318,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;
@@ -264,6 +332,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",
@@ -301,11 +370,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");
@@ -325,6 +421,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"] });
@@ -355,7 +467,6 @@ var provisionCloudAgentAction = {
       await bridge.connect(id);
       import_core.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." : ""}`);
@@ -377,8 +488,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 ?? {};
 }
@@ -395,12 +507,8 @@ 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.",
-  similes: [
-    "resume agent",
-    "unfreeze agent",
-    "restart cloud agent",
-    "restore agent"
-  ],
+  descriptionCompressed: "Resume frozen cloud agent from snapshot.",
+  similes: ["resume agent", "unfreeze agent", "restart cloud agent", "restore agent"],
   tags: ["cloud", "container", "restore"],
   parameters: [
     {
@@ -426,10 +534,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");
@@ -442,6 +577,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"] });
@@ -468,7 +619,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;
@@ -502,6 +653,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) {
@@ -548,6 +700,7 @@ var cloudStatusProvider = {
 var containerHealthProvider = {
   name: "elizacloud_health",
   description: "ElizaCloud container health",
+  descriptionCompressed: "ElizaCloud container health.",
   dynamic: true,
   position: 92,
   private: true,
@@ -588,12 +741,13 @@ var containerHealthProvider = {
 
 // cloud-providers/credit-balance.ts
 var import_core2 = require("@elizaos/core");
-var TOP_UP_URL = "https://www.elizacloud.ai/dashboard/billing";
+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) {
@@ -644,6 +798,7 @@ 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) {
@@ -699,12 +854,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");
@@ -732,23 +881,32 @@ function getEmbeddingApiKey(runtime) {
   return getApiKey(runtime);
 }
 function getSmallModel(runtime) {
-  return getSetting(runtime, "ELIZAOS_CLOUD_SMALL_MODEL") ?? getSetting(runtime, "SMALL_MODEL", "openai/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", "anthropic/claude-sonnet-4.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");
+  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 getReasoningSmallModel(runtime) {
-  return getSetting(runtime, "ELIZAOS_CLOUD_REASONING_SMALL_MODEL") ?? getSetting(runtime, "REASONING_SMALL_MODEL", "deepseek/deepseek-r1");
-}
-function getReasoningLargeModel(runtime) {
-  return getSetting(runtime, "ELIZAOS_CLOUD_REASONING_LARGE_MODEL") ?? getSetting(runtime, "REASONING_LARGE_MODEL", "anthropic/claude-opus-4.5");
-}
 function getResearchModel(runtime) {
   return getSetting(runtime, "ELIZAOS_CLOUD_RESEARCH_MODEL") ?? getSetting(runtime, "RESEARCH_MODEL", "o3-deep-research");
 }
@@ -757,6 +915,33 @@ function getExperimentalTelemetry(runtime) {
   return String(setting).toLowerCase() === "true";
 }
 
+// utils/sdk-client.ts
+var import_cloud_sdk2 = require("@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 import_cloud_sdk2.CloudApiClient(trimTrailingSlash(baseUrl), apiKeyForRuntime(runtime, embedding));
+}
+function createElizaCloudClient(runtime) {
+  const apiBaseUrl = trimTrailingSlash(getBaseURL(runtime));
+  return new import_cloud_sdk2.ElizaCloudClient({
+    apiBaseUrl,
+    baseUrl: apiBaseToSiteBaseUrl(apiBaseUrl),
+    apiKey: apiKeyForRuntime(runtime)
+  });
+}
+
 // init.ts
 function initializeOpenAI(_config, runtime) {
   (async () => {
@@ -767,20 +952,11 @@ function initializeOpenAI(_config, runtime) {
         return;
       }
       try {
-        const baseURL = getBaseURL(runtime);
-        const response = await fetch(`${baseURL}/models`, {
-          headers: { ...getAuthHeader(runtime) }
-        });
-        if (!response.ok) {
-          import_core4.logger.warn(`ElizaOS Cloud API key validation failed: ${response.statusText}`);
-          import_core4.logger.warn("ElizaOS Cloud functionality will be limited until a valid API key is provided");
-          import_core4.logger.info("Get your API key from https://www.elizacloud.ai/dashboard/api-keys");
-        } else {
-          import_core4.logger.log("ElizaOS Cloud API key validated successfully");
-        }
+        await createCloudApiClient(runtime).get("/models");
+        import_core4.logger.log("ElizaOS Cloud API key validated successfully");
       } catch (fetchError) {
         const message = fetchError instanceof Error ? fetchError.message : String(fetchError);
-        import_core4.logger.warn(`Error validating ElizaOS Cloud API key: ${message}`);
+        import_core4.logger.warn(`ElizaOS Cloud API key validation failed: ${message}`);
         import_core4.logger.warn("ElizaOS Cloud functionality will be limited until a valid API key is provided");
       }
     } catch (error) {
@@ -800,7 +976,7 @@ 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(import_core5.EventType.MODEL_USED, {
+  const payload = {
     runtime,
     source: "elizacloud",
     type,
@@ -809,7 +985,8 @@ function emitModelUsageEvent(runtime, type, _prompt, usage) {
       completion: outputTokens,
       total: totalTokens
     }
-  });
+  };
+  runtime.emitEvent(import_core5.EventType.MODEL_USED, payload);
 }
 
 // models/embeddings.ts
@@ -864,7 +1041,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) {
     import_core6.logger.warn("[BatchEmbeddings] Empty texts array");
     return [];
@@ -889,16 +1066,11 @@ async function handleBatchTextEmbedding(runtime, texts) {
     const batchTexts = batch.map((b) => b.text);
     import_core6.logger.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) {
@@ -908,16 +1080,11 @@ async function handleBatchTextEmbedding(runtime, texts) {
         const retryAfter = rateLimitInfo.retryAfter || 30;
         import_core6.logger.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) {
           import_core6.logger.error(`[BatchEmbeddings] Retry failed: ${retryResponse.status}`);
@@ -1037,7 +1204,6 @@ async function handleImageGeneration(runtime, params) {
   const prompt = params.prompt;
   const modelName = getImageGenerationModel(runtime);
   import_core8.logger.log(`[ELIZAOS_CLOUD] Using IMAGE model: ${modelName}`);
-  const baseURL = getBaseURL(runtime);
   const aspectRatioMap = {
     "1024x1024": "1:1",
     "1792x1024": "16:9",
@@ -1045,27 +1211,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
     }));
@@ -1098,7 +1250,7 @@ async function handleImageDescription(runtime, params) {
       ]
     }
   ];
-  const baseURL = getBaseURL(runtime);
+  const client = createElizaCloudClient(runtime);
   try {
     const requestBody = {
       model: modelName,
@@ -1107,13 +1259,8 @@ async function handleImageDescription(runtime, params) {
     };
     let response = null;
     for (let attempt = 0;attempt < 3; attempt++) {
-      response = await fetch(`${baseURL}/chat/completions`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          ...getAuthHeader(runtime)
-        },
-        body: JSON.stringify(requestBody)
+      response = await client.routes.postApiV1ChatCompletionsRaw({
+        json: requestBody
       });
       if (response.status === 429 && attempt < 2) {
         const wait = (attempt + 1) * 2000;
@@ -1123,10 +1270,10 @@ async function handleImageDescription(runtime, params) {
       }
       break;
     }
-    if (!response || !response.ok) {
+    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/billing");
+        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}`);
     }
@@ -1157,17 +1304,82 @@ async function handleImageDescription(runtime, params) {
 }
 // models/object.ts
 var import_core9 = require("@elizaos/core");
-var import_ai2 = require("ai");
 
-// providers/openai.ts
-var import_openai = require("@ai-sdk/openai");
-function createOpenAIClient(runtime) {
-  const baseURL = getBaseURL(runtime);
-  const apiKey = getApiKey(runtime) ?? (isProxyMode(runtime) ? "eliza-proxy" : undefined);
-  return import_openai.createOpenAI({
-    apiKey: apiKey ?? "",
-    baseURL
-  });
+// 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
@@ -1177,9 +1389,8 @@ var REASONING_MODEL_PATTERNS = [
   "o4",
   "deepseek-r1",
   "deepseek-reasoner",
-  "claude-opus-4.5",
-  "claude-opus-4",
-  "gpt-5-mini",
+  "claude-opus-4.7",
+  "claude-opus-4-7",
   "gpt-5"
 ];
 function isReasoningModel(modelName) {
@@ -1187,50 +1398,85 @@ function isReasoningModel(modelName) {
   return REASONING_MODEL_PATTERNS.some((pattern) => lower.includes(pattern));
 }
 async function generateObjectByModelType(runtime, params, modelType, getModelFn) {
-  const openai = createOpenAIClient(runtime);
   const modelName = getModelFn(runtime);
   import_core9.logger.log(`[ELIZAOS_CLOUD] Using ${modelType} model: ${modelName}`);
   const reasoning = isReasoningModel(modelName);
-  try {
-    const model = openai.chat(modelName);
-    const { object, usage } = await import_ai2.generateObject({
-      model,
-      output: "no-schema",
-      prompt: params.prompt,
-      ...reasoning ? {} : { temperature: params.temperature ?? 0 },
-      experimental_repairText: getJsonRepairFunction()
+  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) {
+      import_core9.logger.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 import_ai2.JSONParseError) {
-      import_core9.logger.error(`[generateObject] Failed to parse JSON: ${error.message}`);
-      const repairFunction = getJsonRepairFunction();
-      const repairedJsonString = await repairFunction({
-        text: error.text,
-        error
-      });
-      if (repairedJsonString) {
-        try {
-          const repairedObject = JSON.parse(repairedJsonString);
-          import_core9.logger.info("[generateObject] Successfully repaired JSON.");
-          return repairedObject;
-        } catch (repairParseError) {
-          const message = repairParseError instanceof Error ? repairParseError.message : String(repairParseError);
-          import_core9.logger.error(`[generateObject] Failed to parse repaired JSON: ${message}`);
-          throw repairParseError;
-        }
-      } else {
-        import_core9.logger.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);
+        import_core9.logger.info("[generateObject] Successfully repaired JSON.");
+        return repairedObject;
+      } catch (repairParseError) {
+        const message2 = repairParseError instanceof Error ? repairParseError.message : String(repairParseError);
+        import_core9.logger.error(`[generateObject] Failed to parse repaired JSON: ${message2}`);
+        throw repairParseError;
       }
-    } else {
-      const message = error instanceof Error ? error.message : String(error);
-      import_core9.logger.error(`[generateObject] Error: ${message}`);
-      throw error;
     }
+    const message = error instanceof Error ? error.message : String(error);
+    import_core9.logger.error(`[generateObject] Failed to parse JSON: ${message}`);
+    throw error;
   }
 }
 async function handleObjectSmall(runtime, params) {
@@ -1241,6 +1487,33 @@ async function handleObjectLarge(runtime, params) {
 }
 // models/research.ts
 var import_core10 = require("@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,
@@ -1317,11 +1590,10 @@ function parseOutputItems(raw) {
 async function handleResearch(runtime, params) {
   const modelName = params.model ?? getResearchModel(runtime);
   import_core10.logger.log(`[ELIZAOS_CLOUD] Using RESEARCH model: ${modelName}`);
-  const baseURL = getBaseURL(runtime);
   const tools = params.tools ?? [{ type: "web_search_preview" }];
   const requestBody = {
     model: modelName,
-    input: params.input,
+    input: normalizeInput(params.input),
     tools
   };
   if (params.instructions) {
@@ -1336,17 +1608,12 @@ async function handleResearch(runtime, params) {
   if (params.reasoningSummary) {
     requestBody.reasoning = { summary: params.reasoningSummary };
   }
-  const response = await fetch(`${baseURL}/responses`, {
-    method: "POST",
-    headers: {
-      ...getAuthHeader(runtime),
-      "Content-Type": "application/json"
-    },
-    body: JSON.stringify(requestBody)
+  const response = await createCloudApiClient(runtime).requestRaw("POST", "/responses", {
+    json: requestBody
   });
   if (!response.ok) {
     const errorText = await response.text();
-    throw new Error(`Research API error: ${response.status} ${errorText}`);
+    throw buildResearchApiError(response.status, errorText);
   }
   const data = await response.json();
   if (data.usage) {
@@ -1382,27 +1649,21 @@ var import_core11 = require("@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();
@@ -1422,51 +1683,103 @@ async function fetchTextToSpeech(runtime, options) {
 }
 // models/text.ts
 var import_core12 = require("@elizaos/core");
-var import_ai3 = require("ai");
+
+// providers/openai.ts
+var import_openai = require("@ai-sdk/openai");
+function createOpenAIClient(runtime) {
+  const baseURL = getBaseURL(runtime);
+  const apiKey = getApiKey(runtime) ?? (isProxyMode(runtime) ? "eliza-proxy" : undefined);
+  return import_openai.createOpenAI({
+    apiKey: apiKey ?? "",
+    baseURL
+  });
+}
+
+// models/text.ts
+var TEXT_NANO_MODEL_TYPE = import_core12.ModelType.TEXT_NANO ?? "TEXT_NANO";
+var TEXT_MEDIUM_MODEL_TYPE = import_core12.ModelType.TEXT_MEDIUM ?? "TEXT_MEDIUM";
+var TEXT_SMALL_MODEL_TYPE = import_core12.ModelType.TEXT_SMALL;
+var TEXT_LARGE_MODEL_TYPE = import_core12.ModelType.TEXT_LARGE;
+var TEXT_MEGA_MODEL_TYPE = import_core12.ModelType.TEXT_MEGA ?? "TEXT_MEGA";
+var RESPONSE_HANDLER_MODEL_TYPE = import_core12.ModelType.RESPONSE_HANDLER ?? "RESPONSE_HANDLER";
+var ACTION_PLANNER_MODEL_TYPE = import_core12.ModelType.ACTION_PLANNER ?? "ACTION_PLANNER";
 var REASONING_MODEL_PATTERNS2 = [
   "o1",
   "o3",
   "o4",
   "deepseek-r1",
   "deepseek-reasoner",
-  "claude-opus-4.5",
-  "claude-opus-4",
-  "gpt-5-mini",
+  "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 import_core12.ModelType.TEXT_SMALL:
+    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 import_core12.ModelType.TEXT_LARGE:
+    case TEXT_LARGE_MODEL_TYPE:
       return getLargeModel(runtime);
-    case import_core12.ModelType.TEXT_REASONING_SMALL:
-      return getReasoningSmallModel(runtime);
-    case import_core12.ModelType.TEXT_REASONING_LARGE:
-      return getReasoningLargeModel(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 paramsWithAttachments = params;
+  const { prompt } = params;
   const maxTokens = params.maxTokens ?? 8192;
   const openai = createOpenAIClient(runtime);
   const modelName = getModelNameForType(runtime, modelType);
   const experimentalTelemetry = getExperimentalTelemetry(runtime);
+  const userContent = (paramsWithAttachments.attachments?.length ?? 0) > 0 ? buildUserContent(paramsWithAttachments) : undefined;
   const model = openai.chat(modelName);
-  const reasoning = isReasoningModel2(modelName) || modelType === import_core12.ModelType.TEXT_REASONING_SMALL || modelType === import_core12.ModelType.TEXT_REASONING_LARGE;
+  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,
-    ...reasoning ? {} : {
-      stopSequences
-    },
+    ...stopSequences ? { stopSequences } : {},
     maxOutputTokens: maxTokens,
     experimental_telemetry: {
       isEnabled: experimentalTelemetry
@@ -1474,129 +1787,101 @@ function buildGenerateParams(runtime, modelType, params) {
   };
   return { generateParams, modelName, modelType, prompt };
 }
-function handleStreamingGeneration(runtime, modelType, generateParams, prompt) {
-  import_core12.logger.debug(`[ELIZAOS_CLOUD] Streaming text with ${modelType} model`);
-  const streamResult = import_ai3.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)
-  };
-}
 async function generateTextWithModel(runtime, modelType, params) {
-  const { generateParams, modelName, prompt } = buildGenerateParams(runtime, modelType, params);
+  const { modelName, prompt } = buildGenerateParams(runtime, modelType, params);
   import_core12.logger.debug(`[ELIZAOS_CLOUD] Generating text with ${modelType} model: ${modelName}`);
   if (params.stream) {
-    return handleStreamingGeneration(runtime, modelType, generateParams, prompt);
+    import_core12.logger.debug("[ELIZAOS_CLOUD] Streaming text disabled for responses compatibility; falling back to buffered response.");
   }
   import_core12.logger.log(`[ELIZAOS_CLOUD] Using ${modelType} model: ${modelName}`);
   import_core12.logger.log(prompt);
-  const response = await import_ai3.generateText(generateParams);
-  if (response.usage) {
-    emitModelUsageEvent(runtime, modelType, prompt, response.usage);
+  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) {
+      import_core12.logger.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
+    });
   }
-  return response.text;
+  const text = extractResponsesOutputText(data);
+  if (!text.trim()) {
+    throw new Error("elizaOS Cloud returned no text response");
+  }
+  return text;
 }
 async function handleTextSmall(runtime, params) {
-  return generateTextWithModel(runtime, import_core12.ModelType.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, import_core12.ModelType.TEXT_LARGE, params);
+  return generateTextWithModel(runtime, TEXT_LARGE_MODEL_TYPE, params);
 }
-async function handleTextReasoningSmall(runtime, params) {
-  return generateTextWithModel(runtime, import_core12.ModelType.TEXT_REASONING_SMALL, params);
+async function handleTextMega(runtime, params) {
+  return generateTextWithModel(runtime, TEXT_MEGA_MODEL_TYPE, params);
 }
-async function handleTextReasoningLarge(runtime, params) {
-  return generateTextWithModel(runtime, import_core12.ModelType.TEXT_REASONING_LARGE, 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
-var import_core14 = require("@elizaos/core");
+var import_core13 = require("@elizaos/core");
+var import_shared = require("@elizaos/shared");
+var import_jose = require("jose");
 
 // utils/cloud-api.ts
-var import_core13 = require("@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}`;
-    import_core13.logger.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;
-  }
-}
+var import_cloud_sdk3 = require("@elizaos/cloud-sdk");
 
 // services/cloud-auth.ts
 async function deriveDeviceId() {
@@ -1623,15 +1908,14 @@ function detectPlatform() {
   };
   return map[process.platform] ?? "linux";
 }
-
-class CloudAuthService extends import_core14.Service {
+class CloudAuthService extends import_core13.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 import_cloud_sdk3.CloudApiClient(DEFAULT_CLOUD_CONFIG.baseUrl);
   }
   static async start(runtime) {
     const service = new CloudAuthService(runtime);
@@ -1651,13 +1935,13 @@ class CloudAuthService extends import_core14.Service {
       this.credentials = {
         apiKey: key,
         userId: String(this.runtime.getSetting("ELIZAOS_CLOUD_USER_ID") ?? ""),
-        organizationId: String(this.runtime.getSetting("ELIZAOS_CLOUD_ORG_ID") ?? ""),
+        organizationId: String(this.runtime.getSetting("ELIZAOS_CLOUD_ORG_ID") ?? this.runtime.getSetting("ELIZA_CLOUD_ORGANIZATION_ID") ?? ""),
         authenticatedAt: Date.now()
       };
-      import_core14.logger.info("[CloudAuth] Authenticated with saved API key");
+      import_core13.logger.info("[CloudAuth] Authenticated with saved API key");
       this.validateApiKey(key).then((valid) => {
         if (!valid) {
-          import_core14.logger.warn("[CloudAuth] Saved API key could not be validated (cloud may be unreachable or key revoked) — model calls will use the key anyway");
+          import_core13.logger.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;
@@ -1668,23 +1952,21 @@ class CloudAuthService extends import_core14.Service {
         await this.authenticateWithDevice();
       } catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
-        import_core14.logger.warn(`[CloudAuth] Device auth failed (cloud may be unreachable): ${msg}`);
-        import_core14.logger.info("[CloudAuth] Service will start unauthenticated — cloud features disabled until connectivity is restored");
+        import_core13.logger.warn(`[CloudAuth] Device auth failed (cloud may be unreachable): ${msg}`);
+        import_core13.logger.info("[CloudAuth] Service will start unauthenticated — cloud features disabled until connectivity is restored");
       }
     } else {
-      import_core14.logger.info("[CloudAuth] Cloud not enabled (set ELIZAOS_CLOUD_ENABLED=true)");
+      import_core13.logger.info("[CloudAuth] Cloud not enabled (set ELIZAOS_CLOUD_ENABLED=true)");
     }
   }
   async validateApiKey(key) {
     try {
-      const resp = await fetch(`${this.client.getBaseUrl()}/models`, {
-        headers: { Authorization: `Bearer ${key}` },
-        signal: AbortSignal.timeout(1e4)
-      });
-      return resp.ok;
+      const validationClient = new import_cloud_sdk3.CloudApiClient(this.client.getBaseUrl(), key);
+      await validationClient.get("/models", { timeoutMs: 1e4 });
+      return true;
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
-      import_core14.logger.warn(`[CloudAuth] Could not reach cloud API to validate key: ${msg}`);
+      import_core13.logger.warn(`[CloudAuth] Could not reach cloud API to validate key: ${msg}`);
       return false;
     }
   }
@@ -1693,7 +1975,7 @@ class CloudAuthService extends import_core14.Service {
     const platform = detectPlatform();
     const appVersion = process.env.ELIZAOS_CLOUD_APP_VERSION ?? "2.0.0-alpha";
     const os = await import("node:os");
-    import_core14.logger.info(`[CloudAuth] Authenticating device (platform=${platform})`);
+    import_core13.logger.info(`[CloudAuth] Authenticating device (platform=${platform})`);
     const response = await this.client.postUnauthenticated("/device-auth", {
       deviceId,
       platform,
@@ -1708,9 +1990,28 @@ class CloudAuthService extends import_core14.Service {
     };
     this.client.setApiKey(response.data.apiKey);
     const action = response.data.isNew ? "New account created" : "Authenticated";
-    import_core14.logger.info(`[CloudAuth] ${action} (credits: $${response.data.credits.toFixed(2)})`);
+    import_core13.logger.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()
+    };
+    import_core13.logger.info("[CloudAuth] Authenticated with API key");
+    return this.credentials;
+  }
+  clearAuth() {
+    this.credentials = null;
+    this.client.setApiKey(undefined);
+  }
   isAuthenticated() {
     return this.credentials !== null;
   }
@@ -1732,8 +2033,8 @@ class CloudAuthService extends import_core14.Service {
 }
 
 // services/cloud-backup.ts
-var import_core15 = require("@elizaos/core");
-class CloudBackupService extends import_core15.Service {
+var import_core14 = require("@elizaos/core");
+class CloudBackupService extends import_core14.Service {
   static serviceType = "CLOUD_BACKUP";
   capabilityDescription = "ElizaCloud agent state backup and restore";
   authService;
@@ -1750,21 +2051,21 @@ class CloudBackupService extends import_core15.Service {
       clearInterval(entry.timer);
     }
     this.autoBackups.clear();
-    import_core15.logger.info("[CloudBackup] Service stopped");
+    import_core14.logger.info("[CloudBackup] Service stopped");
   }
   async initialize() {
     const auth = this.runtime.getService("CLOUD_AUTH");
     if (!auth) {
-      import_core15.logger.warn("[CloudBackup] CloudAuthService not available");
+      import_core14.logger.debug("[CloudBackup] CloudAuthService not available");
       return;
     }
     this.authService = auth;
-    import_core15.logger.info("[CloudBackup] Service initialized");
+    import_core14.logger.info("[CloudBackup] Service initialized");
   }
   async createSnapshot(containerId, snapshotType = "manual", metadata) {
     const client = this.authService.getClient();
     const response = await client.post(`/agent-state/${containerId}/snapshot`, { snapshotType, metadata });
-    import_core15.logger.info(`[CloudBackup] Created ${snapshotType} snapshot for container ${containerId} (id=${response.data.id}, size=${formatBytes(response.data.sizeBytes)})`);
+    import_core14.logger.info(`[CloudBackup] Created ${snapshotType} snapshot for container ${containerId} (id=${response.data.id}, size=${formatBytes(response.data.sizeBytes)})`);
     const autoEntry = this.autoBackups.get(containerId);
     if (autoEntry) {
       autoEntry.lastBackupAt = Date.now();
@@ -1778,8 +2079,10 @@ class CloudBackupService extends import_core15.Service {
   }
   async restoreSnapshot(containerId, snapshotId) {
     const client = this.authService.getClient();
-    await client.post(`/agent-state/${containerId}/restore`, { snapshotId });
-    import_core15.logger.info(`[CloudBackup] Restored snapshot ${snapshotId} for container ${containerId}`);
+    await client.post(`/agent-state/${containerId}/restore`, {
+      snapshotId
+    });
+    import_core14.logger.info(`[CloudBackup] Restored snapshot ${snapshotId} for container ${containerId}`);
   }
   async getLatestSnapshot(containerId) {
     const snapshots = await this.listSnapshots(containerId);
@@ -1790,17 +2093,17 @@ class CloudBackupService extends import_core15.Service {
   }
   scheduleAutoBackup(containerId, intervalMs) {
     if (this.autoBackups.has(containerId)) {
-      import_core15.logger.debug(`[CloudBackup] Auto-backup already scheduled for ${containerId}`);
+      import_core14.logger.debug(`[CloudBackup] Auto-backup already scheduled for ${containerId}`);
       return;
     }
     const interval = intervalMs ?? this.backupIntervalMs;
     const timer = setInterval(() => {
-      import_core15.logger.debug(`[CloudBackup] Running auto-backup for container ${containerId}`);
+      import_core14.logger.debug(`[CloudBackup] Running auto-backup for container ${containerId}`);
       this.createSnapshot(containerId, "auto", {
         trigger: "scheduled",
         scheduledIntervalMs: interval
       }).then(() => this.pruneSnapshots(containerId)).catch((err) => {
-        import_core15.logger.error(`[CloudBackup] Auto-backup failed for ${containerId}: ${err.message}`);
+        import_core14.logger.error(`[CloudBackup] Auto-backup failed for ${containerId}: ${err.message}`);
       });
     }, interval);
     this.autoBackups.set(containerId, {
@@ -1808,7 +2111,7 @@ class CloudBackupService extends import_core15.Service {
       timer,
       lastBackupAt: null
     });
-    import_core15.logger.info(`[CloudBackup] Scheduled auto-backup for ${containerId} every ${Math.round(interval / 60000)} minutes`);
+    import_core14.logger.info(`[CloudBackup] Scheduled auto-backup for ${containerId} every ${Math.round(interval / 60000)} minutes`);
   }
   cancelAutoBackup(containerId) {
     const entry = this.autoBackups.get(containerId);
@@ -1816,10 +2119,10 @@ class CloudBackupService extends import_core15.Service {
       return;
     clearInterval(entry.timer);
     this.autoBackups.delete(containerId);
-    import_core15.logger.info(`[CloudBackup] Cancelled auto-backup for ${containerId}`);
+    import_core14.logger.info(`[CloudBackup] Cancelled auto-backup for ${containerId}`);
   }
   async createPreEvictionSnapshot(containerId) {
-    import_core15.logger.info(`[CloudBackup] Creating pre-eviction snapshot for ${containerId}`);
+    import_core14.logger.info(`[CloudBackup] Creating pre-eviction snapshot for ${containerId}`);
     return this.createSnapshot(containerId, "pre-eviction", {
       trigger: "billing-eviction",
       createdAt: new Date().toISOString()
@@ -1834,9 +2137,9 @@ class CloudBackupService extends import_core15.Service {
     const client = this.authService.getClient();
     for (const snapshot of excess) {
       await client.delete(`/agent-state/${containerId}/snapshots/${snapshot.id}`);
-      import_core15.logger.debug(`[CloudBackup] Pruned old auto snapshot ${snapshot.id} for ${containerId}`);
+      import_core14.logger.debug(`[CloudBackup] Pruned old auto snapshot ${snapshot.id} for ${containerId}`);
     }
-    import_core15.logger.info(`[CloudBackup] Pruned ${excess.length} old auto snapshot(s) for ${containerId}`);
+    import_core14.logger.info(`[CloudBackup] Pruned ${excess.length} old auto snapshot(s) for ${containerId}`);
   }
   isAutoBackupScheduled(containerId) {
     return this.autoBackups.has(containerId);
@@ -1855,6 +2158,68 @@ function formatBytes(bytes) {
   return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
 }
 
+// services/cloud-bootstrap.ts
+var import_core15 = require("@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 import_core15.Service {
+  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) {
+      import_core15.logger.info(`[CloudBootstrap] Trust anchor configured (issuer=${issuer}, containerId=${containerId ?? "<unset>"})`);
+    } else {
+      import_core15.logger.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
 var import_core16 = require("@elizaos/core");
 var import_undici = require("undici");
@@ -1878,15 +2243,15 @@ class CloudBridgeService extends import_core16.Service {
   async initialize() {
     const auth = this.runtime.getService("CLOUD_AUTH");
     if (!auth) {
-      import_core16.logger.warn("[CloudBridge] CloudAuthService not available");
+      import_core16.logger.debug("[CloudBridge] CloudAuthService not available");
       return;
     }
     this.authService = auth;
     import_core16.logger.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") {
         import_core16.logger.debug(`[CloudBridge] Already connected/connecting to ${containerId}`);
         return;
@@ -2129,7 +2494,7 @@ class CloudContainerService extends import_core17.Service {
   async initialize() {
     const auth = this.runtime.getService("CLOUD_AUTH");
     if (!auth) {
-      import_core17.logger.warn("[CloudContainer] CloudAuthService not available, container operations will fail");
+      import_core17.logger.debug("[CloudContainer] CloudAuthService not available, container operations will fail");
       return;
     }
     this.authService = auth;
@@ -2295,8 +2660,458 @@ class CloudContainerService extends import_core17.Service {
   }
 }
 
-// services/cloud-model-registry.ts
+// services/cloud-managed-gateway-relay.ts
 var import_core18 = require("@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 import_core18.ChannelType ? import_core18.ChannelType[candidate] : import_core18.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" ? import_core18.ContentType.IMAGE : type === "video" ? import_core18.ContentType.VIDEO : type === "audio" ? import_core18.ContentType.AUDIO : type === "document" ? import_core18.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 import_core18.Service {
+  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) => {
+        import_core18.logger.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()) {
+      import_core18.logger.debug("[CloudManagedGatewayRelay] Skipping gateway relay outside Node.js runtime");
+      this.relayStatus = "stopped";
+      return;
+    }
+    if (isCloudProvisionedRuntime()) {
+      import_core18.logger.debug("[CloudManagedGatewayRelay] Skipping local relay inside provisioned cloud runtime");
+      this.relayStatus = "stopped";
+      return;
+    }
+    if (!this.runtime.messageService) {
+      import_core18.logger.debug("[CloudManagedGatewayRelay] Skipping gateway relay without message service");
+      this.relayStatus = "idle";
+      return;
+    }
+    const auth = this.runtime.getService("CLOUD_AUTH");
+    if (!auth) {
+      import_core18.logger.debug("[CloudManagedGatewayRelay] CloudAuthService not available");
+      this.relayStatus = "idle";
+      return;
+    }
+    this.authService = auth;
+    if (!this.authService.isAuthenticated()) {
+      import_core18.logger.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();
+    import_core18.logger.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";
+        import_core18.logger.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})`);
+    }
+    import_core18.logger.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) {
+      import_core18.logger.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 : import_core18.createUniqueUuid(this.runtime, payload.roomKey);
+    const worldId = import_core18.createUniqueUuid(this.runtime, buildWorldKey(payload.source, payload.transportMetadata, payload.roomKey));
+    const entityId = import_core18.createUniqueUuid(this.runtime, `${payload.source}:${payload.senderId}`);
+    const messageServerId = import_core18.createUniqueUuid(this.runtime, `eliza-cloud-gateway:${payload.source}`);
+    const messageId = import_core18.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 = import_core18.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 = import_core18.createMessageMemory({
+        id: import_core18.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
+var import_core19 = require("@elizaos/core");
 var CACHE_TTL_MS = 30 * 60 * 1000;
 var PROVIDER_PREFIXES = [
   ["gpt-", "openai"],
@@ -2330,16 +3145,13 @@ function stripProvider(modelId) {
   return modelId;
 }
 
-class CloudModelRegistryService extends import_core18.Service {
+class CloudModelRegistryService extends import_core19.Service {
   static serviceType = "CLOUD_MODEL_REGISTRY";
   capabilityDescription = "Discovers and caches available AI models from ElizaCloud";
   models = [];
   byProvider = {};
   lastFetchedAt = 0;
   fetchPromise = null;
-  constructor(runtime) {
-    super(runtime);
-  }
   static async start(runtime) {
     const service = new CloudModelRegistryService(runtime);
     await service.initialize();
@@ -2353,7 +3165,7 @@ class CloudModelRegistryService extends import_core18.Service {
   async initialize() {
     const auth = this.runtime.getService("CLOUD_AUTH");
     if (!auth?.isAuthenticated()) {
-      import_core18.logger.info("[CloudModelRegistry] Auth not available, will fetch models on first access");
+      import_core19.logger.info("[CloudModelRegistry] Auth not available, will fetch models on first access");
       return;
     }
     await this.fetchModels();
@@ -2389,7 +3201,7 @@ class CloudModelRegistryService extends import_core18.Service {
       this.byProvider[model.provider].push(model);
     }
     this.lastFetchedAt = Date.now();
-    import_core18.logger.info(`[CloudModelRegistry] Loaded ${this.models.length} models from ${Object.keys(this.byProvider).length} providers`);
+    import_core19.logger.info(`[CloudModelRegistry] Loaded ${this.models.length} models from ${Object.keys(this.byProvider).length} providers`);
   }
   validateConfiguredModels() {
     if (this.models.length === 0)
@@ -2397,23 +3209,42 @@ class CloudModelRegistryService extends import_core18.Service {
     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_REASONING_SMALL_MODEL", label: "reasoning small model" },
-      { key: "ELIZAOS_CLOUD_REASONING_LARGE_MODEL", label: "reasoning 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_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" }
+      {
+        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) {
-          import_core18.logger.warn(`[CloudModelRegistry] Configured ${label} "${value}" not found in available models. ` + "It may still work if the gateway supports it, but check your configuration.");
+          import_core19.logger.warn(`[CloudModelRegistry] Configured ${label} "${value}" not found in available models. ` + "It may still work if the gateway supports it, but check your configuration.");
         }
       }
     }
@@ -2433,6 +3264,11 @@ class CloudModelRegistryService extends import_core18.Service {
 }
 
 // index.ts
+var TEXT_NANO_MODEL_TYPE2 = import_core20.ModelType.TEXT_NANO ?? "TEXT_NANO";
+var TEXT_MEDIUM_MODEL_TYPE2 = import_core20.ModelType.TEXT_MEDIUM ?? "TEXT_MEDIUM";
+var TEXT_MEGA_MODEL_TYPE2 = import_core20.ModelType.TEXT_MEGA ?? "TEXT_MEGA";
+var RESPONSE_HANDLER_MODEL_TYPE2 = import_core20.ModelType.RESPONSE_HANDLER ?? "RESPONSE_HANDLER";
+var ACTION_PLANNER_MODEL_TYPE2 = import_core20.ModelType.ACTION_PLANNER ?? "ACTION_PLANNER";
 function getProcessEnv() {
   if (typeof process === "undefined") {
     return {};
@@ -2447,14 +3283,26 @@ 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,
-    ELIZAOS_CLOUD_REASONING_SMALL_MODEL: env.ELIZAOS_CLOUD_REASONING_SMALL_MODEL ?? null,
-    ELIZAOS_CLOUD_REASONING_LARGE_MODEL: env.ELIZAOS_CLOUD_REASONING_LARGE_MODEL ?? null,
-    REASONING_SMALL_MODEL: env.REASONING_SMALL_MODEL ?? null,
-    REASONING_LARGE_MODEL: env.REASONING_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,
@@ -2473,6 +3321,8 @@ var elizaOSCloudPlugin = {
   },
   services: [
     CloudAuthService,
+    CloudBootstrapServiceImpl,
+    CloudManagedGatewayRelayService,
     CloudModelRegistryService,
     CloudContainerService,
     CloudBridgeService,
@@ -2491,16 +3341,19 @@ var elizaOSCloudPlugin = {
     modelRegistryProvider
   ],
   models: {
-    [import_core19.ModelType.TEXT_EMBEDDING]: handleTextEmbedding,
-    [import_core19.ModelType.TEXT_SMALL]: handleTextSmall,
-    [import_core19.ModelType.TEXT_LARGE]: handleTextLarge,
-    [import_core19.ModelType.TEXT_REASONING_SMALL]: handleTextReasoningSmall,
-    [import_core19.ModelType.TEXT_REASONING_LARGE]: handleTextReasoningLarge,
-    [import_core19.ModelType.RESEARCH]: handleResearch,
-    [import_core19.ModelType.IMAGE]: handleImageGeneration,
-    [import_core19.ModelType.IMAGE_DESCRIPTION]: handleImageDescription,
-    [import_core19.ModelType.OBJECT_SMALL]: handleObjectSmall,
-    [import_core19.ModelType.OBJECT_LARGE]: handleObjectLarge
+    [import_core20.ModelType.TEXT_EMBEDDING]: handleTextEmbedding,
+    [TEXT_NANO_MODEL_TYPE2]: handleTextNano,
+    [TEXT_MEDIUM_MODEL_TYPE2]: handleTextMedium,
+    [import_core20.ModelType.TEXT_SMALL]: handleTextSmall,
+    [import_core20.ModelType.TEXT_LARGE]: handleTextLarge,
+    [TEXT_MEGA_MODEL_TYPE2]: handleTextMega,
+    [RESPONSE_HANDLER_MODEL_TYPE2]: handleResponseHandler,
+    [ACTION_PLANNER_MODEL_TYPE2]: handleActionPlanner,
+    [import_core20.ModelType.RESEARCH]: handleResearch,
+    [import_core20.ModelType.IMAGE]: handleImageGeneration,
+    [import_core20.ModelType.IMAGE_DESCRIPTION]: handleImageDescription,
+    [import_core20.ModelType.OBJECT_SMALL]: handleObjectSmall,
+    [import_core20.ModelType.OBJECT_LARGE]: handleObjectLarge
   },
   tests: [
     {
@@ -2509,118 +3362,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();
-            import_core19.logger.log({
-              data: data?.data?.length ?? "N/A"
+            const data = await createCloudApiClient(runtime).get("/models");
+            import_core20.logger.log({
+              data: data.data?.length ?? "N/A"
             }, "Models Available");
-            if (!response.ok) {
-              throw new Error(`Failed to validate OpenAI API key: ${response.statusText}`);
-            }
           }
         },
         {
           name: "ELIZAOS_CLOUD_test_text_embedding",
           fn: async (runtime) => {
-            const embedding = await runtime.useModel(import_core19.ModelType.TEXT_EMBEDDING, {
+            const embedding = await runtime.useModel(import_core20.ModelType.TEXT_EMBEDDING, {
               text: "Hello, world!"
             });
-            import_core19.logger.log({ embedding }, "embedding");
+            import_core20.logger.log({ embedding }, "embedding");
           }
         },
         {
           name: "ELIZAOS_CLOUD_test_text_large",
           fn: async (runtime) => {
-            const text = await runtime.useModel(import_core19.ModelType.TEXT_LARGE, {
+            const text = await runtime.useModel(import_core20.ModelType.TEXT_LARGE, {
               prompt: "What is the nature of reality in 10 words?"
             });
             if (text.length === 0) {
               throw new Error("Failed to generate text");
             }
-            import_core19.logger.log({ text }, "generated with test_text_large");
+            import_core20.logger.log({ text }, "generated with test_text_large");
           }
         },
         {
           name: "ELIZAOS_CLOUD_test_text_small",
           fn: async (runtime) => {
-            const text = await runtime.useModel(import_core19.ModelType.TEXT_SMALL, {
+            const text = await runtime.useModel(import_core20.ModelType.TEXT_SMALL, {
               prompt: "What is the nature of reality in 10 words?"
             });
             if (text.length === 0) {
               throw new Error("Failed to generate text");
             }
-            import_core19.logger.log({ text }, "generated with test_text_small");
+            import_core20.logger.log({ text }, "generated with test_text_small");
           }
         },
         {
           name: "ELIZAOS_CLOUD_test_image_generation",
           fn: async (runtime) => {
-            import_core19.logger.log("ELIZAOS_CLOUD_test_image_generation");
-            const image = await runtime.useModel(import_core19.ModelType.IMAGE, {
+            import_core20.logger.log("ELIZAOS_CLOUD_test_image_generation");
+            const image = await runtime.useModel(import_core20.ModelType.IMAGE, {
               prompt: "A beautiful sunset over a calm ocean",
               count: 1,
               size: "1024x1024"
             });
-            import_core19.logger.log({ image }, "generated with test_image_generation");
+            import_core20.logger.log({ image }, "generated with test_image_generation");
           }
         },
         {
           name: "image-description",
           fn: async (runtime) => {
-            import_core19.logger.log("ELIZAOS_CLOUD_test_image_description");
-            const result = await runtime.useModel(import_core19.ModelType.IMAGE_DESCRIPTION, "https://upload.wikimedia.org/wikipedia/commons/thumb/1/1c/Vitalik_Buterin_TechCrunch_London_2015_%28cropped%29.jpg/537px-Vitalik_Buterin_TechCrunch_London_2015_%28cropped%29.jpg");
+            import_core20.logger.log("ELIZAOS_CLOUD_test_image_description");
+            const result = await runtime.useModel(import_core20.ModelType.IMAGE_DESCRIPTION, "https://upload.wikimedia.org/wikipedia/commons/thumb/1/1c/Vitalik_Buterin_TechCrunch_London_2015_%28cropped%29.jpg/537px-Vitalik_Buterin_TechCrunch_London_2015_%28cropped%29.jpg");
             if (result && typeof result === "object" && "title" in result && "description" in result) {
-              import_core19.logger.log({ result }, "Image description");
+              import_core20.logger.log({ result }, "Image description");
             } else {
-              import_core19.logger.error(`Invalid image description result format: ${JSON.stringify(result)}`);
+              import_core20.logger.error(`Invalid image description result format: ${JSON.stringify(result)}`);
             }
           }
         },
         {
           name: "ELIZAOS_CLOUD_test_transcription",
           fn: async (runtime) => {
-            import_core19.logger.log("ELIZAOS_CLOUD_test_transcription");
+            import_core20.logger.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(import_core19.ModelType.TRANSCRIPTION, Buffer.from(new Uint8Array(arrayBuffer)));
-            import_core19.logger.log({ transcription }, "generated with test_transcription");
+            const transcription = await runtime.useModel(import_core20.ModelType.TRANSCRIPTION, Buffer.from(new Uint8Array(arrayBuffer)));
+            import_core20.logger.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(import_core19.ModelType.TEXT_TOKENIZER_ENCODE, {
+            const tokens = await runtime.useModel(import_core20.ModelType.TEXT_TOKENIZER_ENCODE, {
               prompt,
-              modelType: import_core19.ModelType.TEXT_SMALL
+              modelType: import_core20.ModelType.TEXT_SMALL
             });
             if (!Array.isArray(tokens) || tokens.length === 0) {
               throw new Error("Failed to tokenize text: expected non-empty array of tokens");
             }
-            import_core19.logger.log({ tokens }, "Tokenized output");
+            import_core20.logger.log({ tokens }, "Tokenized output");
           }
         },
         {
           name: "ELIZAOS_CLOUD_test_text_tokenizer_decode",
           fn: async (runtime) => {
             const prompt = "Hello tokenizer decode!";
-            const tokens = await runtime.useModel(import_core19.ModelType.TEXT_TOKENIZER_ENCODE, {
+            const tokens = await runtime.useModel(import_core20.ModelType.TEXT_TOKENIZER_ENCODE, {
               prompt,
-              modelType: import_core19.ModelType.TEXT_SMALL
+              modelType: import_core20.ModelType.TEXT_SMALL
             });
-            const decodedText = await runtime.useModel(import_core19.ModelType.TEXT_TOKENIZER_DECODE, {
+            const decodedText = await runtime.useModel(import_core20.ModelType.TEXT_TOKENIZER_DECODE, {
               tokens,
-              modelType: import_core19.ModelType.TEXT_SMALL
+              modelType: import_core20.ModelType.TEXT_SMALL
             });
             if (decodedText !== prompt) {
               throw new Error(`Decoded text does not match original. Expected "${prompt}", got "${decodedText}"`);
             }
-            import_core19.logger.log({ decodedText }, "Decoded text");
+            import_core20.logger.log({ decodedText }, "Decoded text");
           }
         },
         {
@@ -2632,13 +3476,16 @@ var elizaOSCloudPlugin = {
             if (!response) {
               throw new Error("Failed to generate speech");
             }
-            import_core19.logger.log("Generated speech successfully");
+            import_core20.logger.log("Generated speech successfully");
           }
         }
       ]
     }
   ]
 };
-var typescript_default = elizaOSCloudPlugin;
+var plugin_elizacloud_default = elizaOSCloudPlugin;
+
+// index.node.ts
+var index_node_default = plugin_elizacloud_default;
 
-//# debugId=54ED4B75D5D15C8364756E2164756E21
+//# debugId=5B1B04FCBB721DF464756E2164756E21