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

package/dist/node/index.node.js

@@ -1,36 +1,16 @@
 import { createRequire } from "node:module";
-var __create = Object.create;
-var __getProtoOf = Object.getPrototypeOf;
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-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 __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // index.ts
-import { logger as logger18, ModelType as ModelType6 } from "@elizaos/core";
+import { logger as logger19, ModelType as ModelType6 } from "@elizaos/core";
 
 // actions/check-credits.ts
 var DAILY_COST_PER_CONTAINER = 0.67;
 var checkCloudCreditsAction = {
   name: "CHECK_CLOUD_CREDITS",
   description: "Check ElizaCloud credit balance, container costs, and estimated remaining runtime.",
-  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: [
     {
@@ -40,8 +20,29 @@ var checkCloudCreditsAction = {
       schema: { type: "boolean" }
     }
   ],
-  async validate(runtime) {
-    return !!runtime.getService("CLOUD_AUTH")?.isAuthenticated();
+  validate: async (runtime, message, state, options) => {
+    const __avTextRaw = typeof message?.content?.text === "string" ? message.content.text : "";
+    const __avText = __avTextRaw.toLowerCase();
+    const __avKeywords = ["check", "cloud", "credits"];
+    const __avKeywordOk = __avKeywords.length > 0 && __avKeywords.some((kw) => kw.length > 0 && __avText.includes(kw));
+    const __avRegex = /\b(?:check|cloud|credits)\b/i;
+    const __avRegexOk = Boolean(__avText.match(__avRegex));
+    const __avSource = String(message?.content?.source ?? "");
+    const __avExpectedSource = "";
+    const __avSourceOk = __avExpectedSource ? __avSource === __avExpectedSource : Boolean(__avSource || state || runtime?.agentId || runtime?.getService);
+    const __avOptions = options && typeof options === "object" ? options : {};
+    const __avInputOk = __avText.trim().length > 0 || Object.keys(__avOptions).length > 0 || Boolean(message?.content && typeof message.content === "object");
+    if (!(__avKeywordOk && __avRegexOk && __avSourceOk && __avInputOk)) {
+      return false;
+    }
+    const __avLegacyValidate = async (runtime2) => {
+      return !!runtime2.getService("CLOUD_AUTH")?.isAuthenticated();
+    };
+    try {
+      return Boolean(await __avLegacyValidate(runtime));
+    } catch {
+      return false;
+    }
   },
   async handler(runtime, message, _state, options, callback) {
     const auth = runtime.getService("CLOUD_AUTH");
@@ -83,22 +84,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: [
     {
@@ -106,10 +122,37 @@ var freezeCloudAgentAction = {
       description: "ID of the container to freeze",
       required: true,
       schema: { type: "string" }
+    },
+    {
+      name: "confirmed",
+      description: "Must be true to freeze the cloud agent after preview.",
+      required: false,
+      schema: { type: "boolean", default: false }
     }
   ],
-  async validate(runtime) {
-    return !!runtime.getService("CLOUD_AUTH")?.isAuthenticated();
+  validate: async (runtime, message, state, options) => {
+    const __avTextRaw = typeof message?.content?.text === "string" ? message.content.text : "";
+    const __avText = __avTextRaw.toLowerCase();
+    const __avKeywords = ["freeze", "cloud"];
+    const __avKeywordOk = __avKeywords.length > 0 && __avKeywords.some((kw) => kw.length > 0 && __avText.includes(kw));
+    const __avRegex = /\b(?:freeze|cloud)\b/i;
+    const __avRegexOk = Boolean(__avText.match(__avRegex));
+    const __avSource = String(message?.content?.source ?? "");
+    const __avExpectedSource = "";
+    const __avSourceOk = __avExpectedSource ? __avSource === __avExpectedSource : Boolean(__avSource || state || runtime?.agentId || runtime?.getService);
+    const __avOptions = options && typeof options === "object" ? options : {};
+    const __avInputOk = __avText.trim().length > 0 || Object.keys(__avOptions).length > 0 || Boolean(message?.content && typeof message.content === "object");
+    if (!(__avKeywordOk && __avRegexOk && __avSourceOk && __avInputOk)) {
+      return false;
+    }
+    const __avLegacyValidate = async (runtime2) => {
+      return !!runtime2.getService("CLOUD_AUTH")?.isAuthenticated();
+    };
+    try {
+      return Boolean(await __avLegacyValidate(runtime));
+    } catch {
+      return false;
+    }
   },
   async handler(runtime, message, _state, options, callback) {
     const containers = runtime.getService("CLOUD_CONTAINER");
@@ -125,6 +168,20 @@ var freezeCloudAgentAction = {
         error: `Container not running (status: ${container.status})`
       };
     }
+    const preview = [
+      "Confirmation required before freezing Eliza Cloud agent:",
+      `Container: ${container.name}`,
+      `ID: ${containerId}`,
+      "Effects: create snapshot, disconnect bridge, stop container."
+    ].join(`
+`);
+    if (!isConfirmed(options)) {
+      await callback?.({ text: preview, actions: ["FREEZE_CLOUD_AGENT"] });
+      return confirmationRequired(preview, {
+        containerId,
+        containerName: container.name
+      });
+    }
     const notify = async (text) => {
       if (callback)
         await callback({ text, actions: ["FREEZE_CLOUD_AGENT"] });
@@ -155,6 +212,10 @@ var freezeCloudAgentAction = {
 import { logger } from "@elizaos/core";
 
 // types/cloud.ts
+import {
+  CloudApiError,
+  InsufficientCreditsError
+} from "@elizaos/cloud-sdk";
 var DEFAULT_CLOUD_CONFIG = {
   enabled: false,
   baseUrl: "https://www.elizacloud.ai/api/v1",
@@ -178,36 +239,32 @@ var DEFAULT_CLOUD_CONFIG = {
   }
 };
 
-class CloudApiError extends Error {
-  statusCode;
-  errorBody;
-  constructor(statusCode, body) {
-    super(body.error);
-    this.name = "CloudApiError";
-    this.statusCode = statusCode;
-    this.errorBody = body;
-  }
-}
-
-class InsufficientCreditsError extends CloudApiError {
-  requiredCredits;
-  constructor(body) {
-    super(402, body);
-    this.name = "InsufficientCreditsError";
-    this.requiredCredits = body.requiredCredits ?? 0;
-  }
-}
-
 // utils/forwarded-settings.ts
 var FORWARDED_SETTINGS = [
   "OPENAI_API_KEY",
   "ANTHROPIC_API_KEY",
   "GROQ_API_KEY",
   "ELIZAOS_CLOUD_API_KEY",
+  "NANO_MODEL",
+  "MEDIUM_MODEL",
   "SMALL_MODEL",
   "LARGE_MODEL",
+  "MEGA_MODEL",
+  "RESPONSE_HANDLER_MODEL",
+  "ACTION_PLANNER_MODEL",
+  "SHOULD_RESPOND_MODEL",
+  "PLANNER_MODEL",
+  "RESPONSE_MODEL",
   "ELIZAOS_CLOUD_SMALL_MODEL",
-  "ELIZAOS_CLOUD_LARGE_MODEL"
+  "ELIZAOS_CLOUD_NANO_MODEL",
+  "ELIZAOS_CLOUD_MEDIUM_MODEL",
+  "ELIZAOS_CLOUD_LARGE_MODEL",
+  "ELIZAOS_CLOUD_MEGA_MODEL",
+  "ELIZAOS_CLOUD_RESPONSE_HANDLER_MODEL",
+  "ELIZAOS_CLOUD_ACTION_PLANNER_MODEL",
+  "ELIZAOS_CLOUD_SHOULD_RESPOND_MODEL",
+  "ELIZAOS_CLOUD_PLANNER_MODEL",
+  "ELIZAOS_CLOUD_RESPONSE_MODEL"
 ];
 function collectEnvVars(runtime) {
   const vars = {};
@@ -221,8 +278,9 @@ function collectEnvVars(runtime) {
 
 // actions/provision-agent.ts
 function extractParams(message, options) {
-  if (options && Object.keys(options).length > 0)
-    return options;
+  const params = mergedOptions(options);
+  if (Object.keys(params).length > 0)
+    return params;
   const meta = message.metadata;
   if (meta?.actionParams)
     return meta.actionParams;
@@ -234,6 +292,7 @@ function extractParams(message, options) {
 var provisionCloudAgentAction = {
   name: "PROVISION_CLOUD_AGENT",
   description: "Deploy an ElizaOS agent to ElizaCloud. Provisions a container, waits for deployment, connects the bridge, and starts auto-backup.",
+  descriptionCompressed: "Deploy agent to ElizaCloud. Provisions container, connects bridge, starts backup.",
   similes: [
     "deploy agent to cloud",
     "launch cloud agent",
@@ -271,11 +330,38 @@ var provisionCloudAgentAction = {
       description: "Enable periodic auto-backup (default: true)",
       required: false,
       schema: { type: "boolean" }
+    },
+    {
+      name: "confirmed",
+      description: "Must be true to provision the cloud agent after preview.",
+      required: false,
+      schema: { type: "boolean", default: false }
     }
   ],
-  async validate(runtime) {
-    const auth = runtime.getService("CLOUD_AUTH");
-    return !!auth?.isAuthenticated();
+  validate: async (runtime, message, state, options) => {
+    const __avTextRaw = typeof message?.content?.text === "string" ? message.content.text : "";
+    const __avText = __avTextRaw.toLowerCase();
+    const __avKeywords = ["provision", "cloud"];
+    const __avKeywordOk = __avKeywords.length > 0 && __avKeywords.some((kw) => kw.length > 0 && __avText.includes(kw));
+    const __avRegex = /\b(?:provision|cloud)\b/i;
+    const __avRegexOk = Boolean(__avText.match(__avRegex));
+    const __avSource = String(message?.content?.source ?? "");
+    const __avExpectedSource = "";
+    const __avSourceOk = __avExpectedSource ? __avSource === __avExpectedSource : Boolean(__avSource || state || runtime?.agentId || runtime?.getService);
+    const __avOptions = options && typeof options === "object" ? options : {};
+    const __avInputOk = __avText.trim().length > 0 || Object.keys(__avOptions).length > 0 || Boolean(message?.content && typeof message.content === "object");
+    if (!(__avKeywordOk && __avRegexOk && __avSourceOk && __avInputOk)) {
+      return false;
+    }
+    const __avLegacyValidate = async (runtime2) => {
+      const auth = runtime2.getService("CLOUD_AUTH");
+      return !!auth?.isAuthenticated();
+    };
+    try {
+      return Boolean(await __avLegacyValidate(runtime));
+    } catch {
+      return false;
+    }
   },
   async handler(runtime, message, _state, options, callback) {
     const auth = runtime.getService("CLOUD_AUTH");
@@ -295,6 +381,22 @@ var provisionCloudAgentAction = {
         error: "Missing required parameters: name and project_name"
       };
     }
+    const autoBackup = params.auto_backup !== false;
+    const preview = [
+      "Confirmation required before provisioning Eliza Cloud agent:",
+      `Name: ${String(params.name)}`,
+      `Project: ${String(params.project_name)}`,
+      `Auto-backup: ${autoBackup ? "enabled" : "disabled"}`
+    ].join(`
+`);
+    if (!isConfirmed(options)) {
+      await callback?.({ text: preview, actions: ["PROVISION_CLOUD_AGENT"] });
+      return confirmationRequired(preview, {
+        name: String(params.name),
+        project_name: String(params.project_name),
+        auto_backup: autoBackup
+      });
+    }
     const notify = async (text) => {
       if (callback)
         await callback({ text, actions: ["PROVISION_CLOUD_AGENT"] });
@@ -325,7 +427,6 @@ var provisionCloudAgentAction = {
       await bridge.connect(id);
       logger.info(`[PROVISION] Bridge connected to ${id}`);
     }
-    const autoBackup = params.auto_backup !== false;
     if (autoBackup && backup)
       backup.scheduleAutoBackup(id);
     await notify(`Agent "${params.name}" deployed.${autoBackup ? " Auto-backup enabled." : ""}`);
@@ -347,8 +448,9 @@ var provisionCloudAgentAction = {
 
 // actions/resume-agent.ts
 function extractParams2(message, options) {
-  if (options && Object.keys(options).length > 0)
-    return options;
+  const params = mergedOptions(options);
+  if (Object.keys(params).length > 0)
+    return params;
   const meta = message.metadata;
   return meta?.actionParams ?? {};
 }
@@ -365,12 +467,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: [
     {
@@ -396,10 +494,37 @@ var resumeCloudAgentAction = {
       description: "Additional environment variables",
       required: false,
       schema: { type: "object" }
+    },
+    {
+      name: "confirmed",
+      description: "Must be true to resume the cloud agent after preview.",
+      required: false,
+      schema: { type: "boolean", default: false }
     }
   ],
-  async validate(runtime) {
-    return !!runtime.getService("CLOUD_AUTH")?.isAuthenticated();
+  validate: async (runtime, message, state, options) => {
+    const __avTextRaw = typeof message?.content?.text === "string" ? message.content.text : "";
+    const __avText = __avTextRaw.toLowerCase();
+    const __avKeywords = ["resume", "cloud"];
+    const __avKeywordOk = __avKeywords.length > 0 && __avKeywords.some((kw) => kw.length > 0 && __avText.includes(kw));
+    const __avRegex = /\b(?:resume|cloud)\b/i;
+    const __avRegexOk = Boolean(__avText.match(__avRegex));
+    const __avSource = String(message?.content?.source ?? "");
+    const __avExpectedSource = "";
+    const __avSourceOk = __avExpectedSource ? __avSource === __avExpectedSource : Boolean(__avSource || state || runtime?.agentId || runtime?.getService);
+    const __avOptions = options && typeof options === "object" ? options : {};
+    const __avInputOk = __avText.trim().length > 0 || Object.keys(__avOptions).length > 0 || Boolean(message?.content && typeof message.content === "object");
+    if (!(__avKeywordOk && __avRegexOk && __avSourceOk && __avInputOk)) {
+      return false;
+    }
+    const __avLegacyValidate = async (runtime2) => {
+      return !!runtime2.getService("CLOUD_AUTH")?.isAuthenticated();
+    };
+    try {
+      return Boolean(await __avLegacyValidate(runtime));
+    } catch {
+      return false;
+    }
   },
   async handler(runtime, message, _state, options, callback) {
     const containerSvc = runtime.getService("CLOUD_CONTAINER");
@@ -412,6 +537,22 @@ var resumeCloudAgentAction = {
         error: "Missing required parameters: name and project_name"
       };
     }
+    const explicitSnapshot = typeof params.snapshotId === "string" && params.snapshotId.length > 0 ? params.snapshotId : null;
+    const preview = [
+      "Confirmation required before resuming Eliza Cloud agent:",
+      `Name: ${String(params.name)}`,
+      `Project: ${String(params.project_name)}`,
+      `Snapshot: ${explicitSnapshot ?? "latest available"}`
+    ].join(`
+`);
+    if (!isConfirmed(options)) {
+      await callback?.({ text: preview, actions: ["RESUME_CLOUD_AGENT"] });
+      return confirmationRequired(preview, {
+        name: String(params.name),
+        project_name: String(params.project_name),
+        snapshotId: explicitSnapshot
+      });
+    }
     const notify = async (text) => {
       if (callback)
         await callback({ text, actions: ["RESUME_CLOUD_AGENT"] });
@@ -438,7 +579,7 @@ var resumeCloudAgentAction = {
     const running = await containerSvc.waitForDeployment(id);
     let restoredId = null;
     if (backup) {
-      const explicit = params.snapshotId;
+      const explicit = explicitSnapshot ?? undefined;
       if (explicit) {
         await backup.restoreSnapshot(id, explicit);
         restoredId = explicit;
@@ -472,6 +613,7 @@ var resumeCloudAgentAction = {
 var cloudStatusProvider = {
   name: "elizacloud_status",
   description: "ElizaCloud container and connection status",
+  descriptionCompressed: "ElizaCloud container/connection status.",
   dynamic: true,
   position: 90,
   async get(runtime, _message, _state) {
@@ -518,6 +660,7 @@ var cloudStatusProvider = {
 var containerHealthProvider = {
   name: "elizacloud_health",
   description: "ElizaCloud container health",
+  descriptionCompressed: "ElizaCloud container health.",
   dynamic: true,
   position: 92,
   private: true,
@@ -558,12 +701,13 @@ var containerHealthProvider = {
 
 // cloud-providers/credit-balance.ts
 import { logger as logger2 } from "@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) {
@@ -614,6 +758,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) {
@@ -669,12 +814,6 @@ function isBrowser() {
 function isProxyMode(runtime) {
   return isBrowser() && !!getSetting(runtime, "ELIZAOS_CLOUD_BROWSER_BASE_URL");
 }
-function getAuthHeader(runtime, forEmbedding = false) {
-  if (isBrowser())
-    return {};
-  const key = forEmbedding ? getEmbeddingApiKey(runtime) : getApiKey(runtime);
-  return key ? { Authorization: `Bearer ${key}` } : {};
-}
 function getBaseURL(runtime) {
   const browserURL = getSetting(runtime, "ELIZAOS_CLOUD_BROWSER_BASE_URL");
   const baseURL = isBrowser() && browserURL ? browserURL : getSetting(runtime, "ELIZAOS_CLOUD_BASE_URL", "https://www.elizacloud.ai/api/v1");
@@ -702,23 +841,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");
 }
@@ -727,6 +875,33 @@ function getExperimentalTelemetry(runtime) {
   return String(setting).toLowerCase() === "true";
 }
 
+// utils/sdk-client.ts
+import { CloudApiClient, ElizaCloudClient } from "@elizaos/cloud-sdk";
+function trimTrailingSlash(value) {
+  return value.replace(/\/+$/, "");
+}
+function apiBaseToSiteBaseUrl(apiBaseUrl) {
+  const trimmed = trimTrailingSlash(apiBaseUrl);
+  return trimmed.endsWith("/api/v1") ? trimmed.slice(0, -"/api/v1".length) : trimmed;
+}
+function apiKeyForRuntime(runtime, embedding = false) {
+  if (isBrowser())
+    return;
+  return embedding ? getEmbeddingApiKey(runtime) : getApiKey(runtime);
+}
+function createCloudApiClient(runtime, embedding = false) {
+  const baseUrl = embedding ? getEmbeddingBaseURL(runtime) : getBaseURL(runtime);
+  return new CloudApiClient(trimTrailingSlash(baseUrl), apiKeyForRuntime(runtime, embedding));
+}
+function createElizaCloudClient(runtime) {
+  const apiBaseUrl = trimTrailingSlash(getBaseURL(runtime));
+  return new ElizaCloudClient({
+    apiBaseUrl,
+    baseUrl: apiBaseToSiteBaseUrl(apiBaseUrl),
+    apiKey: apiKeyForRuntime(runtime)
+  });
+}
+
 // init.ts
 function initializeOpenAI(_config, runtime) {
   (async () => {
@@ -737,20 +912,11 @@ function initializeOpenAI(_config, runtime) {
         return;
       }
       try {
-        const baseURL = getBaseURL(runtime);
-        const response = await fetch(`${baseURL}/models`, {
-          headers: { ...getAuthHeader(runtime) }
-        });
-        if (!response.ok) {
-          logger4.warn(`ElizaOS Cloud API key validation failed: ${response.statusText}`);
-          logger4.warn("ElizaOS Cloud functionality will be limited until a valid API key is provided");
-          logger4.info("Get your API key from https://www.elizacloud.ai/dashboard/api-keys");
-        } else {
-          logger4.log("ElizaOS Cloud API key validated successfully");
-        }
+        await createCloudApiClient(runtime).get("/models");
+        logger4.log("ElizaOS Cloud API key validated successfully");
       } catch (fetchError) {
         const message = fetchError instanceof Error ? fetchError.message : String(fetchError);
-        logger4.warn(`Error validating ElizaOS Cloud API key: ${message}`);
+        logger4.warn(`ElizaOS Cloud API key validation failed: ${message}`);
         logger4.warn("ElizaOS Cloud functionality will be limited until a valid API key is provided");
       }
     } catch (error) {
@@ -772,7 +938,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(EventType.MODEL_USED, {
+  const payload = {
     runtime,
     source: "elizacloud",
     type,
@@ -781,7 +947,8 @@ function emitModelUsageEvent(runtime, type, _prompt, usage) {
       completion: outputTokens,
       total: totalTokens
     }
-  });
+  };
+  runtime.emitEvent(EventType.MODEL_USED, payload);
 }
 
 // models/embeddings.ts
@@ -836,7 +1003,7 @@ async function handleTextEmbedding(runtime, params) {
 }
 async function handleBatchTextEmbedding(runtime, texts) {
   const { embeddingModelName, embeddingDimension } = getEmbeddingConfig(runtime);
-  const embeddingBaseURL = getEmbeddingBaseURL(runtime);
+  const client = createCloudApiClient(runtime, true);
   if (!texts || texts.length === 0) {
     logger5.warn("[BatchEmbeddings] Empty texts array");
     return [];
@@ -861,16 +1028,11 @@ async function handleBatchTextEmbedding(runtime, texts) {
     const batchTexts = batch.map((b) => b.text);
     logger5.info(`[BatchEmbeddings] Processing batch ${Math.floor(batchStart / MAX_BATCH_SIZE) + 1}/${Math.ceil(validTexts.length / MAX_BATCH_SIZE)}: ${batch.length} texts`);
     try {
-      const response = await fetch(`${embeddingBaseURL}/embeddings`, {
-        method: "POST",
-        headers: {
-          ...getAuthHeader(runtime, true),
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({
+      const response = await client.requestRaw("POST", "/embeddings", {
+        json: {
           model: embeddingModelName,
           input: batchTexts
-        })
+        }
       });
       const rateLimitInfo = extractRateLimitInfo(response);
       if (rateLimitInfo.remainingRequests !== undefined && rateLimitInfo.remainingRequests < 50) {
@@ -880,16 +1042,11 @@ async function handleBatchTextEmbedding(runtime, texts) {
         const retryAfter = rateLimitInfo.retryAfter || 30;
         logger5.warn(`[BatchEmbeddings] Rate limited, waiting ${retryAfter}s...`);
         await new Promise((resolve) => setTimeout(resolve, retryAfter * 1000));
-        const retryResponse = await fetch(`${embeddingBaseURL}/embeddings`, {
-          method: "POST",
-          headers: {
-            ...getAuthHeader(runtime, true),
-            "Content-Type": "application/json"
-          },
-          body: JSON.stringify({
+        const retryResponse = await client.requestRaw("POST", "/embeddings", {
+          json: {
             model: embeddingModelName,
             input: batchTexts
-          })
+          }
         });
         if (!retryResponse.ok) {
           logger5.error(`[BatchEmbeddings] Retry failed: ${retryResponse.status}`);
@@ -1009,7 +1166,6 @@ async function handleImageGeneration(runtime, params) {
   const prompt = params.prompt;
   const modelName = getImageGenerationModel(runtime);
   logger7.log(`[ELIZAOS_CLOUD] Using IMAGE model: ${modelName}`);
-  const baseURL = getBaseURL(runtime);
   const aspectRatioMap = {
     "1024x1024": "1:1",
     "1792x1024": "16:9",
@@ -1017,27 +1173,13 @@ async function handleImageGeneration(runtime, params) {
   };
   const aspectRatio = aspectRatioMap[size] || "1:1";
   try {
-    const requestUrl = `${baseURL}/generate-image`;
     const requestBody = {
       prompt,
       numImages,
       aspectRatio,
       model: modelName
     };
-    const response = await fetch(requestUrl, {
-      method: "POST",
-      headers: {
-        ...getAuthHeader(runtime),
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify(requestBody)
-    });
-    if (!response.ok) {
-      const errorText = await response.text();
-      throw new Error(`Failed to generate image: ${response.status} ${errorText}`);
-    }
-    const data = await response.json();
-    const typedData = data;
+    const typedData = await createElizaCloudClient(runtime).generateImage(requestBody);
     const result = typedData.images.map((img) => ({
       url: img.url || img.image
     }));
@@ -1070,7 +1212,7 @@ async function handleImageDescription(runtime, params) {
       ]
     }
   ];
-  const baseURL = getBaseURL(runtime);
+  const client = createElizaCloudClient(runtime);
   try {
     const requestBody = {
       model: modelName,
@@ -1079,13 +1221,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;
@@ -1095,10 +1232,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}`);
     }
@@ -1129,17 +1266,82 @@ async function handleImageDescription(runtime, params) {
 }
 // models/object.ts
 import { logger as logger8, ModelType as ModelType3 } from "@elizaos/core";
-import { generateObject, JSONParseError as JSONParseError2 } from "ai";
 
-// providers/openai.ts
-import { createOpenAI } from "@ai-sdk/openai";
-function createOpenAIClient(runtime) {
-  const baseURL = getBaseURL(runtime);
-  const apiKey = getApiKey(runtime) ?? (isProxyMode(runtime) ? "eliza-proxy" : undefined);
-  return createOpenAI({
-    apiKey: apiKey ?? "",
-    baseURL
-  });
+// utils/responses-output.ts
+function asRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return null;
+  }
+  return value;
+}
+function normalizeContentItems(value) {
+  if (Array.isArray(value))
+    return value;
+  if (typeof value === "string")
+    return [{ type: "text", text: value }];
+  return value && typeof value === "object" ? [value] : [];
+}
+function extractTextFromContentItem(value) {
+  if (typeof value === "string") {
+    return [value];
+  }
+  const record = asRecord(value);
+  if (!record)
+    return [];
+  const text = typeof record.text === "string" ? record.text : typeof record.output_text === "string" ? record.output_text : typeof record.content === "string" ? record.content : "";
+  const type = typeof record.type === "string" ? record.type : undefined;
+  if (text && (!type || type === "output_text" || type === "text")) {
+    return [text];
+  }
+  return [];
+}
+function extractTextFromOutputItem(value) {
+  const record = asRecord(value);
+  if (!record)
+    return [];
+  const directContent = normalizeContentItems(record.content);
+  if (directContent.length > 0) {
+    return directContent.flatMap(extractTextFromContentItem);
+  }
+  const nestedMessage = asRecord(record.message);
+  if (nestedMessage) {
+    return normalizeContentItems(nestedMessage.content).flatMap(extractTextFromContentItem);
+  }
+  const type = typeof record.type === "string" ? record.type : undefined;
+  const text = typeof record.text === "string" ? record.text : typeof record.output_text === "string" ? record.output_text : "";
+  if (text && (type === "output_text" || type === "text")) {
+    return [text];
+  }
+  return [];
+}
+function extractTextFromChoice(value) {
+  const record = asRecord(value);
+  if (!record)
+    return [];
+  if (typeof record.text === "string" && record.text) {
+    return [record.text];
+  }
+  const message = asRecord(record.message);
+  if (!message) {
+    return [];
+  }
+  return normalizeContentItems(message.content).flatMap(extractTextFromContentItem);
+}
+function extractResponsesOutputText(data) {
+  const record = asRecord(data);
+  if (!record)
+    return "";
+  const segments = [];
+  if (typeof record.output_text === "string" && record.output_text) {
+    segments.push(record.output_text);
+  }
+  if (Array.isArray(record.output)) {
+    segments.push(...record.output.flatMap(extractTextFromOutputItem));
+  }
+  if (Array.isArray(record.choices)) {
+    segments.push(...record.choices.flatMap(extractTextFromChoice));
+  }
+  return segments.join("");
 }
 
 // models/object.ts
@@ -1149,9 +1351,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) {
@@ -1159,50 +1360,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);
   logger8.log(`[ELIZAOS_CLOUD] Using ${modelType} model: ${modelName}`);
   const reasoning = isReasoningModel(modelName);
-  try {
-    const model = openai.chat(modelName);
-    const { object, usage } = await 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) {
+      logger8.error(`[generateObject] Failed to parse Eliza Cloud 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;
     }
-    return object;
+    throw requestError;
+  }
+  if (data.usage) {
+    emitModelUsageEvent(runtime, modelType, params.prompt, {
+      inputTokens: data.usage.input_tokens ?? 0,
+      outputTokens: data.usage.output_tokens ?? 0,
+      totalTokens: data.usage.total_tokens ?? 0
+    });
+  }
+  let jsonText = extractResponsesOutputText(data);
+  if (!jsonText.trim()) {
+    throw new Error("Object generation returned empty response");
+  }
+  jsonText = jsonText.replace(/^[\s]*```(?:json)?\s*\n?/i, "").replace(/\n?```\s*$/i, "").trim();
+  try {
+    return JSON.parse(jsonText);
   } catch (error) {
-    if (error instanceof JSONParseError2) {
-      logger8.error(`[generateObject] Failed to parse JSON: ${error.message}`);
-      const repairFunction = getJsonRepairFunction();
-      const repairedJsonString = await repairFunction({
-        text: error.text,
-        error
-      });
-      if (repairedJsonString) {
-        try {
-          const repairedObject = JSON.parse(repairedJsonString);
-          logger8.info("[generateObject] Successfully repaired JSON.");
-          return repairedObject;
-        } catch (repairParseError) {
-          const message = repairParseError instanceof Error ? repairParseError.message : String(repairParseError);
-          logger8.error(`[generateObject] Failed to parse repaired JSON: ${message}`);
-          throw repairParseError;
-        }
-      } else {
-        logger8.error("[generateObject] JSON repair failed.");
-        throw error;
+    const repairFunction = getJsonRepairFunction();
+    const repairedJsonString = await repairFunction({
+      text: jsonText,
+      error
+    });
+    if (repairedJsonString) {
+      try {
+        const repairedObject = JSON.parse(repairedJsonString);
+        logger8.info("[generateObject] Successfully repaired JSON.");
+        return repairedObject;
+      } catch (repairParseError) {
+        const message2 = repairParseError instanceof Error ? repairParseError.message : String(repairParseError);
+        logger8.error(`[generateObject] Failed to parse repaired JSON: ${message2}`);
+        throw repairParseError;
       }
-    } else {
-      const message = error instanceof Error ? error.message : String(error);
-      logger8.error(`[generateObject] Error: ${message}`);
-      throw error;
     }
+    const message = error instanceof Error ? error.message : String(error);
+    logger8.error(`[generateObject] Failed to parse JSON: ${message}`);
+    throw error;
   }
 }
 async function handleObjectSmall(runtime, params) {
@@ -1213,6 +1449,33 @@ async function handleObjectLarge(runtime, params) {
 }
 // models/research.ts
 import { logger as logger9, ModelType as ModelType4 } from "@elizaos/core";
+function normalizeInput(input) {
+  if (typeof input !== "string") {
+    return input;
+  }
+  return [
+    {
+      role: "user",
+      content: [
+        {
+          type: "input_text",
+          text: input
+        }
+      ]
+    }
+  ];
+}
+function buildResearchApiError(status, errorText) {
+  try {
+    const parsed = JSON.parse(errorText);
+    const message = parsed.error?.message;
+    const param = parsed.error?.param;
+    if (param === "tools.0.type" && message?.includes('expected "function"')) {
+      return new Error(`Research API error: ${status} Eliza Cloud /responses rejected deep-research tool types; the provider currently only accepts function tools on this route`);
+    }
+  } catch {}
+  return new Error(`Research API error: ${status} ${errorText}`);
+}
 function parseAnnotations(raw) {
   return raw.filter((a) => a.url !== undefined).map((a) => ({
     url: a.url,
@@ -1289,11 +1552,10 @@ function parseOutputItems(raw) {
 async function handleResearch(runtime, params) {
   const modelName = params.model ?? getResearchModel(runtime);
   logger9.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) {
@@ -1308,17 +1570,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) {
@@ -1354,27 +1611,21 @@ import { logger as logger10 } from "@elizaos/core";
 async function fetchTextToSpeech(runtime, options) {
   const defaultModel = getSetting(runtime, "ELIZAOS_CLOUD_TTS_MODEL", "gpt-5-mini-tts");
   const defaultVoice = getSetting(runtime, "ELIZAOS_CLOUD_TTS_VOICE", "nova");
-  const defaultInstructions = getSetting(runtime, "ELIZAOS_CLOUD_TTS_INSTRUCTIONS", "");
-  const baseURL = getBaseURL(runtime);
   const model = options.model || defaultModel;
   const voice = options.voice || defaultVoice;
-  const instructions = options.instructions ?? defaultInstructions;
   const format2 = options.format || "mp3";
+  const modelId = model.startsWith("elevenlabs/") ? model.split("/").slice(1).join("/") : model.startsWith("eleven_") ? model : undefined;
+  const voiceId = voice && voice !== "nova" ? voice : undefined;
   try {
-    const res = await fetch(`${baseURL}/audio/speech`, {
-      method: "POST",
+    const res = await createElizaCloudClient(runtime).routes.postApiV1VoiceTts({
       headers: {
-        ...getAuthHeader(runtime),
-        "Content-Type": "application/json",
         ...format2 === "mp3" ? { Accept: "audio/mpeg" } : {}
       },
-      body: JSON.stringify({
-        model,
-        voice,
-        input: options.text,
-        format: format2,
-        ...instructions && { instructions }
-      })
+      json: {
+        text: options.text,
+        ...voiceId ? { voiceId } : {},
+        ...modelId ? { modelId } : {}
+      }
     });
     if (!res.ok) {
       const err = await res.text();
@@ -1394,51 +1645,103 @@ async function fetchTextToSpeech(runtime, options) {
 }
 // models/text.ts
 import { logger as logger11, ModelType as ModelType5 } from "@elizaos/core";
-import { generateText, streamText } from "ai";
+
+// providers/openai.ts
+import { createOpenAI } from "@ai-sdk/openai";
+function createOpenAIClient(runtime) {
+  const baseURL = getBaseURL(runtime);
+  const apiKey = getApiKey(runtime) ?? (isProxyMode(runtime) ? "eliza-proxy" : undefined);
+  return createOpenAI({
+    apiKey: apiKey ?? "",
+    baseURL
+  });
+}
+
+// models/text.ts
+var TEXT_NANO_MODEL_TYPE = ModelType5.TEXT_NANO ?? "TEXT_NANO";
+var TEXT_MEDIUM_MODEL_TYPE = ModelType5.TEXT_MEDIUM ?? "TEXT_MEDIUM";
+var TEXT_SMALL_MODEL_TYPE = ModelType5.TEXT_SMALL;
+var TEXT_LARGE_MODEL_TYPE = ModelType5.TEXT_LARGE;
+var TEXT_MEGA_MODEL_TYPE = ModelType5.TEXT_MEGA ?? "TEXT_MEGA";
+var RESPONSE_HANDLER_MODEL_TYPE = ModelType5.RESPONSE_HANDLER ?? "RESPONSE_HANDLER";
+var ACTION_PLANNER_MODEL_TYPE = ModelType5.ACTION_PLANNER ?? "ACTION_PLANNER";
 var REASONING_MODEL_PATTERNS2 = [
   "o1",
   "o3",
   "o4",
   "deepseek-r1",
   "deepseek-reasoner",
-  "claude-opus-4.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 ModelType5.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 ModelType5.TEXT_LARGE:
+    case TEXT_LARGE_MODEL_TYPE:
       return getLargeModel(runtime);
-    case ModelType5.TEXT_REASONING_SMALL:
-      return getReasoningSmallModel(runtime);
-    case ModelType5.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 === ModelType5.TEXT_REASONING_SMALL || modelType === ModelType5.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
@@ -1446,129 +1749,109 @@ function buildGenerateParams(runtime, modelType, params) {
   };
   return { generateParams, modelName, modelType, prompt };
 }
-function handleStreamingGeneration(runtime, modelType, generateParams, prompt) {
-  logger11.debug(`[ELIZAOS_CLOUD] Streaming text with ${modelType} model`);
-  const streamResult = streamText(generateParams);
-  return {
-    textStream: streamResult.textStream,
-    text: Promise.resolve(streamResult.text),
-    usage: Promise.resolve(streamResult.usage).then((usage) => {
-      if (usage) {
-        emitModelUsageEvent(runtime, modelType, prompt, usage);
-        const inputTokens = usage.inputTokens ?? 0;
-        const outputTokens = usage.outputTokens ?? 0;
-        return {
-          promptTokens: inputTokens,
-          completionTokens: outputTokens,
-          totalTokens: inputTokens + outputTokens
-        };
-      }
-      return;
-    }),
-    finishReason: Promise.resolve(streamResult.finishReason)
-  };
-}
 async function generateTextWithModel(runtime, modelType, params) {
-  const { generateParams, modelName, prompt } = buildGenerateParams(runtime, modelType, params);
+  const { modelName, prompt } = buildGenerateParams(runtime, modelType, params);
   logger11.debug(`[ELIZAOS_CLOUD] Generating text with ${modelType} model: ${modelName}`);
   if (params.stream) {
-    return handleStreamingGeneration(runtime, modelType, generateParams, prompt);
+    logger11.debug("[ELIZAOS_CLOUD] Streaming text disabled for responses compatibility; falling back to buffered response.");
   }
   logger11.log(`[ELIZAOS_CLOUD] Using ${modelType} model: ${modelName}`);
   logger11.log(prompt);
-  const response = await 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) {
+      logger11.error(`[ELIZAOS_CLOUD] Failed to parse responses JSON: ${parseErr instanceof Error ? parseErr.message : String(parseErr)}`);
+    }
+  }
+  if (!response.ok) {
+    const errorBody = typeof data === "object" && data ? data.error : undefined;
+    const errorMessage = typeof errorBody?.message === "string" && errorBody.message.trim() ? errorBody.message.trim() : `elizaOS Cloud error ${response.status}`;
+    const requestError = new Error(errorMessage);
+    requestError.status = response.status;
+    if (errorBody) {
+      requestError.error = errorBody;
+    }
+    throw requestError;
+  }
+  if (data.usage) {
+    emitModelUsageEvent(runtime, modelType, prompt, {
+      inputTokens: data.usage.input_tokens ?? 0,
+      outputTokens: data.usage.output_tokens ?? 0,
+      totalTokens: data.usage.total_tokens ?? 0
+    });
+  }
+  const text = extractResponsesOutputText(data);
+  if (!text.trim()) {
+    throw new Error("elizaOS Cloud returned no text response");
   }
-  return response.text;
+  return text;
 }
 async function handleTextSmall(runtime, params) {
-  return generateTextWithModel(runtime, ModelType5.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, ModelType5.TEXT_LARGE, params);
+  return generateTextWithModel(runtime, TEXT_LARGE_MODEL_TYPE, params);
+}
+async function handleTextMega(runtime, params) {
+  return generateTextWithModel(runtime, TEXT_MEGA_MODEL_TYPE, params);
 }
-async function handleTextReasoningSmall(runtime, params) {
-  return generateTextWithModel(runtime, ModelType5.TEXT_REASONING_SMALL, params);
+async function handleResponseHandler(runtime, params) {
+  return generateTextWithModel(runtime, RESPONSE_HANDLER_MODEL_TYPE, params);
 }
-async function handleTextReasoningLarge(runtime, params) {
-  return generateTextWithModel(runtime, ModelType5.TEXT_REASONING_LARGE, params);
+async function handleActionPlanner(runtime, params) {
+  return generateTextWithModel(runtime, ACTION_PLANNER_MODEL_TYPE, params);
 }
 // services/cloud-auth.ts
-import { logger as logger13, Service } from "@elizaos/core";
+import { logger as logger12, Service } from "@elizaos/core";
+import {
+  resolveApiSecurityConfig,
+  resolveDesktopApiPort
+} from "@elizaos/shared";
+import { createRemoteJWKSet, jwtVerify } from "jose";
 
 // utils/cloud-api.ts
-import { logger as logger12 } from "@elizaos/core";
-class CloudApiClient {
-  baseUrl;
-  apiKey;
-  constructor(baseUrl, apiKey) {
-    this.baseUrl = baseUrl.replace(/\/+$/, "");
-    this.apiKey = apiKey;
-  }
-  setApiKey(key) {
-    this.apiKey = key;
-  }
-  setBaseUrl(url) {
-    this.baseUrl = url.replace(/\/+$/, "");
-  }
-  getBaseUrl() {
-    return this.baseUrl;
-  }
-  getApiKey() {
-    return this.apiKey;
-  }
-  buildWsUrl(path) {
-    return `${this.baseUrl.replace(/^http/, "ws")}${path}`;
-  }
-  async get(path) {
-    return this.request("GET", path);
-  }
-  async post(path, body) {
-    return this.request("POST", path, body);
-  }
-  async delete(path) {
-    return this.request("DELETE", path);
-  }
-  async postUnauthenticated(path, body) {
-    return this.request("POST", path, body, true);
-  }
-  async request(method, path, body, skipAuth = false) {
-    const url = `${this.baseUrl}${path}`;
-    logger12.debug(`[CloudAPI] ${method} ${url}`);
-    const headers = {
-      "Content-Type": "application/json",
-      Accept: "application/json"
-    };
-    if (!skipAuth && this.apiKey) {
-      headers.Authorization = `Bearer ${this.apiKey}`;
-    }
-    const response = await fetch(url, {
-      method,
-      headers,
-      ...body ? { body: JSON.stringify(body) } : {}
-    });
-    return this.handleResponse(response);
-  }
-  async handleResponse(response) {
-    const contentType = response.headers.get("content-type") ?? "";
-    if (!contentType.includes("application/json")) {
-      if (!response.ok) {
-        throw new CloudApiError(response.status, {
-          success: false,
-          error: `HTTP ${response.status}: ${response.statusText}`
-        });
-      }
-      return { success: true };
-    }
-    const body = await response.json();
-    if (!response.ok) {
-      const err = body;
-      throw response.status === 402 ? new InsufficientCreditsError(err) : new CloudApiError(response.status, err);
-    }
-    return body;
-  }
-}
+import {
+  CloudApiClient as CloudApiClient2,
+  CloudApiError as CloudApiError2,
+  ElizaCloudHttpClient,
+  InsufficientCreditsError as InsufficientCreditsError2
+} from "@elizaos/cloud-sdk";
 
 // services/cloud-auth.ts
 async function deriveDeviceId() {
@@ -1595,15 +1878,14 @@ function detectPlatform() {
   };
   return map[process.platform] ?? "linux";
 }
-
 class CloudAuthService extends Service {
   static serviceType = "CLOUD_AUTH";
-  capabilityDescription = "ElizaCloud device authentication and session management";
+  capabilityDescription = "Eliza Cloud device authentication and SSO session helpers";
   client;
   credentials = null;
   constructor(runtime) {
     super(runtime);
-    this.client = new CloudApiClient(DEFAULT_CLOUD_CONFIG.baseUrl);
+    this.client = new CloudApiClient2(DEFAULT_CLOUD_CONFIG.baseUrl);
   }
   static async start(runtime) {
     const service = new CloudAuthService(runtime);
@@ -1623,13 +1905,13 @@ class CloudAuthService extends 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()
       };
-      logger13.info("[CloudAuth] Authenticated with saved API key");
+      logger12.info("[CloudAuth] Authenticated with saved API key");
       this.validateApiKey(key).then((valid) => {
         if (!valid) {
-          logger13.warn("[CloudAuth] Saved API key could not be validated (cloud may be unreachable or key revoked) — model calls will use the key anyway");
+          logger12.warn("[CloudAuth] Saved API key could not be validated (cloud may be unreachable or key revoked) — model calls will use the key anyway");
         }
       }).catch(() => {});
       return;
@@ -1640,23 +1922,21 @@ class CloudAuthService extends Service {
         await this.authenticateWithDevice();
       } catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
-        logger13.warn(`[CloudAuth] Device auth failed (cloud may be unreachable): ${msg}`);
-        logger13.info("[CloudAuth] Service will start unauthenticated — cloud features disabled until connectivity is restored");
+        logger12.warn(`[CloudAuth] Device auth failed (cloud may be unreachable): ${msg}`);
+        logger12.info("[CloudAuth] Service will start unauthenticated — cloud features disabled until connectivity is restored");
       }
     } else {
-      logger13.info("[CloudAuth] Cloud not enabled (set ELIZAOS_CLOUD_ENABLED=true)");
+      logger12.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 CloudApiClient2(this.client.getBaseUrl(), key);
+      await validationClient.get("/models", { timeoutMs: 1e4 });
+      return true;
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
-      logger13.warn(`[CloudAuth] Could not reach cloud API to validate key: ${msg}`);
+      logger12.warn(`[CloudAuth] Could not reach cloud API to validate key: ${msg}`);
       return false;
     }
   }
@@ -1665,7 +1945,7 @@ class CloudAuthService extends Service {
     const platform = detectPlatform();
     const appVersion = process.env.ELIZAOS_CLOUD_APP_VERSION ?? "2.0.0-alpha";
     const os = await import("node:os");
-    logger13.info(`[CloudAuth] Authenticating device (platform=${platform})`);
+    logger12.info(`[CloudAuth] Authenticating device (platform=${platform})`);
     const response = await this.client.postUnauthenticated("/device-auth", {
       deviceId,
       platform,
@@ -1680,9 +1960,28 @@ class CloudAuthService extends Service {
     };
     this.client.setApiKey(response.data.apiKey);
     const action = response.data.isNew ? "New account created" : "Authenticated";
-    logger13.info(`[CloudAuth] ${action} (credits: $${response.data.credits.toFixed(2)})`);
+    logger12.info(`[CloudAuth] ${action} (credits: $${response.data.credits.toFixed(2)})`);
+    return this.credentials;
+  }
+  authenticateWithApiKey(input) {
+    const apiKey = input.apiKey.trim();
+    if (!apiKey) {
+      throw new Error("Eliza Cloud API key is required");
+    }
+    this.client.setApiKey(apiKey);
+    this.credentials = {
+      apiKey,
+      userId: input.userId ?? "",
+      organizationId: input.organizationId ?? "",
+      authenticatedAt: Date.now()
+    };
+    logger12.info("[CloudAuth] Authenticated with API key");
     return this.credentials;
   }
+  clearAuth() {
+    this.credentials = null;
+    this.client.setApiKey(undefined);
+  }
   isAuthenticated() {
     return this.credentials !== null;
   }
@@ -1704,7 +2003,7 @@ class CloudAuthService extends Service {
 }
 
 // services/cloud-backup.ts
-import { logger as logger14, Service as Service2 } from "@elizaos/core";
+import { logger as logger13, Service as Service2 } from "@elizaos/core";
 class CloudBackupService extends Service2 {
   static serviceType = "CLOUD_BACKUP";
   capabilityDescription = "ElizaCloud agent state backup and restore";
@@ -1722,21 +2021,21 @@ class CloudBackupService extends Service2 {
       clearInterval(entry.timer);
     }
     this.autoBackups.clear();
-    logger14.info("[CloudBackup] Service stopped");
+    logger13.info("[CloudBackup] Service stopped");
   }
   async initialize() {
     const auth = this.runtime.getService("CLOUD_AUTH");
     if (!auth) {
-      logger14.warn("[CloudBackup] CloudAuthService not available");
+      logger13.debug("[CloudBackup] CloudAuthService not available");
       return;
     }
     this.authService = auth;
-    logger14.info("[CloudBackup] Service initialized");
+    logger13.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 });
-    logger14.info(`[CloudBackup] Created ${snapshotType} snapshot for container ${containerId} (id=${response.data.id}, size=${formatBytes(response.data.sizeBytes)})`);
+    logger13.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();
@@ -1750,8 +2049,10 @@ class CloudBackupService extends Service2 {
   }
   async restoreSnapshot(containerId, snapshotId) {
     const client = this.authService.getClient();
-    await client.post(`/agent-state/${containerId}/restore`, { snapshotId });
-    logger14.info(`[CloudBackup] Restored snapshot ${snapshotId} for container ${containerId}`);
+    await client.post(`/agent-state/${containerId}/restore`, {
+      snapshotId
+    });
+    logger13.info(`[CloudBackup] Restored snapshot ${snapshotId} for container ${containerId}`);
   }
   async getLatestSnapshot(containerId) {
     const snapshots = await this.listSnapshots(containerId);
@@ -1762,17 +2063,17 @@ class CloudBackupService extends Service2 {
   }
   scheduleAutoBackup(containerId, intervalMs) {
     if (this.autoBackups.has(containerId)) {
-      logger14.debug(`[CloudBackup] Auto-backup already scheduled for ${containerId}`);
+      logger13.debug(`[CloudBackup] Auto-backup already scheduled for ${containerId}`);
       return;
     }
     const interval = intervalMs ?? this.backupIntervalMs;
     const timer = setInterval(() => {
-      logger14.debug(`[CloudBackup] Running auto-backup for container ${containerId}`);
+      logger13.debug(`[CloudBackup] Running auto-backup for container ${containerId}`);
       this.createSnapshot(containerId, "auto", {
         trigger: "scheduled",
         scheduledIntervalMs: interval
       }).then(() => this.pruneSnapshots(containerId)).catch((err) => {
-        logger14.error(`[CloudBackup] Auto-backup failed for ${containerId}: ${err.message}`);
+        logger13.error(`[CloudBackup] Auto-backup failed for ${containerId}: ${err.message}`);
       });
     }, interval);
     this.autoBackups.set(containerId, {
@@ -1780,7 +2081,7 @@ class CloudBackupService extends Service2 {
       timer,
       lastBackupAt: null
     });
-    logger14.info(`[CloudBackup] Scheduled auto-backup for ${containerId} every ${Math.round(interval / 60000)} minutes`);
+    logger13.info(`[CloudBackup] Scheduled auto-backup for ${containerId} every ${Math.round(interval / 60000)} minutes`);
   }
   cancelAutoBackup(containerId) {
     const entry = this.autoBackups.get(containerId);
@@ -1788,10 +2089,10 @@ class CloudBackupService extends Service2 {
       return;
     clearInterval(entry.timer);
     this.autoBackups.delete(containerId);
-    logger14.info(`[CloudBackup] Cancelled auto-backup for ${containerId}`);
+    logger13.info(`[CloudBackup] Cancelled auto-backup for ${containerId}`);
   }
   async createPreEvictionSnapshot(containerId) {
-    logger14.info(`[CloudBackup] Creating pre-eviction snapshot for ${containerId}`);
+    logger13.info(`[CloudBackup] Creating pre-eviction snapshot for ${containerId}`);
     return this.createSnapshot(containerId, "pre-eviction", {
       trigger: "billing-eviction",
       createdAt: new Date().toISOString()
@@ -1806,9 +2107,9 @@ class CloudBackupService extends Service2 {
     const client = this.authService.getClient();
     for (const snapshot of excess) {
       await client.delete(`/agent-state/${containerId}/snapshots/${snapshot.id}`);
-      logger14.debug(`[CloudBackup] Pruned old auto snapshot ${snapshot.id} for ${containerId}`);
+      logger13.debug(`[CloudBackup] Pruned old auto snapshot ${snapshot.id} for ${containerId}`);
     }
-    logger14.info(`[CloudBackup] Pruned ${excess.length} old auto snapshot(s) for ${containerId}`);
+    logger13.info(`[CloudBackup] Pruned ${excess.length} old auto snapshot(s) for ${containerId}`);
   }
   isAutoBackupScheduled(containerId) {
     return this.autoBackups.has(containerId);
@@ -1827,10 +2128,72 @@ function formatBytes(bytes) {
   return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
 }
 
+// services/cloud-bootstrap.ts
+import { logger as logger14, Service as Service3 } from "@elizaos/core";
+function readEnv() {
+  if (typeof process === "undefined") {
+    return {};
+  }
+  return process.env;
+}
+function readSetting(runtime, key) {
+  if (runtime && typeof runtime.getSetting === "function") {
+    const value = runtime.getSetting(key);
+    if (typeof value === "string" && value.length > 0) {
+      return value;
+    }
+  }
+  const fromEnv = readEnv()[key];
+  if (typeof fromEnv === "string" && fromEnv.length > 0) {
+    return fromEnv;
+  }
+  return null;
+}
+function trimTrailingSlash2(input) {
+  let end = input.length;
+  while (end > 0 && input.charCodeAt(end - 1) === 47) {
+    end -= 1;
+  }
+  return end === input.length ? input : input.slice(0, end);
+}
+
+class CloudBootstrapServiceImpl extends Service3 {
+  static serviceType = "CLOUD_BOOTSTRAP";
+  capabilityDescription = "Exposes Eliza Cloud bootstrap-token trust anchor (issuer, JWKS URL, revocation list URL, expected container id) to app-core";
+  static async start(runtime) {
+    const service = new CloudBootstrapServiceImpl(runtime);
+    const issuer = readSetting(runtime, "ELIZA_CLOUD_ISSUER");
+    const containerId = readSetting(runtime, "ELIZA_CLOUD_CONTAINER_ID");
+    if (issuer) {
+      logger14.info(`[CloudBootstrap] Trust anchor configured (issuer=${issuer}, containerId=${containerId ?? "<unset>"})`);
+    } else {
+      logger14.debug("[CloudBootstrap] ELIZA_CLOUD_ISSUER unset — bootstrap-token verification will reject until configured");
+    }
+    return service;
+  }
+  async stop() {}
+  getExpectedIssuer() {
+    const issuer = readSetting(this.runtime, "ELIZA_CLOUD_ISSUER");
+    if (!issuer) {
+      throw new Error("ELIZA_CLOUD_ISSUER is not configured — bootstrap-token verification cannot proceed");
+    }
+    return trimTrailingSlash2(issuer);
+  }
+  getJwksUrl() {
+    return `${this.getExpectedIssuer()}/.well-known/jwks.json`;
+  }
+  getRevocationListUrl() {
+    return `${this.getExpectedIssuer()}/.well-known/revocations.json`;
+  }
+  getExpectedContainerId() {
+    return readSetting(this.runtime, "ELIZA_CLOUD_CONTAINER_ID");
+  }
+}
+
 // services/cloud-bridge.ts
-import { logger as logger15, Service as Service3 } from "@elizaos/core";
+import { logger as logger15, Service as Service4 } from "@elizaos/core";
 import { WebSocket } from "undici";
-class CloudBridgeService extends Service3 {
+class CloudBridgeService extends Service4 {
   static serviceType = "CLOUD_BRIDGE";
   capabilityDescription = "WebSocket bridge to cloud-hosted ElizaOS agents";
   authService;
@@ -1850,15 +2213,15 @@ class CloudBridgeService extends Service3 {
   async initialize() {
     const auth = this.runtime.getService("CLOUD_AUTH");
     if (!auth) {
-      logger15.warn("[CloudBridge] CloudAuthService not available");
+      logger15.debug("[CloudBridge] CloudAuthService not available");
       return;
     }
     this.authService = auth;
     logger15.info("[CloudBridge] Service initialized");
   }
   async connect(containerId) {
-    if (this.connections.has(containerId)) {
-      const existing = this.connections.get(containerId);
+    const existing = this.connections.get(containerId);
+    if (existing) {
       if (existing.state === "connected" || existing.state === "connecting") {
         logger15.debug(`[CloudBridge] Already connected/connecting to ${containerId}`);
         return;
@@ -2077,8 +2440,8 @@ class CloudBridgeService extends Service3 {
 }
 
 // services/cloud-container.ts
-import { logger as logger16, Service as Service4 } from "@elizaos/core";
-class CloudContainerService extends Service4 {
+import { logger as logger16, Service as Service5 } from "@elizaos/core";
+class CloudContainerService extends Service5 {
   static serviceType = "CLOUD_CONTAINER";
   capabilityDescription = "ElizaCloud container provisioning and lifecycle management";
   authService;
@@ -2101,7 +2464,7 @@ class CloudContainerService extends Service4 {
   async initialize() {
     const auth = this.runtime.getService("CLOUD_AUTH");
     if (!auth) {
-      logger16.warn("[CloudContainer] CloudAuthService not available, container operations will fail");
+      logger16.debug("[CloudContainer] CloudAuthService not available, container operations will fail");
       return;
     }
     this.authService = auth;
@@ -2267,8 +2630,465 @@ class CloudContainerService extends Service4 {
   }
 }
 
+// services/cloud-managed-gateway-relay.ts
+import {
+  ChannelType,
+  ContentType,
+  createMessageMemory,
+  createUniqueUuid,
+  logger as logger17,
+  Service as Service6
+} from "@elizaos/core";
+var POLL_TIMEOUT_MS = 25000;
+var REQUEST_TIMEOUT_MS = POLL_TIMEOUT_MS + 5000;
+var RETRY_DELAY_MS = 2000;
+var IDLE_DELAY_MS = 250;
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isUuidLike(value) {
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value);
+}
+function asTrimmedString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function resolveChannelType(value) {
+  const candidate = asTrimmedString(value)?.toUpperCase();
+  return candidate && candidate in ChannelType ? ChannelType[candidate] : ChannelType.DM;
+}
+function isCloudProvisionedRuntime() {
+  if (typeof process === "undefined") {
+    return false;
+  }
+  return process.env.ELIZA_CLOUD_PROVISIONED === "1";
+}
+function isNodeHost() {
+  return typeof process !== "undefined" && typeof process.versions?.node === "string";
+}
+function normalizeAttachments(value) {
+  if (!Array.isArray(value)) {
+    return;
+  }
+  const attachments = value.map((entry, index) => {
+    if (!isRecord(entry)) {
+      return null;
+    }
+    const url = asTrimmedString(entry.url);
+    if (!url) {
+      return null;
+    }
+    const type = asTrimmedString(entry.type)?.toLowerCase();
+    return {
+      id: asTrimmedString(entry.id) ?? `${index}:${url}`,
+      url,
+      source: asTrimmedString(entry.source),
+      title: asTrimmedString(entry.title),
+      description: asTrimmedString(entry.description),
+      text: asTrimmedString(entry.text),
+      contentType: type === "image" ? ContentType.IMAGE : type === "video" ? ContentType.VIDEO : type === "audio" ? ContentType.AUDIO : type === "document" ? ContentType.DOCUMENT : undefined
+    };
+  }).filter((entry) => entry !== null);
+  return attachments.length > 0 ? attachments : undefined;
+}
+function toJsonRecord(value) {
+  return isRecord(value) ? value : undefined;
+}
+function toJsonMetadataRecord(value) {
+  if (!isRecord(value)) {
+    return;
+  }
+  return JSON.parse(JSON.stringify(value));
+}
+function buildGatewayMessagePayload(runtime, rpc) {
+  const params = toJsonRecord(rpc.params);
+  const sender = toJsonRecord(params?.sender);
+  const source = asTrimmedString(params?.source) ?? "eliza_cloud_gateway";
+  const text = typeof params?.text === "string" ? params.text : "";
+  const senderId = asTrimmedString(sender?.id) ?? `${source}:anonymous`;
+  const senderUserName = asTrimmedString(sender?.username) ?? senderId;
+  const senderName = asTrimmedString(sender?.displayName) ?? asTrimmedString(sender?.name) ?? senderUserName;
+  const roomKey = asTrimmedString(params?.roomId) ?? `${source}:${senderId}:${String(rpc.id ?? Date.now())}:${runtime.agentId}`;
+  if (!text.trim() && !normalizeAttachments(params?.attachments)?.length) {
+    return null;
+  }
+  return {
+    text: text.trim() || " ",
+    roomKey,
+    channelType: resolveChannelType(params?.channelType),
+    source,
+    senderId,
+    senderUserName,
+    senderName,
+    attachments: normalizeAttachments(params?.attachments),
+    senderMetadata: toJsonRecord(sender?.metadata),
+    transportMetadata: toJsonRecord(params?.metadata)
+  };
+}
+function buildWorldKey(source, metadata, roomKey) {
+  const discord = toJsonRecord(metadata?.discord);
+  const guildId = asTrimmedString(discord?.guildId);
+  if (guildId) {
+    return `gateway:${source}:guild:${guildId}`;
+  }
+  const threadId = asTrimmedString(metadata?.threadId);
+  if (threadId) {
+    return `gateway:${source}:thread:${threadId}`;
+  }
+  return `gateway:${source}:room:${roomKey}`;
+}
+
+class SessionMissingError extends Error {
+  constructor() {
+    super("Gateway relay session missing");
+    this.name = "SessionMissingError";
+  }
+}
+
+class CloudManagedGatewayRelayService extends Service6 {
+  static serviceType = "CLOUD_MANAGED_GATEWAY_RELAY";
+  capabilityDescription = "Registers a local Eliza runtime with the cloud managed gateway and handles inbound relay traffic";
+  authService = null;
+  loopPromise = null;
+  currentSessionId = null;
+  stopping = false;
+  activeAbortController = null;
+  relayStatus = "idle";
+  lastSeenAt = null;
+  static async start(runtime) {
+    const service = new CloudManagedGatewayRelayService(runtime);
+    await service.initialize();
+    return service;
+  }
+  async stop() {
+    this.stopping = true;
+    this.relayStatus = "stopped";
+    this.activeAbortController?.abort();
+    if (this.loopPromise) {
+      await this.loopPromise.catch((error) => {
+        logger17.debug(`[CloudManagedGatewayRelay] Ignoring relay loop shutdown error: ${error instanceof Error ? error.message : String(error)}`);
+      });
+    }
+    const sessionId = this.currentSessionId;
+    this.currentSessionId = null;
+    if (sessionId) {
+      await this.disconnectSession(sessionId);
+    }
+  }
+  async initialize() {
+    if (!isNodeHost()) {
+      logger17.debug("[CloudManagedGatewayRelay] Skipping gateway relay outside Node.js runtime");
+      this.relayStatus = "stopped";
+      return;
+    }
+    if (isCloudProvisionedRuntime()) {
+      logger17.debug("[CloudManagedGatewayRelay] Skipping local relay inside provisioned cloud runtime");
+      this.relayStatus = "stopped";
+      return;
+    }
+    if (!this.runtime.messageService) {
+      logger17.debug("[CloudManagedGatewayRelay] Skipping gateway relay without message service");
+      this.relayStatus = "idle";
+      return;
+    }
+    const auth = this.runtime.getService("CLOUD_AUTH");
+    if (!auth) {
+      logger17.debug("[CloudManagedGatewayRelay] CloudAuthService not available");
+      this.relayStatus = "idle";
+      return;
+    }
+    this.authService = auth;
+    if (!this.authService.isAuthenticated()) {
+      logger17.debug("[CloudManagedGatewayRelay] Skipping gateway relay while cloud auth is inactive");
+      this.relayStatus = "idle";
+      return;
+    }
+    this.startRelayLoopIfReady();
+  }
+  getSessionInfo() {
+    const auth = this.authService;
+    const status = this.stopping || this.relayStatus === "stopped" ? "stopped" : auth?.isAuthenticated() === false ? "idle" : this.relayStatus;
+    return {
+      sessionId: this.currentSessionId,
+      organizationId: auth?.getOrganizationId() ?? null,
+      userId: auth?.getUserId() ?? null,
+      agentName: this.getAgentName(),
+      platform: "local-runtime",
+      lastSeenAt: this.lastSeenAt,
+      status
+    };
+  }
+  startRelayLoopIfReady() {
+    if (this.loopPromise && !this.stopping) {
+      return true;
+    }
+    const auth = this.authService ?? this.runtime.getService("CLOUD_AUTH");
+    if (!auth?.isAuthenticated() || !this.runtime.messageService) {
+      this.relayStatus = "idle";
+      return false;
+    }
+    this.authService = auth;
+    this.stopping = false;
+    this.relayStatus = "idle";
+    this.loopPromise = this.runLoop();
+    logger17.info("[CloudManagedGatewayRelay] Local gateway relay loop started");
+    return true;
+  }
+  async runLoop() {
+    while (!this.stopping) {
+      try {
+        if (!this.currentSessionId) {
+          this.currentSessionId = await this.registerSession();
+          this.relayStatus = "registered";
+          this.lastSeenAt = new Date().toISOString();
+          continue;
+        }
+        this.relayStatus = "polling";
+        const request = await this.pollNextRequest(this.currentSessionId);
+        this.lastSeenAt = new Date().toISOString();
+        if (!request) {
+          this.relayStatus = "registered";
+          await sleep(IDLE_DELAY_MS);
+          continue;
+        }
+        const response = await this.handleRequest(request.rpc);
+        await this.submitResponse(this.currentSessionId, request.requestId, response);
+        this.relayStatus = "registered";
+      } catch (error) {
+        if (this.stopping) {
+          return;
+        }
+        if (error instanceof SessionMissingError) {
+          this.currentSessionId = null;
+          this.relayStatus = "idle";
+          await sleep(IDLE_DELAY_MS);
+          continue;
+        }
+        this.relayStatus = "error";
+        logger17.warn(`[CloudManagedGatewayRelay] Relay loop error: ${error instanceof Error ? error.message : String(error)}`);
+        await sleep(RETRY_DELAY_MS);
+      }
+    }
+  }
+  getAgentName() {
+    return this.runtime.character?.name?.trim() || "Eliza";
+  }
+  getClient() {
+    const client = this.authService?.getClient();
+    if (!client) {
+      throw new Error("Cloud API client is unavailable");
+    }
+    return client;
+  }
+  async requestJson(path, options) {
+    const timeoutMs = options.timeoutMs ?? REQUEST_TIMEOUT_MS;
+    const controller = new AbortController;
+    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+    this.activeAbortController = controller;
+    try {
+      const response = await this.getClient().requestRaw(options.method, path, {
+        headers: {
+          Accept: "application/json"
+        },
+        json: options.json,
+        query: options.query,
+        signal: controller.signal
+      });
+      const body = await response.json().catch(() => ({}));
+      return { status: response.status, body };
+    } finally {
+      clearTimeout(timeoutId);
+      if (this.activeAbortController === controller) {
+        this.activeAbortController = null;
+      }
+    }
+  }
+  async registerSession() {
+    const { status, body } = await this.requestJson("/eliza/gateway-relay/sessions", {
+      method: "POST",
+      json: {
+        runtimeAgentId: this.runtime.agentId,
+        agentName: this.getAgentName()
+      }
+    });
+    if (status >= 400 || !body?.success || !body.data?.session?.id) {
+      throw new Error(`Failed to register gateway relay session (status=${status})`);
+    }
+    logger17.info(`[CloudManagedGatewayRelay] Registered local runtime for managed gateway (${body.data.session.id})`);
+    return body.data.session.id;
+  }
+  async disconnectSession(sessionId) {
+    try {
+      await this.requestJson(`/eliza/gateway-relay/sessions/${encodeURIComponent(sessionId)}`, {
+        method: "DELETE",
+        timeoutMs: 1e4
+      });
+    } catch (error) {
+      logger17.debug(`[CloudManagedGatewayRelay] Failed to disconnect relay session ${sessionId}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  async pollNextRequest(sessionId) {
+    const { status, body } = await this.requestJson(`/eliza/gateway-relay/sessions/${encodeURIComponent(sessionId)}/next`, {
+      method: "GET",
+      query: { timeoutMs: POLL_TIMEOUT_MS },
+      timeoutMs: POLL_TIMEOUT_MS + 5000
+    });
+    if (status === 404) {
+      throw new SessionMissingError;
+    }
+    if (status >= 400 || !body?.success) {
+      throw new Error(`Failed to poll gateway relay session ${sessionId} (status=${status})`);
+    }
+    return body.data?.request ?? null;
+  }
+  async submitResponse(sessionId, requestId, response) {
+    const { status, body } = await this.requestJson(`/eliza/gateway-relay/sessions/${encodeURIComponent(sessionId)}/responses`, {
+      method: "POST",
+      json: { requestId, response }
+    });
+    if (status === 404) {
+      throw new SessionMissingError;
+    }
+    if (status >= 400 || body?.success === false) {
+      throw new Error(`Failed to submit gateway relay response (status=${status})`);
+    }
+  }
+  async handleRequest(rpc) {
+    switch (rpc.method) {
+      case "heartbeat":
+        return {
+          jsonrpc: "2.0",
+          id: rpc.id,
+          result: { timestamp: Date.now() }
+        };
+      case "status.get":
+        return {
+          jsonrpc: "2.0",
+          id: rpc.id,
+          result: {
+            status: "running",
+            runtimeAgentId: this.runtime.agentId,
+            agentName: this.getAgentName()
+          }
+        };
+      case "message.send":
+        return this.handleMessageSend(rpc);
+      default:
+        return {
+          jsonrpc: "2.0",
+          id: rpc.id,
+          error: {
+            code: -32601,
+            message: `Unsupported relay method: ${rpc.method}`
+          }
+        };
+    }
+  }
+  async handleMessageSend(rpc) {
+    if (!this.runtime.messageService) {
+      return {
+        jsonrpc: "2.0",
+        id: rpc.id,
+        error: { code: -32603, message: "Message service is not available" }
+      };
+    }
+    const payload = buildGatewayMessagePayload(this.runtime, rpc);
+    if (!payload) {
+      return {
+        jsonrpc: "2.0",
+        id: rpc.id,
+        error: { code: -32602, message: "Invalid message relay payload" }
+      };
+    }
+    const roomId = isUuidLike(payload.roomKey) ? payload.roomKey : createUniqueUuid(this.runtime, payload.roomKey);
+    const worldId = createUniqueUuid(this.runtime, buildWorldKey(payload.source, payload.transportMetadata, payload.roomKey));
+    const entityId = createUniqueUuid(this.runtime, `${payload.source}:${payload.senderId}`);
+    const messageServerId = createUniqueUuid(this.runtime, `eliza-cloud-gateway:${payload.source}`);
+    const messageId = createUniqueUuid(this.runtime, `${payload.source}:${payload.roomKey}:${String(rpc.id ?? Date.now())}:inbound`);
+    const transportMetadata = toJsonMetadataRecord(payload.transportMetadata);
+    await this.runtime.ensureConnection({
+      entityId,
+      roomId,
+      roomName: payload.roomKey,
+      worldId,
+      worldName: payload.source,
+      userName: payload.senderUserName,
+      name: payload.senderName,
+      source: payload.source,
+      channelId: payload.roomKey,
+      type: payload.channelType,
+      messageServerId,
+      metadata: transportMetadata
+    });
+    const message = createMessageMemory({
+      id: messageId,
+      entityId,
+      agentId: this.runtime.agentId,
+      roomId,
+      content: {
+        text: payload.text,
+        source: payload.source,
+        channelType: payload.channelType,
+        ...payload.attachments ? { attachments: payload.attachments } : {}
+      }
+    });
+    message.metadata = {
+      ...message.metadata,
+      entityName: payload.senderName,
+      entityUserName: payload.senderUserName,
+      ...payload.senderMetadata ? { gatewaySender: toJsonMetadataRecord(payload.senderMetadata) } : {},
+      ...payload.transportMetadata ? { gatewayMetadata: transportMetadata } : {}
+    };
+    const callbackTexts = [];
+    const callback = async (content) => {
+      const responseText = typeof content.text === "string" ? content.text : "";
+      if (responseText.trim()) {
+        callbackTexts.push(responseText);
+      }
+      const responseMemory = createMessageMemory({
+        id: createUniqueUuid(this.runtime, `${payload.source}:${payload.roomKey}:${String(rpc.id ?? Date.now())}:response:${callbackTexts.length}`),
+        entityId: this.runtime.agentId,
+        agentId: this.runtime.agentId,
+        roomId,
+        content: {
+          ...content,
+          text: responseText,
+          source: payload.source,
+          channelType: payload.channelType
+        }
+      });
+      await this.runtime.createMemory(responseMemory, "messages");
+      return [responseMemory];
+    };
+    try {
+      const result = await this.runtime.messageService.handleMessage(this.runtime, message, callback);
+      const replyText = callbackTexts[callbackTexts.length - 1] ?? (typeof result.responseContent?.text === "string" ? result.responseContent.text : undefined);
+      return {
+        jsonrpc: "2.0",
+        id: rpc.id,
+        result: {
+          didRespond: result.didRespond,
+          ...replyText ? { text: replyText } : {},
+          runtimeAgentId: this.runtime.agentId
+        }
+      };
+    } catch (error) {
+      return {
+        jsonrpc: "2.0",
+        id: rpc.id,
+        error: {
+          code: -32603,
+          message: error instanceof Error ? error.message : String(error)
+        }
+      };
+    }
+  }
+}
+
 // services/cloud-model-registry.ts
-import { logger as logger17, Service as Service5 } from "@elizaos/core";
+import { logger as logger18, Service as Service7 } from "@elizaos/core";
 var CACHE_TTL_MS = 30 * 60 * 1000;
 var PROVIDER_PREFIXES = [
   ["gpt-", "openai"],
@@ -2302,16 +3122,13 @@ function stripProvider(modelId) {
   return modelId;
 }
 
-class CloudModelRegistryService extends Service5 {
+class CloudModelRegistryService extends Service7 {
   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();
@@ -2325,7 +3142,7 @@ class CloudModelRegistryService extends Service5 {
   async initialize() {
     const auth = this.runtime.getService("CLOUD_AUTH");
     if (!auth?.isAuthenticated()) {
-      logger17.info("[CloudModelRegistry] Auth not available, will fetch models on first access");
+      logger18.info("[CloudModelRegistry] Auth not available, will fetch models on first access");
       return;
     }
     await this.fetchModels();
@@ -2361,7 +3178,7 @@ class CloudModelRegistryService extends Service5 {
       this.byProvider[model.provider].push(model);
     }
     this.lastFetchedAt = Date.now();
-    logger17.info(`[CloudModelRegistry] Loaded ${this.models.length} models from ${Object.keys(this.byProvider).length} providers`);
+    logger18.info(`[CloudModelRegistry] Loaded ${this.models.length} models from ${Object.keys(this.byProvider).length} providers`);
   }
   validateConfiguredModels() {
     if (this.models.length === 0)
@@ -2369,23 +3186,42 @@ class CloudModelRegistryService extends Service5 {
     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) {
-          logger17.warn(`[CloudModelRegistry] Configured ${label} "${value}" not found in available models. ` + "It may still work if the gateway supports it, but check your configuration.");
+          logger18.warn(`[CloudModelRegistry] Configured ${label} "${value}" not found in available models. ` + "It may still work if the gateway supports it, but check your configuration.");
         }
       }
     }
@@ -2405,6 +3241,11 @@ class CloudModelRegistryService extends Service5 {
 }
 
 // index.ts
+var TEXT_NANO_MODEL_TYPE2 = ModelType6.TEXT_NANO ?? "TEXT_NANO";
+var TEXT_MEDIUM_MODEL_TYPE2 = ModelType6.TEXT_MEDIUM ?? "TEXT_MEDIUM";
+var TEXT_MEGA_MODEL_TYPE2 = ModelType6.TEXT_MEGA ?? "TEXT_MEGA";
+var RESPONSE_HANDLER_MODEL_TYPE2 = ModelType6.RESPONSE_HANDLER ?? "RESPONSE_HANDLER";
+var ACTION_PLANNER_MODEL_TYPE2 = ModelType6.ACTION_PLANNER ?? "ACTION_PLANNER";
 function getProcessEnv() {
   if (typeof process === "undefined") {
     return {};
@@ -2419,14 +3260,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,
@@ -2445,6 +3298,8 @@ var elizaOSCloudPlugin = {
   },
   services: [
     CloudAuthService,
+    CloudBootstrapServiceImpl,
+    CloudManagedGatewayRelayService,
     CloudModelRegistryService,
     CloudContainerService,
     CloudBridgeService,
@@ -2464,10 +3319,13 @@ var elizaOSCloudPlugin = {
   ],
   models: {
     [ModelType6.TEXT_EMBEDDING]: handleTextEmbedding,
+    [TEXT_NANO_MODEL_TYPE2]: handleTextNano,
+    [TEXT_MEDIUM_MODEL_TYPE2]: handleTextMedium,
     [ModelType6.TEXT_SMALL]: handleTextSmall,
     [ModelType6.TEXT_LARGE]: handleTextLarge,
-    [ModelType6.TEXT_REASONING_SMALL]: handleTextReasoningSmall,
-    [ModelType6.TEXT_REASONING_LARGE]: handleTextReasoningLarge,
+    [TEXT_MEGA_MODEL_TYPE2]: handleTextMega,
+    [RESPONSE_HANDLER_MODEL_TYPE2]: handleResponseHandler,
+    [ACTION_PLANNER_MODEL_TYPE2]: handleActionPlanner,
     [ModelType6.RESEARCH]: handleResearch,
     [ModelType6.IMAGE]: handleImageGeneration,
     [ModelType6.IMAGE_DESCRIPTION]: handleImageDescription,
@@ -2481,19 +3339,10 @@ 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();
-            logger18.log({
-              data: data?.data?.length ?? "N/A"
+            const data = await createCloudApiClient(runtime).get("/models");
+            logger19.log({
+              data: data.data?.length ?? "N/A"
             }, "Models Available");
-            if (!response.ok) {
-              throw new Error(`Failed to validate OpenAI API key: ${response.statusText}`);
-            }
           }
         },
         {
@@ -2502,7 +3351,7 @@ var elizaOSCloudPlugin = {
             const embedding = await runtime.useModel(ModelType6.TEXT_EMBEDDING, {
               text: "Hello, world!"
             });
-            logger18.log({ embedding }, "embedding");
+            logger19.log({ embedding }, "embedding");
           }
         },
         {
@@ -2514,7 +3363,7 @@ var elizaOSCloudPlugin = {
             if (text.length === 0) {
               throw new Error("Failed to generate text");
             }
-            logger18.log({ text }, "generated with test_text_large");
+            logger19.log({ text }, "generated with test_text_large");
           }
         },
         {
@@ -2526,41 +3375,41 @@ var elizaOSCloudPlugin = {
             if (text.length === 0) {
               throw new Error("Failed to generate text");
             }
-            logger18.log({ text }, "generated with test_text_small");
+            logger19.log({ text }, "generated with test_text_small");
           }
         },
         {
           name: "ELIZAOS_CLOUD_test_image_generation",
           fn: async (runtime) => {
-            logger18.log("ELIZAOS_CLOUD_test_image_generation");
+            logger19.log("ELIZAOS_CLOUD_test_image_generation");
             const image = await runtime.useModel(ModelType6.IMAGE, {
               prompt: "A beautiful sunset over a calm ocean",
               count: 1,
               size: "1024x1024"
             });
-            logger18.log({ image }, "generated with test_image_generation");
+            logger19.log({ image }, "generated with test_image_generation");
           }
         },
         {
           name: "image-description",
           fn: async (runtime) => {
-            logger18.log("ELIZAOS_CLOUD_test_image_description");
+            logger19.log("ELIZAOS_CLOUD_test_image_description");
             const result = await runtime.useModel(ModelType6.IMAGE_DESCRIPTION, "https://upload.wikimedia.org/wikipedia/commons/thumb/1/1c/Vitalik_Buterin_TechCrunch_London_2015_%28cropped%29.jpg/537px-Vitalik_Buterin_TechCrunch_London_2015_%28cropped%29.jpg");
             if (result && typeof result === "object" && "title" in result && "description" in result) {
-              logger18.log({ result }, "Image description");
+              logger19.log({ result }, "Image description");
             } else {
-              logger18.error(`Invalid image description result format: ${JSON.stringify(result)}`);
+              logger19.error(`Invalid image description result format: ${JSON.stringify(result)}`);
             }
           }
         },
         {
           name: "ELIZAOS_CLOUD_test_transcription",
           fn: async (runtime) => {
-            logger18.log("ELIZAOS_CLOUD_test_transcription");
+            logger19.log("ELIZAOS_CLOUD_test_transcription");
             const response = await fetch("https://upload.wikimedia.org/wikipedia/en/4/40/Chris_Benoit_Voice_Message.ogg");
             const arrayBuffer = await response.arrayBuffer();
             const transcription = await runtime.useModel(ModelType6.TRANSCRIPTION, Buffer.from(new Uint8Array(arrayBuffer)));
-            logger18.log({ transcription }, "generated with test_transcription");
+            logger19.log({ transcription }, "generated with test_transcription");
           }
         },
         {
@@ -2574,7 +3423,7 @@ var elizaOSCloudPlugin = {
             if (!Array.isArray(tokens) || tokens.length === 0) {
               throw new Error("Failed to tokenize text: expected non-empty array of tokens");
             }
-            logger18.log({ tokens }, "Tokenized output");
+            logger19.log({ tokens }, "Tokenized output");
           }
         },
         {
@@ -2592,7 +3441,7 @@ var elizaOSCloudPlugin = {
             if (decodedText !== prompt) {
               throw new Error(`Decoded text does not match original. Expected "${prompt}", got "${decodedText}"`);
             }
-            logger18.log({ decodedText }, "Decoded text");
+            logger19.log({ decodedText }, "Decoded text");
           }
         },
         {
@@ -2604,17 +3453,20 @@ var elizaOSCloudPlugin = {
             if (!response) {
               throw new Error("Failed to generate speech");
             }
-            logger18.log("Generated speech successfully");
+            logger19.log("Generated speech successfully");
           }
         }
       ]
     }
   ]
 };
-var typescript_default = elizaOSCloudPlugin;
+var plugin_elizacloud_default = elizaOSCloudPlugin;
+
+// index.node.ts
+var index_node_default = plugin_elizacloud_default;
 export {
   elizaOSCloudPlugin,
-  typescript_default as default
+  index_node_default as default
 };
 
-//# debugId=C04165FB0B21129D64756E2164756E21
+//# debugId=6243C8A3ED6780E664756E2164756E21