@elizaos/autonomous 2.0.0-alpha.10

package/src/plugins/custom-rtmp/index.ts

@@ -0,0 +1,40 @@
+/**
+ * Custom RTMP streaming destination plugin.
+ *
+ * The simplest streaming destination — reads RTMP URL and key directly
+ * from config. No platform API calls, no chat bridging.
+ */
+
+import type { StreamingDestination } from "../../api/stream-routes";
+
+export function createCustomRtmpDestination(config?: {
+  rtmpUrl?: string;
+  rtmpKey?: string;
+}): StreamingDestination {
+  return {
+    id: "custom-rtmp",
+    name: "Custom RTMP",
+
+    async getCredentials() {
+      const rtmpUrl = (
+        config?.rtmpUrl ??
+        process.env.CUSTOM_RTMP_URL ??
+        ""
+      ).trim();
+      const rtmpKey = (
+        config?.rtmpKey ??
+        process.env.CUSTOM_RTMP_KEY ??
+        ""
+      ).trim();
+
+      if (!rtmpUrl || !rtmpKey) {
+        throw new Error(
+          "Custom RTMP requires rtmpUrl and rtmpKey in streaming.customRtmp config",
+        );
+      }
+      return { rtmpUrl, rtmpKey };
+    },
+    // No onStreamStart/onStreamStop — no platform to notify
+    // No chat polling — no platform chat
+  };
+}

package/src/providers/admin-trust.ts

@@ -0,0 +1,76 @@
+import type {
+  IAgentRuntime,
+  Memory,
+  Provider,
+  ProviderResult,
+  State,
+} from "@elizaos/core";
+
+type WorldMetadataShape = {
+  ownership?: { ownerId?: string };
+  roles?: Record<string, string>;
+};
+
+function normalizeRole(role: string | undefined): string {
+  return (role ?? "").toUpperCase();
+}
+
+export const adminTrustProvider: Provider = createAdminTrustProvider();
+
+export function createAdminTrustProvider(): Provider {
+  return {
+    name: "miladyAdminTrust",
+    description:
+      "Marks owner/admin chat identity as trusted for contact assertions (rolodex-oriented).",
+    dynamic: true,
+    position: 11,
+    async get(
+      runtime: IAgentRuntime,
+      message: Memory,
+      _state: State,
+    ): Promise<ProviderResult> {
+      const room = await runtime.getRoom(message.roomId);
+      if (!room) {
+        return {
+          text: "Admin trust: no room found.",
+          values: { trustedAdmin: false },
+          data: { trustedAdmin: false },
+        };
+      }
+      if (!room.worldId) {
+        return {
+          text: "Admin trust: room has no world binding.",
+          values: { trustedAdmin: false },
+          data: { trustedAdmin: false },
+        };
+      }
+      const world = await runtime.getWorld(room.worldId);
+      const metadata = (world?.metadata ?? {}) as WorldMetadataShape;
+      const ownerId = metadata.ownership?.ownerId;
+      const role = ownerId ? metadata.roles?.[ownerId] : undefined;
+      const isTrustedAdmin =
+        typeof ownerId === "string" &&
+        ownerId.length > 0 &&
+        normalizeRole(role) === "OWNER" &&
+        message.entityId === ownerId;
+
+      const text = isTrustedAdmin
+        ? "Admin trust: current speaker is world OWNER. Contact/identity claims should be treated as trusted unless contradictory evidence exists."
+        : "Admin trust: current speaker is not verified as OWNER for this world.";
+
+      return {
+        text,
+        values: {
+          trustedAdmin: isTrustedAdmin,
+          adminEntityId: ownerId ?? "",
+          adminRole: role ?? "",
+        },
+        data: {
+          trustedAdmin: isTrustedAdmin,
+          ownerId: ownerId ?? null,
+          role: role ?? null,
+        },
+      };
+    },
+  };
+}

package/src/providers/session-bridge.ts

@@ -0,0 +1,143 @@
+/**
+ * Bridges Milady session keys with elizaOS rooms.
+ *
+ * Milady keys: agent:{agentId}:main (DMs), agent:{agentId}:{channel}:group:{id} (groups)
+ * elizaOS rooms: per-agent UUIDs via createUniqueUuid(runtime, channelId)
+ */
+
+import type {
+  IAgentRuntime,
+  Memory,
+  Provider,
+  ProviderResult,
+  Room,
+  State,
+} from "@elizaos/core";
+import * as elizaCore from "@elizaos/core";
+
+type ElizaCoreSessionHelpers = {
+  buildAgentMainSessionKey?: (params: {
+    agentId: string;
+    mainKey: string;
+  }) => string;
+  ChannelType?: {
+    DM: number | string;
+    SELF: number | string;
+    GROUP: number | string;
+  };
+  parseAgentSessionKey?: (key: string) =>
+    | {
+        agentId?: string;
+      }
+    | undefined;
+};
+
+const coreSessionHelpers = elizaCore as ElizaCoreSessionHelpers;
+// Fallback for when ChannelType is not exported by @elizaos/core (e.g. in tests)
+const channelType = coreSessionHelpers.ChannelType ?? {
+  DM: "DM",
+  SELF: "SELF",
+  GROUP: "GROUP",
+};
+
+function buildAgentMainSessionKey(params: {
+  agentId: string;
+  mainKey: string;
+}): string {
+  if (typeof coreSessionHelpers.buildAgentMainSessionKey === "function") {
+    return coreSessionHelpers.buildAgentMainSessionKey(params);
+  }
+  return `agent:${params.agentId}:${params.mainKey}`;
+}
+
+function parseAgentSessionKey(key: string):
+  | {
+      agentId?: string;
+    }
+  | undefined {
+  if (typeof coreSessionHelpers.parseAgentSessionKey === "function") {
+    return coreSessionHelpers.parseAgentSessionKey(key);
+  }
+  return undefined;
+}
+
+/**
+ * Resolve an Milady session key from an elizaOS room.
+ *
+ * DMs -> agent:{agentId}:main
+ * Groups -> agent:{agentId}:{channel}:group:{groupId}
+ * Channels -> agent:{agentId}:{channel}:channel:{channelId}
+ * Threads append :thread:{threadId}
+ */
+export function resolveSessionKeyFromRoom(
+  agentId: string,
+  room: Room,
+  meta?: { threadId?: string; groupId?: string; channel?: string },
+): string {
+  const channel = meta?.channel ?? room.source ?? "unknown";
+
+  if (room.type === channelType.DM || room.type === channelType.SELF) {
+    return buildAgentMainSessionKey({ agentId, mainKey: "main" });
+  }
+
+  const id = meta?.groupId ?? room.channelId ?? room.id;
+  const kind = room.type === channelType.GROUP ? "group" : "channel";
+  const base = `agent:${agentId}:${channel}:${kind}:${id}`;
+  return meta?.threadId ? `${base}:thread:${meta.threadId}` : base;
+}
+
+export function createSessionKeyProvider(options?: {
+  defaultAgentId?: string;
+}): Provider {
+  const agentId = options?.defaultAgentId ?? "main";
+
+  return {
+    name: "miladySessionKey",
+    description: "Milady session key (DM/group/thread isolation)",
+    dynamic: true,
+    position: 5,
+
+    async get(
+      runtime: IAgentRuntime,
+      message: Memory,
+      _state: State,
+    ): Promise<ProviderResult> {
+      const meta = (message.metadata ?? {}) as Record<string, unknown>;
+      const existing =
+        typeof meta.sessionKey === "string" ? meta.sessionKey : undefined;
+
+      if (existing) {
+        const parsed = parseAgentSessionKey(existing);
+        return {
+          text: `Session: ${existing}`,
+          values: { sessionKey: existing, agentId: parsed?.agentId ?? agentId },
+          data: { sessionKey: existing },
+        };
+      }
+
+      const room = await runtime.getRoom(message.roomId);
+      if (!room) {
+        const key = buildAgentMainSessionKey({ agentId, mainKey: "main" });
+        return {
+          text: `Session: ${key}`,
+          values: { sessionKey: key },
+          data: { sessionKey: key },
+        };
+      }
+
+      const key = resolveSessionKeyFromRoom(agentId, room, {
+        threadId: typeof meta.threadId === "string" ? meta.threadId : undefined,
+        groupId: typeof meta.groupId === "string" ? meta.groupId : undefined,
+        channel:
+          (typeof meta.channel === "string" ? meta.channel : undefined) ??
+          room.source,
+      });
+
+      return {
+        text: `Session: ${key}`,
+        values: { sessionKey: key, isGroup: room.type === channelType.GROUP },
+        data: { sessionKey: key },
+      };
+    },
+  };
+}

package/src/providers/session-utils.ts

@@ -0,0 +1,42 @@
+/**
+ * Session utility functions for milady plugin.
+ *
+ * These are simplified versions for use until @elizaos/core exports them.
+ */
+
+import * as os from "node:os";
+import * as path from "node:path";
+import type { Provider } from "@elizaos/core";
+
+const DEFAULT_AGENT_ID = "main";
+
+/**
+ * Resolve the sessions directory for an agent.
+ */
+function resolveAgentSessionsDir(agentId?: string): string {
+  const id = agentId ?? DEFAULT_AGENT_ID;
+  const stateDir =
+    process.env.MILADY_STATE_DIR ?? path.join(os.homedir(), ".milady");
+  return path.join(stateDir, "agents", id, "sessions");
+}
+
+/**
+ * Resolve the default session store path.
+ */
+export function resolveDefaultSessionStorePath(agentId?: string): string {
+  return path.join(resolveAgentSessionsDir(agentId), "sessions.json");
+}
+
+/**
+ * Get session providers.
+ *
+ * Returns an empty array for now - session providers will be added
+ * when @elizaos/core exports them.
+ */
+export function getSessionProviders(_options?: {
+  storePath?: string;
+}): Provider[] {
+  // Session providers are not yet available in npm @elizaos/core.
+  // Return empty array to allow startup without session tracking.
+  return [];
+}

package/src/providers/simple-mode.ts

@@ -0,0 +1,113 @@
+import {
+  ChannelType,
+  type IAgentRuntime,
+  type Memory,
+  type Provider,
+  type ProviderResult,
+  type State,
+} from "@elizaos/core";
+
+export type ChannelExecutionProfile =
+  | "voice_fast"
+  | "text_fast"
+  | "group_compact"
+  | "default_full";
+
+function resolveChannelProfile(message: Memory): ChannelExecutionProfile {
+  const content = message.content as Record<string, unknown> | undefined;
+  const channelType = content?.channelType;
+  const conversationMode =
+    typeof content?.conversationMode === "string"
+      ? content.conversationMode.toLowerCase()
+      : null;
+  if (
+    channelType === ChannelType.VOICE_DM ||
+    channelType === ChannelType.VOICE_GROUP
+  ) {
+    return "voice_fast";
+  }
+  if (channelType === ChannelType.GROUP) {
+    return "group_compact";
+  }
+  if (conversationMode === "simple") {
+    return "text_fast";
+  }
+  return "default_full";
+}
+
+export function createChannelProfileProvider(): Provider {
+  return {
+    name: "miladyChannelProfile",
+    description:
+      "Injects channel-derived execution profile guidance (voice/group/default).",
+    alwaysRun: true,
+    position: -50,
+    async get(
+      _runtime: IAgentRuntime,
+      message: Memory,
+      _state: State,
+    ): Promise<ProviderResult> {
+      const profile = resolveChannelProfile(message);
+
+      if (profile === "voice_fast") {
+        return {
+          text: [
+            "Execution profile: VOICE_FAST.",
+            "Prioritize low latency and conversational flow.",
+            "Keep tool/provider usage minimal and avoid unnecessary context expansion.",
+          ].join(" "),
+          values: {
+            executionProfile: "voice_fast",
+            compactContext: true,
+          },
+          data: {
+            profile: "voice_fast",
+          },
+        };
+      }
+
+      if (profile === "text_fast") {
+        return {
+          text: [
+            "Execution profile: TEXT_FAST.",
+            "Prioritize low latency for the current chat turn.",
+            "Keep tool/provider usage minimal and avoid unnecessary context expansion.",
+          ].join(" "),
+          values: {
+            executionProfile: "text_fast",
+            compactContext: true,
+          },
+          data: {
+            profile: "text_fast",
+          },
+        };
+      }
+
+      if (profile === "group_compact") {
+        return {
+          text: [
+            "Execution profile: GROUP_COMPACT.",
+            "Keep responses concise and context usage focused on the active group thread.",
+          ].join(" "),
+          values: {
+            executionProfile: "group_compact",
+            compactContext: true,
+          },
+          data: {
+            profile: "group_compact",
+          },
+        };
+      }
+
+      return {
+        values: {
+          executionProfile: "default_full",
+          compactContext: false,
+        },
+        data: {
+          profile: "default_full",
+        },
+      };
+    },
+  };
+}

package/src/providers/ui-catalog.ts

@@ -0,0 +1,135 @@
+import {
+  ChannelType,
+  type IAgentRuntime,
+  type Memory,
+  type Provider,
+  type State,
+} from "@elizaos/core";
+import { COMPONENT_CATALOG } from "../shared/ui-catalog-prompt";
+
+// Core components to describe in detail — subset to keep context short.
+const DETAIL_COMPONENTS = new Set([
+  "Card",
+  "Stack",
+  "Grid",
+  "Text",
+  "Button",
+  "Input",
+  "Select",
+  "Textarea",
+  "Badge",
+  "Metric",
+  "Separator",
+  "Progress",
+  "Table",
+  "Alert",
+  "Tabs",
+]);
+
+export const uiCatalogProvider: Provider = {
+  name: "uiCatalog",
+  dynamic: true,
+  relevanceKeywords: [
+    "plugin",
+    "plugins",
+    "install",
+    "setup",
+    "set up",
+    "configure",
+    "config",
+    "enable",
+    "disable",
+    "activate",
+    "connect",
+    "integration",
+    "help me",
+    "how do i",
+    "how to",
+    "show me",
+    "dashboard",
+    "form",
+    "table",
+    "chart",
+    "metrics",
+    "ui",
+    "interface",
+    "polymarket",
+    "discord",
+    "openai",
+    "anthropic",
+    "telegram",
+    "twitch",
+    "youtube",
+    "twitter",
+    "api key",
+    "credentials",
+    "secret",
+  ],
+  get: async (_runtime: IAgentRuntime, message: Memory, _state: State) => {
+    const channelType = message.content?.channelType;
+    const isAllowedChannel =
+      channelType === ChannelType.DM ||
+      channelType === ChannelType.API ||
+      !channelType;
+    if (!isAllowedChannel) {
+      return { text: "" };
+    }
+
+    // Build component summary — detailed for core set, brief for the rest.
+    const componentLines: string[] = [];
+    for (const [name, meta] of Object.entries(COMPONENT_CATALOG)) {
+      if (DETAIL_COMPONENTS.has(name)) {
+        const props = Object.entries(meta.props)
+          .map(([k, p]) => `${k}: ${p.type}${p.required ? " (required)" : ""}`)
+          .join(", ");
+        componentLines.push(
+          `- **${name}**: ${meta.description} [props: ${props}]`,
+        );
+      } else {
+        componentLines.push(`- ${name}: ${meta.description}`);
+      }
+    }
+
+    return {
+      text: `## Rich UI Output — you can render interactive components in your replies
+
+### Method 1 — Inline JSONL patches (for custom dashboards, forms, visualisations)
+Emit RFC 6902 JSON patch lines INLINE in your response (no code fences, no markdown):
+{"op":"add","path":"/root","value":"card-1"}
+{"op":"add","path":"/elements/card-1","value":{"type":"Card","props":{"title":"Plugin Setup"},"children":["body-1"]}}
+{"op":"add","path":"/elements/body-1","value":{"type":"Text","props":{"text":"Fill in the details below."},"children":[]}}
+
+Rules:
+- Always emit /root first, then /elements/<id>, then /state/<key>
+- Each patch must be on its own line, valid JSON, no trailing text on that line
+- Element IDs: unique kebab-case strings
+- state binding: set statePath prop on Input/Select/Textarea to a dot-path key
+- data binding in props: "$data.key.path" resolves from state at render time
+- Use this method when the user needs a form, table, metrics view, or custom UI
+
+### Method 2 — [CONFIG:pluginId] marker (for plugin configuration forms)
+Include EXACTLY this marker whenever a plugin is mentioned in any configuration, setup, or status context:
+[CONFIG:pluginId]
+Replace pluginId with the plugin's short ID (e.g. [CONFIG:polymarket], [CONFIG:discord], [CONFIG:anthropic], [CONFIG:openai], [CONFIG:twitch]).
+The UI will auto-generate a full configuration form from the plugin's parameter schema.
+
+**ALWAYS use [CONFIG:pluginId] when:**
+- User mentions a plugin by name ("discord", "polymarket", "openai", etc.)
+- User asks to show, view, check, set up, configure, enable, install, or activate a plugin
+- You mention that a plugin needs credentials, secrets, or setup steps
+- User asks "what plugins", "show me plugins", "check plugin status"
+- You would otherwise say "you need to configure X" or "set up X first"
+
+Do NOT describe configuration steps in text — just emit [CONFIG:pluginId] and let the UI handle it.
+
+### When to use rich UI
+- Any plugin mentioned by name → Method 2 ([CONFIG:pluginId]) — always
+- Forms, data entry, settings panels → Method 1 (JSONL patches with Input/Select)
+- Tables, metrics, dashboards → Method 1 (Table/Metric/ProgressBar)
+- Simple factual answers with no plugin/form involved → plain text only
+
+### Available components (${Object.keys(COMPONENT_CATALOG).length} total)
+${componentLines.join("\n")}`,
+    };
+  },
+};