@openclaw/irc 2026.9.1-beta.1 → 2026.9.2

package/dist/api.js

@@ -1,3 +1,3 @@
-import { _ as resolveDefaultIrcAccountId, g as listIrcAccountIds, h as listEnabledIrcAccounts, n as ircSetupWizard, r as ircSetupAdapter, t as ircPlugin, v as resolveIrcAccount } from "./channel-W4DLS5ip.js";
+import { _ as listIrcAccountIds, g as listEnabledIrcAccounts, n as ircSetupWizard, r as ircSetupAdapter, t as ircPlugin, v as resolveDefaultIrcAccountId, y as resolveIrcAccount } from "./channel-C0XrtiC0.js";
 import { n as setIrcRuntime } from "./runtime-xy-FcjJC.js";
 export { ircPlugin, ircSetupAdapter, ircSetupWizard, listEnabledIrcAccounts, listIrcAccountIds, resolveDefaultIrcAccountId, resolveIrcAccount, setIrcRuntime };

package/dist/{channel-W4DLS5ip.js → channel-C0XrtiC0.js}

@@ -1,10 +1,11 @@
-import { t as IrcChannelConfigSchema } from "./config-schema-BDXGjxOr.js";
+import { t as IrcChannelConfigSchema } from "./config-schema-DcYE4WjJ.js";
 import { t as getIrcRuntime } from "./runtime-xy-FcjJC.js";
 import { n as collectRuntimeConfigAssignments, r as secretTargetRegistryEntries } from "./secret-contract-D_DC3YWj.js";
 import { createAccountListHelpers, describeAccountSnapshot } from "openclaw/plugin-sdk/account-helpers";
 import { formatNormalizedAllowFromEntries } from "openclaw/plugin-sdk/allow-from";
 import { adaptScopedAccountAccessor, createScopedChannelConfigAdapter, createScopedDmSecurityResolver } from "openclaw/plugin-sdk/channel-config-helpers";
 import { buildChannelOutboundSessionRoute, createChatChannelPlugin, parseOptionalDelimitedEntries } from "openclaw/plugin-sdk/channel-core";
+import { defineStableChannelIngressIdentity, identityEntryAuthenticationClassifier } from "openclaw/plugin-sdk/channel-ingress-runtime";
 import { buildMutableAllowEntryDetector, collectStandardAllowlistLists, createAllowlistProviderOpenWarningCollector, createConditionalWarningCollector, createDangerousNameMatchingMutableAllowlistWarningCollector, resolveScopeKeyCaseInsensitive, resolveScopeRequireMention, resolveScopeToolsPolicy } from "openclaw/plugin-sdk/channel-policy";
 import { createChannelDirectoryAdapter, createResolvedDirectoryEntriesLister } from "openclaw/plugin-sdk/directory-runtime";
 import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
@@ -188,9 +189,12 @@ function listEnabledIrcAccounts(cfg) {
 		accountId
 	})).filter((account) => account.enabled);
 }
+//#endregion
+//#region extensions/irc/src/doctor.ts
+const isIrcMutableAllowEntry = buildMutableAllowEntryDetector({ stableIdPattern: /^(?:(?:irc|user):)*[^@]*@/i });
 const collectIrcMutableAllowlistWarnings = createDangerousNameMatchingMutableAllowlistWarningCollector({
 	channel: "irc",
-	detector: buildMutableAllowEntryDetector({ stableIdPattern: /^(?:(?:irc|user):)*[^@]*@/i }),
+	detector: isIrcMutableAllowEntry,
 	collectLists: (scope) => collectStandardAllowlistLists(scope, {
 		includeGroups: true,
 		groupField: "allowFrom"
@@ -198,7 +202,7 @@ const collectIrcMutableAllowlistWarnings = createDangerousNameMatchingMutableAll
 });
 //#endregion
 //#region extensions/irc/src/gateway.ts
-const loadIrcChannelRuntime$1 = createLazyRuntimeModule(() => import("./channel-runtime-CA62Mbrh.js"));
+const loadIrcChannelRuntime$1 = createLazyRuntimeModule(() => import("./channel-runtime-Bhm49qnu.js"));
 async function startIrcGatewayAccount(ctx) {
 	const account = ctx.account;
 	const statusSink = createAccountStatusSink({
@@ -223,18 +227,6 @@ async function startIrcGatewayAccount(ctx) {
 	});
 }
 //#endregion
-//#region extensions/irc/src/outbound-base.ts
-function sanitizeIrcAssistantText(text) {
-	return sanitizeForPlainText(sanitizeAssistantVisibleText(text));
-}
-const ircOutboundBaseAdapter = {
-	deliveryMode: "direct",
-	chunker: chunkTextForOutbound,
-	chunkerMode: "markdown",
-	textChunkLimit: 350,
-	sanitizeText: ({ text }) => sanitizeIrcAssistantText(text)
-};
-//#endregion
 //#region extensions/irc/src/control-chars.ts
 function isIrcControlChar(charCode) {
 	return charCode <= 31 || charCode === 127;
@@ -249,8 +241,158 @@ function stripIrcControlChars(value) {
 	return out;
 }
 //#endregion
-//#region extensions/irc/src/protocol.ts
+//#region extensions/irc/src/normalize.ts
 const IRC_TARGET_PATTERN$1 = /^[^\s:]+$/u;
+function isChannelTarget(target) {
+	return target.startsWith("#") || target.startsWith("&");
+}
+function normalizeIrcMessagingTarget(raw) {
+	const trimmed = raw.trim();
+	if (!trimmed) return;
+	let target = trimmed;
+	if (normalizeLowercaseStringOrEmpty(target).startsWith("irc:")) target = target.slice(4).trim();
+	if (normalizeLowercaseStringOrEmpty(target).startsWith("channel:")) {
+		target = target.slice(8).trim();
+		if (!target.startsWith("#") && !target.startsWith("&")) target = `#${target}`;
+	}
+	if (normalizeLowercaseStringOrEmpty(target).startsWith("user:")) target = target.slice(5).trim();
+	if (!target || !looksLikeIrcTargetId(target)) return;
+	return target;
+}
+function resolveIrcOutboundSessionRoute(params) {
+	const target = normalizeIrcMessagingTarget(params.target);
+	if (!target) return null;
+	const chatType = isChannelTarget(target) ? "group" : "direct";
+	return buildChannelOutboundSessionRoute({
+		cfg: params.cfg,
+		agentId: params.agentId,
+		channel: "irc",
+		accountId: params.accountId,
+		recipientSessionExact: chatType === "direct" ? "direct-alias" : false,
+		peer: {
+			kind: chatType,
+			id: target
+		},
+		chatType,
+		from: `irc:${target}`,
+		to: target
+	});
+}
+function looksLikeIrcTargetId(raw) {
+	const trimmed = raw.trim();
+	if (!trimmed) return false;
+	if (hasIrcControlChars(trimmed)) return false;
+	return IRC_TARGET_PATTERN$1.test(trimmed);
+}
+function normalizeIrcAllowEntry(raw) {
+	let value = normalizeLowercaseStringOrEmpty(raw);
+	if (!value) return "";
+	if (value.startsWith("irc:")) value = value.slice(4);
+	if (value.startsWith("user:")) value = value.slice(5);
+	return value.trim();
+}
+function buildIrcAllowlistCandidates(message, params) {
+	const nick = normalizeLowercaseStringOrEmpty(message.senderNick);
+	const user = normalizeOptionalLowercaseString(message.senderUser);
+	const host = normalizeOptionalLowercaseString(message.senderHost);
+	const candidates = /* @__PURE__ */ new Set();
+	if (nick && params?.allowNameMatching === true) candidates.add(nick);
+	if (nick && user) candidates.add(`${nick}!${user}`);
+	if (nick && host) candidates.add(`${nick}@${host}`);
+	if (nick && user && host) candidates.add(`${nick}!${user}@${host}`);
+	return [...candidates];
+}
+const ircIngressIdentity = defineStableChannelIngressIdentity({
+	key: "irc-id",
+	authentication: "asserted",
+	normalizeEntry: normalizeIrcStableEntry,
+	normalizeSubject: normalizeLowercaseStringOrEmpty,
+	sensitivity: "pii",
+	aliases: [
+		{
+			key: "irc-id-nick-user",
+			kind: "stable-id",
+			normalizeEntry: normalizeIrcNickUserEntry,
+			normalizeSubject: normalizeLowercaseStringOrEmpty,
+			authentication: "mutable",
+			sensitivity: "pii"
+		},
+		{
+			key: "irc-id-nick-host",
+			kind: "stable-id",
+			authentication: "asserted",
+			normalizeEntry: normalizeIrcNickHostEntry,
+			normalizeSubject: normalizeLowercaseStringOrEmpty,
+			sensitivity: "pii"
+		},
+		{
+			key: "irc-nick",
+			kind: "plugin:irc-nick",
+			normalizeEntry: normalizeIrcNickEntry,
+			normalizeSubject: normalizeLowercaseStringOrEmpty,
+			authentication: "mutable",
+			sensitivity: "pii"
+		}
+	],
+	isWildcardEntry: (entry) => normalizeIrcAllowEntry(entry) === "*",
+	resolveEntryId: ({ entryIndex, fieldKey }) => `irc-entry-${entryIndex + 1}:${fieldKey === "irc-nick" ? "nick" : "id"}`
+});
+function isBareNick(value) {
+	return !value.includes("!") && !value.includes("@");
+}
+function hasVerifiedHost(value) {
+	return value.includes("@");
+}
+function isHostlessNickUser(value) {
+	return value.includes("!") && !value.includes("@");
+}
+function normalizeIrcStableEntry(value) {
+	const normalized = normalizeIrcAllowEntry(value);
+	if (!normalized.includes("!") || !hasVerifiedHost(normalized)) return null;
+	return normalized;
+}
+function normalizeIrcNickHostEntry(value) {
+	const normalized = normalizeIrcAllowEntry(value);
+	return !normalized.includes("!") && hasVerifiedHost(normalized) ? normalized : null;
+}
+function normalizeIrcNickUserEntry(value) {
+	const normalized = normalizeIrcAllowEntry(value);
+	if (!normalized || normalized === "*" || !isHostlessNickUser(normalized)) return null;
+	return normalized;
+}
+function normalizeIrcNickEntry(value) {
+	const normalized = normalizeIrcAllowEntry(value);
+	if (!normalized || normalized === "*" || !isBareNick(normalized)) return null;
+	return normalized;
+}
+function createIrcIngressSubject(message) {
+	const candidates = buildIrcAllowlistCandidates(message, { allowNameMatching: true });
+	const stableCandidates = candidates.filter((candidate) => hasVerifiedHost(candidate));
+	const nick = normalizeLowercaseStringOrEmpty(message.senderNick);
+	return {
+		stableId: stableCandidates[stableCandidates.length - 1] ?? nick,
+		aliases: {
+			"irc-id-nick-user": candidates.find((candidate) => isHostlessNickUser(candidate)),
+			"irc-id-nick-host": stableCandidates.find((candidate) => !candidate.includes("!") && candidate.includes("@")),
+			"irc-nick": nick
+		}
+	};
+}
+//#endregion
+//#region extensions/irc/src/outbound-base.ts
+function sanitizeIrcAssistantText(text) {
+	return sanitizeForPlainText(sanitizeAssistantVisibleText(text));
+}
+const ircOutboundBaseAdapter = {
+	deliveryMode: "direct",
+	chunker: chunkTextForOutbound,
+	chunkerMode: "markdown",
+	textChunkLimit: 350,
+	sanitizeText: ({ text }) => sanitizeIrcAssistantText(text)
+};
+//#endregion
+//#region extensions/irc/src/protocol.ts
+const IRC_TARGET_PATTERN = /^[^\s:]+$/u;
 function parseIrcLine(line) {
 	const raw = line.replace(/[\r\n]+/g, "").trim();
 	if (!raw) return null;
@@ -329,7 +471,7 @@ function sanitizeIrcTarget(raw) {
 	if (!decoded) throw new Error("IRC target is required");
 	if (decoded !== decoded.trim()) throw new Error(`Invalid IRC target: ${raw}`);
 	if (hasIrcControlChars(decoded)) throw new Error(`Invalid IRC target: ${raw}`);
-	if (!IRC_TARGET_PATTERN$1.test(decoded)) throw new Error(`Invalid IRC target: ${raw}`);
+	if (!IRC_TARGET_PATTERN.test(decoded)) throw new Error(`Invalid IRC target: ${raw}`);
 	return decoded;
 }
 function makeIrcMessageId() {
@@ -661,68 +803,6 @@ function buildIrcConnectOptions(account, overrides = {}) {
 	};
 }
 //#endregion
-//#region extensions/irc/src/normalize.ts
-const IRC_TARGET_PATTERN = /^[^\s:]+$/u;
-function isChannelTarget(target) {
-	return target.startsWith("#") || target.startsWith("&");
-}
-function normalizeIrcMessagingTarget(raw) {
-	const trimmed = raw.trim();
-	if (!trimmed) return;
-	let target = trimmed;
-	if (normalizeLowercaseStringOrEmpty(target).startsWith("irc:")) target = target.slice(4).trim();
-	if (normalizeLowercaseStringOrEmpty(target).startsWith("channel:")) {
-		target = target.slice(8).trim();
-		if (!target.startsWith("#") && !target.startsWith("&")) target = `#${target}`;
-	}
-	if (normalizeLowercaseStringOrEmpty(target).startsWith("user:")) target = target.slice(5).trim();
-	if (!target || !looksLikeIrcTargetId(target)) return;
-	return target;
-}
-function resolveIrcOutboundSessionRoute(params) {
-	const target = normalizeIrcMessagingTarget(params.target);
-	if (!target) return null;
-	const chatType = isChannelTarget(target) ? "group" : "direct";
-	return buildChannelOutboundSessionRoute({
-		cfg: params.cfg,
-		agentId: params.agentId,
-		channel: "irc",
-		accountId: params.accountId,
-		recipientSessionExact: chatType === "direct" ? "direct-alias" : false,
-		peer: {
-			kind: chatType,
-			id: target
-		},
-		chatType,
-		from: `irc:${target}`,
-		to: target
-	});
-}
-function looksLikeIrcTargetId(raw) {
-	const trimmed = raw.trim();
-	if (!trimmed) return false;
-	if (hasIrcControlChars(trimmed)) return false;
-	return IRC_TARGET_PATTERN.test(trimmed);
-}
-function normalizeIrcAllowEntry(raw) {
-	let value = normalizeLowercaseStringOrEmpty(raw);
-	if (!value) return "";
-	if (value.startsWith("irc:")) value = value.slice(4);
-	if (value.startsWith("user:")) value = value.slice(5);
-	return value.trim();
-}
-function buildIrcAllowlistCandidates(message, params) {
-	const nick = normalizeLowercaseStringOrEmpty(message.senderNick);
-	const user = normalizeOptionalLowercaseString(message.senderUser);
-	const host = normalizeOptionalLowercaseString(message.senderHost);
-	const candidates = /* @__PURE__ */ new Set();
-	if (nick && params?.allowNameMatching === true) candidates.add(nick);
-	if (nick && user) candidates.add(`${nick}!${user}`);
-	if (nick && host) candidates.add(`${nick}@${host}`);
-	if (nick && user && host) candidates.add(`${nick}!${user}@${host}`);
-	return [...candidates];
-}
-//#endregion
 //#region extensions/irc/src/send.ts
 function recordIrcOutboundActivity(accountId) {
 	try {
@@ -735,35 +815,27 @@ function recordIrcOutboundActivity(accountId) {
 		if (!(error instanceof Error) || error.message !== "IRC runtime not initialized") throw error;
 	}
 }
-function resolveTarget(to, opts) {
-	const fromArg = normalizeIrcMessagingTarget(to);
-	if (fromArg) return fromArg;
-	const fromOpt = normalizeIrcMessagingTarget(opts?.target ?? "");
-	if (fromOpt) return fromOpt;
-	throw new Error(`Invalid IRC target: ${to}`);
-}
-async function sendIrcMessages(to, messages, opts, onDeliveryResult) {
+async function sendIrcMessages(to, text, opts, planMessages = (preparedText) => [{
+	text: preparedText,
+	replyTo: opts.replyTo
+}], onDeliveryResult) {
 	const cfg = requireRuntimeConfig(opts.cfg, "IRC send");
 	const account = resolveIrcAccount({
 		cfg,
 		accountId: opts.accountId
 	});
 	if (!account.configured) throw new Error(`IRC is not configured for account "${account.accountId}" (need host and nick in channels.irc).`);
-	const target = resolveTarget(to, opts);
+	const target = normalizeIrcMessagingTarget(to);
+	if (!target) throw new Error(`Invalid IRC target: ${to}`);
 	const tableMode = resolveMarkdownTableMode({
 		cfg,
 		channel: "irc",
 		accountId: account.accountId
 	});
-	const preparedMessages = messages.map((message) => {
-		const prepared = stripMarkdown(convertMarkdownTables(message.text.trim(), tableMode));
-		if (!prepared.trim()) throw new Error("Message must be non-empty for IRC sends");
-		return {
-			payload: message.replyTo ? `${prepared}\n\n[reply:${message.replyTo}]` : prepared,
-			replyTo: message.replyTo
-		};
-	});
-	if (preparedMessages.length === 0) return [];
+	if (!text) return [];
+	const prepared = stripMarkdown(convertMarkdownTables(text.trim(), tableMode));
+	if (!prepared.trim()) throw new Error("Message must be non-empty for IRC sends");
+	const messages = planMessages(prepared);
 	opts.abortSignal?.throwIfAborted();
 	let transient;
 	const client = opts.client?.isReady() ? opts.client : transient = await connectIrcClient(buildIrcConnectOptions(account, {
@@ -774,13 +846,13 @@ async function sendIrcMessages(to, messages, opts, onDeliveryResult) {
 	try {
 		opts.abortSignal?.throwIfAborted();
 		if (transient && (target.startsWith("#") || target.startsWith("&"))) client.join(target);
-		for (const message of preparedMessages) {
+		for (const message of messages) {
 			opts.abortSignal?.throwIfAborted();
 			if (!client.isReady()) throw new Error("IRC connection closed before send");
 			await opts.onPlatformSendDispatch?.();
 			opts.abortSignal?.throwIfAborted();
 			if (!client.isReady()) throw new Error("IRC connection closed before send");
-			client.sendPrivmsg(target, message.payload);
+			client.sendPrivmsg(target, message.replyTo ? `${message.text}\n\n[reply:${message.replyTo}]` : message.text);
 			recordIrcOutboundActivity(account.accountId);
 			const messageId = makeIrcMessageId();
 			const result = {
@@ -805,10 +877,7 @@ async function sendIrcMessages(to, messages, opts, onDeliveryResult) {
 	}
 }
 async function sendMessageIrc(to, text, opts) {
-	const result = (await sendIrcMessages(to, [{
-		text,
-		...opts.replyTo ? { replyTo: opts.replyTo } : {}
-	}], opts))[0];
+	const result = (await sendIrcMessages(to, text, opts))[0];
 	if (!result) throw new Error("Message must be non-empty for IRC sends");
 	return result;
 }
@@ -823,37 +892,30 @@ function toIrcMessageResult({ target, ...result }) {
 		}
 	};
 }
-async function sendIrcMessage(...args) {
-	return toIrcMessageResult(await sendMessageIrc(...args));
+async function sendIrcMessage(ctx, text = ctx.text) {
+	return toIrcMessageResult(await sendMessageIrc(ctx.to, text, {
+		cfg: ctx.cfg,
+		accountId: ctx.accountId ?? void 0,
+		replyTo: ctx.replyToId ?? void 0,
+		abortSignal: ctx.signal,
+		onPlatformSendDispatch: ctx.onPlatformSendDispatch
+	}));
 }
 const sendFormattedIrcText = async (ctx) => {
-	const { chunkMarkdownTextWithMode, resolveChunkMode, resolveTextChunkLimit } = await import("openclaw/plugin-sdk/reply-chunking");
+	const { chunkTextWithMode, resolveChunkMode, resolveTextChunkLimit } = await import("openclaw/plugin-sdk/reply-chunking");
 	const accountId = ctx.accountId ?? void 0;
 	const textLimit = ctx.formatting?.textLimit ?? resolveTextChunkLimit(ctx.cfg, "irc", accountId, { fallbackLimit: ircOutboundBaseAdapter.textChunkLimit });
 	const chunkMode = ctx.formatting?.chunkMode ?? resolveChunkMode(ctx.cfg, "irc", accountId);
-	const chunkText = (text) => ctx.formatting ? ircOutboundBaseAdapter.chunker(text, textLimit, { formatting: ctx.formatting }) : ircOutboundBaseAdapter.chunker(text, textLimit);
-	let chunks;
-	if (chunkMode === "newline") {
-		const blocks = chunkMarkdownTextWithMode(ctx.text, textLimit, chunkMode);
-		if (blocks.length === 0 && ctx.text) blocks.push(ctx.text);
-		chunks = blocks.flatMap((block) => {
-			const blockChunks = chunkText(block);
-			return blockChunks.length === 0 && block ? [block] : blockChunks;
-		});
-	} else chunks = chunkText(ctx.text);
 	const nextReplyToId = createReplyToFanout(ctx);
-	return (await sendIrcMessages(ctx.to, chunks.map((text) => {
-		const replyTo = nextReplyToId();
-		return replyTo ? {
-			text,
-			replyTo
-		} : { text };
-	}), {
+	return (await sendIrcMessages(ctx.to, ctx.text, {
 		cfg: ctx.cfg,
 		accountId,
 		abortSignal: ctx.abortSignal,
 		onPlatformSendDispatch: ctx.onPlatformSendDispatch
-	}, async (result) => {
+	}, (preparedText) => chunkTextWithMode(preparedText, textLimit, chunkMode).map((text) => ({
+		text,
+		replyTo: nextReplyToId()
+	})), async (result) => {
 		await ctx.onDeliveryResult?.(attachChannelToResult("irc", toIrcMessageResult(result)));
 	})).map((result) => attachChannelToResult("irc", toIrcMessageResult(result)));
 };
@@ -865,16 +927,8 @@ const ircMessageAdapter = defineChannelMessageAdapter({
 		replyTo: true
 	} },
 	send: {
-		text: async ({ cfg, to, text, accountId, replyToId }) => await sendIrcMessage(to, text, {
-			cfg,
-			accountId: accountId ?? void 0,
-			replyTo: replyToId ?? void 0
-		}),
-		media: async ({ cfg, to, text, mediaUrl, accountId, replyToId }) => await sendIrcMessage(to, mediaUrl ? `${text}\n\nAttachment: ${mediaUrl}` : text, {
-			cfg,
-			accountId: accountId ?? void 0,
-			replyTo: replyToId ?? void 0
-		})
+		text: sendIrcMessage,
+		media: (ctx) => sendIrcMessage(ctx, ctx.mediaUrl ? `${ctx.text}\n\nAttachment: ${ctx.mediaUrl}` : ctx.text)
 	}
 });
 //#endregion
@@ -1317,7 +1371,8 @@ const ircSetupWizard = {
 				return String(defaultPort);
 			},
 			validate: ({ value }) => {
-				const parsed = parseStrictPositiveInteger(normalizeStringifiedOptionalString(value) ?? "");
+				const raw = normalizeStringifiedOptionalString(value) ?? "";
+				const parsed = parseStrictPositiveInteger(raw);
 				return parsed !== void 0 && parsed <= 65535 ? void 0 : "Use a port between 1 and 65535";
 			},
 			normalizeValue: ({ value }) => String(parsePort(value, 6697)),
@@ -1489,7 +1544,7 @@ const meta = {
 	systemImage: "number",
 	markdownCapable: true
 };
-const loadIrcChannelRuntime = createLazyRuntimeModule(() => import("./channel-runtime-CA62Mbrh.js"));
+const loadIrcChannelRuntime = createLazyRuntimeModule(() => import("./channel-runtime-Bhm49qnu.js"));
 function normalizePairingTarget(raw) {
 	const normalized = normalizeIrcAllowEntry(raw);
 	if (!normalized) return "";
@@ -1543,6 +1598,7 @@ const resolveIrcDmPolicy = createScopedDmSecurityResolver({
 	resolvePolicy: (account) => account.config.dmPolicy,
 	resolveAllowFrom: (account) => account.config.allowFrom,
 	policyPathSuffix: "dmPolicy",
+	classifyEntryAuthentication: identityEntryAuthenticationClassifier(ircIngressIdentity),
 	normalizeEntry: (raw) => normalizeIrcAllowEntry(raw)
 });
 const collectIrcGroupPolicyWarnings = createAllowlistProviderOpenWarningCollector({
@@ -1580,7 +1636,10 @@ const ircPlugin = createChatChannelPlugin({
 			media: true,
 			blockStreaming: true
 		},
-		reload: { configPrefixes: ["channels.irc"] },
+		reload: {
+			configPrefixes: ["channels.irc"],
+			accountScopedRestart: true
+		},
 		configSchema: IrcChannelConfigSchema,
 		config: {
 			...ircConfigAdapter,
@@ -1747,4 +1806,4 @@ const ircPlugin = createChatChannelPlugin({
 	}
 });
 //#endregion
-export { resolveDefaultIrcAccountId as _, resolveIrcGroupRequireMention as a, isChannelTarget as c, connectIrcClient as d, parseIrcLine as f, listIrcAccountIds as g, listEnabledIrcAccounts as h, resolveIrcGroupMatch as i, normalizeIrcAllowEntry as l, sanitizeIrcAssistantText as m, ircSetupWizard as n, sendMessageIrc as o, parseIrcPrefix as p, ircSetupAdapter as r, buildIrcAllowlistCandidates as s, ircPlugin as t, buildIrcConnectOptions as u, resolveIrcAccount as v };
+export { listIrcAccountIds as _, resolveIrcGroupRequireMention as a, connectIrcClient as c, sanitizeIrcAssistantText as d, createIrcIngressSubject as f, listEnabledIrcAccounts as g, normalizeIrcAllowEntry as h, resolveIrcGroupMatch as i, parseIrcLine as l, isChannelTarget as m, ircSetupWizard as n, sendMessageIrc as o, ircIngressIdentity as p, ircSetupAdapter as r, buildIrcConnectOptions as s, ircPlugin as t, parseIrcPrefix as u, resolveDefaultIrcAccountId as v, resolveIrcAccount as y };

package/dist/channel-config-api.js

@@ -1,2 +1,2 @@
-import { t as IrcChannelConfigSchema } from "./config-schema-BDXGjxOr.js";
+import { t as IrcChannelConfigSchema } from "./config-schema-DcYE4WjJ.js";
 export { IrcChannelConfigSchema };

package/dist/channel-plugin-api.js

@@ -1,2 +1,2 @@
-import { t as ircPlugin } from "./channel-W4DLS5ip.js";
+import { t as ircPlugin } from "./channel-C0XrtiC0.js";
 export { ircPlugin };

package/dist/{channel-runtime-CA62Mbrh.js → channel-runtime-Bhm49qnu.js}

@@ -1,51 +1,18 @@
-import { a as resolveIrcGroupRequireMention, c as isChannelTarget, d as connectIrcClient, f as parseIrcLine, i as resolveIrcGroupMatch, l as normalizeIrcAllowEntry, m as sanitizeIrcAssistantText, o as sendMessageIrc, p as parseIrcPrefix, s as buildIrcAllowlistCandidates, u as buildIrcConnectOptions, v as resolveIrcAccount } from "./channel-W4DLS5ip.js";
+import { a as resolveIrcGroupRequireMention, c as connectIrcClient, d as sanitizeIrcAssistantText, f as createIrcIngressSubject, h as normalizeIrcAllowEntry, i as resolveIrcGroupMatch, l as parseIrcLine, m as isChannelTarget, o as sendMessageIrc, p as ircIngressIdentity, s as buildIrcConnectOptions, u as parseIrcPrefix, y as resolveIrcAccount } from "./channel-C0XrtiC0.js";
 import { t as getIrcRuntime } from "./runtime-xy-FcjJC.js";
+import { channelIngressRoutes, createChannelIngressResolver } from "openclaw/plugin-sdk/channel-ingress-runtime";
 import { normalizeLowercaseStringOrEmpty, normalizeOptionalString, normalizeStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { bindIngressLifecycleToReplyOptions, createChannelIngressError, createChannelIngressMonitor, resolveChannelStreamingBlockEnabled } from "openclaw/plugin-sdk/channel-outbound";
 import { randomUUID } from "node:crypto";
 import { resolveLoggerBackedRuntime } from "openclaw/plugin-sdk/extension-shared";
 import { channelReadyPatch } from "openclaw/plugin-sdk/gateway-runtime";
 import { logInboundDrop, resolveChannelInboundRouteEnvelope } from "openclaw/plugin-sdk/channel-inbound";
-import { channelIngressRoutes, createChannelIngressResolver, defineStableChannelIngressIdentity } from "openclaw/plugin-sdk/channel-ingress-runtime";
 import { createChannelPairingController } from "openclaw/plugin-sdk/channel-pairing";
 import { isDangerousNameMatchingEnabled } from "openclaw/plugin-sdk/dangerous-name-runtime";
 import { deliverFormattedTextWithAttachments } from "openclaw/plugin-sdk/reply-payload";
 import { GROUP_POLICY_BLOCKED_LABEL, resolveAllowlistProviderRuntimeGroupPolicy, resolveDefaultGroupPolicy, warnMissingProviderGroupPolicyFallbackOnce } from "openclaw/plugin-sdk/runtime-group-policy";
 //#region extensions/irc/src/inbound.ts
 const CHANNEL_ID = "irc";
-const ircIngressIdentity = defineStableChannelIngressIdentity({
-	key: "irc-id",
-	normalizeEntry: normalizeIrcStableEntry,
-	normalizeSubject: normalizeLowercaseStringOrEmpty,
-	sensitivity: "pii",
-	aliases: [
-		{
-			key: "irc-id-nick-user",
-			kind: "stable-id",
-			normalizeEntry: normalizeIrcNickUserEntry,
-			normalizeSubject: normalizeLowercaseStringOrEmpty,
-			dangerous: true,
-			sensitivity: "pii"
-		},
-		{
-			key: "irc-id-nick-host",
-			kind: "stable-id",
-			normalizeEntry: () => null,
-			normalizeSubject: normalizeLowercaseStringOrEmpty,
-			sensitivity: "pii"
-		},
-		{
-			key: "irc-nick",
-			kind: "plugin:irc-nick",
-			normalizeEntry: normalizeIrcNickEntry,
-			normalizeSubject: normalizeLowercaseStringOrEmpty,
-			dangerous: true,
-			sensitivity: "pii"
-		}
-	],
-	isWildcardEntry: (entry) => normalizeIrcAllowEntry(entry) === "*",
-	resolveEntryId: ({ entryIndex, fieldKey }) => `irc-entry-${entryIndex + 1}:${fieldKey === "irc-nick" ? "nick" : "id"}`
-});
 const escapeIrcRegexLiteral = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 const IRC_NICK_CHARACTER = String.raw`[A-Za-z0-9_\-\[\]\\\x60^{}|~]`;
 const IRC_RFC1459_CASE_EQUIVALENTS = /* @__PURE__ */ new Map([
@@ -64,46 +31,9 @@ function buildIrcNickMentionPattern(value) {
 		return equivalent ? `[${escapeIrcRegexLiteral(character)}${escapeIrcRegexLiteral(equivalent)}]` : escapeIrcRegexLiteral(character);
 	}).join("");
 }
-function isBareNick(value) {
-	return !value.includes("!") && !value.includes("@");
-}
-function hasVerifiedHost(value) {
-	return value.includes("@");
-}
-function isHostlessNickUser(value) {
-	return value.includes("!") && !value.includes("@");
-}
-function normalizeIrcStableEntry(value) {
-	const normalized = normalizeIrcAllowEntry(value);
-	if (!normalized || normalized === "*" || !hasVerifiedHost(normalized)) return null;
-	return normalized;
-}
-function normalizeIrcNickUserEntry(value) {
-	const normalized = normalizeIrcAllowEntry(value);
-	if (!normalized || normalized === "*" || !isHostlessNickUser(normalized)) return null;
-	return normalized;
-}
-function normalizeIrcNickEntry(value) {
-	const normalized = normalizeIrcAllowEntry(value);
-	if (!normalized || normalized === "*" || !isBareNick(normalized)) return null;
-	return normalized;
-}
 function hasEntries(entries) {
 	return normalizeStringEntries(entries).some((entry) => normalizeIrcAllowEntry(entry));
 }
-function createIrcIngressSubject(message) {
-	const candidates = buildIrcAllowlistCandidates(message, { allowNameMatching: true });
-	const stableCandidates = candidates.filter((candidate) => hasVerifiedHost(candidate));
-	const nick = normalizeLowercaseStringOrEmpty(message.senderNick);
-	return {
-		stableId: stableCandidates[stableCandidates.length - 1] ?? nick,
-		aliases: {
-			"irc-id-nick-user": candidates.find((candidate) => isHostlessNickUser(candidate)),
-			"irc-id-nick-host": stableCandidates.find((candidate) => !candidate.includes("!") && candidate.includes("@")),
-			"irc-nick": nick
-		}
-	};
-}
 function routeDescriptorsForIrcGroup(params) {
 	if (!params.isGroup) return [];
 	return channelIngressRoutes(params.groupPolicy === "allowlist" && {
@@ -287,10 +217,11 @@ async function handleIrcInbound(params) {
 			});
 			return { kind: "completed" };
 		}
-		if (message.isGroup) if (access.routeAccess.reason === "channel_not_allowlisted") runtime.log?.(`irc: drop channel ${message.target} (not allowlisted)`);
-		else if (access.routeAccess.reason === "channel_disabled") runtime.log?.(`irc: drop channel ${message.target} (disabled)`);
-		else runtime.log?.(`irc: drop group sender ${senderDisplay} (policy=${groupPolicy})`);
-		else runtime.log?.(`irc: drop DM sender ${senderDisplay} (dmPolicy=${dmPolicy})`);
+		if (message.isGroup) {
+			if (access.routeAccess.reason === "channel_not_allowlisted") runtime.log?.(`irc: drop channel ${message.target} (not allowlisted)`);
+			else if (access.routeAccess.reason === "channel_disabled") runtime.log?.(`irc: drop channel ${message.target} (disabled)`);
+			else runtime.log?.(`irc: drop group sender ${senderDisplay} (policy=${groupPolicy})`);
+		} else runtime.log?.(`irc: drop DM sender ${senderDisplay} (dmPolicy=${dmPolicy})`);
 		return { kind: "completed" };
 	}
 	if (turnAdoptionLifecycle?.abortSignal.aborted) return {

package/dist/{config-schema-BDXGjxOr.js → config-schema-DcYE4WjJ.js}

@@ -56,7 +56,7 @@ const IrcNickServSchema = z.object({
 		message: "channels.irc.nickserv.register=true requires channels.irc.nickserv.registerEmail"
 	});
 });
-const IrcChannelConfigSchema = buildChannelConfigSchema(buildMultiAccountChannelSchema(z.object({
+const IrcAccountSchemaBase = z.object({
 	name: z.string().optional(),
 	enabled: z.boolean().optional(),
 	configWrites: z.boolean().optional(),
@@ -77,10 +77,10 @@ const IrcChannelConfigSchema = buildChannelConfigSchema(buildMultiAccountChannel
 	groupAllowFrom: z.array(z.union([z.string(), z.number()])).optional(),
 	groups: z.record(z.string(), ChannelGroupEntrySchema.optional()).optional(),
 	channels: z.array(z.string()).optional(),
-	mentionPatterns: z.array(z.string()).optional(),
 	markdown: MarkdownConfigSchema,
 	...ReplyRuntimeConfigSchemaShape
-}).strict(), {
+}).strict();
+const IrcConfigSchema = buildMultiAccountChannelSchema(IrcAccountSchemaBase, {
 	optionalAccount: true,
 	refine: (value, ctx) => {
 		requireOpenAllowFrom({
@@ -91,6 +91,7 @@ const IrcChannelConfigSchema = buildChannelConfigSchema(buildMultiAccountChannel
 			message: "channels.irc.dmPolicy=\"open\" requires channels.irc.allowFrom to include \"*\""
 		});
 	}
-}), { uiHints: ircChannelConfigUiHints });
+});
+const IrcChannelConfigSchema = buildChannelConfigSchema(IrcConfigSchema, { uiHints: ircChannelConfigUiHints });
 //#endregion
 export { IrcChannelConfigSchema as t };

package/dist/doctor-contract-api.js

@@ -1,5 +1,5 @@
-import { defineChannelAliasMigration } from "openclaw/plugin-sdk/runtime-doctor-migrations";
-//#region extensions/irc/doctor-contract-api.ts
+import { asObjectRecord, defineChannelAliasMigration, stripRetiredChannelKeys } from "openclaw/plugin-sdk/runtime-doctor-migrations";
+//#region extensions/irc/config-doctor-api.ts
 const streamingAliasMigration = defineChannelAliasMigration({
 	channelId: "irc",
 	streaming: {
@@ -8,9 +8,39 @@ const streamingAliasMigration = defineChannelAliasMigration({
 	},
 	accountStreamingReplacesRoot: true
 });
-const legacyConfigRules = streamingAliasMigration.legacyConfigRules;
+const RETIRED_IRC_KEYS = /* @__PURE__ */ new Set(["mentionPatterns"]);
+const legacyConfigRules = [
+	...streamingAliasMigration.legacyConfigRules,
+	{
+		path: ["channels", "irc"],
+		match: (value) => Object.hasOwn(asObjectRecord(value) ?? {}, "mentionPatterns"),
+		message: "channels.irc.mentionPatterns was accepted but never read; configure mention patterns with messages.groupChat.mentionPatterns. Run \"openclaw doctor --fix\"."
+	},
+	{
+		path: [
+			"channels",
+			"irc",
+			"accounts"
+		],
+		match: (value) => Object.values(asObjectRecord(value) ?? {}).some((account) => Object.hasOwn(asObjectRecord(account) ?? {}, "mentionPatterns")),
+		message: "channels.irc.accounts.<id>.mentionPatterns was accepted but never read; configure mention patterns with messages.groupChat.mentionPatterns. Run \"openclaw doctor --fix\"."
+	}
+];
 function normalizeCompatibilityConfig({ cfg }) {
-	return streamingAliasMigration.normalizeChannelConfig({ cfg });
+	const aliases = streamingAliasMigration.normalizeChannelConfig({ cfg });
+	const changes = [...aliases.changes];
+	return {
+		config: stripRetiredChannelKeys({
+			cfg: aliases.config,
+			channelId: "irc",
+			keys: RETIRED_IRC_KEYS,
+			scope: "root-and-accounts",
+			onRemove: (removed) => {
+				changes.push(`Removed ${removed.pathPrefix}.${removed.key}; it was never read.`);
+			}
+		}).config,
+		changes
+	};
 }
 //#endregion
 export { legacyConfigRules, normalizeCompatibilityConfig };

package/openclaw.plugin.json

@@ -1,5 +1,7 @@
 {
   "id": "irc",
+  "name": "IRC",
+  "description": "OpenClaw IRC channel plugin.",
   "doctorContract": {
     "configRepair": true
   },
@@ -247,12 +249,6 @@
               "type": "string"
             }
           },
-          "mentionPatterns": {
-            "type": "array",
-            "items": {
-              "type": "string"
-            }
-          },
           "markdown": {
             "type": "object",
             "properties": {
@@ -593,12 +589,6 @@
                     "type": "string"
                   }
                 },
-                "mentionPatterns": {
-                  "type": "array",
-                  "items": {
-                    "type": "string"
-                  }
-                },
                 "markdown": {
                   "type": "object",
                   "properties": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/irc",
-  "version": "2026.9.1-beta.1",
+  "version": "2026.9.2",
   "description": "OpenClaw IRC channel plugin",
   "type": "module",
   "openclaw": {
@@ -121,10 +121,10 @@
       }
     },
     "compat": {
-      "pluginApi": ">=2026.9.1-beta.1"
+      "pluginApi": ">=2026.9.2"
     },
     "build": {
-      "openclawVersion": "2026.9.1-beta.1",
+      "openclawVersion": "2026.9.2",
       "bundledDist": false
     },
     "release": {
@@ -149,7 +149,7 @@
     "README.md"
   ],
   "peerDependencies": {
-    "openclaw": ">=2026.9.1-beta.1"
+    "openclaw": ">=2026.9.2"
   },
   "peerDependenciesMeta": {
     "openclaw": {