@elizaos/plugin-twitch 2.0.0-beta.1 → 2.0.3-beta.2

package/dist/index.js

@@ -1,972 +0,0 @@
-// src/index.ts
-import { getConnectorAccountManager, logger as logger2 } from "@elizaos/core";
-
-// src/accounts.ts
-var DEFAULT_TWITCH_ACCOUNT_ID = "default";
-function stringSetting(runtime, key) {
-  const value = runtime.getSetting(key);
-  return typeof value === "string" && value.trim() ? value.trim() : undefined;
-}
-function characterConfig(runtime) {
-  const settings = runtime.character?.settings;
-  const raw = settings?.twitch;
-  return raw && typeof raw === "object" ? raw : {};
-}
-function parseAccountsJson(runtime) {
-  const raw = stringSetting(runtime, "TWITCH_ACCOUNTS");
-  if (!raw)
-    return {};
-  try {
-    const parsed = JSON.parse(raw);
-    if (Array.isArray(parsed)) {
-      return Object.fromEntries(parsed.filter((item) => Boolean(item) && typeof item === "object").map((item) => [
-        normalizeTwitchAccountId(item.accountId ?? item.id),
-        item
-      ]));
-    }
-    return parsed && typeof parsed === "object" ? parsed : {};
-  } catch {
-    return {};
-  }
-}
-function allAccountConfigs(runtime) {
-  return {
-    ...characterConfig(runtime).accounts ?? {},
-    ...parseAccountsJson(runtime)
-  };
-}
-function accountConfig(runtime, accountId) {
-  const accounts = allAccountConfigs(runtime);
-  return accounts[accountId] ?? accounts[normalizeTwitchAccountId(accountId)] ?? {};
-}
-function boolValue(value, fallback = false) {
-  if (typeof value === "boolean")
-    return value;
-  if (typeof value === "string")
-    return value.trim().toLowerCase() === "true";
-  return fallback;
-}
-function stringList(value) {
-  if (Array.isArray(value))
-    return value.map((item) => String(item).trim()).filter(Boolean);
-  if (typeof value === "string") {
-    return value.split(",").map((item) => item.trim()).filter(Boolean);
-  }
-  return [];
-}
-function roleList(value) {
-  const values = stringList(value).map((role) => role.toLowerCase());
-  return values.length ? values : ["all"];
-}
-function normalizeTwitchAccountId(accountId) {
-  if (typeof accountId !== "string")
-    return DEFAULT_TWITCH_ACCOUNT_ID;
-  const trimmed = accountId.trim();
-  return trimmed || DEFAULT_TWITCH_ACCOUNT_ID;
-}
-function listTwitchAccountIds(runtime) {
-  const ids = new Set;
-  const config = characterConfig(runtime);
-  if (stringSetting(runtime, "TWITCH_ACCESS_TOKEN") || config.accessToken) {
-    ids.add(DEFAULT_TWITCH_ACCOUNT_ID);
-  }
-  for (const id of Object.keys(allAccountConfigs(runtime))) {
-    ids.add(normalizeTwitchAccountId(id));
-  }
-  return Array.from(ids.size ? ids : new Set([DEFAULT_TWITCH_ACCOUNT_ID])).sort((a, b) => a.localeCompare(b));
-}
-function resolveDefaultTwitchAccountId(runtime) {
-  const requested = stringSetting(runtime, "TWITCH_DEFAULT_ACCOUNT_ID") ?? stringSetting(runtime, "TWITCH_ACCOUNT_ID");
-  if (requested)
-    return normalizeTwitchAccountId(requested);
-  const ids = listTwitchAccountIds(runtime);
-  return ids.includes(DEFAULT_TWITCH_ACCOUNT_ID) ? DEFAULT_TWITCH_ACCOUNT_ID : ids[0];
-}
-function readTwitchAccountId(...sources) {
-  for (const source of sources) {
-    if (!source || typeof source !== "object")
-      continue;
-    const record = source;
-    const parameters = record.parameters && typeof record.parameters === "object" ? record.parameters : {};
-    const data = record.data && typeof record.data === "object" ? record.data : {};
-    const metadata = record.metadata && typeof record.metadata === "object" ? record.metadata : {};
-    const twitch = data.twitch && typeof data.twitch === "object" ? data.twitch : {};
-    const value = record.accountId ?? parameters.accountId ?? data.accountId ?? twitch.accountId ?? metadata.accountId;
-    if (typeof value === "string" && value.trim())
-      return normalizeTwitchAccountId(value);
-  }
-  return;
-}
-function resolveTwitchAccountSettings(runtime, requestedAccountId) {
-  const accountId = normalizeTwitchAccountId(requestedAccountId ?? resolveDefaultTwitchAccountId(runtime));
-  const base = characterConfig(runtime);
-  const account = accountConfig(runtime, accountId);
-  const allowEnv = accountId === DEFAULT_TWITCH_ACCOUNT_ID;
-  return {
-    accountId,
-    username: account.username ?? base.username ?? (allowEnv ? stringSetting(runtime, "TWITCH_USERNAME") : undefined) ?? "",
-    clientId: account.clientId ?? base.clientId ?? (allowEnv ? stringSetting(runtime, "TWITCH_CLIENT_ID") : undefined) ?? "",
-    accessToken: account.accessToken ?? base.accessToken ?? (allowEnv ? stringSetting(runtime, "TWITCH_ACCESS_TOKEN") : undefined) ?? "",
-    clientSecret: account.clientSecret ?? base.clientSecret ?? (allowEnv ? stringSetting(runtime, "TWITCH_CLIENT_SECRET") : undefined),
-    refreshToken: account.refreshToken ?? base.refreshToken ?? (allowEnv ? stringSetting(runtime, "TWITCH_REFRESH_TOKEN") : undefined),
-    channel: account.channel ?? base.channel ?? (allowEnv ? stringSetting(runtime, "TWITCH_CHANNEL") : undefined) ?? "",
-    additionalChannels: stringList(account.additionalChannels ?? account.channels ?? base.additionalChannels ?? base.channels ?? (allowEnv ? stringSetting(runtime, "TWITCH_CHANNELS") : undefined)),
-    requireMention: boolValue(account.requireMention ?? base.requireMention ?? (allowEnv ? stringSetting(runtime, "TWITCH_REQUIRE_MENTION") : undefined)),
-    allowedRoles: roleList(account.allowedRoles ?? base.allowedRoles ?? (allowEnv ? stringSetting(runtime, "TWITCH_ALLOWED_ROLES") : undefined)),
-    allowedUserIds: stringList(account.allowedUserIds ?? base.allowedUserIds),
-    enabled: boolValue(account.enabled ?? base.enabled, true)
-  };
-}
-// 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
-var TWITCH_CONNECTOR_CONTEXTS = ["social", "connectors"];
-var TWITCH_CONNECTOR_CAPABILITIES = [
-  "send_message",
-  "resolve_targets",
-  "list_rooms",
-  "join",
-  "leave",
-  "chat_context"
-];
-function normalizeTwitchConnectorQuery(value) {
-  return normalizeChannel(value.trim().replace(/^@/, "")).toLowerCase();
-}
-function scoreTwitchChannelMatch(query, channel) {
-  const normalized = normalizeTwitchConnectorQuery(channel);
-  if (!query) {
-    return 0.45;
-  }
-  if (normalized === query) {
-    return 1;
-  }
-  if (normalized.startsWith(query)) {
-    return 0.85;
-  }
-  if (normalized.includes(query)) {
-    return 0.7;
-  }
-  return 0;
-}
-async function logTwurpleCall(op, context, fn) {
-  const startedAt = Date.now();
-  logger.debug({ sdk: "twurple", op, ...context }, `[TwitchService] ${op} started`);
-  try {
-    const result = await fn();
-    logger.info({
-      sdk: "twurple",
-      op,
-      ...context,
-      durationMs: Date.now() - startedAt
-    }, `[TwitchService] ${op} ok`);
-    return result;
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    logger.warn({
-      sdk: "twurple",
-      op,
-      ...context,
-      durationMs: Date.now() - startedAt,
-      error: message
-    }, `[TwitchService] ${op} failed`);
-    throw error;
-  }
-}
-
-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;
-  accountServices = new Map;
-  static async start(runtime) {
-    const service = new TwitchService;
-    await service.initialize(runtime);
-    return service;
-  }
-  static registerSendHandlers(runtime, serviceInstance) {
-    if (!serviceInstance) {
-      return;
-    }
-    for (const accountService of serviceInstance.getAccountServiceList()) {
-      const accountId = accountService.getAccountId(runtime);
-      const sendHandler = accountService.handleSendMessage.bind(accountService);
-      if (typeof runtime.registerMessageConnector === "function") {
-        runtime.registerMessageConnector({
-          source: "twitch",
-          accountId,
-          label: "Twitch",
-          description: "Twitch public chat connector for sending messages to joined channels.",
-          capabilities: [...TWITCH_CONNECTOR_CAPABILITIES],
-          supportedTargetKinds: ["channel"],
-          contexts: [...TWITCH_CONNECTOR_CONTEXTS],
-          metadata: {
-            accountId,
-            service: TWITCH_SERVICE_NAME,
-            maxMessageLength: MAX_TWITCH_MESSAGE_LENGTH
-          },
-          resolveTargets: accountService.resolveConnectorTargets.bind(accountService),
-          listRecentTargets: accountService.listRecentConnectorTargets.bind(accountService),
-          listRooms: accountService.listConnectorRooms.bind(accountService),
-          joinHandler: accountService.handleJoinChannel.bind(accountService),
-          leaveHandler: accountService.handleLeaveChannel.bind(accountService),
-          getChatContext: accountService.getConnectorChatContext.bind(accountService),
-          sendHandler
-        });
-        runtime.logger.info({ src: "plugin:twitch", agentId: runtime.agentId }, "Registered Twitch chat connector");
-        continue;
-      }
-    }
-  }
-  static async stopRuntime(runtime) {
-    const service = runtime.getService(TWITCH_SERVICE_NAME);
-    if (service) {
-      await service.stop();
-    }
-  }
-  async initialize(runtime) {
-    this.runtime = runtime;
-    const startedAccounts = [];
-    for (const accountId of listTwitchAccountIds(runtime)) {
-      const settings = resolveTwitchAccountSettings(runtime, accountId);
-      if (settings.enabled === false) {
-        continue;
-      }
-      const accountService = new TwitchService;
-      await accountService.initializeAccount(runtime, accountId);
-      this.accountServices.set(accountService.getAccountId(), accountService);
-      startedAccounts.push(accountService.getAccountId());
-    }
-    if (startedAccounts.length === 0) {
-      logger.warn("No enabled Twitch accounts configured");
-      return;
-    }
-    logger.info(`Twitch service started ${startedAccounts.length} account(s): ${startedAccounts.join(", ")}`);
-  }
-  async initializeAccount(runtime, accountId) {
-    this.runtime = runtime;
-    this.settings = this.loadSettings(accountId);
-    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(accountId) {
-    return resolveTwitchAccountSettings(this.runtime, accountId);
-  }
-  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,
-        accountId: this.getAccountId()
-      });
-    });
-    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,
-        accountId: this.getAccountId(),
-        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,
-          accountId: this.getAccountId(),
-          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,
-          accountId: this.getAccountId(),
-          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,
-      accountId: this.getAccountId(),
-      message
-    });
-  }
-  async connect() {
-    await this.client.connect();
-    this.connected = true;
-  }
-  async stop() {
-    if (this.accountServices?.size > 0) {
-      await Promise.all(Array.from(this.accountServices.values()).map((service) => service.stop()));
-      this.accountServices.clear();
-      logger.info("Twitch service stopped");
-      return;
-    }
-    if (this.client) {
-      this.client.quit();
-    }
-    this.connected = false;
-    this.joinedChannels.clear();
-    logger.info("Twitch service stopped");
-  }
-  getAccountServiceList() {
-    return this.accountServices?.size > 0 ? Array.from(this.accountServices.values()) : [this];
-  }
-  getDefaultAccountService() {
-    if (!this.accountServices || this.accountServices.size === 0) {
-      return this;
-    }
-    const defaultAccountId = normalizeTwitchAccountId(resolveDefaultTwitchAccountId(this.runtime));
-    return this.accountServices.get(defaultAccountId) ?? Array.from(this.accountServices.values())[0];
-  }
-  getAccountService(accountId) {
-    if (!this.accountServices || this.accountServices.size === 0) {
-      const ownAccountId = this.getAccountId();
-      if (normalizeTwitchAccountId(accountId) !== ownAccountId) {
-        throw new Error(`Twitch account '${accountId}' is not available in this service instance`);
-      }
-      return this;
-    }
-    const normalized = normalizeTwitchAccountId(accountId);
-    const service = this.accountServices.get(normalized);
-    if (!service) {
-      throw new Error(`Twitch account '${normalized}' is not available`);
-    }
-    return service;
-  }
-  isConnected() {
-    if (this.accountServices?.size > 0) {
-      return Array.from(this.accountServices.values()).some((service) => service.isConnected());
-    }
-    return this.connected;
-  }
-  getBotUsername() {
-    if (this.accountServices?.size > 0) {
-      return this.getDefaultAccountService().getBotUsername();
-    }
-    return this.settings.username;
-  }
-  getAccountId(runtime) {
-    if (this.accountServices?.size > 0) {
-      return this.getDefaultAccountService().getAccountId(runtime);
-    }
-    return normalizeTwitchAccountId(this.settings?.accountId ?? (runtime ? resolveDefaultTwitchAccountId(runtime) : undefined));
-  }
-  getPrimaryChannel() {
-    if (this.accountServices?.size > 0) {
-      return this.getDefaultAccountService().getPrimaryChannel();
-    }
-    return this.settings.channel;
-  }
-  getJoinedChannels() {
-    if (this.accountServices?.size > 0) {
-      return this.getDefaultAccountService().getJoinedChannels();
-    }
-    return Array.from(this.joinedChannels);
-  }
-  async handleSendMessage(runtime, target, content) {
-    const requestedAccountId = normalizeTwitchAccountId(target.accountId ?? readTwitchAccountId(content, target) ?? this.getAccountId());
-    if (this.accountServices?.size > 0) {
-      await this.getAccountService(requestedAccountId).handleSendMessage(runtime, target, content);
-      return;
-    }
-    if (requestedAccountId !== this.getAccountId()) {
-      throw new Error(`Twitch account '${requestedAccountId}' is not available in this service instance`);
-    }
-    const text = typeof content.text === "string" ? content.text.trim() : "";
-    if (!text) {
-      throw new Error("Twitch connector requires non-empty text content.");
-    }
-    let channel = target.channelId;
-    let replyTo = target.threadId;
-    if (target.roomId && !channel) {
-      const room = await runtime.getRoom(target.roomId);
-      channel = room?.channelId;
-      const metadata = room?.metadata;
-      replyTo = replyTo ?? (typeof metadata?.twitchReplyTo === "string" ? metadata.twitchReplyTo : undefined);
-    }
-    await this.sendMessage(text, {
-      channel: channel ? normalizeChannel(channel) : this.getPrimaryChannel(),
-      replyTo
-    });
-  }
-  async resolveConnectorTargets(query, _context) {
-    const normalizedQuery = normalizeTwitchConnectorQuery(query);
-    return this.getConnectorChannels().map((channel) => {
-      const score = scoreTwitchChannelMatch(normalizedQuery, channel);
-      return score > 0 ? this.buildChannelTarget(channel, score) : null;
-    }).filter((target) => Boolean(target)).slice(0, 25);
-  }
-  async listConnectorRooms(_context) {
-    return this.getConnectorChannels().map((channel) => this.buildChannelTarget(channel, 0.5)).slice(0, 50);
-  }
-  async listRecentConnectorTargets(context) {
-    const targets = [];
-    const room = context.roomId && typeof context.runtime.getRoom === "function" ? await context.runtime.getRoom(context.roomId) : null;
-    const channel = context.target?.channelId ?? room?.channelId;
-    if (channel) {
-      targets.push(this.buildChannelTarget(channel, 0.95));
-    }
-    targets.push(...await this.listConnectorRooms(context));
-    const seen = new Set;
-    return targets.filter((target) => {
-      const channelId = target.target.channelId;
-      if (!channelId || seen.has(channelId)) {
-        return false;
-      }
-      seen.add(channelId);
-      return true;
-    }).slice(0, 25);
-  }
-  async handleJoinChannel(_runtime, params) {
-    const channel = this.resolveChannelOpTarget(params);
-    if (!channel) {
-      throw new Error("Twitch MESSAGE operation=join requires channelId, alias, or target channel.");
-    }
-    if (this.joinedChannels.has(channel)) {
-      return;
-    }
-    await this.joinChannel(channel);
-  }
-  async handleLeaveChannel(_runtime, params) {
-    const channel = this.resolveChannelOpTarget(params);
-    if (!channel) {
-      throw new Error("Twitch MESSAGE operation=leave requires channelId, alias, or target channel.");
-    }
-    if (channel === normalizeChannel(this.getPrimaryChannel())) {
-      throw new Error(`Cannot leave the primary Twitch channel #${channel}.`);
-    }
-    if (!this.joinedChannels.has(channel)) {
-      throw new Error(`Not currently in Twitch channel #${channel}.`);
-    }
-    await this.leaveChannel(channel);
-  }
-  async getConnectorChatContext(target, context) {
-    let channel = target.channelId;
-    if (!channel && target.roomId) {
-      const room = await context.runtime.getRoom(target.roomId);
-      channel = room?.channelId;
-    }
-    channel = channel ? normalizeChannel(channel) : this.getPrimaryChannel();
-    return {
-      target: {
-        source: "twitch",
-        accountId: this.getAccountId(),
-        channelId: channel
-      },
-      label: formatChannelForDisplay(channel),
-      summary: "Twitch chat messages are public and visible to viewers in the channel.",
-      metadata: {
-        accountId: this.getAccountId(),
-        twitchChannel: channel,
-        botUsername: this.getBotUsername(),
-        joined: this.joinedChannels.has(channel)
-      }
-    };
-  }
-  getConnectorChannels() {
-    const channels = new Set;
-    if (this.settings?.channel) {
-      channels.add(normalizeChannel(this.settings.channel));
-    }
-    for (const channel of this.settings?.additionalChannels ?? []) {
-      channels.add(normalizeChannel(channel));
-    }
-    for (const channel of this.joinedChannels) {
-      channels.add(normalizeChannel(channel));
-    }
-    return Array.from(channels);
-  }
-  resolveChannelOpTarget(params) {
-    const targetRecord = params.target;
-    const raw = params.target?.channelId ?? params.channelId ?? params.alias ?? targetRecord?.alias ?? targetRecord?.name;
-    return typeof raw === "string" && raw.trim() ? normalizeChannel(raw.trim()) : null;
-  }
-  buildChannelTarget(channel, score) {
-    const normalized = normalizeChannel(channel);
-    return {
-      target: {
-        source: "twitch",
-        accountId: this.getAccountId(),
-        channelId: normalized
-      },
-      label: formatChannelForDisplay(normalized),
-      kind: "channel",
-      description: "Twitch public chat channel",
-      score,
-      contexts: [...TWITCH_CONNECTOR_CONTEXTS],
-      metadata: {
-        accountId: this.getAccountId(),
-        twitchChannel: normalized,
-        joined: this.joinedChannels.has(normalized),
-        primary: normalized === this.getPrimaryChannel()
-      }
-    };
-  }
-  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.accountServices?.size > 0) {
-      const accountId = normalizeTwitchAccountId(options?.accountId ?? this.getAccountId());
-      return this.getAccountService(accountId).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) {
-      await logTwurpleCall("say", { channel, chunkLen: chunk.length, replyTo: options?.replyTo }, async () => {
-        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,
-      accountId: this.getAccountId(),
-      channel,
-      text: cleanedText,
-      messageId: lastMessageId
-    });
-    return { success: true, messageId: lastMessageId };
-  }
-  async joinChannel(channel) {
-    if (this.accountServices?.size > 0) {
-      await this.getDefaultAccountService().joinChannel(channel);
-      return;
-    }
-    const normalized = normalizeChannel(channel);
-    await logTwurpleCall("join", { channel: normalized }, async () => {
-      await this.client.join(normalized);
-    });
-    this.joinedChannels.add(normalized);
-  }
-  async leaveChannel(channel) {
-    if (this.accountServices?.size > 0) {
-      await this.getDefaultAccountService().leaveChannel(channel);
-      return;
-    }
-    const normalized = normalizeChannel(channel);
-    await logTwurpleCall("part", { channel: normalized }, async () => {
-      await this.client.part(normalized);
-    });
-    this.joinedChannels.delete(normalized);
-  }
-}
-// src/connector-account-provider.ts
-var TWITCH_PROVIDER_ID = "twitch";
-function toConnectorAccount(settings) {
-  const now = Date.now();
-  const configured = Boolean(settings.username && settings.clientId && settings.accessToken);
-  return {
-    id: normalizeTwitchAccountId(settings.accountId),
-    provider: TWITCH_PROVIDER_ID,
-    label: settings.username || settings.channel || settings.accountId,
-    role: "OWNER",
-    purpose: ["messaging"],
-    accessGate: "open",
-    status: settings.enabled !== false && configured ? "connected" : "disabled",
-    externalId: settings.username || undefined,
-    displayHandle: settings.username || undefined,
-    createdAt: now,
-    updatedAt: now,
-    metadata: {
-      channel: settings.channel ?? "",
-      additionalChannels: settings.additionalChannels ?? [],
-      requireMention: settings.requireMention ?? false,
-      hasRefreshToken: Boolean(settings.refreshToken)
-    }
-  };
-}
-function createTwitchConnectorAccountProvider(runtime) {
-  return {
-    provider: TWITCH_PROVIDER_ID,
-    label: "Twitch",
-    listAccounts: async (_manager) => {
-      const ids = listTwitchAccountIds(runtime);
-      if (ids.length === 0) {
-        return [
-          toConnectorAccount(resolveTwitchAccountSettings(runtime, DEFAULT_TWITCH_ACCOUNT_ID))
-        ];
-      }
-      return ids.map((id) => toConnectorAccount(resolveTwitchAccountSettings(runtime, id)));
-    },
-    createAccount: async (input, _manager) => {
-      return {
-        ...input,
-        provider: TWITCH_PROVIDER_ID,
-        role: input.role ?? "OWNER",
-        purpose: input.purpose ?? ["messaging"],
-        accessGate: input.accessGate ?? "open",
-        status: input.status ?? "pending"
-      };
-    },
-    patchAccount: async (_accountId, patch, _manager) => {
-      return { ...patch, provider: TWITCH_PROVIDER_ID };
-    },
-    deleteAccount: async (_accountId, _manager) => {}
-  };
-}
-
-// src/workflow-credential-provider.ts
-import { Service as Service2 } from "@elizaos/core";
-var WORKFLOW_CREDENTIAL_PROVIDER_TYPE = "workflow_credential_provider";
-var SUPPORTED = ["httpHeaderAuth"];
-
-class TwitchWorkflowCredentialProvider extends Service2 {
-  static serviceType = WORKFLOW_CREDENTIAL_PROVIDER_TYPE;
-  capabilityDescription = "Supplies Twitch credentials to the workflow plugin.";
-  static async start(runtime) {
-    return new TwitchWorkflowCredentialProvider(runtime);
-  }
-  async stop() {}
-  async resolve(_userId, credType) {
-    if (credType !== "httpHeaderAuth")
-      return null;
-    const accessToken = this.runtime.getSetting("TWITCH_ACCESS_TOKEN");
-    if (!accessToken?.trim())
-      return null;
-    return {
-      status: "credential_data",
-      data: { name: "Authorization", value: `Bearer ${accessToken.trim()}` }
-    };
-  }
-  checkCredentialTypes(credTypes) {
-    return {
-      supported: credTypes.filter((t) => SUPPORTED.includes(t)),
-      unsupported: credTypes.filter((t) => !SUPPORTED.includes(t))
-    };
-  }
-}
-
-// src/index.ts
-var twitchPlugin = {
-  name: "twitch",
-  description: "Twitch chat integration plugin for ElizaOS with real-time messaging",
-  services: [TwitchService, TwitchWorkflowCredentialProvider],
-  actions: [],
-  providers: [],
-  tests: [],
-  autoEnable: {
-    connectorKeys: ["twitch"]
-  },
-  init: async (_config, runtime) => {
-    try {
-      const manager = getConnectorAccountManager(runtime);
-      manager.registerProvider(createTwitchConnectorAccountProvider(runtime));
-    } catch (err) {
-      logger2.warn({
-        src: "plugin:twitch",
-        err: err instanceof Error ? err.message : String(err)
-      }, "Failed to register Twitch provider with ConnectorAccountManager");
-    }
-    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 {
-  stripMarkdownForTwitch,
-  splitMessageForTwitch,
-  resolveTwitchAccountSettings,
-  resolveDefaultTwitchAccountId,
-  readTwitchAccountId,
-  normalizeTwitchAccountId,
-  normalizeChannel,
-  listTwitchAccountIds,
-  getTwitchUserDisplayName,
-  formatChannelForDisplay,
-  src_default as default,
-  TwitchServiceNotInitializedError,
-  TwitchService,
-  TwitchPluginError,
-  TwitchNotConnectedError,
-  TwitchEventTypes,
-  TwitchConfigurationError,
-  TwitchApiError,
-  TWITCH_SERVICE_NAME,
-  MAX_TWITCH_MESSAGE_LENGTH,
-  DEFAULT_TWITCH_ACCOUNT_ID
-};
-
-//# debugId=E272CF35229333E264756E2164756E21