@elizaos/plugin-elizacloud 2.0.0-alpha.7 → 2.0.0-beta.1

package/src/services/cloud-model-registry.ts

@@ -0,0 +1,202 @@
+/** Fetches and caches available models from ElizaCloud. */
+
+import { type IAgentRuntime, logger, Service } from "@elizaos/core";
+import type { CloudAuthService } from "./cloud-auth";
+
+interface ModelListEntry {
+  id: string;
+  object: string;
+  created: number;
+  owned_by: string;
+}
+
+interface ModelListResponse {
+  object: string;
+  data: ModelListEntry[];
+}
+
+export interface AvailableModel {
+  id: string;
+  provider: string;
+  name: string;
+  createdAt: number;
+}
+
+export interface ModelsByProvider {
+  [provider: string]: AvailableModel[];
+}
+
+const CACHE_TTL_MS = 30 * 60 * 1000; // 30 minutes
+
+const PROVIDER_PREFIXES: ReadonlyArray<[string, string]> = [
+  ["gpt-", "openai"],
+  ["o1", "openai"],
+  ["o3", "openai"],
+  ["o4", "openai"],
+  ["dall-e", "openai"],
+  ["whisper", "openai"],
+  ["tts", "openai"],
+  ["claude-", "anthropic"],
+  ["gemini-", "google"],
+  ["llama", "meta"],
+  ["deepseek", "deepseek"],
+  ["grok", "xai"],
+  ["kimi", "moonshot"],
+];
+
+function extractProvider(modelId: string): string {
+  if (modelId.includes("/")) return modelId.split("/")[0];
+  const lower = modelId.toLowerCase();
+  for (const [prefix, provider] of PROVIDER_PREFIXES) {
+    if (lower.startsWith(prefix)) return provider;
+  }
+  return "unknown";
+}
+
+function stripProvider(modelId: string): string {
+  if (modelId.includes("/")) {
+    return modelId.split("/").slice(1).join("/");
+  }
+  return modelId;
+}
+
+export class CloudModelRegistryService extends Service {
+  static serviceType = "CLOUD_MODEL_REGISTRY";
+  capabilityDescription = "Discovers and caches available AI models from ElizaCloud";
+
+  private models: AvailableModel[] = [];
+  private byProvider: ModelsByProvider = {};
+  private lastFetchedAt = 0;
+  private fetchPromise: Promise<void> | null = null;
+
+  static async start(runtime: IAgentRuntime): Promise<Service> {
+    const service = new CloudModelRegistryService(runtime);
+    await service.initialize();
+    return service;
+  }
+
+  async stop(): Promise<void> {
+    this.models = [];
+    this.byProvider = {};
+    this.lastFetchedAt = 0;
+  }
+
+  private async initialize(): Promise<void> {
+    const auth = this.runtime.getService("CLOUD_AUTH") as CloudAuthService | undefined;
+
+    if (!auth?.isAuthenticated()) {
+      logger.info("[CloudModelRegistry] Auth not available, will fetch models on first access");
+      return;
+    }
+
+    await this.fetchModels();
+    this.validateConfiguredModels();
+  }
+
+  private async fetchModels(): Promise<void> {
+    if (this.fetchPromise) {
+      await this.fetchPromise;
+      return;
+    }
+
+    this.fetchPromise = this.doFetchModels();
+    await this.fetchPromise;
+    this.fetchPromise = null;
+  }
+
+  private async doFetchModels(): Promise<void> {
+    const auth = this.runtime.getService("CLOUD_AUTH") as CloudAuthService | undefined;
+    if (!auth?.isAuthenticated()) return;
+
+    const client = auth.getClient();
+
+    const response = await client.get<ModelListResponse>("/models");
+    const entries = response.data ?? [];
+
+    this.models = entries.map((entry) => ({
+      id: entry.id,
+      provider: extractProvider(entry.id),
+      name: stripProvider(entry.id),
+      createdAt: entry.created,
+    }));
+
+    this.byProvider = {};
+    for (const model of this.models) {
+      if (!this.byProvider[model.provider]) {
+        this.byProvider[model.provider] = [];
+      }
+      this.byProvider[model.provider].push(model);
+    }
+
+    this.lastFetchedAt = Date.now();
+    logger.info(
+      `[CloudModelRegistry] Loaded ${this.models.length} models from ${Object.keys(this.byProvider).length} providers`
+    );
+  }
+
+  private validateConfiguredModels(): void {
+    if (this.models.length === 0) return;
+
+    const modelIds = new Set(this.models.map((m) => m.id));
+    const nameSet = new Set(this.models.map((m) => m.name));
+
+    const settingsToCheck = [
+      { key: "ELIZAOS_CLOUD_NANO_MODEL", label: "nano model" },
+      { key: "ELIZAOS_CLOUD_MEDIUM_MODEL", label: "medium model" },
+      { key: "ELIZAOS_CLOUD_SMALL_MODEL", label: "small model" },
+      { key: "ELIZAOS_CLOUD_LARGE_MODEL", label: "large model" },
+      { key: "ELIZAOS_CLOUD_MEGA_MODEL", label: "mega model" },
+      {
+        key: "ELIZAOS_CLOUD_RESPONSE_HANDLER_MODEL",
+        label: "response handler model",
+      },
+      {
+        key: "ELIZAOS_CLOUD_ACTION_PLANNER_MODEL",
+        label: "action planner model",
+      },
+      { key: "ELIZAOS_CLOUD_RESPONSE_MODEL", label: "response model" },
+      { key: "ELIZAOS_CLOUD_RESEARCH_MODEL", label: "research model" },
+      { key: "ELIZAOS_CLOUD_EMBEDDING_MODEL", label: "embedding model" },
+      {
+        key: "ELIZAOS_CLOUD_IMAGE_DESCRIPTION_MODEL",
+        label: "image description model",
+      },
+      {
+        key: "ELIZAOS_CLOUD_IMAGE_GENERATION_MODEL",
+        label: "image generation model",
+      },
+      { key: "ELIZAOS_CLOUD_TTS_MODEL", label: "TTS model" },
+      {
+        key: "ELIZAOS_CLOUD_TRANSCRIPTION_MODEL",
+        label: "transcription model",
+      },
+    ];
+
+    for (const { key, label } of settingsToCheck) {
+      const value = this.runtime.getSetting(key);
+      if (value && typeof value === "string") {
+        const found = modelIds.has(value) || nameSet.has(value);
+        if (!found) {
+          logger.warn(
+            `[CloudModelRegistry] Configured ${label} "${value}" not found in available models. ` +
+              "It may still work if the gateway supports it, but check your configuration."
+          );
+        }
+      }
+    }
+  }
+
+  async getAvailableModels(): Promise<AvailableModel[]> {
+    if (Date.now() - this.lastFetchedAt > CACHE_TTL_MS) {
+      await this.fetchModels();
+    }
+    return this.models;
+  }
+
+  async getModelsByProvider(): Promise<ModelsByProvider> {
+    if (Date.now() - this.lastFetchedAt > CACHE_TTL_MS) {
+      await this.fetchModels();
+    }
+    return this.byProvider;
+  }
+}

package/src/services/index.ts

@@ -0,0 +1,17 @@
+export {
+  CloudAuthService,
+  type CloudSsoIdTokenClaims,
+  type CloudSsoSession,
+  type ExchangeCodeArgs,
+  exchangeCodeForSession,
+  getSsoRedirectUrl,
+  type SsoRedirectArgs,
+} from "./cloud-auth";
+export { CloudBackupService } from "./cloud-backup";
+export {
+  type CloudBootstrapService,
+  CloudBootstrapServiceImpl,
+} from "./cloud-bootstrap";
+export { CloudBridgeService } from "./cloud-bridge";
+export { CloudContainerService } from "./cloud-container";
+export { CloudManagedGatewayRelayService } from "./cloud-managed-gateway-relay";

package/{types → src/types}/cloud.ts

@@ -197,6 +197,53 @@ export interface BridgeConnection {
   reconnectAttempts: number;
 }
 
+// ─── Managed Gateway Relay Types ───────────────────────────────────────────
+
+export interface GatewayRelaySession {
+  id: string;
+  organizationId: string;
+  userId: string;
+  runtimeAgentId: string;
+  agentName: string | null;
+  platform: "local-runtime";
+  createdAt: string;
+  lastSeenAt: string;
+}
+
+export interface GatewayRelayRequest {
+  jsonrpc: "2.0";
+  id?: string | number;
+  method: string;
+  params?: Record<string, unknown>;
+}
+
+export interface GatewayRelayResponse {
+  jsonrpc: "2.0";
+  id?: string | number;
+  result?: Record<string, unknown>;
+  error?: BridgeError;
+}
+
+export interface GatewayRelayRequestEnvelope {
+  requestId: string;
+  rpc: GatewayRelayRequest;
+  queuedAt: string;
+}
+
+export interface RegisterGatewayRelaySessionResponse {
+  success: boolean;
+  data: {
+    session: GatewayRelaySession;
+  };
+}
+
+export interface PollGatewayRelayResponse {
+  success: boolean;
+  data: {
+    request: GatewayRelayRequestEnvelope | null;
+  };
+}
+
 // ─── Snapshot / Backup Types ────────────────────────────────────────────────
 
 export type SnapshotType = "manual" | "auto" | "pre-eviction";
@@ -302,32 +349,8 @@ export const DEFAULT_CLOUD_CONFIG: CloudPluginConfig = {
 
 // ─── API Error Types ────────────────────────────────────────────────────────
 
-export interface CloudApiErrorBody {
-  success: false;
-  error: string;
-  details?: Record<string, unknown>;
-  requiredCredits?: number;
-  quota?: { current: number; max: number };
-}
-
-export class CloudApiError extends Error {
-  readonly statusCode: number;
-  readonly errorBody: CloudApiErrorBody;
-
-  constructor(statusCode: number, body: CloudApiErrorBody) {
-    super(body.error);
-    this.name = "CloudApiError";
-    this.statusCode = statusCode;
-    this.errorBody = body;
-  }
-}
-
-export class InsufficientCreditsError extends CloudApiError {
-  readonly requiredCredits: number;
-
-  constructor(body: CloudApiErrorBody) {
-    super(402, body);
-    this.name = "InsufficientCreditsError";
-    this.requiredCredits = body.requiredCredits ?? 0;
-  }
-}
+export type { CloudApiErrorBody } from "@elizaos/cloud-sdk";
+export {
+  CloudApiError,
+  InsufficientCreditsError,
+} from "@elizaos/cloud-sdk";

package/{types → src/types}/index.ts

@@ -63,7 +63,13 @@ export type {
   DeviceAuthRequest,
   DeviceAuthResponse,
   DevicePlatform,
+  GatewayRelayRequest,
+  GatewayRelayRequestEnvelope,
+  GatewayRelayResponse,
+  GatewayRelaySession,
   InferenceMode,
+  PollGatewayRelayResponse,
+  RegisterGatewayRelaySessionResponse,
   RestoreSnapshotRequest,
   RestoreSnapshotResponse,
   SnapshotListResponse,

package/src/utils/cloud-api.ts

@@ -0,0 +1,10 @@
+export type {
+  CloudApiErrorBody,
+  CloudRequestOptions,
+} from "@elizaos/cloud-sdk";
+export {
+  CloudApiClient,
+  CloudApiError,
+  ElizaCloudHttpClient,
+  InsufficientCreditsError,
+} from "@elizaos/cloud-sdk";