@elizaos/plugin-twitch 2.0.0-alpha.3

package/dist/index.js

@@ -0,0 +1,1021 @@
+// src/index.ts
+import { logger as logger2 } from "@elizaos/core";
+
+// src/service.ts
+import {
+  logger,
+  Service
+} from "@elizaos/core";
+import { RefreshingAuthProvider, StaticAuthProvider } from "@twurple/auth";
+import { ChatClient } from "@twurple/chat";
+
+// src/types.ts
+var MAX_TWITCH_MESSAGE_LENGTH = 500;
+var TWITCH_SERVICE_NAME = "twitch";
+var TwitchEventTypes;
+((TwitchEventTypes2) => {
+  TwitchEventTypes2["MESSAGE_RECEIVED"] = "TWITCH_MESSAGE_RECEIVED";
+  TwitchEventTypes2["MESSAGE_SENT"] = "TWITCH_MESSAGE_SENT";
+  TwitchEventTypes2["JOIN_CHANNEL"] = "TWITCH_JOIN_CHANNEL";
+  TwitchEventTypes2["LEAVE_CHANNEL"] = "TWITCH_LEAVE_CHANNEL";
+  TwitchEventTypes2["CONNECTION_READY"] = "TWITCH_CONNECTION_READY";
+  TwitchEventTypes2["CONNECTION_LOST"] = "TWITCH_CONNECTION_LOST";
+})(TwitchEventTypes ||= {});
+function normalizeChannel(channel) {
+  return channel.startsWith("#") ? channel.slice(1) : channel;
+}
+function formatChannelForDisplay(channel) {
+  const normalized = normalizeChannel(channel);
+  return `#${normalized}`;
+}
+function getTwitchUserDisplayName(user) {
+  return user.displayName || user.username;
+}
+function stripMarkdownForTwitch(text) {
+  return text.replace(/\*\*([^*]+)\*\*/g, "$1").replace(/__([^_]+)__/g, "$1").replace(/\*([^*]+)\*/g, "$1").replace(/_([^_]+)_/g, "$1").replace(/~~([^~]+)~~/g, "$1").replace(/`([^`]+)`/g, "$1").replace(/```[\s\S]*?```/g, "[code block]").replace(/\[([^\]]+)\]\([^)]+\)/g, "$1").replace(/^#{1,6}\s+/gm, "").replace(/^>\s+/gm, "").replace(/^[-*+]\s+/gm, "• ").replace(/^\d+\.\s+/gm, "• ").replace(/\n{3,}/g, `
+
+`).trim();
+}
+function splitMessageForTwitch(text, maxLength = MAX_TWITCH_MESSAGE_LENGTH) {
+  if (text.length <= maxLength) {
+    return [text];
+  }
+  const chunks = [];
+  let remaining = text;
+  while (remaining.length > 0) {
+    if (remaining.length <= maxLength) {
+      chunks.push(remaining);
+      break;
+    }
+    let splitIndex = remaining.lastIndexOf(". ", maxLength);
+    if (splitIndex === -1 || splitIndex < maxLength / 2) {
+      splitIndex = remaining.lastIndexOf(" ", maxLength);
+    }
+    if (splitIndex === -1 || splitIndex < maxLength / 2) {
+      splitIndex = maxLength;
+    }
+    chunks.push(remaining.slice(0, splitIndex).trim());
+    remaining = remaining.slice(splitIndex).trim();
+  }
+  return chunks;
+}
+
+class TwitchPluginError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "TwitchPluginError";
+  }
+}
+
+class TwitchServiceNotInitializedError extends TwitchPluginError {
+  constructor(message = "Twitch service is not initialized") {
+    super(message);
+    this.name = "TwitchServiceNotInitializedError";
+  }
+}
+
+class TwitchNotConnectedError extends TwitchPluginError {
+  constructor(message = "Twitch client is not connected") {
+    super(message);
+    this.name = "TwitchNotConnectedError";
+  }
+}
+
+class TwitchConfigurationError extends TwitchPluginError {
+  settingName;
+  constructor(message, settingName) {
+    super(message);
+    this.name = "TwitchConfigurationError";
+    this.settingName = settingName;
+  }
+}
+
+class TwitchApiError extends TwitchPluginError {
+  statusCode;
+  constructor(message, statusCode) {
+    super(message);
+    this.name = "TwitchApiError";
+    this.statusCode = statusCode;
+  }
+}
+
+// src/service.ts
+class TwitchService extends Service {
+  static serviceType = TWITCH_SERVICE_NAME;
+  capabilityDescription = "Provides Twitch chat integration for sending and receiving messages";
+  settings;
+  client;
+  connected = false;
+  joinedChannels = new Set;
+  static async start(runtime) {
+    const service = new TwitchService;
+    await service.initialize(runtime);
+    return service;
+  }
+  static async stopRuntime(runtime) {
+    const service = runtime.getService(TWITCH_SERVICE_NAME);
+    if (service) {
+      await service.stop();
+    }
+  }
+  async initialize(runtime) {
+    this.runtime = runtime;
+    this.settings = this.loadSettings();
+    this.validateSettings();
+    const authProvider = await this.createAuthProvider();
+    const allChannels = [
+      this.settings.channel,
+      ...this.settings.additionalChannels
+    ].map(normalizeChannel);
+    this.client = new ChatClient({
+      authProvider,
+      channels: allChannels,
+      rejoinChannelsOnReconnect: true
+    });
+    this.setupEventHandlers();
+    await this.connect();
+    logger.info(`Twitch service initialized for ${this.settings.username}, joined channels: ${allChannels.join(", ")}`);
+  }
+  loadSettings() {
+    const username = this.runtime.getSetting("TWITCH_USERNAME");
+    const clientId = this.runtime.getSetting("TWITCH_CLIENT_ID");
+    const accessToken = this.runtime.getSetting("TWITCH_ACCESS_TOKEN");
+    const clientSecret = this.runtime.getSetting("TWITCH_CLIENT_SECRET");
+    const refreshToken = this.runtime.getSetting("TWITCH_REFRESH_TOKEN");
+    const channel = this.runtime.getSetting("TWITCH_CHANNEL");
+    const additionalChannelsStr = this.runtime.getSetting("TWITCH_CHANNELS");
+    const requireMentionStr = this.runtime.getSetting("TWITCH_REQUIRE_MENTION");
+    const allowedRolesStr = this.runtime.getSetting("TWITCH_ALLOWED_ROLES");
+    const additionalChannels = typeof additionalChannelsStr === "string" && additionalChannelsStr ? additionalChannelsStr.split(",").map((c) => c.trim()).filter(Boolean) : [];
+    const allowedRoles = typeof allowedRolesStr === "string" && allowedRolesStr ? allowedRolesStr.split(",").map((r) => r.trim().toLowerCase()) : ["all"];
+    return {
+      username: typeof username === "string" ? username : "",
+      clientId: typeof clientId === "string" ? clientId : "",
+      accessToken: typeof accessToken === "string" ? accessToken : "",
+      clientSecret: typeof clientSecret === "string" ? clientSecret : undefined,
+      refreshToken: typeof refreshToken === "string" ? refreshToken : undefined,
+      channel: typeof channel === "string" ? channel : "",
+      additionalChannels,
+      requireMention: requireMentionStr === "true",
+      allowedRoles,
+      allowedUserIds: [],
+      enabled: true
+    };
+  }
+  validateSettings() {
+    if (!this.settings.username) {
+      throw new TwitchConfigurationError("TWITCH_USERNAME is required", "TWITCH_USERNAME");
+    }
+    if (!this.settings.clientId) {
+      throw new TwitchConfigurationError("TWITCH_CLIENT_ID is required", "TWITCH_CLIENT_ID");
+    }
+    if (!this.settings.accessToken) {
+      throw new TwitchConfigurationError("TWITCH_ACCESS_TOKEN is required", "TWITCH_ACCESS_TOKEN");
+    }
+    if (!this.settings.channel) {
+      throw new TwitchConfigurationError("TWITCH_CHANNEL is required", "TWITCH_CHANNEL");
+    }
+  }
+  async createAuthProvider() {
+    const token = this.normalizeToken(this.settings.accessToken);
+    if (this.settings.clientSecret) {
+      const authProvider = new RefreshingAuthProvider({
+        clientId: this.settings.clientId,
+        clientSecret: this.settings.clientSecret
+      });
+      await authProvider.addUserForToken({
+        accessToken: token,
+        refreshToken: this.settings.refreshToken || null,
+        expiresIn: null,
+        obtainmentTimestamp: Date.now()
+      });
+      authProvider.onRefresh((userId, newToken) => {
+        logger.info(`Twitch token refreshed for user ${userId}, expires in ${newToken.expiresIn}s`);
+      });
+      authProvider.onRefreshFailure((userId, error) => {
+        logger.error(`Twitch token refresh failed for user ${userId}: ${error.message}`);
+      });
+      logger.info(`Using RefreshingAuthProvider for ${this.settings.username}`);
+      return authProvider;
+    }
+    logger.info(`Using StaticAuthProvider for ${this.settings.username}`);
+    return new StaticAuthProvider(this.settings.clientId, token);
+  }
+  normalizeToken(token) {
+    return token.startsWith("oauth:") ? token.slice(6) : token;
+  }
+  setupEventHandlers() {
+    this.client.onConnect(() => {
+      this.connected = true;
+      logger.info("Twitch chat connected");
+      this.runtime.emitEvent("TWITCH_CONNECTION_READY" /* CONNECTION_READY */, {
+        runtime: this.runtime
+      });
+    });
+    this.client.onDisconnect((_manually, reason) => {
+      this.connected = false;
+      logger.warn(`Twitch chat disconnected: ${reason || "unknown reason"}`);
+      this.runtime.emitEvent("TWITCH_CONNECTION_LOST" /* CONNECTION_LOST */, {
+        runtime: this.runtime,
+        reason
+      });
+    });
+    this.client.onJoin((channel, user) => {
+      const normalized = normalizeChannel(channel);
+      if (user.toLowerCase() === this.settings.username.toLowerCase()) {
+        this.joinedChannels.add(normalized);
+        logger.info(`Joined Twitch channel: ${normalized}`);
+        this.runtime.emitEvent("TWITCH_JOIN_CHANNEL" /* JOIN_CHANNEL */, {
+          runtime: this.runtime,
+          channel: normalized
+        });
+      }
+    });
+    this.client.onPart((channel, user) => {
+      const normalized = normalizeChannel(channel);
+      if (user.toLowerCase() === this.settings.username.toLowerCase()) {
+        this.joinedChannels.delete(normalized);
+        logger.info(`Left Twitch channel: ${normalized}`);
+        this.runtime.emitEvent("TWITCH_LEAVE_CHANNEL" /* LEAVE_CHANNEL */, {
+          runtime: this.runtime,
+          channel: normalized
+        });
+      }
+    });
+    this.client.onMessage((channel, user, text, msg) => {
+      this.handleMessage(channel, user, text, msg);
+    });
+  }
+  handleMessage(channel, _user, text, msg) {
+    const normalizedChannel = normalizeChannel(channel);
+    if (msg.userInfo.userName.toLowerCase() === this.settings.username.toLowerCase()) {
+      return;
+    }
+    const userInfo = {
+      userId: msg.userInfo.userId,
+      username: msg.userInfo.userName,
+      displayName: msg.userInfo.displayName,
+      isModerator: msg.userInfo.isMod,
+      isBroadcaster: msg.userInfo.isBroadcaster,
+      isVip: msg.userInfo.isVip,
+      isSubscriber: msg.userInfo.isSubscriber,
+      color: msg.userInfo.color,
+      badges: msg.userInfo.badges
+    };
+    if (!this.isUserAllowed(userInfo)) {
+      return;
+    }
+    if (this.settings.requireMention) {
+      const mentionPattern = new RegExp(`@${this.settings.username}\\b`, "i");
+      if (!mentionPattern.test(text)) {
+        return;
+      }
+    }
+    const message = {
+      id: msg.id,
+      channel: normalizedChannel,
+      text,
+      user: userInfo,
+      timestamp: new Date,
+      isAction: msg.isCheer,
+      isHighlighted: msg.isHighlight,
+      replyTo: msg.parentMessageId ? {
+        messageId: msg.parentMessageId,
+        userId: msg.parentMessageUserId || "",
+        username: msg.parentMessageUserName || "",
+        text: msg.parentMessageText || ""
+      } : undefined
+    };
+    logger.debug(`Twitch message from ${userInfo.displayName} in #${normalizedChannel}: ${text.slice(0, 50)}...`);
+    this.runtime.emitEvent("TWITCH_MESSAGE_RECEIVED" /* MESSAGE_RECEIVED */, {
+      runtime: this.runtime,
+      message
+    });
+  }
+  async connect() {
+    await this.client.connect();
+    this.connected = true;
+  }
+  async stop() {
+    if (this.client) {
+      this.client.quit();
+    }
+    this.connected = false;
+    this.joinedChannels.clear();
+    logger.info("Twitch service stopped");
+  }
+  isConnected() {
+    return this.connected;
+  }
+  getBotUsername() {
+    return this.settings.username;
+  }
+  getPrimaryChannel() {
+    return this.settings.channel;
+  }
+  getJoinedChannels() {
+    return Array.from(this.joinedChannels);
+  }
+  isUserAllowed(user) {
+    if (this.settings.allowedUserIds.length > 0 && !this.settings.allowedUserIds.includes(user.userId)) {
+      return false;
+    }
+    if (this.settings.allowedRoles.includes("all")) {
+      return true;
+    }
+    if (this.settings.allowedRoles.includes("owner") && user.isBroadcaster) {
+      return true;
+    }
+    if (this.settings.allowedRoles.includes("moderator") && user.isModerator) {
+      return true;
+    }
+    if (this.settings.allowedRoles.includes("vip") && user.isVip) {
+      return true;
+    }
+    if (this.settings.allowedRoles.includes("subscriber") && user.isSubscriber) {
+      return true;
+    }
+    return false;
+  }
+  async sendMessage(text, options) {
+    if (!this.connected) {
+      throw new TwitchNotConnectedError;
+    }
+    const channel = normalizeChannel(options?.channel || this.settings.channel);
+    const cleanedText = stripMarkdownForTwitch(text);
+    if (!cleanedText) {
+      return { success: true, messageId: "skipped-empty" };
+    }
+    const chunks = splitMessageForTwitch(cleanedText);
+    let lastMessageId;
+    for (const chunk of chunks) {
+      if (options?.replyTo) {
+        await this.client.say(channel, chunk, { replyTo: options.replyTo });
+      } else {
+        await this.client.say(channel, chunk);
+      }
+      lastMessageId = crypto.randomUUID();
+      if (chunks.length > 1) {
+        await new Promise((resolve) => setTimeout(resolve, 300));
+      }
+    }
+    this.runtime.emitEvent("TWITCH_MESSAGE_SENT" /* MESSAGE_SENT */, {
+      runtime: this.runtime,
+      channel,
+      text: cleanedText,
+      messageId: lastMessageId
+    });
+    return { success: true, messageId: lastMessageId };
+  }
+  async joinChannel(channel) {
+    const normalized = normalizeChannel(channel);
+    await this.client.join(normalized);
+    this.joinedChannels.add(normalized);
+  }
+  async leaveChannel(channel) {
+    const normalized = normalizeChannel(channel);
+    await this.client.part(normalized);
+    this.joinedChannels.delete(normalized);
+  }
+}
+// src/actions/joinChannel.ts
+import {
+  composePromptFromState,
+  ModelType,
+  parseJSONObjectFromText
+} from "@elizaos/core";
+var JOIN_CHANNEL_TEMPLATE = `You are helping to extract a Twitch channel name.
+
+The user wants to join a Twitch channel.
+
+Recent conversation:
+{{recentMessages}}
+
+Extract the channel name to join (without the # prefix).
+
+Respond with a JSON object like:
+{
+  "channel": "channelname"
+}
+
+Only respond with the JSON object, no other text.`;
+var joinChannel = {
+  name: "TWITCH_JOIN_CHANNEL",
+  similes: ["JOIN_TWITCH_CHANNEL", "ENTER_CHANNEL", "CONNECT_CHANNEL"],
+  description: "Join a Twitch channel to listen and send messages",
+  validate: async (_runtime, message, _state) => {
+    return message.content.source === "twitch";
+  },
+  handler: async (runtime, message, state, _options, callback) => {
+    const twitchService = runtime.getService(TWITCH_SERVICE_NAME);
+    if (!twitchService || !twitchService.isConnected()) {
+      if (callback) {
+        callback({
+          text: "Twitch service is not available.",
+          source: "twitch"
+        });
+      }
+      return { success: false, error: "Twitch service not available" };
+    }
+    const currentState = state ?? await runtime.composeState(message);
+    const prompt = await composePromptFromState({
+      template: JOIN_CHANNEL_TEMPLATE,
+      state: currentState
+    });
+    let channelName = null;
+    for (let attempt = 0;attempt < 3; attempt++) {
+      const response = await runtime.useModel(ModelType.TEXT_SMALL, {
+        prompt
+      });
+      const parsed = parseJSONObjectFromText(String(response));
+      if (parsed?.channel) {
+        channelName = normalizeChannel(String(parsed.channel));
+        break;
+      }
+    }
+    if (!channelName) {
+      if (callback) {
+        callback({
+          text: "I couldn't understand which channel you want me to join. Please specify the channel name.",
+          source: "twitch"
+        });
+      }
+      return { success: false, error: "Could not extract channel name" };
+    }
+    if (twitchService.getJoinedChannels().includes(channelName)) {
+      if (callback) {
+        callback({
+          text: `Already in channel #${channelName}.`,
+          source: "twitch"
+        });
+      }
+      return {
+        success: true,
+        data: { channel: channelName, alreadyJoined: true }
+      };
+    }
+    await twitchService.joinChannel(channelName);
+    if (callback) {
+      callback({
+        text: `Joined channel #${channelName}.`,
+        source: message.content.source
+      });
+    }
+    return {
+      success: true,
+      data: {
+        channel: channelName
+      }
+    };
+  },
+  examples: [
+    [
+      {
+        name: "{{user1}}",
+        content: { text: "Join the channel shroud" }
+      },
+      {
+        name: "{{agent}}",
+        content: {
+          text: "I'll join that channel.",
+          actions: ["TWITCH_JOIN_CHANNEL"]
+        }
+      }
+    ]
+  ]
+};
+
+// src/actions/leaveChannel.ts
+import {
+  composePromptFromState as composePromptFromState2,
+  ModelType as ModelType2,
+  parseJSONObjectFromText as parseJSONObjectFromText2
+} from "@elizaos/core";
+var LEAVE_CHANNEL_TEMPLATE = `You are helping to extract a Twitch channel name.
+
+The user wants to leave a Twitch channel.
+
+Recent conversation:
+{{recentMessages}}
+
+Currently joined channels: {{joinedChannels}}
+
+Extract the channel name to leave (without the # prefix).
+
+Respond with a JSON object like:
+{
+  "channel": "channelname"
+}
+
+Only respond with the JSON object, no other text.`;
+var leaveChannel = {
+  name: "TWITCH_LEAVE_CHANNEL",
+  similes: [
+    "LEAVE_TWITCH_CHANNEL",
+    "EXIT_CHANNEL",
+    "PART_CHANNEL",
+    "DISCONNECT_CHANNEL"
+  ],
+  description: "Leave a Twitch channel",
+  validate: async (_runtime, message, _state) => {
+    return message.content.source === "twitch";
+  },
+  handler: async (runtime, message, state, _options, callback) => {
+    const twitchService = runtime.getService(TWITCH_SERVICE_NAME);
+    if (!twitchService || !twitchService.isConnected()) {
+      if (callback) {
+        callback({
+          text: "Twitch service is not available.",
+          source: "twitch"
+        });
+      }
+      return { success: false, error: "Twitch service not available" };
+    }
+    const joinedChannels = twitchService.getJoinedChannels();
+    const currentState = state ?? await runtime.composeState(message);
+    const enrichedState = {
+      ...currentState,
+      joinedChannels: joinedChannels.join(", ")
+    };
+    const prompt = await composePromptFromState2({
+      template: LEAVE_CHANNEL_TEMPLATE,
+      state: enrichedState
+    });
+    let channelName = null;
+    for (let attempt = 0;attempt < 3; attempt++) {
+      const response = await runtime.useModel(ModelType2.TEXT_SMALL, {
+        prompt
+      });
+      const parsed = parseJSONObjectFromText2(String(response));
+      if (parsed?.channel) {
+        channelName = normalizeChannel(String(parsed.channel));
+        break;
+      }
+    }
+    if (!channelName) {
+      if (callback) {
+        callback({
+          text: "I couldn't understand which channel you want me to leave. Please specify the channel name.",
+          source: "twitch"
+        });
+      }
+      return { success: false, error: "Could not extract channel name" };
+    }
+    if (!joinedChannels.includes(channelName)) {
+      if (callback) {
+        callback({
+          text: `Not currently in channel #${channelName}.`,
+          source: "twitch"
+        });
+      }
+      return { success: false, error: "Not in that channel" };
+    }
+    if (channelName === twitchService.getPrimaryChannel()) {
+      if (callback) {
+        callback({
+          text: `Cannot leave the primary channel #${channelName}.`,
+          source: "twitch"
+        });
+      }
+      return { success: false, error: "Cannot leave primary channel" };
+    }
+    await twitchService.leaveChannel(channelName);
+    if (callback) {
+      callback({
+        text: `Left channel #${channelName}.`,
+        source: message.content.source
+      });
+    }
+    return {
+      success: true,
+      data: {
+        channel: channelName
+      }
+    };
+  },
+  examples: [
+    [
+      {
+        name: "{{user1}}",
+        content: { text: "Leave the channel shroud" }
+      },
+      {
+        name: "{{agent}}",
+        content: {
+          text: "I'll leave that channel.",
+          actions: ["TWITCH_LEAVE_CHANNEL"]
+        }
+      }
+    ]
+  ]
+};
+
+// src/actions/listChannels.ts
+var listChannels = {
+  name: "TWITCH_LIST_CHANNELS",
+  similes: [
+    "LIST_TWITCH_CHANNELS",
+    "SHOW_CHANNELS",
+    "GET_CHANNELS",
+    "CURRENT_CHANNELS"
+  ],
+  description: "List all Twitch channels the bot is currently in",
+  validate: async (_runtime, message, _state) => {
+    return message.content.source === "twitch";
+  },
+  handler: async (runtime, message, _state, _options, callback) => {
+    const twitchService = runtime.getService(TWITCH_SERVICE_NAME);
+    if (!twitchService || !twitchService.isConnected()) {
+      if (callback) {
+        callback({
+          text: "Twitch service is not available.",
+          source: "twitch"
+        });
+      }
+      return { success: false, error: "Twitch service not available" };
+    }
+    const joinedChannels = twitchService.getJoinedChannels();
+    const primaryChannel = twitchService.getPrimaryChannel();
+    const channelList = joinedChannels.map((channel) => {
+      const displayName = formatChannelForDisplay(channel);
+      const isPrimary = channel === primaryChannel;
+      return isPrimary ? `${displayName} (primary)` : displayName;
+    });
+    const responseText = joinedChannels.length > 0 ? `Currently in ${joinedChannels.length} channel(s):
+${channelList.map((c) => `• ${c}`).join(`
+`)}` : "Not currently in any channels.";
+    if (callback) {
+      callback({
+        text: responseText,
+        source: message.content.source
+      });
+    }
+    return {
+      success: true,
+      data: {
+        channelCount: joinedChannels.length,
+        channels: joinedChannels,
+        primaryChannel
+      }
+    };
+  },
+  examples: [
+    [
+      {
+        name: "{{user1}}",
+        content: { text: "What channels are you in?" }
+      },
+      {
+        name: "{{agent}}",
+        content: {
+          text: "I'll list the channels I'm currently in.",
+          actions: ["TWITCH_LIST_CHANNELS"]
+        }
+      }
+    ]
+  ]
+};
+
+// src/actions/sendMessage.ts
+import {
+  composePromptFromState as composePromptFromState3,
+  ModelType as ModelType3,
+  parseJSONObjectFromText as parseJSONObjectFromText3
+} from "@elizaos/core";
+var SEND_MESSAGE_TEMPLATE = `You are helping to extract send message parameters for Twitch chat.
+
+The user wants to send a message to a Twitch channel.
+
+Recent conversation:
+{{recentMessages}}
+
+Extract the following:
+1. text: The message text to send
+2. channel: The channel name to send to (without # prefix), or "current" for the current channel
+
+Respond with a JSON object like:
+{
+  "text": "The message to send",
+  "channel": "current"
+}
+
+Only respond with the JSON object, no other text.`;
+var sendMessage = {
+  name: "TWITCH_SEND_MESSAGE",
+  similes: [
+    "SEND_TWITCH_MESSAGE",
+    "TWITCH_CHAT",
+    "CHAT_TWITCH",
+    "SAY_IN_TWITCH"
+  ],
+  description: "Send a message to a Twitch channel",
+  validate: async (_runtime, message, _state) => {
+    return message.content.source === "twitch";
+  },
+  handler: async (runtime, message, state, _options, callback) => {
+    const twitchService = runtime.getService(TWITCH_SERVICE_NAME);
+    if (!twitchService || !twitchService.isConnected()) {
+      if (callback) {
+        callback({
+          text: "Twitch service is not available.",
+          source: "twitch"
+        });
+      }
+      return { success: false, error: "Twitch service not available" };
+    }
+    const currentState = state ?? await runtime.composeState(message);
+    const prompt = await composePromptFromState3({
+      template: SEND_MESSAGE_TEMPLATE,
+      state: currentState
+    });
+    let messageInfo = null;
+    for (let attempt = 0;attempt < 3; attempt++) {
+      const response = await runtime.useModel(ModelType3.TEXT_SMALL, {
+        prompt
+      });
+      const parsed = parseJSONObjectFromText3(String(response));
+      if (parsed?.text) {
+        messageInfo = {
+          text: String(parsed.text),
+          channel: String(parsed.channel || "current")
+        };
+        break;
+      }
+    }
+    if (!messageInfo || !messageInfo.text) {
+      if (callback) {
+        callback({
+          text: "I couldn't understand what message you want me to send. Please try again.",
+          source: "twitch"
+        });
+      }
+      return { success: false, error: "Could not extract message parameters" };
+    }
+    let targetChannel = twitchService.getPrimaryChannel();
+    if (messageInfo.channel && messageInfo.channel !== "current") {
+      targetChannel = normalizeChannel(messageInfo.channel);
+    }
+    if (currentState?.data?.room?.channelId) {
+      targetChannel = normalizeChannel(currentState.data.room.channelId);
+    }
+    const result = await twitchService.sendMessage(messageInfo.text, {
+      channel: targetChannel
+    });
+    if (!result.success) {
+      if (callback) {
+        callback({
+          text: `Failed to send message: ${result.error}`,
+          source: "twitch"
+        });
+      }
+      return { success: false, error: result.error };
+    }
+    if (callback) {
+      callback({
+        text: "Message sent successfully.",
+        source: message.content.source
+      });
+    }
+    return {
+      success: true,
+      data: {
+        channel: targetChannel,
+        messageId: result.messageId
+      }
+    };
+  },
+  examples: [
+    [
+      {
+        name: "{{user1}}",
+        content: { text: "Send a message to chat saying 'Hello everyone!'" }
+      },
+      {
+        name: "{{agent}}",
+        content: {
+          text: "I'll send that message to the chat.",
+          actions: ["TWITCH_SEND_MESSAGE"]
+        }
+      }
+    ]
+  ]
+};
+
+// src/providers/channelState.ts
+var channelStateProvider = {
+  name: "twitchChannelState",
+  description: "Provides information about the current Twitch channel context",
+  get: async (runtime, message, state) => {
+    if (message.content.source !== "twitch") {
+      return {
+        data: {},
+        values: {},
+        text: ""
+      };
+    }
+    const twitchService = runtime.getService(TWITCH_SERVICE_NAME);
+    if (!twitchService || !twitchService.isConnected()) {
+      return {
+        data: {
+          connected: false
+        },
+        values: {
+          connected: false
+        },
+        text: ""
+      };
+    }
+    const agentName = state?.agentName || "The agent";
+    const room = state?.data?.room;
+    const channelId = room?.channelId;
+    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 += `
+
+Twitch 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
+    };
+  }
+};
+
+// src/providers/userContext.ts
+var userContextProvider = {
+  name: "twitchUserContext",
+  description: "Provides information about the Twitch user in the current conversation",
+  get: async (runtime, message, state) => {
+    if (message.content.source !== "twitch") {
+      return {
+        data: {},
+        values: {},
+        text: ""
+      };
+    }
+    const twitchService = runtime.getService(TWITCH_SERVICE_NAME);
+    if (!twitchService || !twitchService.isConnected()) {
+      return {
+        data: {},
+        values: {},
+        text: ""
+      };
+    }
+    const agentName = state?.agentName || "The agent";
+    const metadata = message.content.metadata;
+    const userInfo = metadata?.user;
+    if (!userInfo) {
+      return {
+        data: {},
+        values: {},
+        text: ""
+      };
+    }
+    const displayName = getTwitchUserDisplayName(userInfo);
+    const roles = [];
+    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
+    };
+  }
+};
+
+// src/index.ts
+var twitchPlugin = {
+  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, runtime) => {
+    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");
+    logger2.info("=".repeat(60));
+    logger2.info("Twitch Plugin Configuration");
+    logger2.info("=".repeat(60));
+    logger2.info(`  Username: ${username ? "✓ Set" : "✗ Missing (required)"}`);
+    logger2.info(`  Client ID: ${clientId ? "✓ Set" : "✗ Missing (required)"}`);
+    logger2.info(`  Access Token: ${accessToken ? "✓ Set" : "✗ Missing (required)"}`);
+    logger2.info(`  Channel: ${channel ? `✓ ${channel}` : "✗ Missing (required)"}`);
+    logger2.info("=".repeat(60));
+    const missing = [];
+    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) {
+      logger2.warn(`Twitch plugin: Missing required configuration: ${missing.join(", ")}`);
+    }
+    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) {
+      logger2.info("  Token Refresh: ✓ Enabled (client secret and refresh token set)");
+    } else if (clientSecret || refreshToken) {
+      logger2.warn("  Token Refresh: ⚠ Partial (need both TWITCH_CLIENT_SECRET and TWITCH_REFRESH_TOKEN)");
+    }
+    if (additionalChannels) {
+      logger2.info(`  Additional Channels: ${additionalChannels}`);
+    }
+    if (requireMention === "true") {
+      logger2.info("  Require Mention: ✓ Enabled (will only respond to @mentions)");
+    }
+    if (allowedRoles) {
+      logger2.info(`  Allowed Roles: ${allowedRoles}`);
+    }
+  }
+};
+var src_default = twitchPlugin;
+export {
+  userContextProvider,
+  stripMarkdownForTwitch,
+  splitMessageForTwitch,
+  sendMessage,
+  normalizeChannel,
+  listChannels,
+  leaveChannel,
+  joinChannel,
+  getTwitchUserDisplayName,
+  formatChannelForDisplay,
+  src_default as default,
+  channelStateProvider,
+  TwitchServiceNotInitializedError,
+  TwitchService,
+  TwitchPluginError,
+  TwitchNotConnectedError,
+  TwitchEventTypes,
+  TwitchConfigurationError,
+  TwitchApiError,
+  TWITCH_SERVICE_NAME,
+  MAX_TWITCH_MESSAGE_LENGTH
+};
+
+//# debugId=A95FC42F6866C30064756E2164756E21