@elizaos/agent 0.25.8 → 2.0.0-alpha.83

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

@@ -0,0 +1,357 @@
+/**
+ * Stream control actions — agents can go live, go offline, switch
+ * destinations, speak via TTS, and manage overlay widgets.
+ *
+ * All actions hit the local Eliza API (127.0.0.1:API_PORT).
+ *
+ * @module actions/stream-control
+ */
+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) {
+    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();
+    }
+    catch {
+        /* ignore */
+    }
+    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;
+    try {
+        data = await res.json();
+    }
+    catch {
+        /* ignore */
+    }
+    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,
+            };
+        }
+    },
+    parameters: [
+        {
+            name: "destinationId",
+            description: "The destination ID (from /api/streaming/destinations). Use this or destinationName.",
+            required: false,
+            schema: { type: "string" },
+        },
+        {
+            name: "destinationName",
+            description: 'The destination name (e.g. "Twitch", "YouTube"). Case-insensitive.',
+            required: false,
+            schema: { type: "string" },
+        },
+    ],
+};
+// ---------------------------------------------------------------------------
+// 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,
+            };
+        }
+    },
+    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,
+                };
+            }
+            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,
+            };
+        }
+    },
+    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" },
+        },
+    ],
+};

package/packages/agent/src/actions/switch-stream-source.d.ts

@@ -0,0 +1,16 @@
+/**
+ * SWITCH_STREAM_SOURCE action — changes the content being captured and streamed.
+ *
+ * When triggered the action:
+ *   1. Validates the requested sourceType against the allowed set
+ *   2. Requires customUrl when sourceType is "custom-url"
+ *   3. POSTs to the local API to apply the new stream source
+ *
+ * All stream-switching logic is handled server-side — this action is a
+ * thin wrapper that validates inputs and forwards the request.
+ *
+ * @module actions/switch-stream-source
+ */
+import type { Action } from "@elizaos/core";
+export declare const switchStreamSourceAction: Action;
+//# sourceMappingURL=switch-stream-source.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"switch-stream-source.d.ts","sourceRoot":"","sources":["../../../../../src/actions/switch-stream-source.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAkB,MAAM,eAAe,CAAC;AAQ5D,eAAO,MAAM,wBAAwB,EAAE,MA6GtC,CAAC"}

package/packages/agent/src/actions/switch-stream-source.js

@@ -0,0 +1,94 @@
+/**
+ * SWITCH_STREAM_SOURCE action — changes the content being captured and streamed.
+ *
+ * When triggered the action:
+ *   1. Validates the requested sourceType against the allowed set
+ *   2. Requires customUrl when sourceType is "custom-url"
+ *   3. POSTs to the local API to apply the new stream source
+ *
+ * All stream-switching logic is handled server-side — this action is a
+ * thin wrapper that validates inputs and forwards the request.
+ *
+ * @module actions/switch-stream-source
+ */
+/** API port for the stream source endpoint. */
+const API_PORT = process.env.API_PORT || process.env.SERVER_PORT || "2138";
+const VALID_SOURCE_TYPES = ["stream-tab", "game", "custom-url"];
+export const switchStreamSourceAction = {
+    name: "SWITCH_STREAM_SOURCE",
+    similes: ["CHANGE_STREAM", "STREAM_GAME", "STREAM_URL", "SET_STREAM_SOURCE"],
+    description: "Switches what content is being captured and streamed. " +
+        'Use "stream-tab" to capture the stream browser tab, "game" to capture a game window, ' +
+        'or "custom-url" to stream from a specific URL.',
+    validate: async () => true,
+    handler: async (_runtime, _message, _state, options) => {
+        try {
+            const params = options?.parameters;
+            // ── Extract parameters ───────────────────────────────────────────
+            const rawSourceType = typeof params?.sourceType === "string"
+                ? params.sourceType.trim()
+                : "stream-tab";
+            const sourceType = VALID_SOURCE_TYPES.includes(rawSourceType)
+                ? rawSourceType
+                : "stream-tab";
+            if (!VALID_SOURCE_TYPES.includes(rawSourceType) &&
+                rawSourceType !== "") {
+                return {
+                    text: `Invalid sourceType "${rawSourceType}". Must be one of: ${VALID_SOURCE_TYPES.join(", ")}.`,
+                    success: false,
+                };
+            }
+            const customUrl = typeof params?.customUrl === "string"
+                ? params.customUrl.trim()
+                : undefined;
+            // ── Validate custom-url requirement ─────────────────────────────
+            if (sourceType === "custom-url" && !customUrl) {
+                return {
+                    text: 'customUrl is required when sourceType is "custom-url".',
+                    success: false,
+                };
+            }
+            // ── POST to stream source API ───────────────────────────────────
+            const response = await fetch(`http://127.0.0.1:${API_PORT}/api/stream/source`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ sourceType, customUrl }),
+                signal: AbortSignal.timeout(10_000),
+            });
+            if (!response.ok) {
+                return {
+                    text: `Failed to switch stream source (HTTP ${response.status}).`,
+                    success: false,
+                };
+            }
+            // ── Format and return ────────────────────────────────────────────
+            const label = sourceType === "custom-url"
+                ? `${sourceType} (${customUrl})`
+                : sourceType;
+            return {
+                text: `Switched stream source to ${label}.`,
+                success: true,
+            };
+        }
+        catch (err) {
+            return {
+                text: `Failed to switch stream source: ${err instanceof Error ? err.message : String(err)}`,
+                success: false,
+            };
+        }
+    },
+    parameters: [
+        {
+            name: "sourceType",
+            description: 'The stream source type to switch to: "stream-tab", "game", or "custom-url".',
+            required: true,
+            schema: { type: "string" },
+        },
+        {
+            name: "customUrl",
+            description: 'The URL to stream from. Required when sourceType is "custom-url".',
+            required: false,
+            schema: { type: "string" },
+        },
+    ],
+};

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

@@ -0,0 +1,14 @@
+/**
+ * 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 } from "@elizaos/core";
+export declare const terminalAction: Action;
+//# sourceMappingURL=terminal.d.ts.map

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

@@ -0,0 +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"}

package/packages/agent/src/actions/terminal.js

@@ -0,0 +1,154 @@
+/**
+ * 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
+ */
+/** API port for posting terminal requests. */
+const API_PORT = process.env.API_PORT || process.env.SERVER_PORT || "2138";
+function nonEmptyString(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+function resolveCommandFromObject(value) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const record = value;
+    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) {
+    if (typeof argumentsValue === "string") {
+        const trimmed = argumentsValue.trim();
+        if (!trimmed)
+            return undefined;
+        try {
+            const parsed = JSON.parse(trimmed);
+            return resolveCommandFromObject(parsed) ?? trimmed;
+        }
+        catch {
+            return trimmed;
+        }
+    }
+    return resolveCommandFromObject(argumentsValue);
+}
+function resolveCommandFromParams(params) {
+    const record = params;
+    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) {
+    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 = {
+    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?.parameters;
+            const command = resolveCommandFromParams(params) ??
+                resolveCommandFromText(_message?.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" },
+        },
+    ],
+};

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

@@ -0,0 +1,38 @@
+import type { AgentRuntime, UUID } from "@elizaos/core";
+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 declare function handleAgentAdminRoutes(ctx: AgentAdminRouteContext): Promise<boolean>;
+export {};
+//# sourceMappingURL=agent-admin-routes.d.ts.map