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

package/src/models/tokenization.ts

@@ -0,0 +1,67 @@
+import type {
+  ProcessEnvLike,
+  DetokenizeTextParams,
+  IAgentRuntime,
+  ModelTypeName,
+  TokenizeTextParams,
+
+} from "@elizaos/core";
+import { ModelType } from "@elizaos/core";
+import { DEFAULT_ELIZA_CLOUD_TEXT_MODEL } from "@elizaos/core";
+import { encodingForModel, type TiktokenModel } from "js-tiktoken";
+
+function getProcessEnv(): ProcessEnvLike {
+  if (typeof process === "undefined") {
+    return {};
+  }
+  return process.env as ProcessEnvLike;
+}
+
+const env = getProcessEnv();
+
+function getConfiguredTokenizerModel(model: ModelTypeName): string {
+  return model === ModelType.TEXT_SMALL
+    ? (env.ELIZAOS_CLOUD_SMALL_MODEL ?? env.SMALL_MODEL ?? DEFAULT_ELIZA_CLOUD_TEXT_MODEL)
+    : (env.ELIZAOS_CLOUD_LARGE_MODEL ?? env.LARGE_MODEL ?? DEFAULT_ELIZA_CLOUD_TEXT_MODEL);
+}
+
+function tiktokenCandidates(modelName: string): string[] {
+  const slashIndex = modelName.indexOf("/");
+  const providerless = slashIndex >= 0 ? modelName.slice(slashIndex + 1) : modelName;
+  const baseVariant = providerless.split(":")[0] || providerless;
+  return [modelName, providerless, baseVariant, "gpt-4o"];
+}
+
+function getEncodingForConfiguredModel(modelName: string) {
+  for (const candidate of tiktokenCandidates(modelName)) {
+    try {
+      return encodingForModel(candidate as TiktokenModel);
+    } catch {
+      // Try the next compatible tokenizer name.
+    }
+  }
+  return encodingForModel("gpt-4o" as TiktokenModel);
+}
+
+async function tokenizeText(model: ModelTypeName, prompt: string): Promise<number[]> {
+  const tokens = getEncodingForConfiguredModel(getConfiguredTokenizerModel(model)).encode(prompt);
+  return tokens;
+}
+
+async function detokenizeText(model: ModelTypeName, tokens: number[]): Promise<string> {
+  return getEncodingForConfiguredModel(getConfiguredTokenizerModel(model)).decode(tokens);
+}
+
+export async function handleTokenizerEncode(
+  _runtime: IAgentRuntime,
+  { prompt, modelType = ModelType.TEXT_LARGE }: TokenizeTextParams
+): Promise<number[]> {
+  return await tokenizeText(modelType ?? ModelType.TEXT_LARGE, prompt);
+}
+
+export async function handleTokenizerDecode(
+  _runtime: IAgentRuntime,
+  { tokens, modelType = ModelType.TEXT_LARGE }: DetokenizeTextParams
+): Promise<string> {
+  return await detokenizeText(modelType ?? ModelType.TEXT_LARGE, tokens);
+}

package/src/models/transcription.ts

@@ -0,0 +1,101 @@
+import type { IAgentRuntime } from "@elizaos/core";
+import { logger } from "@elizaos/core";
+import type { OpenAITranscriptionParams } from "../types";
+import { getSetting, resolveCloudTimeoutMs } from "../utils/config";
+import { detectAudioMimeType } from "../utils/helpers";
+import { createElizaCloudClient } from "../utils/sdk-client";
+
+export async function handleTranscription(
+  runtime: IAgentRuntime,
+  input: Blob | File | Buffer | OpenAITranscriptionParams
+): Promise<string> {
+  let modelName = getSetting(runtime, "ELIZAOS_CLOUD_TRANSCRIPTION_MODEL", "gpt-5-mini-transcribe");
+  logger.log(`[ELIZAOS_CLOUD] Using TRANSCRIPTION model: ${modelName}`);
+
+  let blob: Blob;
+  let extraParams: OpenAITranscriptionParams | null = null;
+
+  if (input instanceof Blob || input instanceof File) {
+    blob = input as Blob;
+  } else if (Buffer.isBuffer(input)) {
+    const detectedMimeType = detectAudioMimeType(input);
+    logger.debug(`Auto-detected audio MIME type: ${detectedMimeType}`);
+    blob = new Blob([input] as never, { type: detectedMimeType });
+  } else if (
+    typeof input === "object" &&
+    input !== null &&
+    "audio" in input &&
+    input.audio != null
+  ) {
+    const params = input as OpenAITranscriptionParams;
+    if (
+      !(params.audio instanceof Blob) &&
+      !(params.audio instanceof File) &&
+      !Buffer.isBuffer(params.audio)
+    ) {
+      throw new Error("TRANSCRIPTION param 'audio' must be a Blob/File/Buffer.");
+    }
+    if (Buffer.isBuffer(params.audio)) {
+      let mimeType = params.mimeType;
+      if (!mimeType) {
+        mimeType = detectAudioMimeType(params.audio);
+        logger.debug(`Auto-detected audio MIME type: ${mimeType}`);
+      } else {
+        logger.debug(`Using provided MIME type: ${mimeType}`);
+      }
+      blob = new Blob([params.audio] as never, { type: mimeType });
+    } else {
+      blob = params.audio as Blob;
+    }
+    extraParams = params;
+    if (typeof params.model === "string" && params.model) {
+      modelName = params.model;
+    }
+  } else {
+    throw new Error(
+      "TRANSCRIPTION expects a Blob/File/Buffer or an object { audio: Blob/File/Buffer, mimeType?, language?, response_format?, timestampGranularities?, prompt?, temperature?, model? }"
+    );
+  }
+
+  const mime = (blob as File).type || "audio/webm";
+  const filename =
+    (blob as File).name ||
+    (mime.includes("mp3") || mime.includes("mpeg")
+      ? "recording.mp3"
+      : mime.includes("ogg")
+        ? "recording.ogg"
+        : mime.includes("wav")
+          ? "recording.wav"
+          : mime.includes("webm")
+            ? "recording.webm"
+            : "recording.bin");
+
+  const formData = new FormData();
+  formData.append("audio", blob, filename);
+  if (extraParams) {
+    if (typeof extraParams.language === "string") {
+      formData.append("languageCode", String(extraParams.language));
+    }
+  }
+
+  try {
+    const response = await createElizaCloudClient(runtime).routes.postApiV1VoiceSttRaw({
+      body: formData,
+      timeoutMs: resolveCloudTimeoutMs("ELIZAOS_CLOUD_STT_TIMEOUT_MS", 60_000),
+    });
+
+    if (!response.ok) {
+      throw new Error(`Failed to transcribe audio: ${response.status} ${response.statusText}`);
+    }
+
+    const data = (await response.json()) as {
+      text?: string;
+      transcript?: string;
+    };
+    return data.text ?? data.transcript ?? "";
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logger.error(`TRANSCRIPTION error: ${message}`);
+    throw error;
+  }
+}

package/src/plugin.ts

@@ -0,0 +1,281 @@
+/**
+ * Eliza Cloud route plugin — registers `/api/cloud/*` route handlers with the
+ * elizaOS runtime plugin route system.
+ *
+ * All routes use `rawPath: true` to preserve the legacy `/api/cloud/*` paths
+ * without a plugin-name prefix. This module is node-only — the main plugin
+ * (services, actions, providers, model handlers) lives in `index.node.ts`
+ * and is browser-safe; this `plugin.ts` is loaded only on the server via
+ * `register-routes.ts`.
+ *
+ * Migrated from packages/app-core/src/api/cloud-routes.ts and
+ * cloud-status-routes.ts. The login/persist, login/status and disconnect
+ * paths each carry a small loopback-PUT that previously lived inline in
+ * server.ts; that orchestration moved here so server.ts no longer needs
+ * to import the cloud handlers directly.
+ */
+
+import type http from "node:http";
+import { logger } from "@elizaos/core";
+import type { Plugin, Route } from "@elizaos/core";
+import { getRuntimeRouteHostContext } from "@elizaos/core";
+import type { ElizaConfig } from "./lib/config-like";
+import { sendJson } from "./lib/http";
+import {
+  type CloudBillingRouteState,
+  handleCloudBillingRoute,
+} from "./routes/cloud-billing-routes";
+import {
+  type CloudRouteState,
+  handleCloudRoute,
+} from "./routes/cloud-routes";
+import { handleCloudStatusRoutes } from "./routes/cloud-status-routes";
+
+type AnyRuntime = Parameters<typeof handleCloudStatusRoutes>[0]["runtime"];
+
+function getHostContext(runtime: unknown) {
+  return getRuntimeRouteHostContext<Record<string, unknown>>(
+    runtime && typeof runtime === "object" ? runtime : null,
+  );
+}
+
+function getRuntimeConfig(runtime: unknown): ElizaConfig {
+  return (getHostContext(runtime)?.config ?? {}) as ElizaConfig;
+}
+
+function makeStatusHandler() {
+  return async (
+    req: unknown,
+    res: unknown,
+    runtime: unknown,
+  ): Promise<void> => {
+    const httpReq = req as http.IncomingMessage;
+    const httpRes = res as http.ServerResponse;
+    const url = new URL(httpReq.url ?? "/", "http://localhost");
+    const method = (httpReq.method ?? "GET").toUpperCase();
+    const runtimeRef = runtime as AnyRuntime;
+    const config = getRuntimeConfig(runtime);
+
+    await handleCloudStatusRoutes({
+      req: httpReq,
+      res: httpRes,
+      method,
+      pathname: url.pathname,
+      config,
+      runtime: runtimeRef,
+      json: (_res, body, status = 200) => {
+        sendJson(httpRes, body, status);
+      },
+    });
+  };
+}
+
+/**
+ * Generic handler for the rest of `/api/cloud/*` (login, disconnect,
+ * relay-status, …).  Carries the post-dispatch loopback sync that
+ * previously lived inline in server.ts.
+ */
+function makeCloudRouteHandler() {
+  return async (
+    req: unknown,
+    res: unknown,
+    runtime: unknown,
+  ): Promise<void> => {
+    const httpReq = req as http.IncomingMessage;
+    const httpRes = res as http.ServerResponse;
+    const url = new URL(httpReq.url ?? "/", "http://localhost");
+    const method = (httpReq.method ?? "GET").toUpperCase();
+    const hostContext = getHostContext(runtime);
+
+    if (!hostContext?.config) {
+      logger.warn("[eliza-cloud-routes] host config unavailable");
+    }
+    const config = (hostContext?.config ?? {}) as ElizaConfig;
+    const cloudState: CloudRouteState = {
+      config,
+      runtime: runtime as CloudRouteState["runtime"],
+      cloudManager: null,
+      restartRuntime: hostContext?.restartRuntime,
+      services: {
+        createIntegrationTelemetrySpan: hostContext?.createTelemetrySpan,
+        saveElizaConfig: (nextConfig) => {
+          hostContext?.saveConfig?.(
+            nextConfig as Record<string, unknown>,
+          );
+        },
+      },
+    };
+
+    const handled = await handleCloudRoute(
+      httpReq,
+      httpRes,
+      url.pathname,
+      method,
+      cloudState,
+    );
+
+    if (!handled) {
+      return;
+    }
+  };
+}
+
+function makeBillingRouteHandler() {
+  return async (
+    req: unknown,
+    res: unknown,
+    runtime: unknown,
+  ): Promise<void> => {
+    const httpReq = req as http.IncomingMessage;
+    const httpRes = res as http.ServerResponse;
+    const url = new URL(httpReq.url ?? "/", "http://localhost");
+    const method = (httpReq.method ?? "GET").toUpperCase();
+    const hostContext = getHostContext(runtime);
+    const state: CloudBillingRouteState = {
+      config: (hostContext?.config ?? {}) as ElizaConfig,
+      runtime: runtime as CloudBillingRouteState["runtime"],
+    };
+
+    await handleCloudBillingRoute(
+      httpReq,
+      httpRes,
+      url.pathname,
+      method,
+      state,
+    );
+  };
+}
+
+const cloudStatusHandler = makeStatusHandler();
+const cloudRouteHandler = makeCloudRouteHandler();
+const cloudBillingRouteHandler = makeBillingRouteHandler();
+
+const cloudRoutes: Route[] = [
+  // Status surface (read-only). Note: server.ts may exempt this from auth on
+  // cloud-provisioned containers BEFORE the plugin route system fires.
+  {
+    type: "GET",
+    path: "/api/cloud/status",
+    rawPath: true,
+    handler: cloudStatusHandler,
+  },
+  {
+    type: "GET",
+    path: "/api/cloud/credits",
+    rawPath: true,
+    handler: cloudStatusHandler,
+  },
+  {
+    type: "GET",
+    path: "/api/cloud/relay-status",
+    rawPath: true,
+    handler: cloudRouteHandler,
+  },
+  {
+    type: "POST",
+    path: "/api/cloud/coding-containers/promotions",
+    rawPath: true,
+    handler: cloudRouteHandler,
+  },
+  {
+    type: "POST",
+    path: "/api/cloud/coding-containers",
+    rawPath: true,
+    handler: cloudRouteHandler,
+  },
+  {
+    type: "POST",
+    path: "/api/cloud/coding-containers/:containerId/sync",
+    rawPath: true,
+    handler: cloudRouteHandler,
+  },
+  ...(["GET", "POST", "PUT", "PATCH", "DELETE"] as const).map((type) => ({
+    type,
+    path: "/api/cloud/billing/:path*",
+    rawPath: true,
+    handler: cloudBillingRouteHandler,
+  })),
+  {
+    type: "POST",
+    path: "/api/cloud/disconnect",
+    rawPath: true,
+    handler: cloudRouteHandler,
+  },
+  {
+    type: "POST",
+    path: "/api/cloud/login",
+    rawPath: true,
+    handler: cloudRouteHandler,
+  },
+  {
+    type: "POST",
+    path: "/api/cloud/login/persist",
+    rawPath: true,
+    handler: cloudRouteHandler,
+  },
+  {
+    type: "GET",
+    path: "/api/cloud/login/status",
+    rawPath: true,
+    handler: cloudRouteHandler,
+  },
+  {
+    type: "GET",
+    path: "/api/cloud/agents",
+    rawPath: true,
+    handler: cloudRouteHandler,
+  },
+  {
+    type: "POST",
+    path: "/api/cloud/agents",
+    rawPath: true,
+    handler: cloudRouteHandler,
+  },
+  {
+    type: "POST",
+    path: "/api/cloud/agents/:agentId/provision",
+    rawPath: true,
+    handler: cloudRouteHandler,
+  },
+  {
+    type: "POST",
+    path: "/api/cloud/agents/:agentId/connect",
+    rawPath: true,
+    handler: cloudRouteHandler,
+  },
+  {
+    type: "POST",
+    path: "/api/cloud/agents/:agentId/shutdown",
+    rawPath: true,
+    handler: cloudRouteHandler,
+  },
+  {
+    type: "POST",
+    path: "/api/cloud/coding-containers/promotions",
+    rawPath: true,
+    handler: cloudRouteHandler,
+  },
+  {
+    type: "POST",
+    path: "/api/cloud/coding-containers",
+    rawPath: true,
+    handler: cloudRouteHandler,
+  },
+  {
+    type: "POST",
+    path: "/api/cloud/coding-containers/:containerId/sync",
+    rawPath: true,
+    handler: cloudRouteHandler,
+  },
+];
+
+export const elizaCloudRoutePlugin: Plugin = {
+  name: "@elizaos/plugin-elizacloud:routes",
+  description:
+    "Eliza Cloud connection, login, status, credit, and relay routes (extracted from app-core/server.ts)",
+  routes: cloudRoutes,
+  // Routes-only plugin — no services or persistent resources to dispose.
+  dispose: async (_runtime) => {},
+};
+
+export default elizaCloudRoutePlugin;

package/src/providers/openai.ts

@@ -0,0 +1,16 @@
+import { createOpenAI } from "@ai-sdk/openai";
+import type { IAgentRuntime } from "@elizaos/core";
+import { getApiKey, getBaseURL, isProxyMode } from "../utils/config";
+
+export function createOpenAIClient(runtime: IAgentRuntime) {
+  const baseURL = getBaseURL(runtime);
+  const apiKey = getApiKey(runtime) ?? (isProxyMode(runtime) ? "eliza-proxy" : undefined);
+  // NOTE: Callers must use openai.chat(modelName) instead of openai(modelName)
+  // to force the Chat Completions API.  The default openai(modelName) routes
+  // to the Responses API which does not support presencePenalty,
+  // frequencyPenalty, or stopSequences and emits noisy warnings.
+  return createOpenAI({
+    apiKey: (apiKey ?? "") as string,
+    baseURL,
+  });
+}

package/src/register-routes.ts

@@ -0,0 +1,6 @@
+import { registerAppRoutePluginLoader } from "@elizaos/core";
+
+registerAppRoutePluginLoader("@elizaos/plugin-elizacloud:routes", async () => {
+  const { elizaCloudRoutePlugin } = await import("./plugin");
+  return elizaCloudRoutePlugin;
+});