@elizaos/plugin-roblox 2.0.0-alpha.6 → 2.0.0-beta.1

package/dist/index.js

@@ -51,59 +51,15 @@ class RobloxTestSuite {
   ];
 }
 
-// actions/executeGameAction.ts
+// actions/robloxAction.ts
 import {
   logger
 } from "@elizaos/core";
-var actionName = "EXECUTE_ROBLOX_ACTION";
-var executeGameActionExamples = [
-  [
-    {
-      name: actionName,
-      content: {
-        text: "Start a fireworks show in the game"
-      }
-    },
-    {
-      name: actionName,
-      content: {
-        text: "I'll trigger the fireworks show for everyone in the game!",
-        action: "EXECUTE_ROBLOX_ACTION"
-      }
-    }
-  ],
-  [
-    {
-      name: "{{user1}}",
-      content: {
-        text: "Give player456 100 coins as a reward"
-      }
-    },
-    {
-      name: "{{agentName}}",
-      content: {
-        text: "I'll give player456 100 coins right away!",
-        action: "EXECUTE_ROBLOX_ACTION"
-      }
-    }
-  ],
-  [
-    {
-      name: "{{user1}}",
-      content: {
-        text: "Teleport everyone to the lobby"
-      }
-    },
-    {
-      name: "{{agentName}}",
-      content: {
-        text: "Teleporting all players to the lobby now!",
-        action: "EXECUTE_ROBLOX_ACTION"
-      }
-    }
-  ]
-];
-var KNOWN_ACTIONS = [
+var actionName = "ROBLOX";
+var ROBLOX_ACTION_TIMEOUT_MS = 15000;
+var MAX_ROBLOX_TARGET_IDS = 25;
+var MAX_ROBLOX_MESSAGE_LENGTH = 1000;
+var KNOWN_GAME_ACTIONS = [
   {
     name: "move_npc",
     patterns: [
@@ -125,16 +81,14 @@ var KNOWN_ACTIONS = [
     name: "give_coins",
     patterns: [/give\s+(?:player\s*)?(\d+)\s+(\d+)\s+coins?/i],
     extractParams: (match) => ({
-      playerId: parseInt(match[1], 10),
-      amount: parseInt(match[2], 10)
+      playerId: Number.parseInt(match[1], 10),
+      amount: Number.parseInt(match[2], 10)
     })
   },
   {
     name: "teleport",
     patterns: [/teleport\s+(?:everyone|all)\s+to\s+(?:the\s+)?(\w+)/i],
-    extractParams: (match) => ({
-      destination: match[1]
-    })
+    extractParams: (match) => ({ destination: match[1] })
   },
   {
     name: "spawn_entity",
@@ -147,478 +101,447 @@ var KNOWN_ACTIONS = [
   {
     name: "start_event",
     patterns: [/start\s+(?:a\s+)?(\w+)\s+(?:show|event|celebration)/i],
-    extractParams: (match) => ({
-      eventType: match[1]
-    })
+    extractParams: (match) => ({ eventType: match[1] })
   }
 ];
-function parseGameAction(message) {
-  for (const action of KNOWN_ACTIONS) {
-    for (const pattern of action.patterns) {
-      const match = message.match(pattern);
+function isRecord(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function parseJsonObject(text) {
+  const trimmed = text.trim();
+  if (!trimmed.startsWith("{") || !trimmed.endsWith("}"))
+    return {};
+  try {
+    const parsed = JSON.parse(trimmed);
+    return isRecord(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function readParams(options) {
+  const maybeParams = isRecord(options) && isRecord(options.parameters) ? options.parameters : {};
+  return maybeParams;
+}
+function mergedInput(message, options) {
+  return {
+    ...parseJsonObject(message.content.text ?? ""),
+    ...readParams(options)
+  };
+}
+function readString(params, ...keys) {
+  for (const key of keys) {
+    const value = params[key];
+    if (typeof value === "string" && value.trim())
+      return value.trim();
+  }
+  return null;
+}
+function readNumber(params, ...keys) {
+  for (const key of keys) {
+    const value = params[key];
+    if (typeof value === "number" && Number.isFinite(value))
+      return value;
+    if (typeof value === "string" && value.trim()) {
+      const parsed = Number(value);
+      if (Number.isFinite(parsed))
+        return parsed;
+    }
+  }
+  return null;
+}
+function normalizeSubaction(value) {
+  const normalized = value?.trim().toLowerCase().replace(/[_\s-]+/g, "_");
+  if (!normalized)
+    return null;
+  if (["message", "send_message", "send", "chat", "announce"].includes(normalized)) {
+    return "message";
+  }
+  if (["execute", "action", "game_action", "run", "trigger"].includes(normalized)) {
+    return "execute";
+  }
+  if (["get_player", "player", "player_info", "user", "lookup"].includes(normalized)) {
+    return "get_player";
+  }
+  return null;
+}
+function inferSubaction(text, params) {
+  const explicit = normalizeSubaction(readString(params, "subaction", "action", "type"));
+  if (explicit)
+    return explicit;
+  const lower = text.toLowerCase();
+  if (/\b(who is|look up|lookup|find|get).*\b(player|user|roblox)\b/.test(lower)) {
+    return "get_player";
+  }
+  if (/\b(execute|run|trigger|start|give|teleport|spawn|move|walk)\b/.test(lower)) {
+    return "execute";
+  }
+  if (/\b(send|message|tell|announce|chat|say)\b/.test(lower)) {
+    return "message";
+  }
+  return null;
+}
+function readTargetPlayerIds(params, text) {
+  const explicit = params.targetPlayerIds;
+  if (Array.isArray(explicit)) {
+    const ids = explicit.map((value) => typeof value === "number" ? value : typeof value === "string" ? Number(value) : NaN).filter((value) => Number.isInteger(value) && value > 0);
+    if (ids.length)
+      return ids.slice(0, MAX_ROBLOX_TARGET_IDS);
+  }
+  const single = readNumber(params, "targetPlayerId", "playerId", "userId");
+  if (single !== null && Number.isInteger(single) && single > 0)
+    return [single];
+  const matches = [...text.matchAll(/\bplayer\s*(\d+)\b/gi)];
+  return matches.length ? matches.map((match) => Number.parseInt(match[1], 10)).slice(0, MAX_ROBLOX_TARGET_IDS) : undefined;
+}
+function withRobloxTimeout(promise, label) {
+  return Promise.race([
+    promise,
+    new Promise((_, reject) => setTimeout(() => reject(new Error(`${label} timed out`)), ROBLOX_ACTION_TIMEOUT_MS))
+  ]);
+}
+function parseGameAction(text, params) {
+  const explicitActionName = readString(params, "actionName", "gameAction", "command");
+  const explicitParameters = params.parameters;
+  if (explicitActionName) {
+    return {
+      name: explicitActionName,
+      parameters: sanitizeParameters(explicitParameters),
+      targetPlayerIds: readTargetPlayerIds(params, text)
+    };
+  }
+  for (const gameAction of KNOWN_GAME_ACTIONS) {
+    for (const pattern of gameAction.patterns) {
+      const match = text.match(pattern);
       if (match) {
         return {
-          actionName: action.name,
-          parameters: action.extractParams(match)
+          name: gameAction.name,
+          parameters: gameAction.extractParams(match),
+          targetPlayerIds: readTargetPlayerIds(params, text)
         };
       }
     }
   }
-  const genericMatch = message.match(/(?:execute|run|do)\s+(\w+)/i);
+  const genericMatch = text.match(/(?:execute|run|do|trigger)\s+(\w+)/i);
   if (genericMatch) {
     return {
-      actionName: genericMatch[1].toLowerCase(),
-      parameters: {}
+      name: genericMatch[1].toLowerCase(),
+      parameters: {},
+      targetPlayerIds: readTargetPlayerIds(params, text)
     };
   }
   return null;
 }
-var executeGameAction = {
-  name: actionName,
-  similes: [],
-  description: "Execute an action in the connected Roblox game.",
-  examples: executeGameActionExamples,
-  validate: async (runtime, message, state, options) => {
-    const __avTextRaw = typeof message?.content?.text === "string" ? message.content.text : "";
-    const __avText = __avTextRaw.toLowerCase();
-    const __avKeywords = ["execute", "roblox"];
-    const __avKeywordOk = __avKeywords.length > 0 && __avKeywords.some((kw) => kw.length > 0 && __avText.includes(kw));
-    const __avRegex = /\b(?:execute|roblox)\b/i;
-    const __avRegexOk = __avRegex.test(__avText);
-    const __avSource = String(message?.content?.source ?? message?.source ?? "");
-    const __avExpectedSource = "";
-    const __avSourceOk = __avExpectedSource ? __avSource === __avExpectedSource : Boolean(__avSource || state || runtime?.agentId || runtime?.getService);
-    const __avOptions = options && typeof options === "object" ? options : {};
-    const __avInputOk = __avText.trim().length > 0 || Object.keys(__avOptions).length > 0 || Boolean(message?.content && typeof message.content === "object");
-    if (!(__avKeywordOk && __avRegexOk && __avSourceOk && __avInputOk)) {
-      return false;
-    }
-    const __avLegacyValidate = async (runtime2) => {
-      const apiKey = runtime2.getSetting("ROBLOX_API_KEY");
-      const universeId = runtime2.getSetting("ROBLOX_UNIVERSE_ID");
-      return Boolean(apiKey && universeId);
-    };
-    try {
-      return Boolean(await __avLegacyValidate(runtime, message, state, options));
-    } catch {
-      return false;
-    }
-  },
-  handler: async (runtime, message, state, _options, callback) => {
-    try {
-      const service = runtime.getService(ROBLOX_SERVICE_NAME);
-      if (!service) {
-        logger.error("Roblox service not found");
-        if (callback) {
-          callback({
-            text: "Roblox service not available.",
-            action: "EXECUTE_ROBLOX_ACTION"
-          });
-        }
-        return {
-          success: false,
-          error: "Roblox service not found"
-        };
-      }
-      const messageContent = state?.message || message.content.text || "";
-      const parsedAction = parseGameAction(messageContent);
-      if (!parsedAction) {
-        logger.warn("Could not parse game action from message");
-        if (callback) {
-          callback({
-            text: "Could not parse action from message.",
-            action: "EXECUTE_ROBLOX_ACTION"
-          });
-        }
-        return {
-          success: false,
-          error: "Could not parse game action from message"
-        };
-      }
-      const { actionName: actionName2, parameters } = parsedAction;
-      const playerIdMatch = messageContent.match(/player\s*(\d+)/i);
-      const targetPlayerIds = playerIdMatch ? [parseInt(playerIdMatch[1], 10)] : undefined;
-      await service.executeAction(runtime.agentId, actionName2, parameters, targetPlayerIds);
-      logger.info({ actionName: actionName2, parameters, targetPlayerIds }, "Executed Roblox game action");
-      if (callback) {
-        callback({
-          text: `I've triggered the "${actionName2}" action in the game.`,
-          action: "EXECUTE_ROBLOX_ACTION"
-        });
-      }
-      return {
-        success: true,
-        text: `Executed "${actionName2}" action in the game`,
-        data: {
-          actionName: actionName2,
-          parameters,
-          targetPlayerIds: targetPlayerIds || undefined
-        }
-      };
-    } catch (error) {
-      logger.error({ error }, "Failed to execute Roblox action");
-      const errorMessage = error instanceof Error ? error.message : "Unknown error";
-      if (callback) {
-        callback({
-          text: "Error executing action.",
-          action: "EXECUTE_ROBLOX_ACTION"
-        });
-      }
-      return {
-        success: false,
-        error: errorMessage
-      };
+function sanitizeParameters(value) {
+  if (!isRecord(value))
+    return {};
+  const out = {};
+  for (const [key, item] of Object.entries(value)) {
+    if (item === null) {
+      out[key] = null;
+    } else if (typeof item === "string" || typeof item === "number" || typeof item === "boolean") {
+      out[key] = item;
     }
   }
-};
-var executeGameAction_default = executeGameAction;
-
-// actions/getPlayerInfo.ts
-import {
-  logger as logger2
-} from "@elizaos/core";
-var actionName2 = "GET_ROBLOX_PLAYER";
-var getPlayerInfoExamples = [
-  [
-    {
-      name: actionName2,
-      content: {
-        text: "Who is player 12345678?"
-      }
-    },
-    {
-      name: actionName2,
-      content: {
-        text: "Let me look up that player's information for you.",
-        action: "GET_ROBLOX_PLAYER"
-      }
-    }
-  ],
-  [
-    {
-      name: "{{user1}}",
-      content: {
-        text: "Look up the Roblox user JohnDoe123"
-      }
-    },
-    {
-      name: "{{agentName}}",
-      content: {
-        text: "I'll find the information for JohnDoe123.",
-        action: "GET_ROBLOX_PLAYER"
-      }
-    }
-  ]
-];
-function extractUserIdentifier(message) {
-  const idMatch = message.match(/\b(?:player|user|id)\s*[:#]?\s*(\d{5,})\b/i);
+  return out;
+}
+function extractUserIdentifier(text, params) {
+  const userId = readNumber(params, "playerId", "userId", "id");
+  if (userId !== null && Number.isInteger(userId) && userId > 0) {
+    return { type: "id", value: userId };
+  }
+  const username = readString(params, "username", "playerName", "user");
+  if (username && !/^\d+$/.test(username)) {
+    return { type: "username", value: username };
+  }
+  const idMatch = text.match(/\b(?:player|user|id)\s*[:#]?\s*(\d{5,})\b/i);
   if (idMatch) {
-    return { type: "id", value: parseInt(idMatch[1], 10) };
+    return { type: "id", value: Number.parseInt(idMatch[1], 10) };
   }
-  const usernameMatch = message.match(/\b(?:user(?:name)?|player)\s*[:#]?\s*([A-Za-z0-9_]{3,20})\b/i);
-  if (usernameMatch) {
-    const username = usernameMatch[1];
-    if (!/^\d+$/.test(username)) {
-      return { type: "username", value: username };
-    }
+  const usernameMatch = text.match(/\b(?:user(?:name)?|player)\s*[:#]?\s*([A-Za-z0-9_]{3,20})\b/i);
+  if (usernameMatch && !/^\d+$/.test(usernameMatch[1])) {
+    return { type: "username", value: usernameMatch[1] };
   }
   return null;
 }
-var getPlayerInfo = {
-  name: actionName2,
-  similes: [],
-  description: "Fetch Roblox player information by username or user id.",
-  examples: getPlayerInfoExamples,
-  validate: async (runtime, message, state, options) => {
-    const __avTextRaw = typeof message?.content?.text === "string" ? message.content.text : "";
-    const __avText = __avTextRaw.toLowerCase();
-    const __avKeywords = ["get", "roblox", "player"];
-    const __avKeywordOk = __avKeywords.length > 0 && __avKeywords.some((kw) => kw.length > 0 && __avText.includes(kw));
-    const __avRegex = /\b(?:get|roblox|player)\b/i;
-    const __avRegexOk = __avRegex.test(__avText);
-    const __avSource = String(message?.content?.source ?? message?.source ?? "");
-    const __avExpectedSource = "";
-    const __avSourceOk = __avExpectedSource ? __avSource === __avExpectedSource : Boolean(__avSource || state || runtime?.agentId || runtime?.getService);
-    const __avOptions = options && typeof options === "object" ? options : {};
-    const __avInputOk = __avText.trim().length > 0 || Object.keys(__avOptions).length > 0 || Boolean(message?.content && typeof message.content === "object");
-    if (!(__avKeywordOk && __avRegexOk && __avSourceOk && __avInputOk)) {
-      return false;
+async function handleMessage(runtime, service, message, state, params, callback) {
+  const content = readString(params, "message", "text", "content") ?? (typeof state?.message === "string" ? state.message : undefined) ?? (message.content.text ?? "").trim();
+  if (!content) {
+    await callback?.({ text: "I need a message to send to the Roblox game.", action: actionName });
+    return { success: false, error: "No message content to send" };
+  }
+  const targetPlayerIds = readTargetPlayerIds(params, content);
+  const cappedContent = content.slice(0, MAX_ROBLOX_MESSAGE_LENGTH);
+  await withRobloxTimeout(service.sendMessage(runtime.agentId, cappedContent, targetPlayerIds), "roblox message");
+  const targetText = targetPlayerIds && targetPlayerIds.length > 0 ? `to ${targetPlayerIds.length} player(s)` : "to all players";
+  await callback?.({ text: `Sent Roblox message ${targetText}.`, action: actionName });
+  return {
+    success: true,
+    text: `Sent Roblox message ${targetText}`,
+    data: { subaction: "message", targetPlayerIds, messageLength: cappedContent.length }
+  };
+}
+async function handleExecute(runtime, service, message, params, callback) {
+  const parsedAction = parseGameAction(message.content.text ?? "", params);
+  if (!parsedAction) {
+    await callback?.({ text: "Could not parse Roblox game action.", action: actionName });
+    return { success: false, error: "Could not parse Roblox game action" };
+  }
+  await withRobloxTimeout(service.executeAction(runtime.agentId, parsedAction.name, parsedAction.parameters, parsedAction.targetPlayerIds), "roblox execute");
+  await callback?.({ text: `Triggered Roblox action "${parsedAction.name}".`, action: actionName });
+  return {
+    success: true,
+    text: `Executed Roblox action "${parsedAction.name}"`,
+    data: {
+      subaction: "execute",
+      actionName: parsedAction.name,
+      parameters: parsedAction.parameters,
+      targetPlayerIds: parsedAction.targetPlayerIds
     }
-    const __avLegacyValidate = async (runtime2) => {
-      const apiKey = runtime2.getSetting("ROBLOX_API_KEY");
-      return Boolean(apiKey);
+  };
+}
+async function handleGetPlayer(runtime, service, message, params, callback) {
+  const client = service.getClient(runtime.agentId);
+  if (!client) {
+    await callback?.({ text: "The Roblox client is not available.", action: actionName });
+    return { success: false, error: "Roblox client not found for agent" };
+  }
+  const identifier = extractUserIdentifier(message.content.text ?? "", params);
+  if (!identifier) {
+    await callback?.({
+      text: "I need a Roblox player ID or username to look up.",
+      action: actionName
+    });
+    return { success: false, error: "Could not extract Roblox player identifier" };
+  }
+  let user;
+  if (identifier.type === "id") {
+    user = await withRobloxTimeout(client.getUserById(identifier.value), "roblox get user");
+  } else {
+    user = await withRobloxTimeout(client.getUserByUsername(identifier.value), "roblox get user");
+  }
+  if (!user) {
+    await callback?.({
+      text: `No Roblox user found for ${identifier.type}: ${identifier.value}.`,
+      action: actionName
+    });
+    return {
+      success: true,
+      text: `Roblox user not found for ${identifier.type}: ${identifier.value}`,
+      data: { subaction: "get_player", found: false, identifier }
     };
-    try {
-      return Boolean(await __avLegacyValidate(runtime, message, state, options));
-    } catch {
-      return false;
-    }
-  },
-  handler: async (runtime, message, state, _options, callback) => {
-    try {
-      const service = runtime.getService(ROBLOX_SERVICE_NAME);
-      if (!service) {
-        logger2.error("Roblox service not found");
-        if (callback) {
-          callback({
-            text: "I couldn't connect to the Roblox service.",
-            action: "GET_ROBLOX_PLAYER"
-          });
-        }
-        return {
-          success: false,
-          error: "Roblox service not found"
-        };
-      }
-      const client = service.getClient(runtime.agentId);
-      if (!client) {
-        logger2.error("Roblox client not found for agent");
-        if (callback) {
-          callback({
-            text: "The Roblox client isn't available right now.",
-            action: "GET_ROBLOX_PLAYER"
-          });
-        }
-        return {
-          success: false,
-          error: "Roblox client not found for agent"
-        };
-      }
-      const messageContent = state?.message || message.content.text || "";
-      const identifier = extractUserIdentifier(messageContent);
-      if (!identifier) {
-        logger2.warn("Could not extract user identifier from message");
-        if (callback) {
-          callback({
-            text: "I need a player ID or username to look up. Please provide one.",
-            action: "GET_ROBLOX_PLAYER"
-          });
-        }
-        return {
-          success: false,
-          error: "Could not extract user identifier from message"
-        };
-      }
-      let user;
-      if (identifier.type === "id") {
-        user = await client.getUserById(identifier.value);
-      } else {
-        user = await client.getUserByUsername(identifier.value);
-      }
-      if (!user) {
-        if (callback) {
-          callback({
-            text: `I couldn't find a Roblox user with that ${identifier.type === "id" ? "ID" : "username"}.`,
-            action: "GET_ROBLOX_PLAYER"
-          });
-        }
-        return {
-          success: true,
-          text: `User not found with ${identifier.type === "id" ? "ID" : "username"}: ${identifier.value}`
-        };
-      }
-      const avatarUrl = await client.getAvatarUrl(user.id);
-      user.avatarUrl = avatarUrl;
-      logger2.info({ userId: user.id, username: user.username }, "Found Roblox user");
-      if (callback) {
-        const createdDate = user.createdAt ? user.createdAt.toLocaleDateString() : "Unknown";
-        const bannedStatus = user.isBanned ? " (Banned)" : "";
-        callback({
-          text: `**${user.displayName}** (@${user.username})${bannedStatus}
-- User ID: ${user.id}
-- Account created: ${createdDate}`,
-          action: "GET_ROBLOX_PLAYER"
-        });
-      }
-      return {
-        success: true,
-        text: `Found Roblox user: ${user.displayName} (@${user.username})`,
-        data: {
-          userId: user.id,
-          username: user.username,
-          displayName: user.displayName,
-          avatarUrl: avatarUrl || undefined,
-          isBanned: user.isBanned,
-          createdAt: user.createdAt ? user.createdAt.toISOString() : undefined
-        }
-      };
-    } catch (error) {
-      logger2.error({ error }, "Failed to get Roblox player info");
-      const errorMessage = error instanceof Error ? error.message : "Unknown error";
-      if (callback) {
-        callback({
-          text: "I encountered an error looking up that player. Please try again.",
-          action: "GET_ROBLOX_PLAYER"
-        });
-      }
-      return {
-        success: false,
-        error: errorMessage
-      };
-    }
   }
-};
-var getPlayerInfo_default = getPlayerInfo;
-
-// actions/sendGameMessage.ts
-import {
-  logger as logger3
-} from "@elizaos/core";
-var actionName3 = "SEND_ROBLOX_MESSAGE";
-var sendGameMessageExamples = [
-  [
+  const avatarUrl = await withRobloxTimeout(client.getAvatarUrl(user.id), "roblox avatar");
+  user.avatarUrl = avatarUrl;
+  await callback?.({
+    text: `${user.displayName} (@${user.username}) - Roblox user ID ${user.id}`,
+    action: actionName
+  });
+  return {
+    success: true,
+    text: `Found Roblox user: ${user.displayName} (@${user.username})`,
+    data: {
+      subaction: "get_player",
+      found: true,
+      userId: user.id,
+      username: user.username,
+      displayName: user.displayName,
+      avatarUrl: avatarUrl || undefined,
+      isBanned: user.isBanned,
+      createdAt: user.createdAt ? user.createdAt.toISOString() : undefined
+    }
+  };
+}
+var robloxAction = {
+  name: actionName,
+  contexts: ["media", "automation"],
+  contextGate: { anyOf: ["media", "automation"] },
+  roleGate: { minRole: "USER" },
+  similes: ["ROBLOX", "ROBLOX_ROUTER", "ROBLOX_GAME_ACTION"],
+  description: "Route Roblox game integration with action message, execute, or get_player.",
+  descriptionCompressed: "Route Roblox action: message, execute, or get_player.",
+  parameters: [
     {
-      name: actionName3,
-      content: {
-        text: "Tell everyone in the game that there's a special event happening"
-      }
+      name: "action",
+      description: "Roblox operation: message, execute, or get_player.",
+      descriptionCompressed: "Roblox action.",
+      required: true,
+      schema: { type: "string", enum: ["message", "execute", "get_player"] }
     },
     {
-      name: actionName3,
-      content: {
-        text: "I'll announce the special event to all players in the game!",
-        action: "SEND_ROBLOX_MESSAGE"
-      }
-    }
-  ],
-  [
+      name: "message",
+      description: "Message content for the message subaction.",
+      descriptionCompressed: "message text",
+      required: false,
+      schema: { type: "string" }
+    },
     {
-      name: "{{user1}}",
-      content: {
-        text: "Send a message to player123 welcoming them to the game"
-      }
+      name: "actionName",
+      description: "Game-side action name for execute.",
+      descriptionCompressed: "game action name",
+      required: false,
+      schema: { type: "string" }
     },
     {
-      name: "{{agentName}}",
-      content: {
-        text: "I'll send a personalized welcome message to player123.",
-        action: "SEND_ROBLOX_MESSAGE"
-      }
+      name: "parameters",
+      description: "Game-side action parameters for execute.",
+      descriptionCompressed: "game action params",
+      required: false,
+      schema: { type: "object" }
+    },
+    {
+      name: "targetPlayerIds",
+      description: "Roblox player IDs to target for message or execute.",
+      descriptionCompressed: "target player ids",
+      required: false,
+      schema: { type: "array", items: { type: "number" } }
+    },
+    {
+      name: "playerId",
+      description: "Roblox player/user ID for lookup or targeting.",
+      descriptionCompressed: "Roblox user id",
+      required: false,
+      schema: { type: "number" }
+    },
+    {
+      name: "username",
+      description: "Roblox username for lookup.",
+      descriptionCompressed: "Roblox username",
+      required: false,
+      schema: { type: "string" }
     }
-  ]
-];
-var sendGameMessage = {
-  name: actionName3,
-  similes: [],
-  description: "Send a message to players in the Roblox game.",
-  examples: sendGameMessageExamples,
-  validate: async (runtime, message, state, options) => {
-    const __avTextRaw = typeof message?.content?.text === "string" ? message.content.text : "";
-    const __avText = __avTextRaw.toLowerCase();
-    const __avKeywords = ["send", "roblox", "message"];
-    const __avKeywordOk = __avKeywords.length > 0 && __avKeywords.some((kw) => kw.length > 0 && __avText.includes(kw));
-    const __avRegex = /\b(?:send|roblox|message)\b/i;
-    const __avRegexOk = __avRegex.test(__avText);
-    const __avSource = String(message?.content?.source ?? message?.source ?? "");
-    const __avExpectedSource = "";
-    const __avSourceOk = __avExpectedSource ? __avSource === __avExpectedSource : Boolean(__avSource || state || runtime?.agentId || runtime?.getService);
-    const __avOptions = options && typeof options === "object" ? options : {};
-    const __avInputOk = __avText.trim().length > 0 || Object.keys(__avOptions).length > 0 || Boolean(message?.content && typeof message.content === "object");
-    if (!(__avKeywordOk && __avRegexOk && __avSourceOk && __avInputOk)) {
+  ],
+  validate: async (runtime, message, _state) => {
+    const params = parseJsonObject(message.content.text ?? "");
+    const hasIntent = Boolean(normalizeSubaction(readString(params, "subaction", "action", "type"))) || /\b(roblox|player|user|send|message|announce|execute|trigger|teleport|spawn|coins|lookup|look up)\b/i.test(message.content.text ?? "");
+    if (!hasIntent)
       return false;
+    const apiKey = runtime.getSetting("ROBLOX_API_KEY");
+    const universeId = runtime.getSetting("ROBLOX_UNIVERSE_ID");
+    return Boolean(apiKey && universeId);
+  },
+  handler: async (runtime, message, state, options, callback) => {
+    const service = runtime.getService(ROBLOX_SERVICE_NAME);
+    if (!service) {
+      logger.error("Roblox service not found");
+      await callback?.({ text: "Roblox service not available.", action: actionName });
+      return { success: false, error: "Roblox service not found" };
     }
-    const __avLegacyValidate = async (runtime2) => {
-      const apiKey = runtime2.getSetting("ROBLOX_API_KEY");
-      const universeId = runtime2.getSetting("ROBLOX_UNIVERSE_ID");
-      return Boolean(apiKey && universeId);
-    };
-    try {
-      return Boolean(await __avLegacyValidate(runtime, message, state, options));
-    } catch {
-      return false;
+    const params = mergedInput(message, options);
+    const maxRobloxTargetIds = MAX_ROBLOX_TARGET_IDS;
+    if (Array.isArray(params.targetPlayerIds)) {
+      params.targetPlayerIds = params.targetPlayerIds.slice(0, maxRobloxTargetIds);
     }
-  },
-  handler: async (runtime, message, state, _options, callback) => {
+    const subaction = inferSubaction(message.content.text ?? "", params);
     try {
-      const service = runtime.getService(ROBLOX_SERVICE_NAME);
-      if (!service) {
-        logger3.error("Roblox service not found");
-        if (callback) {
-          callback({
-            text: "Roblox service not available.",
-            action: "SEND_ROBLOX_MESSAGE"
-          });
-        }
-        return {
-          success: false,
-          error: "Roblox service not found"
-        };
+      if (subaction === "message") {
+        return await handleMessage(runtime, service, message, state, params, callback);
       }
-      const messageContent = state?.message || message.content.text || "";
-      if (!messageContent) {
-        logger3.warn("No message content to send");
-        if (callback) {
-          callback({
-            text: "I need a message to send to the game.",
-            action: "SEND_ROBLOX_MESSAGE"
-          });
-        }
-        return {
-          success: false,
-          error: "No message content to send"
-        };
+      if (subaction === "execute") {
+        return await handleExecute(runtime, service, message, params, callback);
       }
-      const targetPlayerIds = extractPlayerIds(messageContent);
-      await service.sendMessage(runtime.agentId, messageContent, targetPlayerIds);
-      logger3.info({ targetPlayerIds, messageLength: messageContent.length }, "Sent message to Roblox game");
-      if (callback) {
-        const targetInfo = targetPlayerIds && targetPlayerIds.length > 0 ? `to ${targetPlayerIds.length} specific player(s)` : "to all players";
-        callback({
-          text: `I've sent the message ${targetInfo} in the game.`,
-          action: "SEND_ROBLOX_MESSAGE"
-        });
+      if (subaction === "get_player") {
+        return await handleGetPlayer(runtime, service, message, params, callback);
       }
       return {
-        success: true,
-        text: `Sent message ${targetPlayerIds && targetPlayerIds.length > 0 ? `to ${targetPlayerIds.length} specific player(s)` : "to all players"} in the game`,
-        data: {
-          targetPlayerIds,
-          messageLength: messageContent.length
-        }
+        success: false,
+        error: "Missing Roblox subaction",
+        text: "Missing Roblox subaction"
       };
     } catch (error) {
-      logger3.error({ error }, "Failed to send Roblox message");
+      logger.error({ error }, "Roblox action failed");
       const errorMessage = error instanceof Error ? error.message : "Unknown error";
-      if (callback) {
-        callback({
-          text: "Error sending message.",
-          action: "SEND_ROBLOX_MESSAGE"
-        });
-      }
-      return {
-        success: false,
-        error: errorMessage
-      };
+      await callback?.({ text: `Roblox action failed: ${errorMessage}`, action: actionName });
+      return { success: false, error: errorMessage };
     }
-  }
+  },
+  examples: [
+    [
+      {
+        name: "{{user1}}",
+        content: { text: "Tell everyone in Roblox that the event starts now" }
+      },
+      {
+        name: "{{agentName}}",
+        content: {
+          text: "I'll send that message to the Roblox game.",
+          action: actionName
+        }
+      }
+    ]
+  ]
 };
-function extractPlayerIds(message) {
-  const playerIdPattern = /\bplayer\s*(\d+)\b/gi;
-  const matches = [...message.matchAll(playerIdPattern)];
-  if (matches.length > 0) {
-    return matches.map((m) => parseInt(m[1], 10));
-  }
-  return;
-}
-var sendGameMessage_default = sendGameMessage;
+var robloxAction_default = robloxAction;
 
 // actions/index.ts
-var robloxActions = [sendGameMessage_default, executeGameAction_default, getPlayerInfo_default];
+var robloxActions = [robloxAction_default];
 
 // providers/gameStateProvider.ts
 var providerName = "roblox-game-state";
+var EXPERIENCE_NAME_LIMIT = 160;
 var gameStateProvider = {
   name: providerName,
   description: "Provides information about the connected Roblox game/experience",
+  descriptionCompressed: "Read Roblox connection state, experience metadata, and messaging topic.",
+  contexts: ["automation", "agent_internal"],
+  contextGate: { anyOf: ["automation", "agent_internal"] },
+  cacheStable: false,
+  cacheScope: "turn",
   get: async (runtime, _message, _state) => {
+    const apiKeyConfigured = Boolean(runtime.getSetting("ROBLOX_API_KEY"));
+    const universeIdSetting = runtime.getSetting("ROBLOX_UNIVERSE_ID");
+    const universeId = typeof universeIdSetting === "string" ? universeIdSetting : undefined;
+    const configured = apiKeyConfigured && Boolean(universeId);
     try {
       const service = runtime.getService(ROBLOX_SERVICE_NAME);
       if (!service) {
-        return { text: "", data: {}, values: {} };
+        return {
+          text: [
+            "Roblox:",
+            `configured: ${configured}`,
+            "service: unavailable",
+            `apiKey: ${apiKeyConfigured ? "configured" : "missing"}`,
+            `universeId: ${universeId ?? "missing"}`
+          ].join(`
+`),
+          data: {
+            configured,
+            apiKeyConfigured,
+            universeId: universeId ?? null,
+            serviceAvailable: false,
+            clientAvailable: false
+          },
+          values: {
+            configured,
+            serviceAvailable: false,
+            clientAvailable: false
+          }
+        };
       }
       const client = service.getClient(runtime.agentId);
       if (!client) {
-        return { text: "", data: {}, values: {} };
+        return {
+          text: [
+            "Roblox:",
+            `configured: ${configured}`,
+            "service: available",
+            "client: unavailable",
+            `apiKey: ${apiKeyConfigured ? "configured" : "missing"}`,
+            `universeId: ${universeId ?? "missing"}`
+          ].join(`
+`),
+          data: {
+            configured,
+            apiKeyConfigured,
+            universeId: universeId ?? null,
+            serviceAvailable: true,
+            clientAvailable: false
+          },
+          values: {
+            configured,
+            serviceAvailable: true,
+            clientAvailable: false
+          }
+        };
       }
       const config = client.getConfig();
       let experienceInfo = null;
@@ -628,33 +551,64 @@ var gameStateProvider = {
         experienceInfo = null;
       }
       const parts = [
-        "## Roblox Game Connection",
-        "",
-        `- **Universe ID**: ${config.universeId}`
+        "Roblox:",
+        "configured: true",
+        "service: available",
+        "client: available",
+        `universeId: ${config.universeId}`
       ];
       if (config.placeId) {
-        parts.push(`- **Place ID**: ${config.placeId}`);
+        parts.push(`placeId: ${config.placeId}`);
       }
       if (experienceInfo) {
-        parts.push(`- **Experience Name**: ${experienceInfo.name}`);
+        parts.push(`experienceName: ${experienceInfo.name.slice(0, EXPERIENCE_NAME_LIMIT)}`);
         if (experienceInfo.playing !== undefined) {
-          parts.push(`- **Active Players**: ${experienceInfo.playing}`);
+          parts.push(`activePlayers: ${experienceInfo.playing}`);
         }
         if (experienceInfo.visits !== undefined) {
-          parts.push(`- **Total Visits**: ${experienceInfo.visits.toLocaleString()}`);
+          parts.push(`totalVisits: ${experienceInfo.visits}`);
         }
-        parts.push(`- **Creator**: ${experienceInfo.creator.name} (${experienceInfo.creator.type})`);
+        parts.push(`creator: ${experienceInfo.creator.name} (${experienceInfo.creator.type})`);
+      } else {
+        parts.push("experience: unavailable");
       }
-      parts.push(`- **Messaging Topic**: ${config.messagingTopic}`);
+      parts.push(`messagingTopic: ${config.messagingTopic}`);
       if (config.dryRun) {
-        parts.push("");
-        parts.push("*Dry run mode is enabled - actions are simulated*");
+        parts.push("dryRun: true");
       }
-      return { text: parts.join(`
-`), data: {}, values: {} };
+      return {
+        text: parts.join(`
+`),
+        data: {
+          configured: true,
+          serviceAvailable: true,
+          clientAvailable: true,
+          universeId: config.universeId,
+          placeId: config.placeId ?? null,
+          messagingTopic: config.messagingTopic,
+          dryRun: config.dryRun,
+          experienceInfo
+        },
+        values: {
+          configured: true,
+          serviceAvailable: true,
+          clientAvailable: true,
+          universeId: config.universeId,
+          placeId: config.placeId ?? null,
+          messagingTopic: config.messagingTopic,
+          dryRun: config.dryRun,
+          experienceName: experienceInfo?.name ?? null,
+          activePlayers: experienceInfo?.playing ?? null
+        }
+      };
     } catch (error) {
       runtime.logger.error({ error }, "Error in gameStateProvider");
-      return { text: "", data: {}, values: {} };
+      const message = error instanceof Error ? error.message : String(error);
+      return {
+        text: `Roblox provider error: ${message}`,
+        data: { configured, error: message },
+        values: { configured, error: true }
+      };
     }
   }
 };
@@ -876,7 +830,6 @@ class RobloxClient {
 // utils/config.ts
 var ROBLOX_DEFAULTS = {
   MESSAGING_TOPIC: "eliza-agent",
-  POLL_INTERVAL: 30,
   DRY_RUN: false
 };
 function hasRobloxEnabled(runtime) {
@@ -896,8 +849,6 @@ function validateRobloxConfig(runtime) {
   const placeId = runtime.getSetting("ROBLOX_PLACE_ID");
   const webhookSecret = runtime.getSetting("ROBLOX_WEBHOOK_SECRET");
   const messagingTopic = runtime.getSetting("ROBLOX_MESSAGING_TOPIC") || ROBLOX_DEFAULTS.MESSAGING_TOPIC;
-  const pollIntervalStr = runtime.getSetting("ROBLOX_POLL_INTERVAL");
-  const pollInterval = pollIntervalStr ? parseInt(pollIntervalStr, 10) : ROBLOX_DEFAULTS.POLL_INTERVAL;
   const dryRunStr = runtime.getSetting("ROBLOX_DRY_RUN");
   const dryRun = dryRunStr === "true";
   return {
@@ -906,7 +857,6 @@ function validateRobloxConfig(runtime) {
     placeId,
     webhookSecret,
     messagingTopic,
-    pollInterval,
     dryRun
   };
 }
@@ -916,7 +866,6 @@ class RobloxAgentManager {
   runtime;
   client;
   config;
-  pollTimer = null;
   isRunning = false;
   constructor(runtime, config) {
     this.runtime = runtime;
@@ -929,35 +878,11 @@ class RobloxAgentManager {
     }
     this.isRunning = true;
     this.runtime.logger.info({ universeId: this.config.universeId }, "Roblox agent manager started");
-    if (this.config.pollInterval > 0) {
-      this.startPolling();
-    }
   }
   async stop() {
     this.isRunning = false;
-    this.stopPolling();
     this.runtime.logger.info("Roblox agent manager stopped");
   }
-  startPolling() {
-    if (this.pollTimer) {
-      return;
-    }
-    const pollIntervalMs = this.config.pollInterval * 1000;
-    this.pollTimer = setInterval(() => {
-      this.poll().catch((error) => {
-        this.runtime.logger.error({ error }, "Error during Roblox polling");
-      });
-    }, pollIntervalMs);
-    this.runtime.logger.debug({ intervalSeconds: this.config.pollInterval }, "Roblox polling started");
-  }
-  stopPolling() {
-    if (this.pollTimer) {
-      clearInterval(this.pollTimer);
-      this.pollTimer = null;
-      this.runtime.logger.debug("Roblox polling stopped");
-    }
-  }
-  async poll() {}
   async sendMessage(content, targetPlayerIds) {
     await this.client.sendAgentMessage({
       topic: this.config.messagingTopic,
@@ -973,12 +898,12 @@ class RobloxAgentManager {
       }
     });
   }
-  async executeAction(actionName4, parameters, targetPlayerIds) {
+  async executeAction(actionName2, parameters, targetPlayerIds) {
     await this.client.sendAgentMessage({
       topic: this.config.messagingTopic,
       data: {
         type: "agent_action",
-        action: actionName4,
+        action: actionName2,
         parameters,
         targetPlayerIds,
         timestamp: Date.now()
@@ -1059,12 +984,12 @@ class RobloxService extends Service {
     }
     await manager.sendMessage(content, targetPlayerIds);
   }
-  async executeAction(agentId, actionName4, parameters, targetPlayerIds) {
+  async executeAction(agentId, actionName2, parameters, targetPlayerIds) {
     const manager = this.managers.get(agentId);
     if (!manager) {
       throw new Error(`No Roblox manager found for agent ${agentId}`);
     }
-    await manager.executeAction(actionName4, parameters, targetPlayerIds);
+    await manager.executeAction(actionName2, parameters, targetPlayerIds);
   }
   async healthCheck() {
     const managerStatuses = {};
@@ -1121,13 +1046,13 @@ var robloxPlugin = {
     runtime.logger.info({ universeId }, "Roblox plugin initialized");
   }
 };
-var typescript_default = robloxPlugin;
+var plugin_roblox_default = robloxPlugin;
 export {
   robloxPlugin,
-  typescript_default as default,
+  plugin_roblox_default as default,
   RobloxService,
   RobloxClient,
   RobloxApiError
 };
 
-//# debugId=740C50B5F8DE5EDA64756E2164756E21
+//# debugId=A93F5CB897AB162864756E2164756E21