@elizaos/plugin-elizacloud 2.0.3-beta.5 → 2.0.3-beta.7

package/README.md

@@ -40,7 +40,7 @@ helpers in `src/utils/sdk-client.ts`:
 | `src/utils/cloud-api.ts` | Backwards-compatible re-export of SDK classes and types |
 
 `ELIZAOS_CLOUD_BASE_URL` remains the API base URL and defaults to
-`https://www.elizacloud.ai/api/v1`. `createElizaCloudClient` derives the site
+`https://elizacloud.ai/api/v1`. `createElizaCloudClient` derives the site
 root from that API URL when generated SDK route wrappers need `/api/v1/...`
 paths.
 
@@ -105,7 +105,7 @@ Get an API key from
 | Setting | Description | Default |
 | --- | --- | --- |
 | `ELIZAOS_CLOUD_API_KEY` | API key used for authenticated Cloud requests | Required |
-| `ELIZAOS_CLOUD_BASE_URL` | Eliza Cloud API base URL | `https://www.elizacloud.ai/api/v1` |
+| `ELIZAOS_CLOUD_BASE_URL` | Eliza Cloud API base URL | `https://elizacloud.ai/api/v1` |
 | `ELIZAOS_CLOUD_ENABLED` | Enables container provisioning, device auth, bridge, and backup services | `false` |
 | `ELIZAOS_CLOUD_NANO_MODEL` | Nano/cheapest model override | `NANO_MODEL` or `gpt-oss-120b` |
 | `ELIZAOS_CLOUD_SMALL_MODEL` | Small/fast model override | `SMALL_MODEL` or `gpt-oss-120b` |

package/dist/cjs/index.node.cjs

@@ -62,9 +62,9 @@ var __export = (target, all) => {
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 
 // src/cloud/base-url.ts
-var import_shared2;
+var import_shared;
 var init_base_url = __esm(() => {
-  import_shared2 = require("@elizaos/shared");
+  import_shared = require("@elizaos/shared");
 });
 
 // src/cloud/auth-service-types.ts
@@ -356,7 +356,7 @@ async function fetchCryptoStatusCached(baseUrl, headers) {
   return value;
 }
 function resolveCloudBaseUrl(config) {
-  return import_shared2.normalizeCloudSiteUrl(config.cloud?.baseUrl);
+  return import_shared.normalizeCloudSiteUrl(config.cloud?.baseUrl);
 }
 function resolveProxyApiKey(state) {
   const cloudAuth = state.runtime ? state.runtime.getService("CLOUD_AUTH") : null;
@@ -439,8 +439,8 @@ async function fetchUpstream(url, method, headers, body) {
       throw Object.assign(new Error("redirect"), { code: "REDIRECT" });
     }
     const nextUrl = new URL(location, currentUrl).toString();
-    const currentOrigin = import_shared2.normalizeCloudSiteUrl(new URL(currentUrl).origin);
-    const nextOrigin = import_shared2.normalizeCloudSiteUrl(new URL(nextUrl).origin);
+    const currentOrigin = import_shared.normalizeCloudSiteUrl(new URL(currentUrl).origin);
+    const nextOrigin = import_shared.normalizeCloudSiteUrl(new URL(nextUrl).origin);
     if (new URL(currentUrl).origin !== new URL(nextUrl).origin && currentOrigin !== nextOrigin) {
       throw Object.assign(new Error("redirect"), { code: "REDIRECT" });
     }
@@ -793,7 +793,7 @@ function buildHomeRemoteRunnerAccessUrl(input) {
   if (!sessionId)
     return null;
   try {
-    const url = new URL(import_shared3.normalizeCloudSiteUrl(input.cloudBaseUrl ?? undefined));
+    const url = new URL(import_shared2.normalizeCloudSiteUrl(input.cloudBaseUrl ?? undefined));
     url.pathname = "/dashboard/app";
     url.search = "";
     url.hash = "";
@@ -848,9 +848,9 @@ function normalizeSshTarget(value) {
 function quoteShellArg(value) {
   return `'${value.replace(/'/g, "'\\''")}'`;
 }
-var import_shared3, HOME_REMOTE_RUNNER_ACCESS_SESSION_PARAM = "homeRemoteRunnerSession";
+var import_shared2, HOME_REMOTE_RUNNER_ACCESS_SESSION_PARAM = "homeRemoteRunnerSession";
 var init_home_remote_runner_access_url = __esm(() => {
-  import_shared3 = require("@elizaos/shared");
+  import_shared2 = require("@elizaos/shared");
 });
 
 // src/lib/state-paths.ts
@@ -1347,7 +1347,7 @@ async function fetchWithTimeout(input, init, timeoutMs) {
 }
 async function handleCloudRoute(req, res, pathname, method, state) {
   if (method === "POST" && pathname === "/api/cloud/login") {
-    const baseUrl = import_shared2.normalizeCloudSiteUrl(state.config.cloud?.baseUrl);
+    const baseUrl = import_shared.normalizeCloudSiteUrl(state.config.cloud?.baseUrl);
     const urlError = await validateCloudBaseUrl(baseUrl);
     if (urlError) {
       sendJsonError(res, urlError);
@@ -1407,7 +1407,7 @@ async function handleCloudRoute(req, res, pathname, method, state) {
       sendJsonError(res, "sessionId query parameter is required");
       return true;
     }
-    const baseUrl = import_shared2.normalizeCloudSiteUrl(state.config.cloud?.baseUrl);
+    const baseUrl = import_shared.normalizeCloudSiteUrl(state.config.cloud?.baseUrl);
     const urlError = await validateCloudBaseUrl(baseUrl);
     if (urlError) {
       sendJsonError(res, urlError);
@@ -1818,9 +1818,9 @@ var init_cloud_routes_autonomous = __esm(() => {
 });
 
 // src/lib/cloud-secrets.ts
-var import_shared4;
+var import_shared3;
 var init_cloud_secrets = __esm(() => {
-  import_shared4 = require("@elizaos/shared");
+  import_shared3 = require("@elizaos/shared");
 });
 
 // src/lib/cloud-connection.ts
@@ -1856,7 +1856,7 @@ function resolvePersistedCloudIdentity(runtime) {
   };
 }
 function resolveCloudApiBaseUrl2(rawBaseUrl) {
-  return import_shared2.resolveCloudApiBaseUrl(rawBaseUrl ?? DEFAULT_CLOUD_API_BASE_URL) ?? DEFAULT_CLOUD_API_BASE_URL;
+  return import_shared.resolveCloudApiBaseUrl(rawBaseUrl ?? DEFAULT_CLOUD_API_BASE_URL) ?? DEFAULT_CLOUD_API_BASE_URL;
 }
 function resolveCloudApiKey2(config, runtime) {
   import_core25.migrateLegacyRuntimeConfig(config);
@@ -1866,7 +1866,7 @@ function resolveCloudApiKey2(config, runtime) {
   if (!import_core25.isCloudInferenceSelectedInConfig(config)) {
     return;
   }
-  const sealedKey = normalizeEnvValue(import_shared4.getCloudSecret("ELIZAOS_CLOUD_API_KEY"));
+  const sealedKey = normalizeEnvValue(import_shared3.getCloudSecret("ELIZAOS_CLOUD_API_KEY"));
   if (sealedKey)
     return sealedKey;
   const envKey = normalizeEnvValue(process.env.ELIZAOS_CLOUD_API_KEY);
@@ -2040,8 +2040,8 @@ function clearCloudEnv() {
   for (const key of CLOUD_ENV_KEYS) {
     delete process.env[key];
   }
-  import_shared4.clearCloudSecrets();
-  import_shared4.scrubCloudSecretsFromEnv();
+  import_shared3.clearCloudSecrets();
+  import_shared3.scrubCloudSecretsFromEnv();
 }
 async function clearRuntimeCloudState(runtime) {
   const runtimeWithCloud = asRuntimeCloud(runtime);
@@ -2255,7 +2255,7 @@ async function handleCloudCodingContainerRoute(req, res, pathname, method, state
     const body = await readJsonBody3(req, res);
     if (!body)
       return true;
-    const parsed = import_shared7.PromoteVfsToCloudContainerRequestSchema.safeParse(body);
+    const parsed = import_shared6.PromoteVfsToCloudContainerRequestSchema.safeParse(body);
     if (!parsed.success) {
       sendJsonError(res, parsed.error.issues[0]?.message ?? "Invalid promotion request", 400);
       return true;
@@ -2272,7 +2272,7 @@ async function handleCloudCodingContainerRoute(req, res, pathname, method, state
     const body = await readJsonBody3(req, res);
     if (!body)
       return true;
-    const parsed = import_shared7.RequestCodingAgentContainerRequestSchema.safeParse(body);
+    const parsed = import_shared6.RequestCodingAgentContainerRequestSchema.safeParse(body);
     if (!parsed.success) {
       sendJsonError(res, parsed.error.issues[0]?.message ?? "Invalid coding container request", 400);
       return true;
@@ -2291,7 +2291,7 @@ async function handleCloudCodingContainerRoute(req, res, pathname, method, state
     const body = await readJsonBody3(req, res);
     if (!body)
       return true;
-    const parsed = import_shared7.SyncCloudCodingContainerRequestSchema.safeParse(body);
+    const parsed = import_shared6.SyncCloudCodingContainerRequestSchema.safeParse(body);
     if (!parsed.success) {
       sendJsonError(res, parsed.error.issues[0]?.message ?? "Invalid sync request", 400);
       return true;
@@ -2344,9 +2344,9 @@ async function sendServiceResponse(res, fn) {
     sendJsonError(res, error instanceof Error ? error.message : String(error), status);
   }
 }
-var import_shared7;
+var import_shared6;
 var init_cloud_coding_container_routes = __esm(() => {
-  import_shared7 = require("@elizaos/shared");
+  import_shared6 = require("@elizaos/shared");
 });
 
 // src/routes/cloud-routes.ts
@@ -2416,14 +2416,14 @@ async function persistCloudLoginStatus(args) {
   } catch (saveErr) {
     import_core37.logger.error(`[cloud-login] Failed to save cloud API key to config: ${saveErr instanceof Error ? saveErr.message : String(saveErr)}`);
   }
-  import_shared4.clearCloudSecrets();
+  import_shared3.clearCloudSecrets();
   process.env.ELIZAOS_CLOUD_API_KEY = args.apiKey;
   if (cloudInferenceSelected) {
     process.env.ELIZAOS_CLOUD_ENABLED = "true";
   } else {
     delete process.env.ELIZAOS_CLOUD_ENABLED;
   }
-  import_shared4.scrubCloudSecretsFromEnv();
+  import_shared3.scrubCloudSecretsFromEnv();
   const cloudManager = args.state.cloudManager;
   if (cloudManager && typeof cloudManager.replaceApiKey === "function") {
     await cloudManager.replaceApiKey(args.apiKey);
@@ -2680,7 +2680,7 @@ async function handleCloudRoute2(req, res, pathname, method, state) {
     return true;
   }
   const result = await services.handleAutonomousCloudRoute(req, res, pathname, method, toAutonomousState(state, services));
-  import_shared4.scrubCloudSecretsFromEnv();
+  import_shared3.scrubCloudSecretsFromEnv();
   return result;
 }
 var import_core36, import_core37, CLOUD_LOGIN_POLL_TIMEOUT_MS2 = 1e4, DEFAULT_CLOUD_ROUTE_SERVICES, cloudDisconnectEpoch = 0;
@@ -2700,7 +2700,7 @@ var init_cloud_routes = __esm(() => {
       return;
     },
     handleAutonomousCloudRoute: handleCloudRoute,
-    normalizeCloudSiteUrl: import_shared2.normalizeCloudSiteUrl,
+    normalizeCloudSiteUrl: import_shared.normalizeCloudSiteUrl,
     saveElizaConfig: () => {
       import_core37.logger.warn("[cloud-routes] saveConfig unavailable - config not persisted");
     },
@@ -2919,15 +2919,15 @@ __export(exports_index_node, {
   validateCloudBaseUrl: () => validateCloudBaseUrl,
   setCloudVoiceClientFactoryForTesting: () => setCloudVoiceClientFactoryForTesting,
   searchFlights: () => searchFlights,
-  scrubCloudSecretsFromEnv: () => import_shared4.scrubCloudSecretsFromEnv,
+  scrubCloudSecretsFromEnv: () => import_shared3.scrubCloudSecretsFromEnv,
   runCloudSetup: () => runCloudSetup,
   resolveLifeOpsScheduleSyncSiteUrl: () => resolveLifeOpsScheduleSyncSiteUrl,
   resolveLifeOpsScheduleSyncConfig: () => resolveLifeOpsScheduleSyncConfig,
   resolveEnvElizaCloudManagedClientConfig: () => resolveEnvElizaCloudManagedClientConfig,
-  resolveElevenLabsApiKeyForCloudMode: () => import_shared6.resolveElevenLabsApiKeyForCloudMode,
-  resolveCloudTtsBaseUrl: () => import_shared6.resolveCloudTtsBaseUrl,
+  resolveElevenLabsApiKeyForCloudMode: () => import_shared5.resolveElevenLabsApiKeyForCloudMode,
+  resolveCloudTtsBaseUrl: () => import_shared5.resolveCloudTtsBaseUrl,
   resolveCloudApiKey: () => resolveCloudApiKey,
-  resolveCloudApiBaseUrl: () => import_shared2.resolveCloudApiBaseUrl,
+  resolveCloudApiBaseUrl: () => import_shared.resolveCloudApiBaseUrl,
   resetCloudVoiceCatalogCacheForTesting: () => resetCloudVoiceCatalogCacheForTesting,
   requestPayment: () => requestPayment,
   readDuffelConfigFromEnv: () => readDuffelConfigFromEnv,
@@ -2936,10 +2936,10 @@ __export(exports_index_node, {
   parseX402Response: () => parseX402Response,
   normalizeLifeOpsScheduleSyncSecret: () => normalizeLifeOpsScheduleSyncSecret,
   normalizeElizaCloudApiKey: () => normalizeElizaCloudApiKey,
-  normalizeCloudSiteUrl: () => import_shared2.normalizeCloudSiteUrl,
+  normalizeCloudSiteUrl: () => import_shared.normalizeCloudSiteUrl,
   normalizeCloudSecret: () => normalizeCloudSecret,
   normalizeCloudApiKey: () => normalizeCloudApiKey,
-  mirrorCompatHeaders: () => import_shared6.mirrorCompatHeaders,
+  mirrorCompatHeaders: () => import_shared5.mirrorCompatHeaders,
   isCloudProvisionedContainer: () => isCloudProvisionedContainer,
   isCloudAuthApiKeyService: () => isCloudAuthApiKeyService,
   handleCloudTtsPreviewRoute: () => handleCloudTtsPreviewRoute,
@@ -2952,17 +2952,17 @@ __export(exports_index_node, {
   getOrder: () => getOrder,
   getOrCreateClientAddressKey: () => getOrCreateClientAddressKey,
   getOffer: () => getOffer,
-  getCloudSecret: () => import_shared4.getCloudSecret,
+  getCloudSecret: () => import_shared3.getCloudSecret,
   fetchCloudVoiceCatalog: () => fetchCloudVoiceCatalog,
-  ensureCloudTtsApiKeyAlias: () => import_shared6.ensureCloudTtsApiKeyAlias,
+  ensureCloudTtsApiKeyAlias: () => import_shared5.ensureCloudTtsApiKeyAlias,
   elizaOSCloudPlugin: () => elizaOSCloudPlugin,
   elizaCloudRoutePlugin: () => elizaCloudRoutePlugin,
   default: () => index_node_default,
   createPayment: () => createPayment,
   createOrder: () => createOrder,
   cloudLogin: () => cloudLogin,
-  clearCloudSecrets: () => import_shared4.clearCloudSecrets,
-  __resetCloudBaseUrlCache: () => import_shared6.__resetCloudBaseUrlCache,
+  clearCloudSecrets: () => import_shared3.clearCloudSecrets,
+  __resetCloudBaseUrlCache: () => import_shared5.__resetCloudBaseUrlCache,
   PlaidManagedClientError: () => PlaidManagedClientError,
   PlaidManagedClient: () => PlaidManagedClient,
   PaypalManagedClientError: () => PaypalManagedClientError,
@@ -3013,6 +3013,7 @@ var cloudStatusProvider = {
       const bridgeSvc = runtime.getService("CLOUD_BRIDGE");
       const containers = containerSvc?.getTrackedContainers() ?? [];
       const connected = bridgeSvc?.getConnectedContainerIds() ?? [];
+      const apiKeyInvalid = auth.isApiKeyInvalid();
       const running = containers.filter((c) => c.status === "running").length;
       const deploying = containers.filter((c) => c.status === "pending" || c.status === "building" || c.status === "deploying").length;
       const summaries = containers.slice(0, MAX_CONTAINER_SUMMARIES).map((c) => ({
@@ -3025,6 +3026,7 @@ var cloudStatusProvider = {
       }));
       const lines = [
         `ElizaCloud: ${containers.length} container(s), ${running} running, ${connected.length} bridged`,
+        ...apiKeyInvalid ? ["  - WARNING: Eliza Cloud API key REVOKED/INVALID — model calls will 401 until re-provisioned"] : [],
         ...summaries.map((c) => `  - ${c.name} [${c.status}]${c.url ? ` @ ${c.url}` : ""}${c.bridged ? " (bridged)" : ""}`)
       ];
       return {
@@ -3032,6 +3034,7 @@ var cloudStatusProvider = {
 `),
         values: {
           cloudAuthenticated: true,
+          cloudApiKeyInvalid: apiKeyInvalid,
           totalContainers: containers.length,
           runningContainers: running,
           deployingContainers: deploying
@@ -5064,7 +5067,6 @@ async function handleActionPlanner(runtime, params) {
 }
 // src/services/cloud-auth.ts
 var import_core12 = require("@elizaos/core");
-var import_shared = require("@elizaos/shared");
 var import_jose = require("jose");
 
 // src/types/cloud.ts
@@ -5120,11 +5122,57 @@ function detectPlatform() {
   };
   return map[process.platform] ?? "linux";
 }
+var DEFAULT_REVALIDATION_CONFIG = {
+  retryMs: 60000,
+  steadyMs: 1800000,
+  invalidThreshold: 2
+};
+function decideRevalidation(prev, probe, cfg = DEFAULT_REVALIDATION_CONFIG) {
+  if (probe === "valid") {
+    const log = prev.keyState !== "valid" ? { level: "info", message: "[CloudAuth] API key validated" } : null;
+    return {
+      state: { keyState: "valid", consecutiveInvalid: 0 },
+      delayMs: cfg.steadyMs,
+      log
+    };
+  }
+  if (probe === "invalid") {
+    const consecutiveInvalid = prev.consecutiveInvalid + 1;
+    const confirmed = consecutiveInvalid >= cfg.invalidThreshold;
+    if (confirmed) {
+      const log = prev.keyState !== "invalid" ? {
+        level: "error",
+        message: "[CloudAuth] Eliza Cloud API key is REVOKED/INVALID (cloud reachable, key rejected). Model calls will fail with 401 until the agent is re-provisioned or a valid ELIZAOS_CLOUD_API_KEY is set."
+      } : null;
+      return {
+        state: { keyState: "invalid", consecutiveInvalid },
+        delayMs: cfg.steadyMs,
+        log
+      };
+    }
+    return {
+      state: { keyState: prev.keyState, consecutiveInvalid },
+      delayMs: cfg.retryMs,
+      log: null
+    };
+  }
+  return {
+    state: { ...prev },
+    delayMs: cfg.retryMs,
+    log: null
+  };
+}
+
 class CloudAuthService extends import_core12.Service {
   static serviceType = "CLOUD_AUTH";
   capabilityDescription = "Eliza Cloud device authentication and SSO session helpers";
   client;
   credentials = null;
+  revalidationTimer = null;
+  revalidationState = {
+    keyState: "unknown",
+    consecutiveInvalid: 0
+  };
   constructor(runtime) {
     super(runtime);
     this.client = new import_cloud_sdk3.CloudApiClient(DEFAULT_CLOUD_CONFIG.baseUrl);
@@ -5135,6 +5183,11 @@ class CloudAuthService extends import_core12.Service {
     return service;
   }
   async stop() {
+    if (this.revalidationTimer) {
+      clearTimeout(this.revalidationTimer);
+      this.revalidationTimer = null;
+    }
+    this.revalidationState = { keyState: "unknown", consecutiveInvalid: 0 };
     this.credentials = null;
   }
   async initialize() {
@@ -5151,11 +5204,7 @@ class CloudAuthService extends import_core12.Service {
         authenticatedAt: Date.now()
       };
       import_core12.logger.info("[CloudAuth] Authenticated with saved API key");
-      this.validateApiKey(key).then((valid) => {
-        if (!valid) {
-          import_core12.logger.warn("[CloudAuth] Saved API key could not be validated (cloud may be unreachable or key revoked) — model calls will use the key anyway");
-        }
-      }).catch(() => {});
+      this.scheduleRevalidation(0);
       return;
     }
     const enabled = this.runtime.getSetting("ELIZAOS_CLOUD_ENABLED");
@@ -5171,20 +5220,50 @@ class CloudAuthService extends import_core12.Service {
       import_core12.logger.info("[CloudAuth] Cloud not enabled (set ELIZAOS_CLOUD_ENABLED=true)");
     }
   }
-  async validateApiKey(key) {
-    if (!await import_shared.isCloudReachable()) {
-      import_core12.logger.warn("[CloudAuth] Cloud unreachable at boot — skipping API key validation; key will be used as-is");
-      return false;
-    }
+  async probeApiKey(key) {
     try {
       const validationClient = new import_cloud_sdk3.CloudApiClient(this.client.getBaseUrl(), key);
       await validationClient.get("/models", { timeoutMs: 2500 });
-      return true;
+      return "valid";
     } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      import_core12.logger.warn(`[CloudAuth] Could not reach cloud API to validate key: ${msg}`);
-      return false;
+      if (err instanceof import_cloud_sdk3.CloudApiError && (err.statusCode === 401 || err.statusCode === 403)) {
+        return "invalid";
+      }
+      return "unreachable";
+    }
+  }
+  scheduleRevalidation(delayMs) {
+    if (this.revalidationTimer) {
+      clearTimeout(this.revalidationTimer);
     }
+    const timer = setTimeout(() => {
+      this.runRevalidation();
+    }, delayMs);
+    timer.unref?.();
+    this.revalidationTimer = timer;
+  }
+  async runRevalidation() {
+    const key = this.credentials?.apiKey;
+    if (!key) {
+      return;
+    }
+    const probe = await this.probeApiKey(key).catch(() => "unreachable");
+    if (this.credentials?.apiKey !== key) {
+      return;
+    }
+    const decision = decideRevalidation(this.revalidationState, probe);
+    this.revalidationState = decision.state;
+    if (decision.log) {
+      if (decision.log.level === "error") {
+        import_core12.logger.error(decision.log.message);
+      } else {
+        import_core12.logger.info(decision.log.message);
+      }
+    }
+    this.scheduleRevalidation(decision.delayMs);
+  }
+  isApiKeyInvalid() {
+    return this.revalidationState.keyState === "invalid";
   }
   async authenticateWithDevice() {
     const deviceId = await deriveDeviceId();
@@ -6867,7 +6946,7 @@ var PROXY_TIMEOUT_MS2 = 15000;
 var MAX_BODY_BYTES2 = 1048576;
 var JSON_CONTENT_TYPE_RE = /\b(?:application\/json|[^;\s]+\+json)\b/i;
 function resolveCloudBaseUrl2(config) {
-  return import_shared2.normalizeCloudSiteUrl(config.cloud?.baseUrl);
+  return import_shared.normalizeCloudSiteUrl(config.cloud?.baseUrl);
 }
 function resolveProxyApiKey2(state) {
   const cloudAuth = state.runtime ? state.runtime.getService("CLOUD_AUTH") : null;
@@ -7128,7 +7207,7 @@ async function fetchWithTimeout2(input, init, timeoutMs) {
   });
 }
 async function cloudLogin(options = {}) {
-  const baseUrl = import_shared2.normalizeCloudSiteUrl(options.baseUrl);
+  const baseUrl = import_shared.normalizeCloudSiteUrl(options.baseUrl);
   const urlError = await validateCloudBaseUrl(baseUrl);
   if (urlError) {
     throw new Error(urlError);
@@ -7300,7 +7379,7 @@ class ElizaCloudClient2 {
   baseUrl;
   apiKey;
   constructor(baseUrl, apiKey) {
-    this.baseUrl = import_shared2.normalizeCloudSiteUrl(baseUrl);
+    this.baseUrl = import_shared.normalizeCloudSiteUrl(baseUrl);
     this.apiKey = apiKey;
   }
   async listAgents() {
@@ -7571,7 +7650,7 @@ var PROVISION_TIMEOUT_MS = 120000;
 var PROVISION_POLL_INTERVAL_MS = 3000;
 async function checkCloudAvailability(baseUrl) {
   try {
-    const url = `${import_shared2.normalizeCloudSiteUrl(baseUrl)}/api/compat/availability`;
+    const url = `${import_shared.normalizeCloudSiteUrl(baseUrl)}/api/compat/availability`;
     const res = await fetch(url, {
       method: "GET",
       headers: { Accept: "application/json" },
@@ -7722,7 +7801,7 @@ function classifyPollError(err) {
   return "terminal";
 }
 async function runCloudSetup(observer, agentName, preset, baseUrl) {
-  const resolvedBaseUrl = import_shared2.normalizeCloudSiteUrl(baseUrl ?? DEFAULT_CLOUD_BASE_URL);
+  const resolvedBaseUrl = import_shared.normalizeCloudSiteUrl(baseUrl ?? DEFAULT_CLOUD_BASE_URL);
   const unavailableReason = await checkCloudAvailability(resolvedBaseUrl);
   observer.onAvailabilityChecked({
     ok: unavailableReason === null,
@@ -8131,7 +8210,7 @@ class CloudManager {
     this.callbacks = callbacks;
   }
   async init() {
-    const rawUrl = import_shared2.normalizeCloudSiteUrl(this.cloudConfig.baseUrl);
+    const rawUrl = import_shared.normalizeCloudSiteUrl(this.cloudConfig.baseUrl);
     const apiKey = this.cloudConfig.apiKey;
     if (!apiKey)
       throw new Error("Cloud API key is not configured. Run cloud login first.");
@@ -8234,8 +8313,8 @@ class CloudManager {
 }
 // src/lib/server-cloud-tts.ts
 var import_core34 = require("@elizaos/core");
+var import_shared4 = require("@elizaos/shared");
 var import_shared5 = require("@elizaos/shared");
-var import_shared6 = require("@elizaos/shared");
 function readTtsDebugClientHeaders(req) {
   const pick = (name) => {
     const raw = req.headers[name];
@@ -8313,9 +8392,9 @@ function forwardCloudTtsUpstreamError(res, status, bodyText) {
 async function handleCloudTtsPreviewRoute(req, res) {
   const clientTtsDbg = readTtsDebugClientHeaders(req);
   const dbgExtra = ttsClientDbgFields(clientTtsDbg);
-  const cloudApiKey = import_shared5._internalResolveCloudApiKey();
+  const cloudApiKey = import_shared4._internalResolveCloudApiKey();
   if (!cloudApiKey) {
-    import_shared5.ttsDebug("server:cloud-tts:reject", {
+    import_shared4.ttsDebug("server:cloud-tts:reject", {
       reason: "no_api_key",
       ...dbgExtra
     });
@@ -8335,15 +8414,15 @@ async function handleCloudTtsPreviewRoute(req, res) {
     sendJsonErrorResponse(res, 400, "Missing text");
     return true;
   }
-  if (text.length > import_shared5.ELIZA_CLOUD_TTS_MAX_TEXT_CHARS) {
-    sendJsonErrorResponse(res, 400, `Text too long. Maximum length is ${import_shared5.ELIZA_CLOUD_TTS_MAX_TEXT_CHARS} characters`);
+  if (text.length > import_shared4.ELIZA_CLOUD_TTS_MAX_TEXT_CHARS) {
+    sendJsonErrorResponse(res, 400, `Text too long. Maximum length is ${import_shared4.ELIZA_CLOUD_TTS_MAX_TEXT_CHARS} characters`);
     return true;
   }
-  const cloudModel = import_shared5.resolveCloudProxyTtsModel(pickBodyString(body, "modelId", "model_id"));
-  const cloudVoice = import_shared5.resolveElizaCloudTtsVoiceId(pickBodyString(body, "voiceId", "voice_id"));
-  const cloudUrls = import_shared5.resolveCloudTtsCandidateUrls();
-  const ttsPreview = import_shared5.ttsDebugTextPreview(text);
-  import_shared5.ttsDebug("server:cloud-tts:proxy", {
+  const cloudModel = import_shared4.resolveCloudProxyTtsModel(pickBodyString(body, "modelId", "model_id"));
+  const cloudVoice = import_shared4.resolveElizaCloudTtsVoiceId(pickBodyString(body, "voiceId", "voice_id"));
+  const cloudUrls = import_shared4.resolveCloudTtsCandidateUrls();
+  const ttsPreview = import_shared4.ttsDebugTextPreview(text);
+  import_shared4.ttsDebug("server:cloud-tts:proxy", {
     textChars: text.length,
     preview: ttsPreview,
     modelId: cloudModel,
@@ -8376,7 +8455,7 @@ async function handleCloudTtsPreviewRoute(req, res) {
       });
       if (attempt.ok) {
         cloudResponse = attempt;
-        import_shared5.ttsDebug("server:cloud-tts:upstream-ok", {
+        import_shared4.ttsDebug("server:cloud-tts:upstream-ok", {
           urlIndex: i,
           status: attempt.status,
           preview: ttsPreview,
@@ -8386,19 +8465,19 @@ async function handleCloudTtsPreviewRoute(req, res) {
       }
       lastStatus = attempt.status;
       lastDetails = await attempt.text().catch(() => "unknown error");
-      import_shared5.ttsDebug("server:cloud-tts:upstream-retry", {
+      import_shared4.ttsDebug("server:cloud-tts:upstream-retry", {
         urlIndex: i,
         status: attempt.status,
         preview: ttsPreview,
         ...dbgExtra
       });
       const hasMoreCandidates = i < cloudUrls.length - 1;
-      if (!hasMoreCandidates || !import_shared5.shouldRetryCloudTtsUpstream(attempt.status)) {
+      if (!hasMoreCandidates || !import_shared4.shouldRetryCloudTtsUpstream(attempt.status)) {
         break;
       }
     }
     if (!cloudResponse) {
-      import_shared5.ttsDebug("server:cloud-tts:reject", {
+      import_shared4.ttsDebug("server:cloud-tts:reject", {
         reason: "upstream_failed",
         lastStatus,
         preview: ttsPreview,
@@ -8412,7 +8491,7 @@ async function handleCloudTtsPreviewRoute(req, res) {
       return true;
     }
     const audioBuffer = Buffer.from(await cloudResponse.arrayBuffer());
-    import_shared5.ttsDebug("server:cloud-tts:success", {
+    import_shared4.ttsDebug("server:cloud-tts:success", {
       bytes: audioBuffer.length,
       preview: ttsPreview,
       ...dbgExtra
@@ -9075,7 +9154,7 @@ function resolveLifeOpsScheduleSyncConfig(config = {}) {
   return {
     configured: true,
     mode: "cloud",
-    apiBaseUrl: import_shared2.resolveCloudApiBaseUrl(normalizeOptionalString(config.baseUrl) ?? process.env.ELIZAOS_CLOUD_BASE_URL),
+    apiBaseUrl: import_shared.resolveCloudApiBaseUrl(normalizeOptionalString(config.baseUrl) ?? process.env.ELIZAOS_CLOUD_BASE_URL),
     apiKey,
     agentId
   };
@@ -9101,7 +9180,7 @@ async function readJsonResponse2(response) {
   return await response.json();
 }
 function resolveLifeOpsScheduleSyncSiteUrl(rawUrl) {
-  return import_shared2.normalizeCloudSiteUrl(rawUrl);
+  return import_shared.normalizeCloudSiteUrl(rawUrl);
 }
 
 class LifeOpsScheduleSyncClient {
@@ -9208,8 +9287,8 @@ function resolveEnvElizaCloudManagedClientConfig(env = typeof process === "undef
   return {
     configured: Boolean(apiKey),
     apiKey,
-    apiBaseUrl: import_shared2.resolveCloudApiBaseUrl(baseUrl),
-    siteUrl: import_shared2.normalizeCloudSiteUrl(baseUrl)
+    apiBaseUrl: import_shared.resolveCloudApiBaseUrl(baseUrl),
+    siteUrl: import_shared.normalizeCloudSiteUrl(baseUrl)
   };
 }
 var PLAID_REQUEST_TIMEOUT_MS = 30000;
@@ -9640,4 +9719,4 @@ init_cloud_wallet();
 init_cloud_secrets();
 var index_node_default = src_default;
 
-//# debugId=D034ECA0AAC234DD64756E2164756E21
+//# debugId=9886BE012F992E7064756E2164756E21