@elizaos/plugin-roblox 2.0.3-beta.6 → 2.0.3-beta.7

package/dist/index.js

@@ -0,0 +1,1062 @@
+// types/index.ts
+var ROBLOX_SERVICE_NAME = "roblox";
+
+// __tests__/suite.ts
+class RobloxTestSuite {
+  name = "roblox";
+  description = "Test suite for Roblox plugin";
+  tests = [
+    {
+      name: "Service initialization",
+      fn: async (runtime) => {
+        const service = runtime.getService(ROBLOX_SERVICE_NAME);
+        const apiKey = runtime.getSetting("ROBLOX_API_KEY");
+        const universeId = runtime.getSetting("ROBLOX_UNIVERSE_ID");
+        if (apiKey && universeId) {
+          if (!service) {
+            throw new Error("Roblox service should be initialized when API key and Universe ID are provided");
+          }
+        } else {
+          runtime.logger.info("Roblox service not initialized - missing configuration (expected)");
+        }
+      }
+    },
+    {
+      name: "Configuration validation",
+      fn: async (runtime) => {
+        const apiKey = runtime.getSetting("ROBLOX_API_KEY");
+        const universeId = runtime.getSetting("ROBLOX_UNIVERSE_ID");
+        if (apiKey && universeId) {
+          const service = runtime.getService(ROBLOX_SERVICE_NAME);
+          if (!service) {
+            throw new Error("Service should exist when properly configured");
+          }
+          const client = service.getClient(runtime.agentId);
+          if (!client) {
+            throw new Error("Client should exist for agent");
+          }
+          const config = client.getConfig();
+          if (config.universeId !== universeId) {
+            throw new Error("Universe ID mismatch in config");
+          }
+        }
+      }
+    },
+    {
+      name: "Actions registered",
+      fn: async (runtime) => {
+        runtime.logger.info("Roblox actions registration check passed");
+      }
+    }
+  ];
+}
+
+// actions/robloxAction.ts
+import {
+  logger
+} from "@elizaos/core";
+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: [
+      /(?:move|walk)\s+(?:the\s+)?(?:npc|bot|agent)?\s*(?:to|towards)\s+(?:the\s+)?(\w+)/i,
+      /(?:move|walk)\s+to\s+\(?(-?\d+(?:\.\d+)?)\s*,\s*(-?\d+(?:\.\d+)?)\s*,\s*(-?\d+(?:\.\d+)?)\)?/i
+    ],
+    extractParams: (match) => {
+      if (match.length >= 4 && match[1] && match[2] && match[3]) {
+        return {
+          x: Number.parseFloat(match[1]),
+          y: Number.parseFloat(match[2]),
+          z: Number.parseFloat(match[3])
+        };
+      }
+      return { waypoint: match[1] ?? "" };
+    }
+  },
+  {
+    name: "give_coins",
+    patterns: [/give\s+(?:player\s*)?(\d+)\s+(\d+)\s+coins?/i],
+    extractParams: (match) => ({
+      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] })
+  },
+  {
+    name: "spawn_entity",
+    patterns: [/spawn\s+(?:a\s+)?(\w+)\s+at\s+(\w+)/i],
+    extractParams: (match) => ({
+      entityType: match[1],
+      location: match[2]
+    })
+  },
+  {
+    name: "start_event",
+    patterns: [/start\s+(?:a\s+)?(\w+)\s+(?:show|event|celebration)/i],
+    extractParams: (match) => ({ eventType: match[1] })
+  }
+];
+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 {
+          name: gameAction.name,
+          parameters: gameAction.extractParams(match),
+          targetPlayerIds: readTargetPlayerIds(params, text)
+        };
+      }
+    }
+  }
+  const genericMatch = text.match(/(?:execute|run|do|trigger)\s+(\w+)/i);
+  if (genericMatch) {
+    return {
+      name: genericMatch[1].toLowerCase(),
+      parameters: {},
+      targetPlayerIds: readTargetPlayerIds(params, text)
+    };
+  }
+  return null;
+}
+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;
+    }
+  }
+  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: Number.parseInt(idMatch[1], 10) };
+  }
+  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;
+}
+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
+    }
+  };
+}
+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 }
+    };
+  }
+  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: "action",
+      description: "Roblox operation: message, execute, or get_player.",
+      descriptionCompressed: "Roblox action.",
+      required: true,
+      schema: { type: "string", enum: ["message", "execute", "get_player"] }
+    },
+    {
+      name: "message",
+      description: "Message content for the message subaction.",
+      descriptionCompressed: "message text",
+      required: false,
+      schema: { type: "string" }
+    },
+    {
+      name: "actionName",
+      description: "Game-side action name for execute.",
+      descriptionCompressed: "game action name",
+      required: false,
+      schema: { type: "string" }
+    },
+    {
+      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" }
+    }
+  ],
+  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 params = mergedInput(message, options);
+    const maxRobloxTargetIds = MAX_ROBLOX_TARGET_IDS;
+    if (Array.isArray(params.targetPlayerIds)) {
+      params.targetPlayerIds = params.targetPlayerIds.slice(0, maxRobloxTargetIds);
+    }
+    const subaction = inferSubaction(message.content.text ?? "", params);
+    try {
+      if (subaction === "message") {
+        return await handleMessage(runtime, service, message, state, params, callback);
+      }
+      if (subaction === "execute") {
+        return await handleExecute(runtime, service, message, params, callback);
+      }
+      if (subaction === "get_player") {
+        return await handleGetPlayer(runtime, service, message, params, callback);
+      }
+      return {
+        success: false,
+        error: "Missing Roblox subaction",
+        text: "Missing Roblox subaction"
+      };
+    } catch (error) {
+      logger.error({ error }, "Roblox action failed");
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      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
+        }
+      }
+    ]
+  ]
+};
+var robloxAction_default = robloxAction;
+
+// actions/index.ts
+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: [
+            "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: [
+            "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;
+      try {
+        experienceInfo = await client.getExperienceInfo();
+      } catch {
+        experienceInfo = null;
+      }
+      const parts = [
+        "Roblox:",
+        "configured: true",
+        "service: available",
+        "client: available",
+        `universeId: ${config.universeId}`
+      ];
+      if (config.placeId) {
+        parts.push(`placeId: ${config.placeId}`);
+      }
+      if (experienceInfo) {
+        parts.push(`experienceName: ${experienceInfo.name.slice(0, EXPERIENCE_NAME_LIMIT)}`);
+        if (experienceInfo.playing !== undefined) {
+          parts.push(`activePlayers: ${experienceInfo.playing}`);
+        }
+        if (experienceInfo.visits !== undefined) {
+          parts.push(`totalVisits: ${experienceInfo.visits}`);
+        }
+        parts.push(`creator: ${experienceInfo.creator.name} (${experienceInfo.creator.type})`);
+      } else {
+        parts.push("experience: unavailable");
+      }
+      parts.push(`messagingTopic: ${config.messagingTopic}`);
+      if (config.dryRun) {
+        parts.push("dryRun: true");
+      }
+      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");
+      const message = error instanceof Error ? error.message : String(error);
+      return {
+        text: `Roblox provider error: ${message}`,
+        data: { configured, error: message },
+        values: { configured, error: true }
+      };
+    }
+  }
+};
+
+// providers/index.ts
+var robloxProviders = [gameStateProvider];
+
+// services/RobloxService.ts
+import { Service } from "@elizaos/core";
+
+// client/RobloxClient.ts
+import { logger as logger2 } from "@elizaos/core";
+var ROBLOX_API_BASE = "https://apis.roblox.com";
+var USERS_API_BASE = "https://users.roblox.com";
+
+class RobloxApiError extends Error {
+  statusCode;
+  endpoint;
+  details;
+  constructor(message, statusCode, endpoint, details) {
+    super(message);
+    this.statusCode = statusCode;
+    this.endpoint = endpoint;
+    this.details = details;
+    this.name = "RobloxApiError";
+  }
+}
+
+class RobloxClient {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  async request(endpoint, options = {}, baseUrl = ROBLOX_API_BASE) {
+    const url = `${baseUrl}${endpoint}`;
+    const headers = {
+      "x-api-key": this.config.apiKey,
+      "Content-Type": "application/json",
+      ...options.headers || {}
+    };
+    const response = await fetch(url, {
+      ...options,
+      headers
+    });
+    if (!response.ok) {
+      let details;
+      try {
+        details = await response.json();
+      } catch {
+        details = await response.text();
+      }
+      throw new RobloxApiError(`Roblox API error: ${response.statusText}`, response.status, endpoint, details);
+    }
+    const text = await response.text();
+    if (!text) {
+      return {};
+    }
+    return JSON.parse(text);
+  }
+  async publishMessage(topic, data, universeId) {
+    if (this.config.dryRun) {
+      return;
+    }
+    const targetUniverseId = universeId || this.config.universeId;
+    await this.request(`/messaging-service/v1/universes/${targetUniverseId}/topics/${encodeURIComponent(topic)}`, {
+      method: "POST",
+      body: JSON.stringify({ message: JSON.stringify(data) })
+    });
+  }
+  async sendAgentMessage(message) {
+    const payload = {
+      ...message.data
+    };
+    if (message.sender) {
+      payload.sender = message.sender;
+    }
+    await this.publishMessage(message.topic, payload);
+  }
+  async getDataStoreEntry(datastoreName, key, scope = "global") {
+    try {
+      const response = await this.request(`/datastores/v1/universes/${this.config.universeId}/standard-datastores/datastore/entries/entry?datastoreName=${encodeURIComponent(datastoreName)}&scope=${encodeURIComponent(scope)}&entryKey=${encodeURIComponent(key)}`);
+      return {
+        key,
+        value: JSON.parse(response.value),
+        version: response.version,
+        createdAt: new Date(response.createdTime),
+        updatedAt: new Date(response.updatedTime)
+      };
+    } catch (error) {
+      if (error instanceof RobloxApiError && error.statusCode === 404) {
+        return null;
+      }
+      throw error;
+    }
+  }
+  async setDataStoreEntry(datastoreName, key, value, scope = "global") {
+    if (this.config.dryRun) {
+      logger2.info({ datastoreName, key, scope, value }, "[RobloxClient] Dry run: would set DataStore entry");
+      return {
+        key,
+        value,
+        version: "dry-run",
+        createdAt: new Date,
+        updatedAt: new Date
+      };
+    }
+    const response = await this.request(`/datastores/v1/universes/${this.config.universeId}/standard-datastores/datastore/entries/entry?datastoreName=${encodeURIComponent(datastoreName)}&scope=${encodeURIComponent(scope)}&entryKey=${encodeURIComponent(key)}`, {
+      method: "POST",
+      body: JSON.stringify(value)
+    });
+    return {
+      key,
+      value,
+      version: response.version,
+      createdAt: new Date(response.createdTime),
+      updatedAt: new Date(response.updatedTime)
+    };
+  }
+  async deleteDataStoreEntry(datastoreName, key, scope = "global") {
+    if (this.config.dryRun) {
+      logger2.info({ datastoreName, key, scope }, "[RobloxClient] Dry run: would delete DataStore entry");
+      return;
+    }
+    await this.request(`/datastores/v1/universes/${this.config.universeId}/standard-datastores/datastore/entries/entry?datastoreName=${encodeURIComponent(datastoreName)}&scope=${encodeURIComponent(scope)}&entryKey=${encodeURIComponent(key)}`, { method: "DELETE" });
+  }
+  async listDataStoreEntries(datastoreName, scope = "global", prefix, limit = 100) {
+    let url = `/datastores/v1/universes/${this.config.universeId}/standard-datastores/datastore/entries?datastoreName=${encodeURIComponent(datastoreName)}&scope=${encodeURIComponent(scope)}&limit=${limit}`;
+    if (prefix) {
+      url += `&prefix=${encodeURIComponent(prefix)}`;
+    }
+    const response = await this.request(url);
+    return {
+      keys: response.keys.map((k) => k.key),
+      nextPageCursor: response.nextPageCursor
+    };
+  }
+  async getUserById(userId) {
+    const response = await this.request(`/v1/users/${userId}`, {}, USERS_API_BASE);
+    return {
+      id: response.id,
+      username: response.name,
+      displayName: response.displayName,
+      createdAt: new Date(response.created),
+      isBanned: response.isBanned
+    };
+  }
+  async getUserByUsername(username) {
+    try {
+      const response = await this.request(`/v1/usernames/users`, {
+        method: "POST",
+        body: JSON.stringify({
+          usernames: [username],
+          excludeBannedUsers: false
+        })
+      }, USERS_API_BASE);
+      if (response.data.length === 0) {
+        return null;
+      }
+      const user = response.data[0];
+      return {
+        id: user.id,
+        username: user.name,
+        displayName: user.displayName
+      };
+    } catch {
+      return null;
+    }
+  }
+  async getUsersByIds(userIds) {
+    if (userIds.length === 0) {
+      return [];
+    }
+    const response = await this.request(`/v1/users`, {
+      method: "POST",
+      body: JSON.stringify({ userIds, excludeBannedUsers: false })
+    }, USERS_API_BASE);
+    return response.data.map((user) => ({
+      id: user.id,
+      username: user.name,
+      displayName: user.displayName
+    }));
+  }
+  async getAvatarUrl(userId, size = "150x150") {
+    try {
+      const response = await this.request(`/v1/users/avatar-headshot?userIds=${userId}&size=${size}&format=Png`, {}, "https://thumbnails.roblox.com");
+      return response.data[0]?.imageUrl;
+    } catch {
+      return;
+    }
+  }
+  async getExperienceInfo(universeId) {
+    const targetUniverseId = universeId || this.config.universeId;
+    const response = await this.request(`/v1/games?universeIds=${targetUniverseId}`, {}, "https://games.roblox.com");
+    const experience = response.data[0];
+    if (!experience) {
+      throw new RobloxApiError(`Experience not found: ${targetUniverseId}`, 404, `/v1/games?universeIds=${targetUniverseId}`);
+    }
+    return {
+      universeId: targetUniverseId,
+      name: experience.name,
+      description: experience.description,
+      creator: {
+        id: experience.creator.id,
+        type: experience.creator.type,
+        name: experience.creator.name
+      },
+      playing: experience.playing,
+      visits: experience.visits,
+      rootPlaceId: String(experience.rootPlaceId)
+    };
+  }
+  getConfig() {
+    return { ...this.config };
+  }
+  isDryRun() {
+    return this.config.dryRun;
+  }
+}
+
+// utils/config.ts
+var ROBLOX_DEFAULTS = {
+  MESSAGING_TOPIC: "eliza-agent",
+  DRY_RUN: false
+};
+function hasRobloxEnabled(runtime) {
+  const apiKey = runtime.getSetting("ROBLOX_API_KEY");
+  const universeId = runtime.getSetting("ROBLOX_UNIVERSE_ID");
+  return Boolean(apiKey && universeId);
+}
+function validateRobloxConfig(runtime) {
+  const apiKey = runtime.getSetting("ROBLOX_API_KEY");
+  const universeId = runtime.getSetting("ROBLOX_UNIVERSE_ID");
+  if (!apiKey) {
+    throw new Error("ROBLOX_API_KEY is required but not configured");
+  }
+  if (!universeId) {
+    throw new Error("ROBLOX_UNIVERSE_ID is required but not configured");
+  }
+  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 dryRunStr = runtime.getSetting("ROBLOX_DRY_RUN");
+  const dryRun = dryRunStr === "true";
+  return {
+    apiKey,
+    universeId,
+    placeId,
+    webhookSecret,
+    messagingTopic,
+    dryRun
+  };
+}
+
+// services/RobloxService.ts
+class RobloxAgentManager {
+  runtime;
+  client;
+  config;
+  isRunning = false;
+  constructor(runtime, config) {
+    this.runtime = runtime;
+    this.config = config;
+    this.client = new RobloxClient(config);
+  }
+  async start() {
+    if (this.isRunning) {
+      return;
+    }
+    this.isRunning = true;
+    this.runtime.logger.info({ universeId: this.config.universeId }, "Roblox agent manager started");
+  }
+  async stop() {
+    this.isRunning = false;
+    this.runtime.logger.info("Roblox agent manager stopped");
+  }
+  async sendMessage(content, targetPlayerIds) {
+    await this.client.sendAgentMessage({
+      topic: this.config.messagingTopic,
+      data: {
+        type: "agent_message",
+        content,
+        targetPlayerIds,
+        timestamp: Date.now()
+      },
+      sender: {
+        agentId: this.runtime.agentId,
+        agentName: this.runtime.character.name ?? this.runtime.agentId
+      }
+    });
+  }
+  async executeAction(actionName2, parameters, targetPlayerIds) {
+    await this.client.sendAgentMessage({
+      topic: this.config.messagingTopic,
+      data: {
+        type: "agent_action",
+        action: actionName2,
+        parameters,
+        targetPlayerIds,
+        timestamp: Date.now()
+      },
+      sender: {
+        agentId: this.runtime.agentId,
+        agentName: this.runtime.character.name ?? this.runtime.agentId
+      }
+    });
+  }
+}
+
+class RobloxService extends Service {
+  static instance;
+  managers = new Map;
+  static serviceType = ROBLOX_SERVICE_NAME;
+  description = "Roblox integration service for game communication";
+  capabilityDescription = "The agent can communicate with Roblox games and players";
+  static getInstance() {
+    if (!RobloxService.instance) {
+      RobloxService.instance = new RobloxService;
+    }
+    return RobloxService.instance;
+  }
+  async initialize(runtime) {
+    await RobloxService.start(runtime);
+  }
+  static async start(runtime) {
+    const service = RobloxService.getInstance();
+    let manager = service.managers.get(runtime.agentId);
+    if (manager) {
+      runtime.logger.warn({ agentId: runtime.agentId }, "Roblox service already started");
+      return service;
+    }
+    if (!hasRobloxEnabled(runtime)) {
+      runtime.logger.debug({ agentId: runtime.agentId }, "Roblox service not enabled - missing API key or Universe ID");
+      return service;
+    }
+    const robloxConfig = validateRobloxConfig(runtime);
+    manager = new RobloxAgentManager(runtime, robloxConfig);
+    service.managers.set(runtime.agentId, manager);
+    await manager.start();
+    runtime.logger.success({ agentId: runtime.agentId, universeId: robloxConfig.universeId }, "Roblox service started");
+    return service;
+  }
+  static async stop(runtime) {
+    const service = RobloxService.getInstance();
+    const manager = service.managers.get(runtime.agentId);
+    if (manager) {
+      await manager.stop();
+      service.managers.delete(runtime.agentId);
+      runtime.logger.info({ agentId: runtime.agentId }, "Roblox service stopped");
+    } else {
+      runtime.logger.debug({ agentId: runtime.agentId }, "Roblox service not running");
+    }
+  }
+  async stop() {
+    for (const manager of Array.from(this.managers.values())) {
+      const agentId = manager.runtime.agentId;
+      manager.runtime.logger.debug("Stopping Roblox service");
+      try {
+        await RobloxService.stop(manager.runtime);
+      } catch (error) {
+        manager.runtime.logger.error({ agentId, error }, "Error stopping Roblox service");
+      }
+    }
+  }
+  getManager(agentId) {
+    return this.managers.get(agentId);
+  }
+  getClient(agentId) {
+    return this.managers.get(agentId)?.client;
+  }
+  async sendMessage(agentId, content, targetPlayerIds) {
+    const manager = this.managers.get(agentId);
+    if (!manager) {
+      throw new Error(`No Roblox manager found for agent ${agentId}`);
+    }
+    await manager.sendMessage(content, 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(actionName2, parameters, targetPlayerIds);
+  }
+  async healthCheck() {
+    const managerStatuses = {};
+    let overallHealthy = true;
+    for (const [agentId, manager] of Array.from(this.managers.entries())) {
+      try {
+        const experienceInfo = await manager.client.getExperienceInfo();
+        managerStatuses[agentId] = {
+          status: "healthy",
+          universeId: manager.config.universeId,
+          experienceName: experienceInfo.name,
+          playing: experienceInfo.playing
+        };
+      } catch (error) {
+        managerStatuses[agentId] = {
+          status: "unhealthy",
+          error: error instanceof Error ? error.message : "Unknown error"
+        };
+        overallHealthy = false;
+      }
+    }
+    return {
+      healthy: overallHealthy,
+      details: {
+        activeManagers: this.managers.size,
+        managerStatuses
+      }
+    };
+  }
+  getActiveManagers() {
+    return new Map(this.managers);
+  }
+}
+
+// index.ts
+var robloxPlugin = {
+  name: "roblox",
+  description: "Roblox game integration plugin for sending and receiving messages",
+  services: [RobloxService],
+  actions: robloxActions,
+  providers: robloxProviders,
+  tests: [new RobloxTestSuite],
+  init: async (_config, runtime) => {
+    const apiKey = runtime.getSetting("ROBLOX_API_KEY");
+    const universeId = runtime.getSetting("ROBLOX_UNIVERSE_ID");
+    if (!apiKey || apiKey.trim() === "") {
+      runtime.logger.warn("ROBLOX_API_KEY not provided");
+      return;
+    }
+    if (!universeId || universeId.trim() === "") {
+      runtime.logger.warn("ROBLOX_UNIVERSE_ID not provided");
+      return;
+    }
+    runtime.logger.info({ universeId }, "Roblox plugin initialized");
+  },
+  async dispose(runtime) {
+    await runtime.getService(RobloxService.serviceType)?.stop();
+  }
+};
+var plugin_roblox_default = robloxPlugin;
+export {
+  robloxPlugin,
+  plugin_roblox_default as default,
+  RobloxService,
+  RobloxClient,
+  RobloxApiError
+};
+
+//# debugId=3495E3233296F8F764756E2164756E21