@elizaos/ui 2.0.0-alpha.43 → 2.0.0-alpha.430

package/packages/agent/src/middleware/x402/x402-types.js

@@ -0,0 +1,189 @@
+/**
+ * x402scan Validation Schema Types
+ * Stricter schema required for listing on x402scan
+ * Allows UI-based resource invocation
+ */
+/**
+ * Valid x402scan networks
+ */
+const VALID_NETWORKS = [
+    "base-sepolia",
+    "base",
+    "avalanche-fuji",
+    "avalanche",
+    "iotex",
+    "solana-devnet",
+    "solana",
+    "sei",
+    "sei-testnet",
+    "polygon",
+    "polygon-amoy",
+    "peaq",
+];
+/**
+ * Validate URL format
+ */
+function isValidUrl(url) {
+    try {
+        const parsed = new URL(url);
+        return parsed.protocol === "http:" || parsed.protocol === "https:";
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Validate wallet address format based on network
+ */
+function isValidWalletAddress(address, network) {
+    if (!address || typeof address !== "string")
+        return false;
+    // Solana addresses are base58 encoded, typically 32-44 characters
+    if (network.includes("solana")) {
+        return /^[1-9A-HJ-NP-Za-km-z]{32,44}$/.test(address);
+    }
+    // EVM-compatible chains use 0x addresses
+    return /^0x[a-fA-F0-9]{40}$/.test(address);
+}
+/**
+ * Validate that an Accepts object conforms to the x402scan schema
+ */
+export function validateAccepts(accepts) {
+    const errors = [];
+    // Required fields
+    if (accepts.scheme !== "exact") {
+        errors.push('scheme must be "exact"');
+    }
+    if (!accepts.network ||
+        !VALID_NETWORKS.includes(accepts.network)) {
+        errors.push(`network must be one of: ${VALID_NETWORKS.join(", ")}`);
+    }
+    if (!accepts.maxAmountRequired ||
+        typeof accepts.maxAmountRequired !== "string") {
+        errors.push("maxAmountRequired is required and must be a string");
+    }
+    if (!accepts.resource || typeof accepts.resource !== "string") {
+        errors.push("resource is required and must be a string (full URL)");
+    }
+    else if (!isValidUrl(accepts.resource)) {
+        errors.push("resource must be a valid URL (must start with http:// or https://)");
+    }
+    if (!accepts.description || typeof accepts.description !== "string") {
+        errors.push("description is required and must be a string");
+    }
+    if (!accepts.mimeType || typeof accepts.mimeType !== "string") {
+        errors.push('mimeType is required and must be a string (e.g., "application/json")');
+    }
+    if (!accepts.payTo || typeof accepts.payTo !== "string") {
+        errors.push("payTo is required and must be a string (wallet address)");
+    }
+    else if (accepts.network &&
+        !isValidWalletAddress(accepts.payTo, accepts.network)) {
+        errors.push(`payTo must be a valid wallet address for network ${accepts.network}`);
+    }
+    if (!accepts.maxTimeoutSeconds ||
+        typeof accepts.maxTimeoutSeconds !== "number") {
+        errors.push("maxTimeoutSeconds is required and must be a number");
+    }
+    if (!accepts.asset || typeof accepts.asset !== "string") {
+        errors.push('asset is required and must be a string (e.g., "USDC", "ETH")');
+    }
+    // Validate outputSchema if present
+    if (accepts.outputSchema) {
+        const schema = accepts.outputSchema;
+        if (!schema.input || schema.input.type !== "http") {
+            errors.push('outputSchema.input.type must be "http"');
+        }
+        if (!schema.input.method ||
+            !["GET", "POST"].includes(schema.input.method)) {
+            errors.push('outputSchema.input.method must be "GET" or "POST"');
+        }
+        if (schema.input.bodyType) {
+            const validBodyTypes = [
+                "json",
+                "form-data",
+                "multipart-form-data",
+                "text",
+                "binary",
+            ];
+            if (!validBodyTypes.includes(schema.input.bodyType)) {
+                errors.push(`outputSchema.input.bodyType must be one of: ${validBodyTypes.join(", ")}`);
+            }
+        }
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+    };
+}
+/**
+ * Validate that an X402Response conforms to the x402scan schema
+ */
+export function validateX402Response(response) {
+    const errors = [];
+    // x402Version is required
+    if (typeof response.x402Version !== "number") {
+        errors.push("x402Version is required and must be a number");
+    }
+    // If accepts is provided, validate each entry
+    if (response.accepts) {
+        if (!Array.isArray(response.accepts)) {
+            errors.push("accepts must be an array");
+        }
+        else {
+            response.accepts.forEach((accepts, index) => {
+                const validation = validateAccepts(accepts);
+                if (!validation.valid) {
+                    errors.push(`accepts[${index}]: ${validation.errors.join(", ")}`);
+                }
+            });
+        }
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+    };
+}
+/**
+ * Create a validated Accepts object with sensible defaults
+ */
+export function createAccepts(params) {
+    const accepts = {
+        scheme: "exact",
+        network: params.network,
+        maxAmountRequired: params.maxAmountRequired,
+        resource: params.resource,
+        description: params.description,
+        mimeType: params.mimeType || "application/json",
+        payTo: params.payTo,
+        maxTimeoutSeconds: params.maxTimeoutSeconds || 300, // 5 minutes default
+        asset: params.asset,
+    };
+    if (params.outputSchema) {
+        accepts.outputSchema = params.outputSchema;
+    }
+    if (params.extra) {
+        accepts.extra = params.extra;
+    }
+    // Validate before returning
+    const validation = validateAccepts(accepts);
+    if (!validation.valid) {
+        throw new Error(`Invalid Accepts object: ${validation.errors.join(", ")}`);
+    }
+    return accepts;
+}
+/**
+ * Create a validated X402Response
+ */
+export function createX402Response(params) {
+    const response = {
+        x402Version: 1,
+        ...params,
+    };
+    // Validate before returning
+    const validation = validateX402Response(response);
+    if (!validation.valid) {
+        throw new Error(`Invalid X402Response: ${validation.errors.join(", ")}`);
+    }
+    return response;
+}

package/packages/agent/src/plugins/custom-rtmp/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 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.js";
+export declare function createCustomRtmpDestination(config?: {
+    rtmpUrl?: string;
+    rtmpKey?: string;
+}): StreamingDestination;
+//# sourceMappingURL=index.d.ts.map

package/packages/agent/src/plugins/custom-rtmp/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../agent/src/plugins/custom-rtmp/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AAEvE,wBAAgB,2BAA2B,CAAC,MAAM,CAAC,EAAE;IACnD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,GAAG,oBAAoB,CA2BvB"}

package/packages/agent/src/plugins/custom-rtmp/index.js

@@ -0,0 +1,26 @@
+/**
+ * Custom RTMP streaming destination plugin.
+ *
+ * The simplest streaming destination — reads RTMP URL and key directly
+ * from config. No platform API calls, no chat bridging.
+ */
+export function createCustomRtmpDestination(config) {
+    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/packages/agent/src/providers/admin-panel.d.ts

@@ -0,0 +1,4 @@
+import type { Provider } from "@elizaos/core";
+export declare const adminPanelProvider: Provider;
+export declare function createAdminPanelProvider(): Provider;
+//# sourceMappingURL=admin-panel.d.ts.map

package/packages/agent/src/providers/admin-panel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"admin-panel.d.ts","sourceRoot":"","sources":["../../../../../../agent/src/providers/admin-panel.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAGV,QAAQ,EAIT,MAAM,eAAe,CAAC;AAwEvB,eAAO,MAAM,kBAAkB,EAAE,QAAqC,CAAC;AAEvE,wBAAgB,wBAAwB,IAAI,QAAQ,CAwCnD"}

package/packages/agent/src/providers/admin-panel.js

@@ -0,0 +1,83 @@
+import { resolveCanonicalOwnerIdForMessage } from "@elizaos/core";
+import { hasAdminAccess } from "../security/access.js";
+/** Maximum total characters for the provider text output. */
+const MAX_TEXT_LENGTH = 2000;
+/** Maximum messages to fetch per client_chat room. */
+const MESSAGES_PER_ROOM = 10;
+/** Maximum client_chat rooms to scan (most recent activity wins). */
+const MAX_ROOMS = 3;
+/**
+ * Fetch recent messages from the owner's client_chat rooms.
+ * Returns messages newest-first, capped to a sensible limit.
+ */
+async function fetchOwnerChatMessages(runtime, adminEntityId) {
+    const roomIds = await runtime.getRoomsForParticipant(adminEntityId);
+    if (roomIds.length === 0)
+        return [];
+    // Resolve rooms and filter to client_chat source
+    const roomResults = await Promise.all(roomIds.map((id) => runtime.getRoom(id)));
+    const chatRooms = roomResults.filter((r) => r != null && r.source === "client_chat");
+    if (chatRooms.length === 0)
+        return [];
+    // Limit how many rooms we scan
+    const targetRooms = chatRooms.slice(0, MAX_ROOMS);
+    const targetRoomIds = targetRooms.map((r) => r.id);
+    const memories = await runtime.getMemoriesByRoomIds({
+        tableName: "messages",
+        roomIds: targetRoomIds,
+        limit: MESSAGES_PER_ROOM * MAX_ROOMS,
+    });
+    // Sort newest-first (getMemoriesByRoomIds default may vary)
+    memories.sort((a, b) => {
+        const ta = a.createdAt ?? 0;
+        const tb = b.createdAt ?? 0;
+        return tb - ta;
+    });
+    return memories.slice(0, MESSAGES_PER_ROOM * MAX_ROOMS);
+}
+function formatMessages(messages, agentId) {
+    if (messages.length === 0)
+        return "";
+    // Display oldest-first for natural reading order
+    const ordered = [...messages].reverse();
+    const lines = ordered.map((m) => {
+        const sender = m.entityId === agentId ? "Agent" : "Owner";
+        const text = m.content?.text ?? "";
+        return `[${sender}] ${text.substring(0, 200)}`;
+    });
+    let result = `# Recent Owner Conversation (Eliza App)\n${lines.join("\n")}`;
+    if (result.length > MAX_TEXT_LENGTH) {
+        result = `${result.substring(0, MAX_TEXT_LENGTH - 3)}...`;
+    }
+    return result;
+}
+export const adminPanelProvider = createAdminPanelProvider();
+export function createAdminPanelProvider() {
+    return {
+        name: "adminPanel",
+        description: "Surfaces the owner's recent Eliza app chat so the agent has context across platforms.",
+        dynamic: true,
+        position: 14,
+        async get(runtime, message, _state) {
+            const empty = {
+                text: "",
+                values: { hasAdminChat: false },
+                data: { messageCount: 0 },
+            };
+            if (!(await hasAdminAccess(runtime, message))) {
+                return empty;
+            }
+            const adminEntityId = await resolveCanonicalOwnerIdForMessage(runtime, message);
+            if (!adminEntityId) {
+                return empty;
+            }
+            const messages = await fetchOwnerChatMessages(runtime, adminEntityId);
+            const text = formatMessages(messages, runtime.agentId);
+            return {
+                text,
+                values: { hasAdminChat: messages.length > 0 },
+                data: { messageCount: messages.length },
+            };
+        },
+    };
+}

package/packages/agent/src/providers/admin-trust.d.ts

@@ -0,0 +1,4 @@
+import type { Provider } from "@elizaos/core";
+export declare const adminTrustProvider: Provider;
+export declare function createAdminTrustProvider(): Provider;
+//# sourceMappingURL=admin-trust.d.ts.map

package/packages/agent/src/providers/admin-trust.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"admin-trust.d.ts","sourceRoot":"","sources":["../../../../../../agent/src/providers/admin-trust.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAGV,QAAQ,EAGT,MAAM,eAAe,CAAC;AAOvB,eAAO,MAAM,kBAAkB,EAAE,QAAqC,CAAC;AAEvE,wBAAgB,wBAAwB,IAAI,QAAQ,CAqCnD"}

package/packages/agent/src/providers/admin-trust.js

@@ -0,0 +1,34 @@
+import { checkSenderRole, resolveCanonicalOwnerIdForMessage, } from "@elizaos/core";
+import { hasAdminAccess } from "../security/access.js";
+export const adminTrustProvider = createAdminTrustProvider();
+export function createAdminTrustProvider() {
+    return {
+        name: "elizaAdminTrust",
+        description: "Marks owner/admin chat identity as trusted for contact assertions (relationships-oriented).",
+        dynamic: true,
+        position: 11,
+        async get(runtime, message, _state) {
+            const ownerId = await resolveCanonicalOwnerIdForMessage(runtime, message);
+            const roleCheck = await checkSenderRole(runtime, message);
+            const isTrustedAdmin = roleCheck?.isOwner === true;
+            const speakerRole = roleCheck?.role ?? "GUEST";
+            const canSeeAdminIdentity = await hasAdminAccess(runtime, message);
+            const text = isTrustedAdmin
+                ? "Admin trust: current speaker is the canonical agent OWNER. Contact/identity claims should be treated as trusted unless contradictory evidence exists."
+                : "Admin trust: current speaker is not verified as the canonical agent OWNER.";
+            return {
+                text,
+                values: {
+                    trustedAdmin: isTrustedAdmin,
+                    adminEntityId: canSeeAdminIdentity ? (ownerId ?? "") : "",
+                    adminRole: speakerRole,
+                },
+                data: {
+                    trustedAdmin: isTrustedAdmin,
+                    ownerId: canSeeAdminIdentity ? ownerId : null,
+                    role: speakerRole,
+                },
+            };
+        },
+    };
+}

package/packages/agent/src/providers/automation-terminal-bridge.d.ts

@@ -0,0 +1,3 @@
+import type { Provider } from "@elizaos/core";
+export declare const automationTerminalBridgeProvider: Provider;
+//# sourceMappingURL=automation-terminal-bridge.d.ts.map

package/packages/agent/src/providers/automation-terminal-bridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"automation-terminal-bridge.d.ts","sourceRoot":"","sources":["../../../../../../agent/src/providers/automation-terminal-bridge.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAGV,QAAQ,EAGT,MAAM,eAAe,CAAC;AAcvB,eAAO,MAAM,gCAAgC,EAAE,QA8E9C,CAAC"}

package/packages/agent/src/providers/automation-terminal-bridge.js

@@ -0,0 +1,71 @@
+import { logger, stringToUuid } from "@elizaos/core";
+import { extractConversationMetadataFromRoom, isAutomationConversationMetadata, } from "../api/conversation-metadata.js";
+import { hasAdminAccess } from "../security/access.js";
+import { formatRelativeTimestamp, formatSpeakerLabel, } from "./conversation-utils.js";
+const MAX_TERMINAL_MESSAGES = 8;
+export const automationTerminalBridgeProvider = {
+    name: "automation-terminal-bridge",
+    description: "Recent messages from the linked terminal conversation for the current automation room.",
+    dynamic: true,
+    position: 5,
+    async get(runtime, message) {
+        if (!(await hasAdminAccess(runtime, message))) {
+            return { text: "", values: {}, data: {} };
+        }
+        try {
+            const currentRoom = await runtime.getRoom(message.roomId);
+            const metadata = extractConversationMetadataFromRoom(currentRoom);
+            if (!isAutomationConversationMetadata(metadata)) {
+                return { text: "", values: {}, data: {} };
+            }
+            const terminalConversationId = metadata?.terminalBridgeConversationId;
+            if (!terminalConversationId) {
+                return { text: "", values: {}, data: {} };
+            }
+            const sourceRoomId = stringToUuid(`web-conv-${terminalConversationId}`);
+            if (sourceRoomId === message.roomId) {
+                return { text: "", values: {}, data: {} };
+            }
+            const memories = await runtime.getMemories({
+                roomId: sourceRoomId,
+                tableName: "messages",
+                limit: MAX_TERMINAL_MESSAGES,
+            });
+            const visibleMessages = memories
+                .filter((entry) => entry.content?.text)
+                .sort((left, right) => (left.createdAt ?? 0) - (right.createdAt ?? 0))
+                .slice(-MAX_TERMINAL_MESSAGES);
+            if (visibleMessages.length === 0) {
+                return { text: "", values: {}, data: {} };
+            }
+            const lines = ["Linked terminal conversation:"];
+            for (const mem of visibleMessages) {
+                const speaker = formatSpeakerLabel(runtime, mem);
+                const ts = formatRelativeTimestamp(mem.createdAt);
+                const text = (mem.content.text ?? "").slice(0, 300);
+                lines.push(`(${ts}) ${speaker}: ${text}`);
+            }
+            return {
+                text: lines.join("\n"),
+                values: {
+                    terminalBridgeConversationId: terminalConversationId,
+                    terminalBridgeMessageCount: visibleMessages.length,
+                },
+                data: {
+                    conversationId: terminalConversationId,
+                    messages: visibleMessages.map((entry) => ({
+                        id: entry.id,
+                        roomId: entry.roomId,
+                        entityId: entry.entityId,
+                        text: entry.content.text,
+                        createdAt: entry.createdAt,
+                    })),
+                },
+            };
+        }
+        catch (error) {
+            logger.error("[automation-terminal-bridge] Error:", error instanceof Error ? error.message : String(error));
+            return { text: "", values: {}, data: {} };
+        }
+    },
+};

package/packages/agent/src/providers/conversation-utils.d.ts

@@ -0,0 +1,11 @@
+import type { IAgentRuntime, Memory, Room } from "@elizaos/core";
+export declare function formatSpeakerLabel(runtime: IAgentRuntime, memory: Memory): string;
+/**
+ * Format a Room into a "[source] name" tag for display in provider output.
+ */
+export declare function roomSourceTag(room: Room | null): string;
+/**
+ * Format a createdAt timestamp as a human-readable relative string.
+ */
+export declare function formatRelativeTimestamp(createdAt?: number): string;
+//# sourceMappingURL=conversation-utils.d.ts.map

package/packages/agent/src/providers/conversation-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conversation-utils.d.ts","sourceRoot":"","sources":["../../../../../../agent/src/providers/conversation-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AA2BjE,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,aAAa,EACtB,MAAM,EAAE,MAAM,GACb,MAAM,CA2BR;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,GAAG,MAAM,CAKvD;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,CAYlE"}

package/packages/agent/src/providers/conversation-utils.js

@@ -0,0 +1,69 @@
+import { asNonEmptyString, asRecord } from "@elizaos/shared";
+const readString = asNonEmptyString;
+function normalizeName(value) {
+    return value.trim().toLowerCase();
+}
+function formatExternalSpeakerLabel(displayName, userName, source) {
+    if (displayName &&
+        userName &&
+        normalizeName(displayName) !== normalizeName(userName)) {
+        if (source === "discord") {
+            return `${displayName} (discord username: ${userName})`;
+        }
+        return `${displayName} (username: ${userName})`;
+    }
+    return displayName ?? userName ?? "user";
+}
+export function formatSpeakerLabel(runtime, memory) {
+    if (memory.entityId === runtime.agentId) {
+        return runtime.character?.name ?? "agent";
+    }
+    const metadata = asRecord(memory.metadata);
+    const content = asRecord(memory.content);
+    const defaultMetadata = asRecord(metadata?.default);
+    const source = readString(content?.source);
+    const sourceMetadata = source ? asRecord(metadata?.[source]) : null;
+    const displayName = readString(metadata?.entityName) ??
+        readString(metadata?.displayName) ??
+        readString(sourceMetadata?.displayName) ??
+        readString(sourceMetadata?.name) ??
+        readString(defaultMetadata?.name) ??
+        readString(metadata?.name);
+    const userName = readString(metadata?.entityUserName) ??
+        readString(sourceMetadata?.userName) ??
+        readString(sourceMetadata?.username) ??
+        readString(defaultMetadata?.username) ??
+        readString(metadata?.userName) ??
+        readString(metadata?.username);
+    return formatExternalSpeakerLabel(displayName, userName, source);
+}
+/**
+ * Format a Room into a "[source] name" tag for display in provider output.
+ */
+export function roomSourceTag(room) {
+    if (!room)
+        return "[unknown]";
+    const source = room.source || (room.type ?? "chat");
+    const name = room.name || room.id?.slice(0, 8);
+    return `[${source}] ${name}`;
+}
+/**
+ * Format a createdAt timestamp as a human-readable relative string.
+ */
+export function formatRelativeTimestamp(createdAt) {
+    if (!createdAt)
+        return "";
+    const date = new Date(createdAt);
+    const now = Date.now();
+    const diffMs = now - date.getTime();
+    if (diffMs < 60_000)
+        return "just now";
+    const minutes = Math.floor(diffMs / 60_000);
+    if (minutes < 60)
+        return `${minutes}m ago`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `${hours}h ago`;
+    const days = Math.floor(hours / 24);
+    return `${days}d ago`;
+}

package/packages/agent/src/providers/escalation-trigger.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Escalation trigger provider.
+ *
+ * Monitors conditions that may warrant escalating to the owner and injects
+ * escalation context into the agent's prompt when triggers are detected.
+ *
+ * Checks:
+ * 1. Active (unresolved) escalation in progress
+ * 2. Owner inactive for 24+ hours (only during autonomous agent loops)
+ * 3. Pending identity verification relationships for the current entity
+ */
+import type { Provider } from "@elizaos/core";
+export declare const escalationTriggerProvider: Provider;
+export declare function createEscalationTriggerProvider(): Provider;
+//# sourceMappingURL=escalation-trigger.d.ts.map

package/packages/agent/src/providers/escalation-trigger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"escalation-trigger.d.ts","sourceRoot":"","sources":["../../../../../../agent/src/providers/escalation-trigger.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAGV,QAAQ,EAIT,MAAM,eAAe,CAAC;AAgKvB,eAAO,MAAM,yBAAyB,EAAE,QACL,CAAC;AAEpC,wBAAgB,+BAA+B,IAAI,QAAQ,CAoD1D"}