@elizaos/plugin-twitch 2.0.0-alpha.3

package/src/index.ts

@@ -0,0 +1,117 @@
+/**
+ * Twitch chat integration plugin for ElizaOS.
+ *
+ * This plugin provides Twitch chat integration using the @twurple library.
+ */
+
+import type { IAgentRuntime, Plugin } from "@elizaos/core";
+import { logger } from "@elizaos/core";
+
+// Service
+export { TwitchService } from "./service.js";
+
+// Types
+export * from "./types.js";
+
+import { joinChannel } from "./actions/joinChannel.js";
+import { leaveChannel } from "./actions/leaveChannel.js";
+import { listChannels } from "./actions/listChannels.js";
+// Actions
+import { sendMessage } from "./actions/sendMessage.js";
+
+export { sendMessage, joinChannel, leaveChannel, listChannels };
+
+// Providers
+import { channelStateProvider } from "./providers/channelState.js";
+import { userContextProvider } from "./providers/userContext.js";
+
+export { channelStateProvider, userContextProvider };
+
+// Import service for plugin
+import { TwitchService } from "./service.js";
+
+/**
+ * Twitch plugin definition.
+ */
+const twitchPlugin: Plugin = {
+  name: "twitch",
+  description:
+    "Twitch chat integration plugin for ElizaOS with real-time messaging",
+
+  services: [TwitchService],
+
+  actions: [sendMessage, joinChannel, leaveChannel, listChannels],
+
+  providers: [channelStateProvider, userContextProvider],
+
+  tests: [],
+
+  init: async (
+    _config: Record<string, string>,
+    runtime: IAgentRuntime,
+  ): Promise<void> => {
+    const username = runtime.getSetting("TWITCH_USERNAME");
+    const clientId = runtime.getSetting("TWITCH_CLIENT_ID");
+    const accessToken = runtime.getSetting("TWITCH_ACCESS_TOKEN");
+    const channel = runtime.getSetting("TWITCH_CHANNEL");
+
+    logger.info("=".repeat(60));
+    logger.info("Twitch Plugin Configuration");
+    logger.info("=".repeat(60));
+    logger.info(`  Username: ${username ? "✓ Set" : "✗ Missing (required)"}`);
+    logger.info(`  Client ID: ${clientId ? "✓ Set" : "✗ Missing (required)"}`);
+    logger.info(
+      `  Access Token: ${accessToken ? "✓ Set" : "✗ Missing (required)"}`,
+    );
+    logger.info(
+      `  Channel: ${channel ? `✓ ${channel}` : "✗ Missing (required)"}`,
+    );
+    logger.info("=".repeat(60));
+
+    // Validate required settings
+    const missing: string[] = [];
+    if (!username) missing.push("TWITCH_USERNAME");
+    if (!clientId) missing.push("TWITCH_CLIENT_ID");
+    if (!accessToken) missing.push("TWITCH_ACCESS_TOKEN");
+    if (!channel) missing.push("TWITCH_CHANNEL");
+
+    if (missing.length > 0) {
+      logger.warn(
+        `Twitch plugin: Missing required configuration: ${missing.join(", ")}`,
+      );
+    }
+
+    // Additional optional settings
+    const clientSecret = runtime.getSetting("TWITCH_CLIENT_SECRET");
+    const refreshToken = runtime.getSetting("TWITCH_REFRESH_TOKEN");
+    const additionalChannels = runtime.getSetting("TWITCH_CHANNELS");
+    const requireMention = runtime.getSetting("TWITCH_REQUIRE_MENTION");
+    const allowedRoles = runtime.getSetting("TWITCH_ALLOWED_ROLES");
+
+    if (clientSecret && refreshToken) {
+      logger.info(
+        "  Token Refresh: ✓ Enabled (client secret and refresh token set)",
+      );
+    } else if (clientSecret || refreshToken) {
+      logger.warn(
+        "  Token Refresh: ⚠ Partial (need both TWITCH_CLIENT_SECRET and TWITCH_REFRESH_TOKEN)",
+      );
+    }
+
+    if (additionalChannels) {
+      logger.info(`  Additional Channels: ${additionalChannels}`);
+    }
+
+    if (requireMention === "true") {
+      logger.info(
+        "  Require Mention: ✓ Enabled (will only respond to @mentions)",
+      );
+    }
+
+    if (allowedRoles) {
+      logger.info(`  Allowed Roles: ${allowedRoles}`);
+    }
+  },
+};
+
+export default twitchPlugin;

package/src/providers/channelState.ts

@@ -0,0 +1,98 @@
+/**
+ * Channel state provider for Twitch plugin.
+ */
+
+import type {
+  IAgentRuntime,
+  Memory,
+  Provider,
+  ProviderResult,
+  State,
+} from "@elizaos/core";
+import type { TwitchService } from "../service.js";
+import {
+  formatChannelForDisplay,
+  normalizeChannel,
+  TWITCH_SERVICE_NAME,
+} from "../types.js";
+
+/**
+ * Provider that gives the agent information about the current Twitch channel context.
+ */
+export const channelStateProvider: Provider = {
+  name: "twitchChannelState",
+  description: "Provides information about the current Twitch channel context",
+
+  get: async (
+    runtime: IAgentRuntime,
+    message: Memory,
+    state: State,
+  ): Promise<ProviderResult> => {
+    // Only provide context for Twitch messages
+    if (message.content.source !== "twitch") {
+      return {
+        data: {},
+        values: {},
+        text: "",
+      };
+    }
+
+    const twitchService =
+      runtime.getService<TwitchService>(TWITCH_SERVICE_NAME);
+
+    if (!twitchService || !twitchService.isConnected()) {
+      return {
+        data: {
+          connected: false,
+        },
+        values: {
+          connected: false,
+        },
+        text: "",
+      };
+    }
+
+    const agentName = state?.agentName || "The agent";
+
+    // Get room from state if available
+    const room = state?.data?.room;
+    const channelId = room?.channelId as string | undefined;
+    const channel = channelId
+      ? normalizeChannel(channelId)
+      : twitchService.getPrimaryChannel();
+
+    const joinedChannels = twitchService.getJoinedChannels();
+    const isPrimaryChannel = channel === twitchService.getPrimaryChannel();
+    const botUsername = twitchService.getBotUsername();
+
+    let responseText = `${agentName} is currently in Twitch channel ${formatChannelForDisplay(channel)}.`;
+
+    if (isPrimaryChannel) {
+      responseText += " This is the primary channel.";
+    }
+
+    responseText += `\n\nTwitch is a live streaming platform. Chat messages are public and visible to all viewers.`;
+    responseText += ` ${agentName} is logged in as @${botUsername}.`;
+    responseText += ` Currently connected to ${joinedChannels.length} channel(s).`;
+
+    return {
+      data: {
+        channel,
+        displayChannel: formatChannelForDisplay(channel),
+        isPrimaryChannel,
+        botUsername,
+        joinedChannels,
+        channelCount: joinedChannels.length,
+        connected: true,
+      },
+      values: {
+        channel,
+        displayChannel: formatChannelForDisplay(channel),
+        isPrimaryChannel,
+        botUsername,
+        channelCount: joinedChannels.length,
+      },
+      text: responseText,
+    };
+  },
+};

package/src/providers/userContext.ts

@@ -0,0 +1,117 @@
+/**
+ * User context provider for Twitch plugin.
+ */
+
+import type {
+  IAgentRuntime,
+  Memory,
+  Provider,
+  ProviderResult,
+  State,
+} from "@elizaos/core";
+import type { TwitchService } from "../service.js";
+import {
+  getTwitchUserDisplayName,
+  TWITCH_SERVICE_NAME,
+  type TwitchUserInfo,
+} from "../types.js";
+
+/**
+ * Provider that gives the agent information about the Twitch user context.
+ */
+export const userContextProvider: Provider = {
+  name: "twitchUserContext",
+  description:
+    "Provides information about the Twitch user in the current conversation",
+
+  get: async (
+    runtime: IAgentRuntime,
+    message: Memory,
+    state: State,
+  ): Promise<ProviderResult> => {
+    // Only provide context for Twitch messages
+    if (message.content.source !== "twitch") {
+      return {
+        data: {},
+        values: {},
+        text: "",
+      };
+    }
+
+    const twitchService =
+      runtime.getService<TwitchService>(TWITCH_SERVICE_NAME);
+
+    if (!twitchService || !twitchService.isConnected()) {
+      return {
+        data: {},
+        values: {},
+        text: "",
+      };
+    }
+
+    const agentName = state?.agentName || "The agent";
+
+    // Try to get user info from message metadata
+    const metadata = message.content.metadata as
+      | Record<string, unknown>
+      | undefined;
+    const userInfo = metadata?.user as TwitchUserInfo | undefined;
+
+    if (!userInfo) {
+      return {
+        data: {},
+        values: {},
+        text: "",
+      };
+    }
+
+    const displayName = getTwitchUserDisplayName(userInfo);
+    const roles: string[] = [];
+
+    if (userInfo.isBroadcaster) {
+      roles.push("broadcaster");
+    }
+    if (userInfo.isModerator) {
+      roles.push("moderator");
+    }
+    if (userInfo.isVip) {
+      roles.push("VIP");
+    }
+    if (userInfo.isSubscriber) {
+      roles.push("subscriber");
+    }
+
+    const roleText = roles.length > 0 ? roles.join(", ") : "viewer";
+
+    let responseText = `${agentName} is talking to ${displayName} (${roleText}) in Twitch chat.`;
+
+    if (userInfo.isBroadcaster) {
+      responseText += ` ${displayName} is the channel owner/broadcaster.`;
+    } else if (userInfo.isModerator) {
+      responseText += ` ${displayName} is a channel moderator.`;
+    }
+
+    return {
+      data: {
+        userId: userInfo.userId,
+        username: userInfo.username,
+        displayName,
+        isBroadcaster: userInfo.isBroadcaster,
+        isModerator: userInfo.isModerator,
+        isVip: userInfo.isVip,
+        isSubscriber: userInfo.isSubscriber,
+        roles,
+        color: userInfo.color,
+      },
+      values: {
+        userId: userInfo.userId,
+        username: userInfo.username,
+        displayName,
+        roleText,
+        isBroadcaster: userInfo.isBroadcaster,
+        isModerator: userInfo.isModerator,
+      },
+      text: responseText,
+    };
+  },
+};