@elizaos/plugin-twitch 2.0.0-alpha.7 → 2.0.0-beta.1

package/dist/index.js

@@ -1,6 +1,122 @@
 // src/index.ts
-import { logger as logger2 } from "@elizaos/core";
+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,
@@ -100,6 +216,59 @@ class TwitchApiError extends TwitchPluginError {
 }
 
 // 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";
@@ -107,11 +276,46 @@ class TwitchService extends Service {
   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) {
@@ -120,7 +324,26 @@ class TwitchService extends Service {
   }
   async initialize(runtime) {
     this.runtime = runtime;
-    this.settings = this.loadSettings();
+    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 = [
@@ -136,31 +359,8 @@ class TwitchService extends Service {
     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
-    };
+  loadSettings(accountId) {
+    return resolveTwitchAccountSettings(this.runtime, accountId);
   }
   validateSettings() {
     if (!this.settings.username) {
@@ -209,7 +409,8 @@ class TwitchService extends Service {
       this.connected = true;
       logger.info("Twitch chat connected");
       this.runtime.emitEvent("TWITCH_CONNECTION_READY" /* CONNECTION_READY */, {
-        runtime: this.runtime
+        runtime: this.runtime,
+        accountId: this.getAccountId()
       });
     });
     this.client.onDisconnect((_manually, reason) => {
@@ -217,6 +418,7 @@ class TwitchService extends Service {
       logger.warn(`Twitch chat disconnected: ${reason || "unknown reason"}`);
       this.runtime.emitEvent("TWITCH_CONNECTION_LOST" /* CONNECTION_LOST */, {
         runtime: this.runtime,
+        accountId: this.getAccountId(),
         reason
       });
     });
@@ -227,6 +429,7 @@ class TwitchService extends Service {
         logger.info(`Joined Twitch channel: ${normalized}`);
         this.runtime.emitEvent("TWITCH_JOIN_CHANNEL" /* JOIN_CHANNEL */, {
           runtime: this.runtime,
+          accountId: this.getAccountId(),
           channel: normalized
         });
       }
@@ -238,6 +441,7 @@ class TwitchService extends Service {
         logger.info(`Left Twitch channel: ${normalized}`);
         this.runtime.emitEvent("TWITCH_LEAVE_CHANNEL" /* LEAVE_CHANNEL */, {
           runtime: this.runtime,
+          accountId: this.getAccountId(),
           channel: normalized
         });
       }
@@ -289,6 +493,7 @@ class TwitchService extends Service {
     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
     });
   }
@@ -297,6 +502,12 @@ class TwitchService extends Service {
     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();
     }
@@ -304,18 +515,200 @@ class TwitchService extends Service {
     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;
@@ -338,6 +731,10 @@ class TwitchService extends Service {
     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;
     }
@@ -349,11 +746,15 @@ class TwitchService extends Service {
     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);
-      }
+      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));
@@ -361,6 +762,7 @@ class TwitchService extends Service {
     }
     this.runtime.emitEvent("TWITCH_MESSAGE_SENT" /* MESSAGE_SENT */, {
       runtime: this.runtime,
+      accountId: this.getAccountId(),
       channel,
       text: cleanedText,
       messageId: lastMessageId
@@ -368,672 +770,135 @@ class TwitchService extends Service {
     return { success: true, messageId: lastMessageId };
   }
   async joinChannel(channel) {
+    if (this.accountServices?.size > 0) {
+      await this.getDefaultAccountService().joinChannel(channel);
+      return;
+    }
     const normalized = normalizeChannel(channel);
-    await this.client.join(normalized);
+    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 this.client.part(normalized);
+    await logTwurpleCall("part", { channel: normalized }, async () => {
+      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"
+// 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)
+    }
+  };
 }
-
-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, options) => {
-    const __avTextRaw = typeof message?.content?.text === "string" ? message.content.text : "";
-    const __avText = __avTextRaw.toLowerCase();
-    const __avKeywords = ["twitch", "join", "channel"];
-    const __avKeywordOk = __avKeywords.length > 0 && __avKeywords.some((kw) => kw.length > 0 && __avText.includes(kw)) || String(message?.content?.source ?? message?.source ?? "") === "twitch";
-    const __avRegex = new RegExp("\\b(?:twitch|join|channel)\\b", "i");
-    const __avRegexOk = __avRegex.test(__avText) || String(message?.content?.source ?? message?.source ?? "") === "twitch";
-    const __avSource = String(message?.content?.source ?? message?.source ?? "");
-    const __avExpectedSource = "twitch";
-    const __avSourceOk = __avExpectedSource ? __avSource === __avExpectedSource : Boolean(__avSource || state || runtime?.agentId || runtime?.getService);
-    const __avOptions = options && typeof options === "object" ? options : {};
-    const __avInputOk = __avText.trim().length > 0 || Object.keys(__avOptions).length > 0 || Boolean(message?.content && typeof message.content === "object") || String(message?.content?.source ?? message?.source ?? "") === "twitch";
-    if (!(__avKeywordOk && __avRegexOk && __avSourceOk && __avInputOk)) {
-      return false;
-    }
-    const __avLegacyValidate = async (_runtime, message2, _state) => {
-      return message2.content.source === "twitch";
-    };
-    try {
-      return Boolean(await __avLegacyValidate(runtime, message, state, options));
-    } catch {
-      return false;
-    }
-  },
-  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"
-        });
+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 {
-        success: true,
-        data: { channel: channelName, alreadyJoined: true }
+        ...input,
+        provider: TWITCH_PROVIDER_ID,
+        role: input.role ?? "OWNER",
+        purpose: input.purpose ?? ["messaging"],
+        accessGate: input.accessGate ?? "open",
+        status: input.status ?? "pending"
       };
-    }
-    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, options) => {
-    const __avTextRaw = typeof message?.content?.text === "string" ? message.content.text : "";
-    const __avText = __avTextRaw.toLowerCase();
-    const __avKeywords = ["twitch", "leave", "channel"];
-    const __avKeywordOk = __avKeywords.length > 0 && __avKeywords.some((kw) => kw.length > 0 && __avText.includes(kw)) || String(message?.content?.source ?? message?.source ?? "") === "twitch";
-    const __avRegex = new RegExp("\\b(?:twitch|leave|channel)\\b", "i");
-    const __avRegexOk = __avRegex.test(__avText) || String(message?.content?.source ?? message?.source ?? "") === "twitch";
-    const __avSource = String(message?.content?.source ?? message?.source ?? "");
-    const __avExpectedSource = "twitch";
-    const __avSourceOk = __avExpectedSource ? __avSource === __avExpectedSource : Boolean(__avSource || state || runtime?.agentId || runtime?.getService);
-    const __avOptions = options && typeof options === "object" ? options : {};
-    const __avInputOk = __avText.trim().length > 0 || Object.keys(__avOptions).length > 0 || Boolean(message?.content && typeof message.content === "object") || String(message?.content?.source ?? message?.source ?? "") === "twitch";
-    if (!(__avKeywordOk && __avRegexOk && __avSourceOk && __avInputOk)) {
-      return false;
-    }
-    const __avLegacyValidate = async (_runtime, message2, _state) => {
-      return message2.content.source === "twitch";
-    };
-    try {
-      return Boolean(await __avLegacyValidate(runtime, message, state, options));
-    } catch {
-      return false;
-    }
-  },
-  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, options) => {
-    const __avTextRaw = typeof message?.content?.text === "string" ? message.content.text : "";
-    const __avText = __avTextRaw.toLowerCase();
-    const __avKeywords = ["twitch", "list", "channels"];
-    const __avKeywordOk = __avKeywords.length > 0 && __avKeywords.some((kw) => kw.length > 0 && __avText.includes(kw)) || String(message?.content?.source ?? message?.source ?? "") === "twitch";
-    const __avRegex = new RegExp("\\b(?:twitch|list|channels)\\b", "i");
-    const __avRegexOk = __avRegex.test(__avText) || String(message?.content?.source ?? message?.source ?? "") === "twitch";
-    const __avSource = String(message?.content?.source ?? message?.source ?? "");
-    const __avExpectedSource = "twitch";
-    const __avSourceOk = __avExpectedSource ? __avSource === __avExpectedSource : Boolean(__avSource || state || runtime?.agentId || runtime?.getService);
-    const __avOptions = options && typeof options === "object" ? options : {};
-    const __avInputOk = __avText.trim().length > 0 || Object.keys(__avOptions).length > 0 || Boolean(message?.content && typeof message.content === "object") || String(message?.content?.source ?? message?.source ?? "") === "twitch";
-    if (!(__avKeywordOk && __avRegexOk && __avSourceOk && __avInputOk)) {
-      return false;
-    }
-    const __avLegacyValidate = async (_runtime, message2, _state) => {
-      return message2.content.source === "twitch";
-    };
-    try {
-      return Boolean(await __avLegacyValidate(runtime, message, state, options));
-    } catch {
-      return false;
-    }
-  },
-  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"
+    },
+    patchAccount: async (_accountId, patch, _manager) => {
+      return { ...patch, provider: TWITCH_PROVIDER_ID };
+    },
+    deleteAccount: async (_accountId, _manager) => {}
+  };
 }
 
-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, options) => {
-    const __avTextRaw = typeof message?.content?.text === "string" ? message.content.text : "";
-    const __avText = __avTextRaw.toLowerCase();
-    const __avKeywords = ["twitch", "send", "message"];
-    const __avKeywordOk = __avKeywords.length > 0 && __avKeywords.some((kw) => kw.length > 0 && __avText.includes(kw)) || String(message?.content?.source ?? message?.source ?? "") === "twitch";
-    const __avRegex = new RegExp("\\b(?:twitch|send|message)\\b", "i");
-    const __avRegexOk = __avRegex.test(__avText) || String(message?.content?.source ?? message?.source ?? "") === "twitch";
-    const __avSource = String(message?.content?.source ?? message?.source ?? "");
-    const __avExpectedSource = "twitch";
-    const __avSourceOk = __avExpectedSource ? __avSource === __avExpectedSource : Boolean(__avSource || state || runtime?.agentId || runtime?.getService);
-    const __avOptions = options && typeof options === "object" ? options : {};
-    const __avInputOk = __avText.trim().length > 0 || Object.keys(__avOptions).length > 0 || Boolean(message?.content && typeof message.content === "object") || String(message?.content?.source ?? message?.source ?? "") === "twitch";
-    if (!(__avKeywordOk && __avRegexOk && __avSourceOk && __avInputOk)) {
-      return false;
-    }
-    const __avLegacyValidate = async (_runtime, message2, _state) => {
-      return message2.content.source === "twitch";
-    };
-    try {
-      return Boolean(await __avLegacyValidate(runtime, message, state, options));
-    } catch {
-      return false;
-    }
-  },
-  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/workflow-credential-provider.ts
+import { Service as Service2 } from "@elizaos/core";
+var WORKFLOW_CREDENTIAL_PROVIDER_TYPE = "workflow_credential_provider";
+var SUPPORTED = ["httpHeaderAuth"];
 
-// src/providers/channelState.ts
-var channelStateProvider = {
-  name: "twitchChannelState",
-  description: "Provides information about the current Twitch channel context",
-  dynamic: true,
-  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).`;
+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 {
-      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
+      status: "credential_data",
+      data: { name: "Authorization", value: `Bearer ${accessToken.trim()}` }
     };
   }
-};
-
-// src/providers/userContext.ts
-var userContextProvider = {
-  name: "twitchUserContext",
-  description: "Provides information about the Twitch user in the current conversation",
-  dynamic: true,
-  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.`;
-    }
+  checkCredentialTypes(credTypes) {
     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
+      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],
-  actions: [sendMessage, joinChannel, leaveChannel, listChannels],
-  providers: [channelStateProvider, userContextProvider],
+  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");
@@ -1081,18 +946,17 @@ var twitchPlugin = {
 };
 var src_default = twitchPlugin;
 export {
-  userContextProvider,
   stripMarkdownForTwitch,
   splitMessageForTwitch,
-  sendMessage,
+  resolveTwitchAccountSettings,
+  resolveDefaultTwitchAccountId,
+  readTwitchAccountId,
+  normalizeTwitchAccountId,
   normalizeChannel,
-  listChannels,
-  leaveChannel,
-  joinChannel,
+  listTwitchAccountIds,
   getTwitchUserDisplayName,
   formatChannelForDisplay,
   src_default as default,
-  channelStateProvider,
   TwitchServiceNotInitializedError,
   TwitchService,
   TwitchPluginError,
@@ -1101,7 +965,8 @@ export {
   TwitchConfigurationError,
   TwitchApiError,
   TWITCH_SERVICE_NAME,
-  MAX_TWITCH_MESSAGE_LENGTH
+  MAX_TWITCH_MESSAGE_LENGTH,
+  DEFAULT_TWITCH_ACCOUNT_ID
 };
 
-//# debugId=9A799CC811D81DB364756E2164756E21
+//# debugId=E272CF35229333E264756E2164756E21