@openclaw/twitch 2026.5.7 → 2026.5.10-beta.1

package/dist/api.js

@@ -1,3 +1,3 @@
-import { t as twitchPlugin } from "./plugin-BQX9GiIn.js";
+import { t as twitchPlugin } from "./plugin-BLMSYnzs.js";
 import { n as setTwitchRuntime } from "./runtime-QZ5I3GlI.js";
 export { setTwitchRuntime, twitchPlugin };

package/dist/channel-plugin-api.js

@@ -1,2 +1,2 @@
-import { t as twitchPlugin } from "./plugin-BQX9GiIn.js";
+import { t as twitchPlugin } from "./plugin-BLMSYnzs.js";
 export { twitchPlugin };

package/dist/{markdown-MRdI1sR7.js → markdown-CLNO0I2v.js}

@@ -1,4 +1,4 @@
-import { i as normalizeToken, o as resolveTwitchToken } from "./twitch-CklAMZL5.js";
+import { i as normalizeToken, o as resolveTwitchToken } from "./twitch-D0A1Bjui.js";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { RefreshingAuthProvider, StaticAuthProvider } from "@twurple/auth";
 import { ChatClient, LogLevel } from "@twurple/chat";

package/dist/{monitor-DS0YTAPB.js → monitor-DvbgvvL4.js}

@@ -1,128 +1,132 @@
-import { i as getOrCreateClientManager, n as stripMarkdownForTwitch } from "./markdown-MRdI1sR7.js";
+import { i as getOrCreateClientManager, n as stripMarkdownForTwitch } from "./markdown-CLNO0I2v.js";
 import { t as getTwitchRuntime } from "./runtime-QZ5I3GlI.js";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/text-runtime";
-import { createChannelReplyPipeline } from "openclaw/plugin-sdk/channel-reply-pipeline";
+import { createChannelIngressResolver, defineStableChannelIngressIdentity } from "openclaw/plugin-sdk/channel-ingress-runtime";
 //#region extensions/twitch/src/access-control.ts
-/**
-* Check if a Twitch message should be allowed based on account configuration
-*
-* This function implements the access control logic for incoming Twitch messages,
-* checking allowlists, role-based restrictions, and mention requirements.
-*
-* Priority order:
-* 1. If `requireMention` is true, message must mention the bot
-* 2. If `allowFrom` is set, sender must be in the allowlist (by user ID)
-* 3. If `allowedRoles` is set (and `allowFrom` is not), sender must have at least one role
-*
-* Note: `allowFrom` is a hard allowlist. When set, only those user IDs are allowed.
-* Use `allowedRoles` as an alternative when you don't want to maintain an allowlist.
-*
-* Available roles:
-* - "moderator": Moderators
-* - "owner": Channel owner/broadcaster
-* - "vip": VIPs
-* - "subscriber": Subscribers
-* - "all": Anyone in the chat
-*/
-function checkTwitchAccessControl(params) {
+const twitchUserIdentity = defineStableChannelIngressIdentity({
+	key: "sender-id",
+	entryIdPrefix: "twitch-user-entry"
+});
+const twitchRoleIdentity = defineStableChannelIngressIdentity({
+	key: "role-moderator",
+	kind: "role",
+	normalizeEntry: normalizeTwitchRole,
+	normalizeSubject: normalizeTwitchRole,
+	aliases: [
+		"owner",
+		"vip",
+		"subscriber"
+	].map((role) => ({
+		key: `role-${role}`,
+		kind: "role",
+		normalizeEntry: () => null,
+		normalizeSubject: normalizeTwitchRole
+	})),
+	isWildcardEntry: (entry) => normalizeTwitchRole(entry) === "all",
+	resolveEntryId: ({ entryIndex }) => `twitch-role-entry-${entryIndex + 1}`
+});
+async function checkTwitchAccessControl(params) {
 	const { message, account, botUsername } = params;
-	if (account.requireMention ?? true) {
-		if (!extractMentions(message.message).includes(normalizeLowercaseStringOrEmpty(botUsername))) return {
-			allowed: false,
-			reason: "message does not mention the bot (requireMention is enabled)"
-		};
-	}
-	if (account.allowFrom !== void 0) {
-		const allowFrom = account.allowFrom;
-		if (allowFrom.length === 0) return {
-			allowed: false,
-			reason: "sender is not in allowFrom allowlist"
-		};
-		const senderId = message.userId;
-		if (!senderId) return {
-			allowed: false,
-			reason: "sender user ID not available for allowlist check"
-		};
-		if (allowFrom.includes(senderId)) return {
+	const policyKind = resolveTwitchPolicyKind(account);
+	const decision = (await createChannelIngressResolver({
+		channelId: "twitch",
+		accountId: "default",
+		identity: policyKind === "role" ? twitchRoleIdentity : twitchUserIdentity
+	}).message({
+		subject: policyKind === "role" ? twitchRoleSubject(message) : { stableId: message.userId },
+		conversation: {
+			kind: "group",
+			id: message.channel
+		},
+		event: { mayPair: false },
+		mentionFacts: {
+			canDetectMention: true,
+			wasMentioned: mentionsBot(message.message, botUsername)
+		},
+		dmPolicy: "open",
+		groupPolicy: policyKind === "open" ? "open" : "allowlist",
+		policy: { activation: {
+			requireMention: account.requireMention ?? true,
+			allowTextCommands: false,
+			order: "before-sender"
+		} },
+		groupAllowFrom: policyKind === "allowFrom" ? account.allowFrom : policyKind === "role" ? account.allowedRoles : void 0
+	})).ingress;
+	if (decision.decisiveGateId === "activation" && decision.admission !== "dispatch") return {
+		allowed: false,
+		reason: "message does not mention the bot (requireMention is enabled)"
+	};
+	if (decision.admission === "dispatch") {
+		if (policyKind === "allowFrom") return {
 			allowed: true,
-			matchKey: senderId,
+			matchKey: params.message.userId,
 			matchSource: "allowlist"
 		};
-		return {
-			allowed: false,
-			reason: "sender is not in allowFrom allowlist"
-		};
-	}
-	if (account.allowedRoles && account.allowedRoles.length > 0) {
-		const allowedRoles = account.allowedRoles;
-		if (allowedRoles.includes("all")) return {
+		if (policyKind === "role") return {
 			allowed: true,
-			matchKey: "all",
+			matchKey: params.account.allowedRoles?.join(","),
 			matchSource: "role"
 		};
-		if (!checkSenderRoles({
-			message,
-			allowedRoles
-		})) return {
+		return { allowed: true };
+	}
+	if (policyKind === "allowFrom") {
+		if (!params.message.userId) return {
 			allowed: false,
-			reason: `sender does not have any of the required roles: ${allowedRoles.join(", ")}`
+			reason: "sender user ID not available for allowlist check"
 		};
 		return {
-			allowed: true,
-			matchKey: allowedRoles.join(","),
-			matchSource: "role"
+			allowed: false,
+			reason: "sender is not in allowFrom allowlist"
 		};
 	}
-	return { allowed: true };
+	if (policyKind === "role") return {
+		allowed: false,
+		reason: `sender does not have any of the required roles: ${params.account.allowedRoles?.join(", ") ?? ""}`
+	};
+	return {
+		allowed: false,
+		reason: reasonForTwitchIngressDecision(decision)
+	};
 }
-/**
-* Check if the sender has any of the allowed roles
-*/
-function checkSenderRoles(params) {
-	const { message, allowedRoles } = params;
-	const { isMod, isOwner, isVip, isSub } = message;
-	for (const role of allowedRoles) switch (role) {
-		case "moderator":
-			if (isMod) return true;
-			break;
-		case "owner":
-			if (isOwner) return true;
-			break;
-		case "vip":
-			if (isVip) return true;
-			break;
-		case "subscriber":
-			if (isSub) return true;
-			break;
+function resolveTwitchPolicyKind(account) {
+	if (account.allowFrom !== void 0) return "allowFrom";
+	if (account.allowedRoles && account.allowedRoles.length > 0) return "role";
+	return "open";
+}
+function twitchRoleSubject(message) {
+	return {
+		stableId: message.isMod ? "moderator" : void 0,
+		aliases: {
+			"role-owner": message.isOwner ? "owner" : void 0,
+			"role-vip": message.isVip ? "vip" : void 0,
+			"role-subscriber": message.isSub ? "subscriber" : void 0
+		}
+	};
+}
+function normalizeTwitchRole(value) {
+	const role = normalizeLowercaseStringOrEmpty(value);
+	if (role === "*") return "all";
+	return role === "moderator" || role === "owner" || role === "vip" || role === "subscriber" || role === "all" ? role : null;
+}
+function reasonForTwitchIngressDecision(decision) {
+	switch (decision.reasonCode) {
+		case "activation_skipped": return "message does not mention the bot (requireMention is enabled)";
+		case "group_policy_empty_allowlist":
+		case "group_policy_not_allowlisted": return "sender is not in allowFrom allowlist";
+		default: return decision.reasonCode;
 	}
-	return false;
 }
-/**
-* Extract @mentions from a Twitch chat message
-*
-* Returns a list of lowercase usernames that were mentioned in the message.
-* Twitch mentions are in the format @username.
-*/
-function extractMentions(message) {
+function mentionsBot(message, botUsername) {
+	const expected = normalizeLowercaseStringOrEmpty(botUsername);
 	const mentionRegex = /@(\w+)/g;
-	const mentions = [];
 	let match;
-	while ((match = mentionRegex.exec(message)) !== null) {
-		const username = match[1];
-		if (username) mentions.push(normalizeLowercaseStringOrEmpty(username));
-	}
-	return mentions;
+	while ((match = mentionRegex.exec(message)) !== null) if ((match[1] ? normalizeLowercaseStringOrEmpty(match[1]) : "") === expected) return true;
+	return false;
 }
 //#endregion
 //#region extensions/twitch/src/monitor.ts
 /**
-* Twitch message monitor - processes incoming messages and routes to agents.
-*
-* This monitor connects to the Twitch client manager, processes incoming messages,
-* resolves agent routes, and handles replies.
-*/
-/**
 * Process an incoming Twitch message and dispatch to agent.
 */
 async function processTwitchMessage(params) {
@@ -203,12 +207,6 @@ async function processTwitchMessage(params) {
 					channel: "twitch",
 					accountId
 				});
-				const { onModelSelected, ...replyPipeline } = createChannelReplyPipeline({
-					cfg,
-					agentId: route.agentId,
-					channel: "twitch",
-					accountId
-				});
 				return {
 					cfg,
 					channel: "twitch",
@@ -220,24 +218,26 @@ async function processTwitchMessage(params) {
 					recordInboundSession: core.channel.session.recordInboundSession,
 					dispatchReplyWithBufferedBlockDispatcher: core.channel.reply.dispatchReplyWithBufferedBlockDispatcher,
 					delivery: {
+						durable: () => ({ to: `twitch:channel:${message.channel}` }),
 						deliver: async (payload) => {
-							await deliverTwitchReply({
+							return await deliverTwitchReply({
 								payload,
 								channel: message.channel,
 								account,
 								accountId,
 								config,
 								tableMode,
-								runtime,
-								statusSink
+								runtime
 							});
 						},
+						onDelivered: (_payload, _info, result) => {
+							if (result?.visibleReplySent !== false) statusSink?.({ lastOutboundAt: Date.now() });
+						},
 						onError: (err, info) => {
 							runtime.error?.(`Twitch ${info.kind} reply failed: ${String(err)}`);
 						}
 					},
-					dispatcherOptions: replyPipeline,
-					replyOptions: { onModelSelected },
+					replyPipeline: {},
 					record: { onRecordError: (err) => {
 						runtime.error?.(`Failed updating session meta: ${String(err)}`);
 					} }
@@ -250,7 +250,7 @@ async function processTwitchMessage(params) {
 * Deliver a reply to Twitch chat.
 */
 async function deliverTwitchReply(params) {
-	const { payload, channel, account, accountId, config, runtime, statusSink } = params;
+	const { payload, channel, account, accountId, config, runtime } = params;
 	try {
 		const client = await getOrCreateClientManager(accountId, {
 			info: (msg) => runtime.log?.(msg),
@@ -260,17 +260,18 @@ async function deliverTwitchReply(params) {
 		}).getClient(account, config, accountId);
 		if (!client) {
 			runtime.error?.(`No client available for sending reply`);
-			return;
+			return { visibleReplySent: false };
 		}
 		if (!payload.text) {
 			runtime.error?.(`No text to send in reply payload`);
-			return;
+			return { visibleReplySent: false };
 		}
 		const textToSend = stripMarkdownForTwitch(payload.text);
 		await client.say(channel, textToSend);
-		statusSink?.({ lastOutboundAt: Date.now() });
+		return { visibleReplySent: true };
 	} catch (err) {
 		runtime.error?.(`Failed to send reply: ${String(err)}`);
+		return { visibleReplySent: false };
 	}
 }
 /**
@@ -302,23 +303,26 @@ async function monitorTwitchProvider(options) {
 	}
 	const unregisterHandler = clientManager.onMessage(account, (message) => {
 		if (stopped) return;
-		const botUsername = normalizeLowercaseStringOrEmpty(account.username);
-		if (normalizeLowercaseStringOrEmpty(message.username) === botUsername) return;
-		if (!checkTwitchAccessControl({
-			message,
-			account,
-			botUsername
-		}).allowed) return;
-		statusSink?.({ lastInboundAt: Date.now() });
-		processTwitchMessage({
-			message,
-			account,
-			accountId,
-			config,
-			runtime,
-			core,
-			statusSink
-		}).catch((err) => {
+		(async () => {
+			const botUsername = normalizeLowercaseStringOrEmpty(account.username);
+			if (normalizeLowercaseStringOrEmpty(message.username) === botUsername) return;
+			const access = await checkTwitchAccessControl({
+				message,
+				account,
+				botUsername
+			});
+			if (stopped || !access.allowed) return;
+			statusSink?.({ lastInboundAt: Date.now() });
+			await processTwitchMessage({
+				message,
+				account,
+				accountId,
+				config,
+				runtime,
+				core,
+				statusSink
+			});
+		})().catch((err) => {
 			runtime.error?.(`Message processing failed: ${String(err)}`);
 		});
 	});

package/dist/{plugin-BQX9GiIn.js → plugin-BLMSYnzs.js}

@@ -1,6 +1,6 @@
-import { a as normalizeTwitchChannel, i as normalizeToken, n as isAccountConfigured, o as resolveTwitchToken, r as missingTargetError, t as generateMessageId } from "./twitch-CklAMZL5.js";
-import { a as getAccountConfig, c as resolveTwitchAccountContext, i as DEFAULT_ACCOUNT_ID, l as resolveTwitchSnapshotAccountId, o as listAccountIds, r as twitchSetupWizard, s as resolveDefaultTwitchAccountId, t as twitchSetupAdapter } from "./setup-surface-yArVgckI.js";
-import { a as removeClientManager, n as stripMarkdownForTwitch, r as getClientManager, t as chunkTextForTwitch } from "./markdown-MRdI1sR7.js";
+import { a as normalizeTwitchChannel, i as normalizeToken, n as isAccountConfigured, o as resolveTwitchToken, r as missingTargetError, t as generateMessageId } from "./twitch-D0A1Bjui.js";
+import { a as getAccountConfig, c as resolveTwitchAccountContext, i as DEFAULT_ACCOUNT_ID, l as resolveTwitchSnapshotAccountId, o as listAccountIds, r as twitchSetupWizard, s as resolveDefaultTwitchAccountId, t as twitchSetupAdapter } from "./setup-surface-CDhELE-4.js";
+import { a as removeClientManager, n as stripMarkdownForTwitch, r as getClientManager, t as chunkTextForTwitch } from "./markdown-CLNO0I2v.js";
 import { describeAccountSnapshot } from "openclaw/plugin-sdk/account-helpers";
 import { buildChannelConfigSchema } from "openclaw/plugin-sdk/channel-config-schema";
 import { createChatChannelPlugin } from "openclaw/plugin-sdk/channel-core";
@@ -8,14 +8,33 @@ import { createLoggedPairingApprovalNotifier, createPairingPrefixStripper } from
 import { buildPassiveProbedChannelStatusSummary } from "openclaw/plugin-sdk/extension-shared";
 import { createComputedAccountStatusAdapter, createDefaultChannelRuntimeState } from "openclaw/plugin-sdk/status-helpers";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
+import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/text-runtime";
+import { createMessageReceiptFromOutboundResults, defineChannelMessageAdapter } from "openclaw/plugin-sdk/channel-message";
 import { StaticAuthProvider } from "@twurple/auth";
 import { ChatClient } from "@twurple/chat";
 import { MarkdownConfigSchema } from "openclaw/plugin-sdk/channel-config-primitives";
 import { z } from "openclaw/plugin-sdk/zod";
 import { ApiClient } from "@twurple/api";
-import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/text-runtime";
 //#region extensions/twitch/src/send.ts
 /**
+* Twitch message sending functions with dependency injection support.
+*
+* These functions are the primary interface for sending messages to Twitch.
+* They support dependency injection via the `deps` parameter for testability.
+*/
+function createTwitchSendReceipt(params) {
+	const messageId = params.messageId.trim();
+	const conversationId = params.channel?.trim();
+	return createMessageReceiptFromOutboundResults({
+		results: params.visible === true && messageId && messageId !== "skipped" ? [{
+			channel: "twitch",
+			messageId,
+			...conversationId ? { conversationId } : {}
+		}] : [],
+		kind: "text"
+	});
+}
+/**
 * Internal send function used by the outbound adapter.
 *
 * This function has access to the full OpenClaw config and handles
@@ -44,47 +63,93 @@ async function sendMessageTwitchInternal(channel, text, cfg, accountId, stripMar
 	if (!account) return {
 		ok: false,
 		messageId: generateMessageId(),
+		receipt: createTwitchSendReceipt({
+			messageId: "",
+			channel,
+			visible: false
+		}),
 		error: `Account not found: ${accountId ?? "(default)"}. Available accounts: ${availableAccountIds.join(", ") || "none"}`
 	};
 	if (!configured) return {
 		ok: false,
 		messageId: generateMessageId(),
+		receipt: createTwitchSendReceipt({
+			messageId: "",
+			channel,
+			visible: false
+		}),
 		error: `Account ${resolvedAccountId} is not properly configured. Required: username, clientId, and token (config or env for default account).`
 	};
 	const normalizedChannel = channel || account.channel;
 	if (!normalizedChannel) return {
 		ok: false,
 		messageId: generateMessageId(),
+		receipt: createTwitchSendReceipt({
+			messageId: "",
+			channel: normalizedChannel,
+			visible: false
+		}),
 		error: "No channel specified and no default channel in account config"
 	};
+	const deliveryChannel = normalizeTwitchChannel(normalizedChannel);
 	const cleanedText = stripMarkdown ? stripMarkdownForTwitch(text) : text;
 	if (!cleanedText) return {
 		ok: true,
-		messageId: "skipped"
+		messageId: "skipped",
+		receipt: createTwitchSendReceipt({
+			messageId: "skipped",
+			channel: deliveryChannel,
+			visible: false
+		})
 	};
 	const clientManager = getClientManager(resolvedAccountId);
 	if (!clientManager) return {
 		ok: false,
 		messageId: generateMessageId(),
+		receipt: createTwitchSendReceipt({
+			messageId: "",
+			channel: deliveryChannel,
+			visible: false
+		}),
 		error: `Client manager not found for account: ${resolvedAccountId}. Please start the Twitch gateway first.`
 	};
 	try {
-		const result = await clientManager.sendMessage(account, normalizeTwitchChannel(normalizedChannel), cleanedText, cfg, resolvedAccountId);
-		if (!result.ok) return {
-			ok: false,
-			messageId: result.messageId ?? generateMessageId(),
-			error: result.error ?? "Send failed"
-		};
+		const result = await clientManager.sendMessage(account, deliveryChannel, cleanedText, cfg, resolvedAccountId);
+		if (!result.ok) {
+			const messageId = result.messageId ?? generateMessageId();
+			return {
+				ok: false,
+				messageId,
+				receipt: createTwitchSendReceipt({
+					messageId,
+					channel: deliveryChannel,
+					visible: false
+				}),
+				error: result.error ?? "Send failed"
+			};
+		}
+		const messageId = result.messageId ?? generateMessageId();
 		return {
 			ok: true,
-			messageId: result.messageId ?? generateMessageId()
+			messageId,
+			receipt: createTwitchSendReceipt({
+				messageId,
+				channel: deliveryChannel,
+				visible: true
+			})
 		};
 	} catch (error) {
 		const errorMsg = formatErrorMessage(error);
+		const messageId = generateMessageId();
 		logger.error(`Failed to send message: ${errorMsg}`);
 		return {
 			ok: false,
-			messageId: generateMessageId(),
+			messageId,
+			receipt: createTwitchSendReceipt({
+				messageId,
+				channel: deliveryChannel,
+				visible: false
+			}),
 			error: errorMsg
 		};
 	}
@@ -106,6 +171,11 @@ async function sendMessageTwitchInternal(channel, text, cfg, accountId, stripMar
 const twitchOutbound = {
 	/** Direct delivery mode - messages are sent immediately */
 	deliveryMode: "direct",
+	deliveryCapabilities: { durableFinal: {
+		text: true,
+		media: true,
+		messageSendingHooks: true
+	} },
 	/** Twitch chat message limit is 500 characters */
 	textChunkLimit: 500,
 	/** Word-boundary chunker with markdown stripping */
@@ -184,6 +254,7 @@ const twitchOutbound = {
 		return {
 			channel: "twitch",
 			messageId: result.messageId,
+			receipt: result.receipt,
 			timestamp: Date.now()
 		};
 	},
@@ -216,6 +287,37 @@ const twitchOutbound = {
 		});
 	}
 };
+function toTwitchMessageSendResult(result, kind) {
+	const receipt = result.receipt ?? createMessageReceiptFromOutboundResults({
+		results: result.messageId ? [{
+			channel: "twitch",
+			messageId: result.messageId
+		}] : [],
+		kind
+	});
+	return {
+		messageId: result.messageId || receipt.primaryPlatformMessageId,
+		receipt
+	};
+}
+const twitchMessageAdapter = defineChannelMessageAdapter({
+	id: "twitch",
+	durableFinal: { capabilities: {
+		text: true,
+		media: true,
+		messageSendingHooks: true
+	} },
+	send: {
+		text: async (ctx) => {
+			if (!twitchOutbound.sendText) throw new Error("Twitch text sending is not available.");
+			return toTwitchMessageSendResult(await twitchOutbound.sendText(ctx), "text");
+		},
+		media: async (ctx) => {
+			if (!twitchOutbound.sendMedia) throw new Error("Twitch media sending is not available.");
+			return toTwitchMessageSendResult(await twitchOutbound.sendMedia(ctx), "media");
+		}
+	}
+});
 //#endregion
 //#region extensions/twitch/src/actions.ts
 /**
@@ -779,6 +881,7 @@ const twitchPlugin = createChatChannelPlugin({
 		setup: twitchSetupAdapter,
 		setupWizard: twitchSetupWizard,
 		capabilities: { chatTypes: ["group"] },
+		message: twitchMessageAdapter,
 		configSchema: buildChannelConfigSchema(TwitchConfigSchema),
 		config: {
 			listAccountIds: (cfg) => listAccountIds(cfg),
@@ -851,7 +954,7 @@ const twitchPlugin = createChatChannelPlugin({
 					lastError: null
 				});
 				ctx.log?.info(`Starting Twitch connection for ${account.username}`);
-				const { monitorTwitchProvider } = await import("./monitor-DS0YTAPB.js");
+				const { monitorTwitchProvider } = await import("./monitor-DvbgvvL4.js");
 				await monitorTwitchProvider({
 					account,
 					accountId,

package/dist/setup-plugin-api.js

@@ -1,2 +1,2 @@
-import { n as twitchSetupPlugin } from "./setup-surface-yArVgckI.js";
+import { n as twitchSetupPlugin } from "./setup-surface-CDhELE-4.js";
 export { twitchSetupPlugin };

package/dist/{setup-surface-yArVgckI.js → setup-surface-CDhELE-4.js}

@@ -1,4 +1,4 @@
-import { n as isAccountConfigured, o as resolveTwitchToken } from "./twitch-CklAMZL5.js";
+import { n as isAccountConfigured, o as resolveTwitchToken } from "./twitch-D0A1Bjui.js";
 import { listCombinedAccountIds, normalizeAccountId, resolveNormalizedAccountEntry } from "openclaw/plugin-sdk/account-resolution";
 import { normalizeOptionalAccountId } from "openclaw/plugin-sdk/account-id";
 import { getChatChannelMeta } from "openclaw/plugin-sdk/core";

package/dist/{twitch-CklAMZL5.js → twitch-D0A1Bjui.js}

@@ -1,5 +1,6 @@
 import { DEFAULT_ACCOUNT_ID, normalizeAccountId, resolveNormalizedAccountEntry } from "openclaw/plugin-sdk/account-resolution";
 import { randomUUID } from "node:crypto";
+import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/text-runtime";
 //#region extensions/twitch/src/token.ts
 /**
 * Twitch access token resolution with environment variable support.
@@ -61,9 +62,6 @@ function resolveTwitchToken(cfg, opts = {}) {
 /**
 * Twitch-specific utility functions
 */
-function normalizeLowercaseStringOrEmpty(value) {
-	return typeof value === "string" ? value.trim().toLowerCase() : "";
-}
 /**
 * Normalize Twitch channel names.
 *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/twitch",
-  "version": "2026.5.7",
+  "version": "2026.5.10-beta.1",
   "description": "OpenClaw Twitch channel plugin",
   "repository": {
     "type": "git",
@@ -26,10 +26,10 @@
       "minHostVersion": ">=2026.4.10"
     },
     "compat": {
-      "pluginApi": ">=2026.5.7"
+      "pluginApi": ">=2026.5.10-beta.1"
     },
     "build": {
-      "openclawVersion": "2026.5.7"
+      "openclawVersion": "2026.5.10-beta.1"
     },
     "channel": {
       "id": "twitch",
@@ -56,7 +56,7 @@
     "README.md"
   ],
   "peerDependencies": {
-    "openclaw": ">=2026.5.7"
+    "openclaw": ">=2026.5.10-beta.1"
   },
   "peerDependenciesMeta": {
     "openclaw": {