@elizaos/agent 2.0.0-alpha.98 → 2.0.0-beta.2

package/packages/agent/src/actions/stream-control.d.ts

@@ -1,15 +1,20 @@
 /**
- * Stream control actions — agents can go live, go offline, switch
- * destinations, speak via TTS, and manage overlay widgets.
+ * STREAM — single polymorphic action consolidating live-stream lifecycle.
  *
- * All actions hit the local Eliza API (127.0.0.1:API_PORT).
+ * Actions:
+ *   go_live     — start the live stream to the active destination
+ *   go_offline  — stop the active stream and release capture/RTMP resources
+ *
+ * Dispatch is HTTP-only (POST /api/stream/{live,offline}). The local API route
+ * owns full orchestration — capture mode detection, destination credential
+ * resolution, Xvfb/avfoundation/pipe/file dispatch, browser capture lifecycle,
+ * screen-capture wiring, and destination notifications. The exported
+ * `streamManager` singleton is only one piece of that pipeline; calling it
+ * from this action would require replicating every orchestration step, so we
+ * keep HTTP as the canonical entry point.
  *
  * @module actions/stream-control
  */
 import type { Action } from "@elizaos/core";
-export declare const goLiveAction: Action;
-export declare const goOfflineAction: Action;
-export declare const setStreamDestinationAction: Action;
-export declare const speakOnStreamAction: Action;
-export declare const manageOverlayWidgetAction: Action;
+export declare const streamAction: Action;
 //# sourceMappingURL=stream-control.d.ts.map

package/packages/agent/src/actions/stream-control.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stream-control.d.ts","sourceRoot":"","sources":["../../../../../src/actions/stream-control.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AA2C5C,eAAO,MAAM,YAAY,EAAE,MAoC1B,CAAC;AAMF,eAAO,MAAM,eAAe,EAAE,MAwB7B,CAAC;AAMF,eAAO,MAAM,0BAA0B,EAAE,MAkHxC,CAAC;AAMF,eAAO,MAAM,mBAAmB,EAAE,MA+CjC,CAAC;AAMF,eAAO,MAAM,yBAAyB,EAAE,MA6IvC,CAAC"}
+{"version":3,"file":"stream-control.d.ts","sourceRoot":"","sources":["../../../../../src/actions/stream-control.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EACV,MAAM,EAQP,MAAM,eAAe,CAAC;AA8FvB,eAAO,MAAM,YAAY,EAAE,MAiF1B,CAAC"}

package/packages/agent/src/actions/stream-control.js

@@ -1,357 +1,166 @@
 /**
- * Stream control actions — agents can go live, go offline, switch
- * destinations, speak via TTS, and manage overlay widgets.
+ * STREAM — single polymorphic action consolidating live-stream lifecycle.
  *
- * All actions hit the local Eliza API (127.0.0.1:API_PORT).
+ * Actions:
+ *   go_live     — start the live stream to the active destination
+ *   go_offline  — stop the active stream and release capture/RTMP resources
+ *
+ * Dispatch is HTTP-only (POST /api/stream/{live,offline}). The local API route
+ * owns full orchestration — capture mode detection, destination credential
+ * resolution, Xvfb/avfoundation/pipe/file dispatch, browser capture lifecycle,
+ * screen-capture wiring, and destination notifications. The exported
+ * `streamManager` singleton is only one piece of that pipeline; calling it
+ * from this action would require replicating every orchestration step, so we
+ * keep HTTP as the canonical entry point.
  *
  * @module actions/stream-control
  */
+import { hasContextSignalSyncForKey } from "./context-signal.js";
+const STREAM_ACTION = "STREAM";
+const STREAM_OPS = ["go_live", "go_offline"];
 const API_PORT = process.env.API_PORT || process.env.SERVER_PORT || "2138";
 const BASE = `http://127.0.0.1:${API_PORT}`;
-async function apiPost(path, body) {
+function readOp(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const s = value.trim().toLowerCase();
+    return STREAM_OPS.includes(s)
+        ? s
+        : undefined;
+}
+async function apiPost(path) {
     const res = await fetch(`${BASE}${path}`, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
-        body: body !== undefined ? JSON.stringify(body) : undefined,
         signal: AbortSignal.timeout(10_000),
     });
     let data = null;
     try {
-        data = await res.json();
+        const parsed = await res.json();
+        if (parsed && typeof parsed === "object") {
+            data = parsed;
+        }
     }
     catch {
-        /* ignore */
+        // Empty or non-JSON body — leave data null.
     }
     return { ok: res.ok, status: res.status, data };
 }
-async function apiGet(path) {
-    const res = await fetch(`${BASE}${path}`, {
-        signal: AbortSignal.timeout(10_000),
-    });
-    let data = null;
+function failure(op, message) {
+    return {
+        success: false,
+        text: message,
+        error: `STREAM_${op.toUpperCase()}_FAILED`,
+    };
+}
+async function runGoLive() {
     try {
-        data = await res.json();
+        const result = await apiPost("/api/stream/live");
+        if (!result.ok) {
+            const detail = result.data?.error ?? `HTTP ${result.status}`;
+            return failure("go_live", `Failed to start stream: ${String(detail)}`);
+        }
+        const live = result.data?.live === true;
+        return {
+            success: true,
+            text: live
+                ? "Stream is now live."
+                : "Stream start requested but may not be live yet — check status.",
+        };
     }
-    catch {
-        /* ignore */
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return failure("go_live", `Failed to start stream: ${message}`);
     }
-    return { ok: res.ok, status: res.status, data };
 }
-// ---------------------------------------------------------------------------
-// GO_LIVE
-// ---------------------------------------------------------------------------
-export const goLiveAction = {
-    name: "GO_LIVE",
-    similes: [
-        "START_STREAM",
-        "BEGIN_STREAM",
-        "START_BROADCASTING",
-        "GO_LIVE_NOW",
-    ],
-    description: "Start the live stream, broadcasting to the active destination (Twitch, YouTube, Retake.tv, etc.).",
-    validate: async () => true,
-    handler: async () => {
-        try {
-            const result = await apiPost("/api/stream/live");
-            if (!result.ok) {
-                const msg = result.data?.error ??
-                    `HTTP ${result.status}`;
-                return { text: `Failed to start stream: ${msg}`, success: false };
-            }
-            const data = result.data;
-            return {
-                text: data.live
-                    ? "Stream is now live! 🔴"
-                    : "Stream start requested but may not be live yet — check status.",
-                success: true,
-            };
-        }
-        catch (err) {
-            return {
-                text: `Failed to start stream: ${err instanceof Error ? err.message : String(err)}`,
-                success: false,
-            };
-        }
-    },
-    parameters: [],
-};
-// ---------------------------------------------------------------------------
-// GO_OFFLINE
-// ---------------------------------------------------------------------------
-export const goOfflineAction = {
-    name: "GO_OFFLINE",
-    similes: ["STOP_STREAM", "END_STREAM", "END_BROADCAST", "STOP_BROADCASTING"],
-    description: "Stop the live stream and go offline.",
-    validate: async () => true,
-    handler: async () => {
-        try {
-            const result = await apiPost("/api/stream/offline");
-            if (!result.ok) {
-                const msg = result.data?.error ??
-                    `HTTP ${result.status}`;
-                return { text: `Failed to stop stream: ${msg}`, success: false };
-            }
-            return { text: "Stream stopped. Now offline.", success: true };
-        }
-        catch (err) {
-            return {
-                text: `Failed to stop stream: ${err instanceof Error ? err.message : String(err)}`,
-                success: false,
-            };
-        }
-    },
-    parameters: [],
-};
-// ---------------------------------------------------------------------------
-// SET_STREAM_DESTINATION
-// ---------------------------------------------------------------------------
-export const setStreamDestinationAction = {
-    name: "SET_STREAM_DESTINATION",
-    similes: [
-        "SWITCH_STREAM_DESTINATION",
-        "CHANGE_CHANNEL",
-        "SWITCH_CHANNEL",
-        "SELECT_DESTINATION",
-    ],
-    description: "Switch the active streaming destination (e.g. switch from Twitch to YouTube). " +
-        "The stream must be offline before switching.",
-    validate: async () => true,
-    handler: async (_runtime, _message, _state, options) => {
-        try {
-            const params = options?.parameters;
-            const destinationId = typeof params?.destinationId === "string"
-                ? params.destinationId.trim()
-                : "";
-            const destinationName = typeof params?.destinationName === "string"
-                ? params.destinationName.trim()
-                : "";
-            if (!destinationId && !destinationName) {
-                // List available destinations so the agent can choose
-                const listResult = await apiGet("/api/streaming/destinations");
-                if (!listResult.ok) {
-                    return {
-                        text: "Could not fetch destinations. API may be unavailable.",
-                        success: false,
-                    };
-                }
-                const data = listResult.data;
-                const dests = (data.destinations ?? []);
-                if (dests.length === 0) {
-                    return {
-                        text: "No streaming destinations configured. Install a streaming plugin first.",
-                        success: false,
-                    };
-                }
-                const list = dests.map((d) => `- ${d.name} (id: ${d.id})`).join("\n");
-                return {
-                    text: `Available destinations:\n${list}\n\nCall again with destinationId set.`,
-                    success: false,
-                };
-            }
-            // Resolve by id or name
-            const listResult = await apiGet("/api/streaming/destinations");
-            const dests = (listResult.ok
-                ? (listResult.data.destinations ?? [])
-                : []);
-            const target = dests.find((d) => d.id === destinationId) ??
-                dests.find((d) => d.name.toLowerCase() === destinationName.toLowerCase());
-            if (!target) {
-                const names = dests.map((d) => d.name).join(", ") || "none";
-                return {
-                    text: `Destination "${destinationId || destinationName}" not found. Available: ${names}`,
-                    success: false,
-                };
-            }
-            const result = await apiPost("/api/streaming/destination", {
-                destinationId: target.id,
-            });
-            if (!result.ok) {
-                const msg = result.data?.error ??
-                    `HTTP ${result.status}`;
-                return { text: `Failed to switch destination: ${msg}`, success: false };
-            }
-            return {
-                text: `Switched streaming destination to ${target.name}.`,
-                success: true,
-            };
-        }
-        catch (err) {
-            return {
-                text: `Failed to switch destination: ${err instanceof Error ? err.message : String(err)}`,
-                success: false,
-            };
+async function runGoOffline() {
+    try {
+        const result = await apiPost("/api/stream/offline");
+        if (!result.ok) {
+            const detail = result.data?.error ?? `HTTP ${result.status}`;
+            return failure("go_offline", `Failed to stop stream: ${String(detail)}`);
         }
-    },
+        return {
+            success: true,
+            text: "Stream stopped. Now offline.",
+        };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return failure("go_offline", `Failed to stop stream: ${message}`);
+    }
+}
+export const streamAction = {
+    name: STREAM_ACTION,
+    contexts: ["general", "media", "automation", "settings"],
+    roleGate: { minRole: "OWNER" },
+    description: "Control the live stream lifecycle. Use action='go_live' to start broadcasting " +
+        "to the active destination (Twitch, YouTube, custom RTMP). Use " +
+        "action='go_offline' to stop any active stream and release capture/RTMP " +
+        "resources.",
+    descriptionCompressed: "control live stream: action=go_live start broadcast active destination; action=go_offline stop release capture RTMP",
     parameters: [
         {
-            name: "destinationId",
-            description: "The destination ID (from /api/streaming/destinations). Use this or destinationName.",
-            required: false,
-            schema: { type: "string" },
+            name: "action",
+            description: `Operation: ${STREAM_OPS.join(", ")}.`,
+            required: true,
+            schema: { type: "string", enum: [...STREAM_OPS] },
         },
         {
-            name: "destinationName",
-            description: 'The destination name (e.g. "Twitch", "YouTube"). Case-insensitive.',
+            name: "op",
+            description: "Legacy alias for action.",
             required: false,
-            schema: { type: "string" },
+            schema: { type: "string", enum: [...STREAM_OPS] },
         },
     ],
-};
-// ---------------------------------------------------------------------------
-// SPEAK_ON_STREAM
-// ---------------------------------------------------------------------------
-export const speakOnStreamAction = {
-    name: "SPEAK_ON_STREAM",
-    similes: ["SAY_ON_STREAM", "TTS_SPEAK", "READ_ALOUD", "STREAM_VOICE"],
-    description: "Speak a message aloud on the stream using text-to-speech (TTS). " +
-        "The stream voice must be enabled in settings.",
-    validate: async () => true,
-    handler: async (_runtime, _message, _state, options) => {
-        try {
-            const params = options?.parameters;
-            const text = typeof params?.text === "string" ? params.text.trim() : "";
-            if (!text) {
-                return {
-                    text: "text parameter is required for SPEAK_ON_STREAM.",
-                    success: false,
-                };
-            }
-            const result = await apiPost("/api/stream/voice/speak", { text });
-            if (!result.ok) {
-                const msg = result.data?.error ??
-                    `HTTP ${result.status}`;
-                return { text: `Failed to speak on stream: ${msg}`, success: false };
-            }
-            return { text: `Speaking on stream: "${text}"`, success: true };
-        }
-        catch (err) {
-            return {
-                text: `Failed to speak: ${err instanceof Error ? err.message : String(err)}`,
-                success: false,
-            };
-        }
+    validate: async (_runtime, message, state) => {
+        return hasContextSignalSyncForKey(message, state, "stream_control");
     },
-    parameters: [
-        {
-            name: "text",
-            description: "The text to speak aloud on the stream.",
-            required: true,
-            schema: { type: "string" },
-        },
-    ],
-};
-// ---------------------------------------------------------------------------
-// MANAGE_OVERLAY_WIDGET
-// ---------------------------------------------------------------------------
-export const manageOverlayWidgetAction = {
-    name: "MANAGE_OVERLAY_WIDGET",
-    similes: [
-        "TOGGLE_WIDGET",
-        "ENABLE_WIDGET",
-        "DISABLE_WIDGET",
-        "SHOW_OVERLAY",
-        "HIDE_OVERLAY",
-    ],
-    description: "Enable or disable a stream overlay widget (e.g. viewer count, alert popup, thought bubble, branding). " +
-        'Provide widgetType and action ("enable" or "disable"). Optionally provide destinationId for per-destination layouts.',
-    validate: async () => true,
-    handler: async (_runtime, _message, _state, options) => {
-        try {
-            const params = options?.parameters;
-            const widgetType = typeof params?.widgetType === "string" ? params.widgetType.trim() : "";
-            const action = typeof params?.action === "string"
-                ? params.action.trim().toLowerCase()
-                : "enable";
-            const destinationId = typeof params?.destinationId === "string"
-                ? params.destinationId.trim()
-                : undefined;
-            if (!widgetType) {
-                return {
-                    text: "widgetType is required. Available types: viewer-count, alert-popup, action-ticker, thought-bubble, branding, custom-html, peon-hud, peon-glass, peon-sakura.",
-                    success: false,
-                };
-            }
-            if (action !== "enable" && action !== "disable") {
-                return {
-                    text: 'action must be "enable" or "disable".',
-                    success: false,
-                };
-            }
-            // Fetch current layout
-            const qs = destinationId
-                ? `?destination=${encodeURIComponent(destinationId)}`
-                : "";
-            const getResult = await apiGet(`/api/stream/overlay-layout${qs}`);
-            if (!getResult.ok) {
-                return {
-                    text: `Could not fetch overlay layout: HTTP ${getResult.status}`,
-                    success: false,
-                };
-            }
-            const data = getResult.data;
-            const layout = data.layout;
-            if (!layout || !Array.isArray(layout.widgets)) {
-                return { text: "Could not parse overlay layout.", success: false };
-            }
-            const widget = layout.widgets.find((w) => w.type === widgetType);
-            if (!widget) {
-                const types = layout.widgets.map((w) => w.type).join(", ");
-                return {
-                    text: `Widget type "${widgetType}" not found. Available: ${types}`,
-                    success: false,
-                };
-            }
-            const enable = action === "enable";
-            if (widget.enabled === enable) {
-                return {
-                    text: `Widget "${widgetType}" is already ${enable ? "enabled" : "disabled"}.`,
-                    success: true,
-                };
-            }
-            // Mutate and save
-            const updated = {
-                ...layout,
-                widgets: layout.widgets.map((w) => w.type === widgetType ? { ...w, enabled: enable } : w),
-            };
-            const saveResult = await apiPost(`/api/stream/overlay-layout${qs}`, {
-                layout: updated,
-            });
-            if (!saveResult.ok) {
-                return {
-                    text: `Failed to save overlay layout: HTTP ${saveResult.status}`,
-                    success: false,
-                };
-            }
+    handler: async (_runtime, _message, _state, options, _callback) => {
+        const params = (options ?? {});
+        const op = readOp(params.action ?? params.subaction ?? params.op);
+        if (!op) {
             return {
-                text: `Widget "${widgetType}" ${enable ? "enabled" : "disabled"} on stream overlay.`,
-                success: true,
-            };
-        }
-        catch (err) {
-            return {
-                text: `Failed to manage widget: ${err instanceof Error ? err.message : String(err)}`,
                 success: false,
+                text: `Invalid stream op. Expected one of: ${STREAM_OPS.join(", ")}`,
+                error: "STREAM_INVALID",
             };
         }
+        switch (op) {
+            case "go_live":
+                return runGoLive();
+            case "go_offline":
+                return runGoOffline();
+        }
     },
-    parameters: [
-        {
-            name: "widgetType",
-            description: "Widget type to manage: viewer-count, alert-popup, action-ticker, thought-bubble, branding, custom-html, peon-hud, peon-glass, peon-sakura.",
-            required: true,
-            schema: { type: "string" },
-        },
-        {
-            name: "action",
-            description: '"enable" or "disable".',
-            required: true,
-            schema: { type: "string" },
-        },
-        {
-            name: "destinationId",
-            description: "Optional destination ID for per-destination overlay layouts.",
-            required: false,
-            schema: { type: "string" },
-        },
+    examples: [
+        [
+            {
+                name: "{{name1}}",
+                content: { text: "Let's start the stream now." },
+            },
+            {
+                name: "{{agentName}}",
+                content: {
+                    text: "Stream is now live.",
+                    actions: [STREAM_ACTION],
+                    actionParameters: { action: "go_live" },
+                },
+            },
+        ],
+        [
+            {
+                name: "{{name1}}",
+                content: { text: "Take us offline, please." },
+            },
+            {
+                name: "{{agentName}}",
+                content: {
+                    text: "Stream stopped. Now offline.",
+                    actions: [STREAM_ACTION],
+                    actionParameters: { action: "go_offline" },
+                },
+            },
+        ],
     ],
 };

package/packages/agent/src/actions/terminal.d.ts

@@ -1,11 +1,12 @@
 /**
- * RUN_IN_TERMINAL action — runs a shell command on the server.
+ * SHELL action — runs a shell command on the server.
  *
  * When triggered the action:
- *   1. Extracts the command from the parameters
+ *   1. Extracts the command from parameters or MCP-style JSON
  *   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
+ *   4. Captures the output for planner follow-up
+ *   5. Stores the full output as a document attachment for follow-up actions
  *
  * @module actions/terminal
  */

package/packages/agent/src/actions/terminal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"terminal.d.ts","sourceRoot":"","sources":["../../../../../src/actions/terminal.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAkB,MAAM,eAAe,CAAC;AAuG5D,eAAO,MAAM,cAAc,EAAE,MAsE5B,CAAC"}
+{"version":3,"file":"terminal.d.ts","sourceRoot":"","sources":["../../../../../src/actions/terminal.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EACV,MAAM,EAOP,MAAM,eAAe,CAAC;AAoPvB,eAAO,MAAM,cAAc,EAAE,MA+I5B,CAAC"}