@elizaos/autonomous 2.0.0-alpha.37

package/src/actions/terminal.ts

@@ -0,0 +1,186 @@
+/**
+ * RUN_IN_TERMINAL action — runs a shell command on the server.
+ *
+ * When triggered the action:
+ *   1. Extracts the command from the parameters
+ *   2. POSTs to the local API server to execute it
+ *   3. The API broadcasts output via WebSocket for real-time display
+ *   4. Returns a descriptive text response
+ *
+ * @module actions/terminal
+ */
+
+import type { Action, HandlerOptions } from "@elizaos/core";
+
+/** API port for posting terminal requests. */
+const API_PORT = process.env.API_PORT || process.env.SERVER_PORT || "2138";
+
+type ActionParams = Record<string, unknown>;
+
+function nonEmptyString(value: unknown): string | undefined {
+  if (typeof value !== "string") return undefined;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : undefined;
+}
+
+function resolveCommandFromObject(value: unknown): string | undefined {
+  if (!value || typeof value !== "object") return undefined;
+  const record = value as ActionParams;
+
+  const direct =
+    nonEmptyString(record.command) ??
+    nonEmptyString(record.cmd) ??
+    nonEmptyString(record.commandLine) ??
+    nonEmptyString(record.shellCommand);
+  if (direct) return direct;
+
+  const args = record.args;
+  if (Array.isArray(args) && args.every((entry) => typeof entry === "string")) {
+    const joined = args.join(" ").trim();
+    if (joined) return joined;
+  }
+
+  const nested =
+    resolveCommandFromObject(record.arguments) ??
+    resolveCommandFromObject(record.input) ??
+    resolveCommandFromObject(record.parameters);
+  if (nested) return nested;
+
+  return undefined;
+}
+
+function resolveCommandFromArguments(
+  argumentsValue: unknown,
+): string | undefined {
+  if (typeof argumentsValue === "string") {
+    const trimmed = argumentsValue.trim();
+    if (!trimmed) return undefined;
+    try {
+      const parsed = JSON.parse(trimmed) as unknown;
+      return resolveCommandFromObject(parsed) ?? trimmed;
+    } catch {
+      return trimmed;
+    }
+  }
+  return resolveCommandFromObject(argumentsValue);
+}
+
+function resolveCommandFromParams(params: unknown): string | undefined {
+  const record = params as ActionParams | undefined;
+  if (!record || typeof record !== "object") return undefined;
+
+  const direct =
+    nonEmptyString(record.command) ??
+    nonEmptyString(record.cmd) ??
+    nonEmptyString(record.commandLine) ??
+    nonEmptyString(record.shellCommand);
+  if (direct) return direct;
+
+  return (
+    resolveCommandFromArguments(record.arguments) ??
+    resolveCommandFromArguments(record.input) ??
+    resolveCommandFromObject(record.parameters)
+  );
+}
+
+function resolveCommandFromText(text: unknown): string | undefined {
+  const source = nonEmptyString(text);
+  if (!source) return undefined;
+
+  const fenced = source.match(/```(?:bash|sh|zsh|shell)?\s*([\s\S]*?)```/i);
+  if (fenced) {
+    const command = nonEmptyString(fenced[1]);
+    if (command) return command;
+  }
+
+  const inline = source.match(/`([^`\n]+)`/);
+  if (inline) {
+    const command = nonEmptyString(inline[1]);
+    if (command) return command;
+  }
+
+  const runMatch = source.match(
+    /\b(?:run|execute|exec)\b\s+(?:(?:the|this)\s+)?(?:(?:command|shell command)\s+)?["'`]?([^"'`\n]+?)["'`]?$/i,
+  );
+  if (runMatch) {
+    const candidate = runMatch[1]
+      .replace(/\s+(?:in|on)\s+(?:the\s+)?(?:terminal|shell)\b.*$/i, "")
+      .replace(/[.?!,:;]+$/g, "")
+      .trim();
+    if (candidate) return candidate;
+  }
+
+  return undefined;
+}
+
+export const terminalAction: Action = {
+  name: "RUN_IN_TERMINAL",
+
+  similes: [
+    "RUN_COMMAND",
+    "EXECUTE_COMMAND",
+    "TERMINAL",
+    "SHELL",
+    "RUN_SHELL",
+    "EXEC",
+    // Compatibility for upstream templates that may still emit CALL_MCP_TOOL.
+    "CALL_MCP_TOOL",
+    "CALL_TOOL",
+  ],
+
+  description:
+    "Run a shell command in the user's terminal. Use this when the user asks " +
+    "you to run a command, execute a script, install packages, or perform " +
+    "any terminal operation. Output is shown in real time.",
+
+  validate: async () => true,
+
+  handler: async (_runtime, _message, _state, options) => {
+    try {
+      const params = (options as HandlerOptions | undefined)?.parameters;
+      const command =
+        resolveCommandFromParams(params) ??
+        resolveCommandFromText(
+          (_message as { content?: { text?: string } } | undefined)?.content
+            ?.text,
+        );
+
+      if (!command) {
+        return { text: "", success: false };
+      }
+
+      const response = await fetch(
+        `http://localhost:${API_PORT}/api/terminal/run`,
+        {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            command,
+            clientId: "runtime-terminal-action",
+          }),
+        },
+      );
+
+      if (!response.ok) {
+        return { text: "", success: false };
+      }
+
+      return {
+        text: `Running in terminal: \`${command}\``,
+        success: true,
+        data: { command },
+      };
+    } catch (_err) {
+      return { text: "", success: false };
+    }
+  },
+
+  parameters: [
+    {
+      name: "command",
+      description: "The shell command to execute in the terminal",
+      required: true,
+      schema: { type: "string" as const },
+    },
+  ],
+};

package/src/api/agent-admin-routes.ts

@@ -0,0 +1,178 @@
+import type { AgentRuntime, UUID } from "@elizaos/core";
+import { detectRuntimeModel } from "./agent-model";
+import type { RouteHelpers, RouteRequestMeta } from "./route-helpers";
+
+type AgentStateStatus =
+  | "not_started"
+  | "starting"
+  | "running"
+  | "paused"
+  | "stopped"
+  | "restarting"
+  | "error";
+
+interface AutonomousConfigLike {
+  [key: string]: unknown;
+}
+
+export interface AgentAdminRouteState {
+  runtime: AgentRuntime | null;
+  config: AutonomousConfigLike;
+  agentState: AgentStateStatus;
+  agentName: string;
+  model: string | undefined;
+  startedAt: number | undefined;
+  chatRoomId: UUID | null;
+  chatUserId: UUID | null;
+  chatConnectionReady: { userId: UUID; roomId: UUID; worldId: UUID } | null;
+  chatConnectionPromise: Promise<void> | null;
+  pendingRestartReasons: string[];
+}
+
+export interface AgentAdminRouteContext
+  extends RouteRequestMeta,
+    Pick<RouteHelpers, "json" | "error"> {
+  state: AgentAdminRouteState;
+  onRestart?: (() => Promise<AgentRuntime | null>) | undefined;
+  onRuntimeSwapped?: () => void;
+  resolveStateDir: () => string;
+  resolvePath: (value: string) => string;
+  getHomeDir: () => string;
+  isSafeResetStateDir: (resolvedState: string, homeDir: string) => boolean;
+  stateDirExists: (resolvedState: string) => boolean;
+  removeStateDir: (resolvedState: string) => void;
+  logWarn: (message: string) => void;
+}
+
+export async function handleAgentAdminRoutes(
+  ctx: AgentAdminRouteContext,
+): Promise<boolean> {
+  const {
+    res,
+    method,
+    pathname,
+    state,
+    onRestart,
+    onRuntimeSwapped,
+    json,
+    error,
+    resolveStateDir,
+    resolvePath,
+    getHomeDir,
+    isSafeResetStateDir,
+    stateDirExists,
+    removeStateDir,
+    logWarn,
+  } = ctx;
+
+  if (method === "POST" && pathname === "/api/agent/restart") {
+    if (!onRestart) {
+      error(
+        res,
+        "Restart is not supported in this mode (no restart handler registered)",
+        501,
+      );
+      return true;
+    }
+
+    if (state.agentState === "restarting") {
+      error(res, "A restart is already in progress", 409);
+      return true;
+    }
+
+    const previousState = state.agentState;
+    state.agentState = "restarting";
+    try {
+      const newRuntime = await onRestart();
+      if (newRuntime) {
+        state.runtime = newRuntime;
+        state.chatConnectionReady = null;
+        state.chatConnectionPromise = null;
+        state.agentState = "running";
+        state.agentName = newRuntime.character.name ?? "Milady";
+        state.model = detectRuntimeModel(newRuntime);
+        state.startedAt = Date.now();
+        state.pendingRestartReasons = [];
+        onRuntimeSwapped?.();
+        json(res, {
+          ok: true,
+          pendingRestart: false,
+          status: {
+            state: state.agentState,
+            agentName: state.agentName,
+            model: state.model,
+            startedAt: state.startedAt,
+          },
+        });
+      } else {
+        state.agentState = previousState;
+        error(
+          res,
+          "Restart handler returned null — runtime failed to re-initialize",
+          500,
+        );
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      state.agentState = previousState;
+      error(res, `Restart failed: ${message}`, 500);
+    }
+    return true;
+  }
+
+  if (method === "POST" && pathname === "/api/agent/reset") {
+    try {
+      if (state.runtime) {
+        try {
+          await state.runtime.stop();
+        } catch (stopErr) {
+          const message =
+            stopErr instanceof Error ? stopErr.message : String(stopErr);
+          logWarn(
+            `[milady-api] Error stopping runtime during reset: ${message}`,
+          );
+        }
+        state.runtime = null;
+      }
+
+      const stateDir = resolveStateDir();
+      const resolvedState = resolvePath(stateDir);
+      const home = getHomeDir();
+      const isSafe = isSafeResetStateDir(resolvedState, home);
+      if (!isSafe) {
+        logWarn(
+          `[milady-api] Refusing to delete unsafe state dir: "${resolvedState}"`,
+        );
+        error(
+          res,
+          `Reset aborted: state directory "${resolvedState}" does not appear safe to delete`,
+          400,
+        );
+        return true;
+      }
+
+      if (stateDirExists(resolvedState)) {
+        removeStateDir(resolvedState);
+      }
+
+      state.agentState = "stopped";
+      state.agentName = "Milady";
+      state.model = undefined;
+      state.startedAt = undefined;
+      state.config = {};
+      state.chatRoomId = null;
+      state.chatUserId = null;
+      state.chatConnectionReady = null;
+      state.chatConnectionPromise = null;
+      state.pendingRestartReasons = [];
+
+      json(res, { ok: true });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      error(res, `Reset failed: ${message}`, 500);
+    }
+    return true;
+  }
+
+  return false;
+}

package/src/api/agent-lifecycle-routes.ts

@@ -0,0 +1,120 @@
+import type { AgentRuntime } from "@elizaos/core";
+import { detectRuntimeModel } from "./agent-model";
+import type { RouteHelpers, RouteRequestMeta } from "./route-helpers";
+
+type AgentStateStatus =
+  | "not_started"
+  | "starting"
+  | "running"
+  | "paused"
+  | "stopped"
+  | "restarting"
+  | "error";
+
+export interface AgentLifecycleRouteState {
+  runtime: AgentRuntime | null;
+  agentState: AgentStateStatus;
+  agentName: string;
+  model: string | undefined;
+  startedAt: number | undefined;
+}
+
+export interface AgentLifecycleRouteContext
+  extends RouteRequestMeta,
+    Pick<RouteHelpers, "error" | "json" | "readJsonBody"> {
+  state: AgentLifecycleRouteState;
+}
+
+export async function handleAgentLifecycleRoutes(
+  ctx: AgentLifecycleRouteContext,
+): Promise<boolean> {
+  const { req, res, method, pathname, state, error, json, readJsonBody } = ctx;
+  const runtime = state.runtime as
+    | (AgentRuntime & { enableAutonomy?: boolean })
+    | null;
+
+  if (method === "POST" && pathname === "/api/agent/start") {
+    state.agentState = "paused";
+    state.startedAt = Date.now();
+    state.model = detectRuntimeModel(state.runtime);
+
+    json(res, {
+      ok: true,
+      status: {
+        state: state.agentState,
+        agentName: state.agentName,
+        model: state.model,
+        uptime: 0,
+        startedAt: state.startedAt,
+      },
+    });
+    return true;
+  }
+
+  if (method === "POST" && pathname === "/api/agent/stop") {
+    state.agentState = "stopped";
+    state.startedAt = undefined;
+    state.model = undefined;
+    json(res, {
+      ok: true,
+      status: { state: state.agentState, agentName: state.agentName },
+    });
+    return true;
+  }
+
+  if (method === "POST" && pathname === "/api/agent/pause") {
+    state.agentState = "paused";
+    json(res, {
+      ok: true,
+      status: {
+        state: state.agentState,
+        agentName: state.agentName,
+        model: state.model,
+        uptime: state.startedAt ? Date.now() - state.startedAt : undefined,
+        startedAt: state.startedAt,
+      },
+    });
+    return true;
+  }
+
+  if (method === "POST" && pathname === "/api/agent/resume") {
+    state.agentState = "running";
+    json(res, {
+      ok: true,
+      status: {
+        state: state.agentState,
+        agentName: state.agentName,
+        model: state.model,
+        uptime: state.startedAt ? Date.now() - state.startedAt : undefined,
+        startedAt: state.startedAt,
+      },
+    });
+    return true;
+  }
+
+  if (method === "GET" && pathname === "/api/agent/autonomy") {
+    json(res, { enabled: runtime?.enableAutonomy === true });
+    return true;
+  }
+
+  if (method === "POST" && pathname === "/api/agent/autonomy") {
+    const body = await readJsonBody<{ enabled?: unknown }>(req, res);
+    if (!body) return true;
+
+    if (typeof body.enabled !== "boolean") {
+      error(res, "enabled must be a boolean", 400);
+      return true;
+    }
+
+    if (!runtime) {
+      error(res, "Agent runtime is not available", 503);
+      return true;
+    }
+
+    runtime.enableAutonomy = body.enabled;
+    json(res, { enabled: runtime.enableAutonomy === true });
+    return true;
+  }
+
+  return false;
+}

package/src/api/agent-model.ts

@@ -0,0 +1,143 @@
+import type { AgentRuntime } from "@elizaos/core";
+
+const MODEL_PLACEHOLDERS = new Set(["", "n/a", "na", "unknown", "provided"]);
+
+const PROVIDER_HINTS = [
+  "openai-codex",
+  "openai-subscription",
+  "anthropic-subscription",
+  "openrouter",
+  "moonshot",
+  "kimi",
+  "deepseek",
+  "anthropic",
+  "openai",
+  "groq",
+  "gemini",
+  "google",
+  "xai",
+  "ollama",
+  "pi-ai",
+] as const;
+
+const ENV_PROVIDER_SIGNALS: ReadonlyArray<{
+  envVar: string;
+  label: string;
+}> = [
+  { envVar: "ANTHROPIC_API_KEY", label: "anthropic" },
+  { envVar: "OPENAI_API_KEY", label: "openai" },
+  { envVar: "OPENROUTER_API_KEY", label: "openrouter" },
+  { envVar: "GROQ_API_KEY", label: "groq" },
+  { envVar: "GOOGLE_GENERATIVE_AI_API_KEY", label: "gemini" },
+  { envVar: "XAI_API_KEY", label: "xai" },
+  { envVar: "DEEPSEEK_API_KEY", label: "deepseek" },
+];
+
+function normalizeModelSpec(value: unknown): string | undefined {
+  if (typeof value !== "string") return undefined;
+  const trimmed = value.trim();
+  if (!trimmed) return undefined;
+  if (MODEL_PLACEHOLDERS.has(trimmed.toLowerCase())) return undefined;
+  return trimmed;
+}
+
+function readCharacterModel(runtime: AgentRuntime): string | undefined {
+  const character = (runtime as { character?: unknown }).character;
+  if (!character || typeof character !== "object") return undefined;
+
+  const modelValue = (character as { model?: unknown }).model;
+  const fromCharacterModel = normalizeModelSpec(modelValue);
+  if (fromCharacterModel) return fromCharacterModel;
+
+  const settings = (character as { settings?: unknown }).settings;
+  if (!settings || typeof settings !== "object") return undefined;
+
+  const model = (settings as { model?: unknown }).model;
+  const fromSettingsModel = normalizeModelSpec(model);
+  if (fromSettingsModel) return fromSettingsModel;
+
+  if (!model || typeof model !== "object") return undefined;
+  const modelObj = model as {
+    primary?: unknown;
+    large?: unknown;
+    small?: unknown;
+  };
+
+  return (
+    normalizeModelSpec(modelObj.primary) ??
+    normalizeModelSpec(modelObj.large) ??
+    normalizeModelSpec(modelObj.small)
+  );
+}
+
+export function detectRuntimeModel(
+  runtime: AgentRuntime | null,
+  config?: { agents?: { defaults?: { model?: { primary?: string } } } },
+): string | undefined {
+  if (!runtime) return undefined;
+
+  const configured = readCharacterModel(runtime);
+  if (configured) return configured;
+
+  const configModel = normalizeModelSpec(
+    config?.agents?.defaults?.model?.primary,
+  );
+  if (configModel) return configModel;
+
+  const pluginNames = Array.isArray(runtime.plugins)
+    ? runtime.plugins
+        .map((plugin) =>
+          typeof plugin?.name === "string" ? plugin.name.trim() : "",
+        )
+        .filter((name): name is string => name.length > 0)
+    : [];
+
+  if (pluginNames.length > 0) {
+    const lowerPluginNames = pluginNames.map((name) => name.toLowerCase());
+    for (const hint of PROVIDER_HINTS) {
+      const index = lowerPluginNames.findIndex((name) => name.includes(hint));
+      if (index >= 0) return pluginNames[index];
+    }
+  }
+
+  for (const { envVar, label } of ENV_PROVIDER_SIGNALS) {
+    const value = process.env[envVar]?.trim();
+    if (value && value.length > 0) return label;
+  }
+
+  return undefined;
+}
+
+export function resolveProviderFromModel(model: string): string | null {
+  const lower = model.trim().toLowerCase();
+  if (!lower) return null;
+
+  const providers: Array<{ match: string; label: string }> = [
+    { match: "elizacloud", label: "Eliza Cloud" },
+    { match: "openrouter", label: "OpenRouter" },
+    { match: "openai", label: "OpenAI" },
+    { match: "anthropic", label: "Anthropic" },
+    { match: "gemini", label: "Google" },
+    { match: "google", label: "Google" },
+    { match: "grok", label: "xAI" },
+    { match: "xai", label: "xAI" },
+    { match: "groq", label: "Groq" },
+    { match: "ollama", label: "Ollama" },
+    { match: "deepseek", label: "DeepSeek" },
+    { match: "mistral", label: "Mistral" },
+    { match: "together", label: "Together AI" },
+    { match: "cohere", label: "Cohere" },
+    { match: "pi-ai", label: "Pi AI" },
+    { match: "moonshot", label: "Moonshot" },
+    { match: "kimi", label: "Kimi" },
+  ];
+  for (const { match, label } of providers) {
+    if (lower.includes(match)) return label;
+  }
+
+  if (lower.startsWith("gpt")) return "OpenAI";
+  if (lower.startsWith("claude")) return "Anthropic";
+  if (lower.startsWith("gemini")) return "Google";
+
+  return null;
+}