@openclaw/irc 2026.7.2-beta.5 → 2026.7.33

package/dist/{channel-runtime-CRzAwKGK.js → .setup/channel-runtime-DBtfWzX8.mjs}

@@ -1,13 +1,12 @@
-import { _ as resolveIrcAccount, a as resolveIrcGroupRequireMention, c as isChannelTarget, d as connectIrcClient, f as parseIrcLine, i as resolveIrcGroupMatch, l as normalizeIrcAllowEntry, o as sendMessageIrc, p as parseIrcPrefix, s as buildIrcAllowlistCandidates, u as buildIrcConnectOptions } from "./channel-BZclM5wY.js";
-import { t as getIrcRuntime } from "./runtime-xy-FcjJC.js";
+import { a as resolveIrcRequireMention, c as isChannelTarget, d as connectIrcClient, f as makeIrcMessageId, g as resolveIrcAccount, i as resolveIrcGroupMatch, l as normalizeIrcAllowEntry, o as sendMessageIrc, s as buildIrcAllowlistCandidates, u as buildIrcConnectOptions } from "./channel-SaGThQQW.mjs";
+import { t as getIrcRuntime } from "./runtime-DZfYm3vY.mjs";
 import { normalizeLowercaseStringOrEmpty, normalizeOptionalString, normalizeStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { bindIngressLifecycleToReplyOptions, createChannelIngressMonitor, resolveChannelStreamingBlockEnabled } from "openclaw/plugin-sdk/channel-outbound";
-import { randomUUID } from "node:crypto";
 import { resolveLoggerBackedRuntime } from "openclaw/plugin-sdk/extension-shared";
-import { buildChannelInboundEventContext, logInboundDrop, resolveChannelInboundRouteEnvelope } from "openclaw/plugin-sdk/channel-inbound";
+import { logInboundDrop } 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 { resolveInboundRouteEnvelopeBuilderWithRuntime } from "openclaw/plugin-sdk/inbound-envelope";
 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
@@ -121,7 +120,7 @@ async function deliverIrcReply(params) {
 	});
 }
 async function handleIrcInbound(params) {
-	const { message, account, config, runtime, connectedNick, statusSink, turnAdoptionLifecycle } = params;
+	const { message, account, config, runtime, connectedNick, statusSink } = params;
 	const core = getIrcRuntime();
 	const pairing = createChannelPairingController({
 		core,
@@ -129,11 +128,7 @@ async function handleIrcInbound(params) {
 		accountId: account.accountId
 	});
 	const rawBody = message.text?.trim() ?? "";
-	if (!rawBody) return { kind: "completed" };
-	if (turnAdoptionLifecycle?.abortSignal.aborted) return {
-		kind: "failed-retryable",
-		error: turnAdoptionLifecycle.abortSignal.reason
-	};
+	if (!rawBody) return;
 	statusSink?.({ lastInboundAt: message.timestamp });
 	const senderDisplay = message.senderHost ? `${message.senderNick}!${message.senderUser ?? "?"}@${message.senderHost}` : message.senderNick;
 	const allowNameMatching = isDangerousNameMatchingEnabled(account.config);
@@ -164,9 +159,9 @@ async function handleIrcInbound(params) {
 	const mentionNick = connectedNick?.trim() || account.nick;
 	const explicitMentionRegex = mentionNick ? new RegExp(`\\b${escapeIrcRegexLiteral(mentionNick)}\\b[:,]?`, "i") : null;
 	const wasMentioned = core.channel.mentions.matchesMentionPatterns(rawBody, mentionRegexes) || (explicitMentionRegex ? explicitMentionRegex.test(rawBody) : false);
-	const requireMention = message.isGroup ? resolveIrcGroupRequireMention({
-		groups: account.config.groups,
-		target: message.target
+	const requireMention = message.isGroup ? resolveIrcRequireMention({
+		groupConfig: groupMatch.groupConfig,
+		wildcardConfig: groupMatch.wildcardConfig
 	}) : false;
 	const routeGroupAllowFrom = normalizeStringEntries(groupMatch.groupConfig?.allowFrom?.length ? groupMatch.groupConfig.allowFrom : groupMatch.wildcardConfig?.allowFrom);
 	const accessGroupPolicy = groupPolicy === "open" && (hasEntries(account.config.groupAllowFrom) || hasEntries(routeGroupAllowFrom)) ? "allowlist" : groupPolicy;
@@ -233,11 +228,11 @@ async function handleIrcInbound(params) {
 			}
 		});
 		runtime.log?.(`irc: drop DM sender ${senderDisplay} (dmPolicy=${dmPolicy})`);
-		return { kind: "completed" };
+		return;
 	}
 	if (access.ingress.admission === "skip") {
 		runtime.log?.(`irc: drop channel ${message.target} (missing-mention)`);
-		return { kind: "completed" };
+		return;
 	}
 	if (access.ingress.admission !== "dispatch") {
 		if (message.isGroup && access.ingress.decisiveGateId === "command" && access.commandAccess.shouldBlockControlCommand) {
@@ -247,106 +242,69 @@ async function handleIrcInbound(params) {
 				reason: "control command (unauthorized)",
 				target: senderDisplay
 			});
-			return { kind: "completed" };
+			return;
 		}
-		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 (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;
 	}
-	if (turnAdoptionLifecycle?.abortSignal.aborted) return {
-		kind: "failed-retryable",
-		error: turnAdoptionLifecycle.abortSignal.reason
-	};
 	const channelTarget = message.target.startsWith("#") || message.target.startsWith("&") ? message.target : `#${message.target}`;
 	const peerId = message.isGroup ? channelTarget : message.senderNick;
-	const { route, buildEnvelope } = resolveChannelInboundRouteEnvelope({
+	const { route, buildEnvelope } = resolveInboundRouteEnvelopeBuilderWithRuntime({
 		cfg: config,
 		channel: CHANNEL_ID,
 		accountId: account.accountId,
 		peer: {
 			kind: message.isGroup ? "group" : "direct",
 			id: peerId
-		}
+		},
+		runtime: core.channel,
+		sessionStore: config.session?.store
 	});
 	const fromLabel = message.isGroup ? message.target : senderDisplay;
-	const body = buildEnvelope({
+	const { storePath, body } = buildEnvelope({
 		channel: "IRC",
 		from: fromLabel,
 		timestamp: message.timestamp,
 		body: rawBody
 	});
 	const groupSystemPrompt = normalizeOptionalString(groupMatch.groupConfig?.systemPrompt);
-	const blockStreamingEnabled = resolveChannelStreamingBlockEnabled(account.config);
-	const ctxPayload = buildChannelInboundEventContext({
-		channel: CHANNEL_ID,
-		accountId: route.accountId,
-		messageId: message.messageId,
-		timestamp: message.timestamp,
-		from: message.isGroup ? `channel:${channelTarget}` : `irc:${senderDisplay}`,
-		sender: {
-			id: senderDisplay,
-			name: message.senderNick || void 0
-		},
-		conversation: {
-			kind: message.isGroup ? "group" : "direct",
-			id: peerId,
-			label: fromLabel
-		},
-		route: {
-			agentId: route.agentId,
-			dmScope: route.dmScope,
-			accountId: route.accountId,
-			routeSessionKey: route.sessionKey
-		},
-		reply: {
-			to: message.isGroup ? `channel:${channelTarget}` : `irc:${peerId}`,
-			originatingTo: message.isGroup ? `channel:${channelTarget}` : `irc:${peerId}`
-		},
-		message: {
-			body,
-			bodyForAgent: rawBody,
-			rawBody,
-			commandBody: rawBody
-		},
-		access: {
-			commands: { authorized: commandAuthorized },
-			mentions: {
-				canDetectMention: message.isGroup,
-				wasMentioned
-			}
-		},
-		extra: {
-			GroupSubject: message.isGroup ? message.target : void 0,
-			GroupSystemPrompt: message.isGroup ? groupSystemPrompt : void 0
-		}
+	const ctxPayload = core.channel.reply.finalizeInboundContext({
+		Body: body,
+		RawBody: rawBody,
+		CommandBody: rawBody,
+		From: message.isGroup ? `channel:${channelTarget}` : `irc:${senderDisplay}`,
+		To: message.isGroup ? `channel:${channelTarget}` : `irc:${peerId}`,
+		SessionKey: route.sessionKey,
+		AccountId: route.accountId,
+		ChatType: message.isGroup ? "group" : "direct",
+		ConversationLabel: fromLabel,
+		SenderName: message.senderNick || void 0,
+		SenderId: senderDisplay,
+		GroupSubject: message.isGroup ? message.target : void 0,
+		GroupSystemPrompt: message.isGroup ? groupSystemPrompt : void 0,
+		Provider: CHANNEL_ID,
+		Surface: CHANNEL_ID,
+		WasMentioned: message.isGroup ? wasMentioned : void 0,
+		MessageSid: message.messageId,
+		Timestamp: message.timestamp,
+		OriginatingChannel: CHANNEL_ID,
+		OriginatingTo: message.isGroup ? `channel:${channelTarget}` : `irc:${peerId}`,
+		CommandAuthorized: commandAuthorized
 	});
-	const ingressState = { handoff: "none" };
-	const trackedIngressLifecycle = turnAdoptionLifecycle ? {
-		...turnAdoptionLifecycle,
-		onAdopted: async () => {
-			ingressState.handoff = "adopted";
-			await turnAdoptionLifecycle.onAdopted();
-		},
-		onDeferred: () => {
-			ingressState.handoff = "deferred";
-			turnAdoptionLifecycle.onDeferred();
-		},
-		onAbandoned: async () => {
-			ingressState.handoff = "abandoned";
-			await turnAdoptionLifecycle.onAbandoned();
-		}
-	} : void 0;
-	await core.channel.inbound.dispatch({
+	await core.channel.inbound.dispatchReply({
 		cfg: config,
 		channel: CHANNEL_ID,
 		accountId: account.accountId,
-		route: {
-			agentId: route.agentId,
-			sessionKey: route.sessionKey
-		},
+		agentId: route.agentId,
+		routeSessionKey: route.sessionKey,
+		storePath,
 		ctxPayload,
+		recordInboundSession: core.channel.session.recordInboundSession,
+		dispatchReplyWithBufferedBlockDispatcher: core.channel.reply.dispatchReplyWithBufferedBlockDispatcher,
 		delivery: {
 			deliver: async (payload) => {
 				await deliverIrcReply({
@@ -364,170 +322,30 @@ async function handleIrcInbound(params) {
 		},
 		replyPipeline: {},
 		replyOptions: {
-			...trackedIngressLifecycle ? bindIngressLifecycleToReplyOptions(trackedIngressLifecycle) : {},
 			skillFilter: groupMatch.groupConfig?.skills,
-			disableBlockStreaming: typeof blockStreamingEnabled === "boolean" ? !blockStreamingEnabled : void 0
+			disableBlockStreaming: typeof account.config.blockStreaming === "boolean" ? !account.config.blockStreaming : void 0
 		},
 		record: { onRecordError: (err) => {
 			runtime.error?.(`irc: failed updating session meta: ${String(err)}`);
 		} }
 	});
-	if (turnAdoptionLifecycle?.abortSignal.aborted && ingressState.handoff === "none") return {
-		kind: "failed-retryable",
-		error: turnAdoptionLifecycle.abortSignal.reason
-	};
-	if (turnAdoptionLifecycle && ingressState.handoff === "none") {
-		await turnAdoptionLifecycle.onAdopted();
-		ingressState.handoff = "adopted";
-	}
-	return ingressState.handoff === "deferred" || ingressState.handoff === "abandoned" ? { kind: "deferred" } : { kind: "completed" };
 }
 //#endregion
-//#region extensions/irc/src/irc-ingress.ts
-const IRC_INGRESS_PAYLOAD_VERSION = 1;
-const IRC_INGRESS_POLL_INTERVAL_MS = 1e3;
-const IRC_INGRESS_PRUNE_INTERVAL_MS = 3600 * 1e3;
-const IRC_INGRESS_TOMBSTONE_TTL_MS = 720 * 60 * 60 * 1e3;
-const IRC_INGRESS_TOMBSTONE_MAX_ENTRIES = 1e3;
-var IrcIngressPayloadError = class extends Error {
-	constructor(message) {
-		super(message);
-		this.name = "IrcIngressPayloadError";
-	}
-};
-function inspectRawPrivmsg(rawLine) {
-	const line = parseIrcLine(rawLine);
-	if (!line || line.command !== "PRIVMSG") throw new IrcIngressPayloadError("IRC ingress row is not a PRIVMSG line.");
-	const rawTarget = line.params[0]?.trim() ?? "";
-	const text = line.trailing ?? line.params[1] ?? "";
-	const prefix = parseIrcPrefix(line.prefix);
-	const senderNick = prefix.nick?.trim() ?? "";
-	if (!rawTarget || !senderNick || !text.trim()) throw new IrcIngressPayloadError("IRC PRIVMSG line is missing target, sender, or text.");
-	const isGroup = isChannelTarget(rawTarget);
-	const target = isGroup ? rawTarget : senderNick;
-	const lanePeer = normalizeLowercaseStringOrEmpty(target);
-	return {
-		laneKey: `${isGroup ? "channel" : "direct"}:${lanePeer}`,
-		message: {
-			target,
-			rawTarget,
-			senderNick,
-			senderUser: prefix.user?.trim() || void 0,
-			senderHost: prefix.host?.trim() || void 0,
-			text,
-			isGroup
-		}
-	};
-}
-function decodeIrcIngressPayload(payload, claimedId) {
-	if (!payload || typeof payload !== "object" || Array.isArray(payload) || typeof payload.eventId !== "string" || !Number.isSafeInteger(payload.receivedAt) || (payload.receivedAt ?? 0) <= 0 || typeof payload.connectionEpoch !== "string" || !payload.connectionEpoch?.trim() || typeof payload.connectedNick !== "string" || !payload.connectedNick?.trim() || typeof payload.rawLine !== "string") throw new IrcIngressPayloadError(`IRC ingress row ${claimedId} has invalid metadata.`);
-	const validPayload = payload;
-	return {
-		version: validPayload.version,
-		body: {
-			eventId: validPayload.eventId,
-			receivedAt: validPayload.receivedAt,
-			connectionEpoch: validPayload.connectionEpoch,
-			connectedNick: validPayload.connectedNick,
-			rawLine: validPayload.rawLine
-		}
+//#region extensions/irc/src/monitor.ts
+const IRC_MONITOR_RECONNECT_DELAY_MS = 1e3;
+function resolveIrcInboundTarget(params) {
+	const rawTarget = params.target;
+	if (isChannelTarget(rawTarget)) return {
+		isGroup: true,
+		target: rawTarget,
+		rawTarget
 	};
-}
-function inspectIrcIngress(raw, phase) {
-	try {
-		return {
-			eventId: raw.eventId,
-			laneKey: inspectRawPrivmsg(raw.rawLine).laneKey
-		};
-	} catch (error) {
-		if (phase === "admission" && error instanceof IrcIngressPayloadError) return {
-			eventId: raw.eventId,
-			laneKey: `invalid:${raw.eventId}`
-		};
-		throw error;
-	}
-}
-function resolveIrcIngressNonRetryableFailure(error) {
-	return error instanceof IrcIngressPayloadError ? {
-		reason: "invalid-event",
-		message: error.message
-	} : null;
-}
-function createIrcIngressMonitor(options) {
-	const monitor = createChannelIngressMonitor({
-		queue: options.queue ?? (() => getIrcRuntime().state.openChannelIngressQueue({ accountId: options.accountId })),
-		inspect: (raw, context) => inspectIrcIngress(raw, context.phase),
-		payload: {
-			version: IRC_INGRESS_PAYLOAD_VERSION,
-			serialize: (raw) => raw,
-			deserialize: (body) => body,
-			encode: ({ body }) => ({
-				version: IRC_INGRESS_PAYLOAD_VERSION,
-				...body
-			}),
-			decode: (payload, { claim }) => decodeIrcIngressPayload(payload, claim.id),
-			createClaimError: (_kind, claim) => new IrcIngressPayloadError(`IRC ingress row ${claim.id} has invalid metadata.`)
-		},
-		deliver: (raw, lifecycle, claim) => {
-			const message = {
-				...inspectRawPrivmsg(raw.rawLine).message,
-				messageId: claim.id,
-				timestamp: raw.receivedAt
-			};
-			return options.dispatch(message, lifecycle, {
-				connectedNick: raw.connectedNick.trim(),
-				connectionEpoch: raw.connectionEpoch.trim()
-			});
-		},
-		pollIntervalMs: options.pollIntervalMs ?? IRC_INGRESS_POLL_INTERVAL_MS,
-		retention: {
-			pruneIntervalMs: IRC_INGRESS_PRUNE_INTERVAL_MS,
-			completedTtlMs: IRC_INGRESS_TOMBSTONE_TTL_MS,
-			completedMaxEntries: IRC_INGRESS_TOMBSTONE_MAX_ENTRIES,
-			failedTtlMs: IRC_INGRESS_TOMBSTONE_TTL_MS,
-			failedMaxEntries: IRC_INGRESS_TOMBSTONE_MAX_ENTRIES
-		},
-		drain: {
-			resolveNonRetryableFailure: resolveIrcIngressNonRetryableFailure,
-			...options.adoptionStallTimeoutMs === void 0 ? {} : { adoptionStallTimeoutMs: options.adoptionStallTimeoutMs },
-			onLog: (message) => options.runtime.log?.(`irc ${message}`)
-		},
-		createStoppedError: () => /* @__PURE__ */ new Error("IRC ingress is stopped."),
-		onError: (error) => options.runtime.error?.(`irc ingress drain failed: ${String(error)}`)
-	});
 	return {
-		openConnection: (connectionEpoch = randomUUID()) => {
-			const epoch = connectionEpoch.trim();
-			if (!epoch) throw new Error("IRC ingress connection epoch is required.");
-			let sequence = 0;
-			return {
-				connectionEpoch: epoch,
-				accept: (rawLine, connectedNick) => {
-					if (monitor.isStopped()) return Promise.reject(/* @__PURE__ */ new Error("IRC ingress is stopped."));
-					sequence += 1;
-					const eventId = `local:${epoch}:${String(sequence).padStart(12, "0")}`;
-					const receivedAt = Date.now();
-					const normalizedNick = connectedNick.trim();
-					if (!normalizedNick) return Promise.reject(/* @__PURE__ */ new Error("IRC ingress connected nickname is required."));
-					return monitor.admit({
-						eventId,
-						rawLine,
-						receivedAt,
-						connectionEpoch: epoch,
-						connectedNick: normalizedNick
-					}, { receivedAt }).then(() => void 0);
-				}
-			};
-		},
-		start: monitor.start,
-		pause: monitor.pause,
-		stop: monitor.stop,
-		waitForIdle: monitor.waitForIdle
+		isGroup: false,
+		target: params.senderNick.trim() || rawTarget,
+		rawTarget
 	};
 }
-//#endregion
-//#region extensions/irc/src/monitor.ts
-const IRC_MONITOR_RECONNECT_DELAY_MS = 1e3;
 async function monitorIrcProvider(opts) {
 	const core = getIrcRuntime();
 	const cfg = opts.config ?? core.config.current();
@@ -542,8 +360,6 @@ async function monitorIrcProvider(opts) {
 		accountId: account.accountId
 	});
 	let client = null;
-	let activeConnectionEpoch = null;
-	let ingressPause = Promise.resolve();
 	let reconnectTimer = null;
 	let stopped = false;
 	const monitorAbort = new AbortController();
@@ -556,48 +372,6 @@ async function monitorIrcProvider(opts) {
 			removeAbortListener = () => opts.abortSignal?.removeEventListener("abort", forwardAbort);
 		}
 	}
-	const ingress = createIrcIngressMonitor({
-		accountId: account.accountId,
-		runtime,
-		...opts.ingressQueue ? { queue: opts.ingressQueue } : {},
-		dispatch: async (message, turnAdoptionLifecycle, context) => {
-			const activeClient = client;
-			if (!activeClient || stopped || monitorAbort.signal.aborted) return {
-				kind: "failed-retryable",
-				error: /* @__PURE__ */ new Error("IRC transport disconnected before ingress dispatch.")
-			};
-			if (normalizeLowercaseStringOrEmpty(message.senderNick) === normalizeLowercaseStringOrEmpty(context.connectedNick)) return { kind: "completed" };
-			if (!message.isGroup && context.connectionEpoch !== activeConnectionEpoch) {
-				logger.warn?.(`[${account.accountId}] dropping replayed IRC DM after the connection changed`);
-				return { kind: "completed" };
-			}
-			if (opts.onMessage) {
-				await opts.onMessage(message, activeClient);
-				return { kind: "completed" };
-			}
-			return await handleIrcInbound({
-				message,
-				account,
-				config: cfg,
-				runtime,
-				connectedNick: context.connectedNick,
-				turnAdoptionLifecycle,
-				sendReply: async (target, text) => {
-					const replyClient = client;
-					if (!replyClient || !replyClient.isReady() || stopped || monitorAbort.signal.aborted) throw new Error("IRC transport disconnected before reply send.");
-					if (!message.isGroup && context.connectionEpoch !== activeConnectionEpoch) throw new Error("IRC connection changed before private reply send.");
-					replyClient.sendPrivmsg(target, text);
-					opts.statusSink?.({ lastOutboundAt: Date.now() });
-					core.channel.activity.record({
-						channel: "irc",
-						accountId: account.accountId,
-						direction: "outbound"
-					});
-				},
-				statusSink: opts.statusSink
-			});
-		}
-	});
 	function scheduleReconnect() {
 		if (stopped || monitorAbort.signal.aborted || reconnectTimer) return;
 		reconnectTimer = setTimeout(() => {
@@ -612,7 +386,6 @@ async function monitorIrcProvider(opts) {
 	}
 	async function connect() {
 		if (stopped || monitorAbort.signal.aborted) return;
-		const ingressConnection = ingress.openConnection();
 		const nextClient = await connectIrcClient(buildIrcConnectOptions(account, {
 			channels: account.config.channels,
 			abortSignal: monitorAbort.signal,
@@ -627,20 +400,54 @@ async function monitorIrcProvider(opts) {
 			},
 			onDisconnect: () => {
 				if (stopped || monitorAbort.signal.aborted) return;
-				ingressPause = ingress.pause();
-				if (activeConnectionEpoch === ingressConnection.connectionEpoch) activeConnectionEpoch = null;
 				client = null;
 				logger.warn?.(`[${account.accountId}] IRC connection closed; reconnecting in ${IRC_MONITOR_RECONNECT_DELAY_MS}ms`);
 				scheduleReconnect();
 			},
 			onPrivmsg: async (event) => {
-				await ingressConnection.accept(event.rawLine, event.connectedNick);
-				if (normalizeLowercaseStringOrEmpty(event.senderNick) === normalizeLowercaseStringOrEmpty(event.connectedNick)) return;
+				if (!client) return;
+				if (normalizeLowercaseStringOrEmpty(event.senderNick) === normalizeLowercaseStringOrEmpty(client.nick)) return;
+				const inboundTarget = resolveIrcInboundTarget({
+					target: event.target,
+					senderNick: event.senderNick
+				});
+				const message = {
+					messageId: makeIrcMessageId(),
+					target: inboundTarget.target,
+					rawTarget: inboundTarget.rawTarget,
+					senderNick: event.senderNick,
+					senderUser: event.senderUser,
+					senderHost: event.senderHost,
+					text: event.text,
+					timestamp: Date.now(),
+					isGroup: inboundTarget.isGroup
+				};
 				core.channel.activity.record({
 					channel: "irc",
 					accountId: account.accountId,
 					direction: "inbound",
-					at: Date.now()
+					at: message.timestamp
+				});
+				if (opts.onMessage) {
+					await opts.onMessage(message, client);
+					return;
+				}
+				await handleIrcInbound({
+					message,
+					account,
+					config: cfg,
+					runtime,
+					connectedNick: client.nick,
+					sendReply: async (target, text) => {
+						client?.sendPrivmsg(target, text);
+						opts.statusSink?.({ lastOutboundAt: Date.now() });
+						core.channel.activity.record({
+							channel: "irc",
+							accountId: account.accountId,
+							direction: "outbound"
+						});
+					},
+					statusSink: opts.statusSink
 				});
 			}
 		}));
@@ -649,40 +456,20 @@ async function monitorIrcProvider(opts) {
 			return;
 		}
 		client = nextClient;
-		activeConnectionEpoch = ingressConnection.connectionEpoch;
-		await ingressPause;
-		if (client !== nextClient || !nextClient.isReady()) {
-			if (activeConnectionEpoch === ingressConnection.connectionEpoch) activeConnectionEpoch = null;
-			return;
-		}
-		ingress.start();
 		logger.info(`[${account.accountId}] connected to ${account.host}:${account.port}${account.tls ? " (tls)" : ""} as ${nextClient.nick}`);
 	}
-	try {
-		await connect();
-	} catch (error) {
+	await connect();
+	return { stop: () => {
+		stopped = true;
 		removeAbortListener?.();
 		removeAbortListener = null;
-		await ingress.stop();
-		throw error;
-	}
-	let stopTask;
-	return { stop: () => {
-		stopTask ??= (async () => {
-			stopped = true;
-			removeAbortListener?.();
-			removeAbortListener = null;
-			if (!monitorAbort.signal.aborted) monitorAbort.abort();
-			if (reconnectTimer) {
-				clearTimeout(reconnectTimer);
-				reconnectTimer = null;
-			}
-			client?.quit("shutdown");
-			client = null;
-			activeConnectionEpoch = null;
-			await ingress.stop();
-		})();
-		return stopTask;
+		if (!monitorAbort.signal.aborted) monitorAbort.abort();
+		if (reconnectTimer) {
+			clearTimeout(reconnectTimer);
+			reconnectTimer = null;
+		}
+		client?.quit("shutdown");
+		client = null;
 	} };
 }
 //#endregion

package/dist/{config-schema-BPoye3--.js → .setup/config-schema-BQXbFpTD.mjs}

@@ -1,5 +1,4 @@
-import { createChannelConfigUiHints } from "openclaw/plugin-sdk/channel-core";
-import { ChannelGroupEntrySchema, DmPolicySchema, GroupPolicySchema, MarkdownConfigSchema, ReplyRuntimeConfigSchemaShape, buildChannelConfigSchema, buildMultiAccountChannelSchema, requireOpenAllowFrom } from "openclaw/plugin-sdk/channel-config-schema";
+import { DmPolicySchema, GroupPolicySchema, MarkdownConfigSchema, ReplyRuntimeConfigSchemaShape, ToolPolicySchema, buildChannelConfigSchema, requireOpenAllowFrom } from "openclaw/plugin-sdk/channel-config-schema";
 import { z } from "zod";
 //#region extensions/irc/src/config-ui-hints.ts
 const ircChannelConfigUiHints = {
@@ -7,10 +6,10 @@ const ircChannelConfigUiHints = {
 		label: "IRC",
 		help: "IRC channel provider configuration and compatibility settings for classic IRC transport workflows. Use this section when bridging legacy chat infrastructure into OpenClaw."
 	},
-	...createChannelConfigUiHints({
-		channelLabel: "IRC",
-		dmPolicy: { channelKey: "irc" }
-	}),
+	dmPolicy: {
+		label: "IRC DM Policy",
+		help: "Direct message access control (\"pairing\" recommended). \"open\" requires channels.irc.allowFrom=[\"*\"]."
+	},
 	"nickserv.enabled": {
 		label: "IRC NickServ Enabled",
 		help: "Enable NickServ identify/register after connect (defaults to enabled when password is configured)."
@@ -35,13 +34,22 @@ const ircChannelConfigUiHints = {
 		label: "IRC NickServ Register Email",
 		help: "Email used with NickServ REGISTER (required when register=true)."
 	},
-	...createChannelConfigUiHints({
-		channelLabel: "IRC",
-		configWrites: true
-	})
+	configWrites: {
+		label: "IRC Config Writes",
+		help: "Allow IRC to write config in response to channel events/commands (default: true)."
+	}
 };
 //#endregion
 //#region extensions/irc/src/config-schema.ts
+const IrcGroupSchema = z.object({
+	requireMention: z.boolean().optional(),
+	tools: ToolPolicySchema,
+	toolsBySender: z.record(z.string(), ToolPolicySchema).optional(),
+	skills: z.array(z.string()).optional(),
+	enabled: z.boolean().optional(),
+	allowFrom: z.array(z.union([z.string(), z.number()])).optional(),
+	systemPrompt: z.string().optional()
+}).strict();
 const IrcNickServSchema = z.object({
 	enabled: z.boolean().optional(),
 	service: z.string().optional(),
@@ -56,7 +64,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(),
 	dangerouslyAllowNameMatching: z.boolean().optional(),
@@ -73,22 +81,33 @@ const IrcChannelConfigSchema = buildChannelConfigSchema(buildMultiAccountChannel
 	allowFrom: z.array(z.union([z.string(), z.number()])).optional(),
 	groupPolicy: GroupPolicySchema.optional().default("allowlist"),
 	groupAllowFrom: z.array(z.union([z.string(), z.number()])).optional(),
-	groups: z.record(z.string(), ChannelGroupEntrySchema.optional()).optional(),
+	groups: z.record(z.string(), IrcGroupSchema.optional()).optional(),
 	channels: z.array(z.string()).optional(),
 	mentionPatterns: z.array(z.string()).optional(),
 	markdown: MarkdownConfigSchema,
 	...ReplyRuntimeConfigSchemaShape
-}).strict(), {
-	optionalAccount: true,
-	refine: (value, ctx) => {
-		requireOpenAllowFrom({
-			policy: value.dmPolicy,
-			allowFrom: value.allowFrom,
-			ctx,
-			path: ["allowFrom"],
-			message: "channels.irc.dmPolicy=\"open\" requires channels.irc.allowFrom to include \"*\""
-		});
-	}
-}), { uiHints: ircChannelConfigUiHints });
+}).strict();
+const IrcAccountSchema = IrcAccountSchemaBase.superRefine((value, ctx) => {
+	requireOpenAllowFrom({
+		policy: value.dmPolicy,
+		allowFrom: value.allowFrom,
+		ctx,
+		path: ["allowFrom"],
+		message: "channels.irc.dmPolicy=\"open\" requires channels.irc.allowFrom to include \"*\""
+	});
+});
+const IrcConfigSchema = IrcAccountSchemaBase.extend({
+	accounts: z.record(z.string(), IrcAccountSchema.optional()).optional(),
+	defaultAccount: z.string().optional()
+}).superRefine((value, ctx) => {
+	requireOpenAllowFrom({
+		policy: value.dmPolicy,
+		allowFrom: value.allowFrom,
+		ctx,
+		path: ["allowFrom"],
+		message: "channels.irc.dmPolicy=\"open\" requires channels.irc.allowFrom to include \"*\""
+	});
+});
+const IrcChannelConfigSchema = buildChannelConfigSchema(IrcConfigSchema, { uiHints: ircChannelConfigUiHints });
 //#endregion
 export { IrcChannelConfigSchema as t };