@openclaw/nextcloud-talk 2026.5.9-beta.1 → 2026.5.10-beta.1

package/dist/api.js

@@ -1,2 +1,2 @@
-import { t as nextcloudTalkPlugin } from "./channel-DOIJGKcg.js";
+import { t as nextcloudTalkPlugin } from "./channel-DSNSV1Y5.js";
 export { nextcloudTalkPlugin };

package/dist/{channel-DOIJGKcg.js → channel-DSNSV1Y5.js}

@@ -1,4 +1,4 @@
-import { a as fetchWithSsrFGuard, c as resolveAllowlistProviderRuntimeGroupPolicy, d as warnMissingProviderGroupPolicyFallbackOnce, f as getNextcloudTalkRuntime, i as deliverFormattedTextWithAttachments, l as resolveDefaultGroupPolicy, n as createChannelMessageReplyPipeline, o as logInboundDrop, r as createChannelPairingController, s as readStoreAllowFromForDmPolicy, t as GROUP_POLICY_BLOCKED_LABEL, u as resolveDmGroupAccessWithCommandGate } from "./runtime-api-Cy4XTpP2.js";
+import { a as fetchWithSsrFGuard, c as resolveDefaultGroupPolicy, i as deliverFormattedTextWithAttachments, l as warnMissingProviderGroupPolicyFallbackOnce, o as logInboundDrop, r as createChannelPairingController, s as resolveAllowlistProviderRuntimeGroupPolicy, t as GROUP_POLICY_BLOCKED_LABEL, u as getNextcloudTalkRuntime } from "./runtime-api-D_apwxTv.js";
 import { n as normalizeCompatibilityConfig, t as legacyConfigRules } from "./doctor-contract-DIa4Qbi_.js";
 import { n as collectRuntimeConfigAssignments, r as secretTargetRegistryEntries } from "./secret-contract-bczDw2-2.js";
 import { describeWebhookAccountSnapshot } from "openclaw/plugin-sdk/account-helpers";
@@ -8,7 +8,7 @@ import { createAllowlistProviderRouteAllowlistWarningCollector } from "openclaw/
 import { buildWebhookChannelStatusSummary, createComputedAccountStatusAdapter, createDefaultChannelRuntimeState } from "openclaw/plugin-sdk/status-helpers";
 import { DEFAULT_ACCOUNT_ID, createAccountListHelpers, normalizeAccountId, resolveAccountWithDefaultFallback, resolveMergedAccountConfig } from "openclaw/plugin-sdk/account-core";
 import { tryReadSecretFileSync } from "openclaw/plugin-sdk/secret-file-runtime";
-import { convertMarkdownTables, normalizeLowercaseStringOrEmpty, normalizeOptionalLowercaseString, normalizeOptionalString } from "openclaw/plugin-sdk/text-runtime";
+import { convertMarkdownTables, normalizeLowercaseStringOrEmpty, normalizeOptionalLowercaseString, normalizeOptionalString, normalizeStringEntries } from "openclaw/plugin-sdk/text-runtime";
 import { buildSecretInputSchema, hasConfiguredSecretInput, normalizeResolvedSecretInputString } from "openclaw/plugin-sdk/secret-input";
 import { createResolvedApproverActionAuthAdapter, resolveApprovalApprovers } from "openclaw/plugin-sdk/approval-auth-runtime";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
@@ -27,8 +27,9 @@ import { requireChannelOpenAllowFrom, resolveLoggerBackedRuntime, runStoppablePa
 import { z } from "openclaw/plugin-sdk/zod";
 import { createAccountStatusSink } from "openclaw/plugin-sdk/channel-lifecycle";
 import os from "node:os";
+import { channelIngressRoutes, resolveStableChannelMessageIngress } from "openclaw/plugin-sdk/channel-ingress-runtime";
+import { resolveInboundRouteEnvelopeBuilderWithRuntime } from "openclaw/plugin-sdk/inbound-envelope";
 import { buildChannelKeyCandidates, normalizeChannelSlug, resolveChannelEntryMatchWithFallback, resolveNestedAllowlistDecision } from "openclaw/plugin-sdk/channel-targets";
-import { evaluateMatchedGroupAccessForPolicy } from "openclaw/plugin-sdk/group-access";
 import { createServer } from "node:http";
 import { WEBHOOK_RATE_LIMIT_DEFAULTS, createAuthRateLimiter, isRequestBodyLimitError, readRequestBodyWithLimit, requestBodyErrorToText } from "openclaw/plugin-sdk/webhook-ingress";
 import path from "node:path";
@@ -441,11 +442,11 @@ const nextcloudTalkDoctor = {
 };
 //#endregion
 //#region extensions/nextcloud-talk/src/policy.ts
-function normalizeAllowEntry(raw) {
+function normalizeNextcloudTalkAllowEntry(raw) {
 	return raw.trim().replace(/^(nextcloud-talk|nc-talk|nc):/i, "").toLowerCase();
 }
 function normalizeNextcloudTalkAllowlist(values) {
-	return (values ?? []).map((value) => normalizeAllowEntry(String(value))).filter(Boolean);
+	return (values ?? []).map((value) => normalizeNextcloudTalkAllowEntry(String(value))).filter(Boolean);
 }
 function resolveNextcloudTalkAllowlistMatch(params) {
 	const allowFrom = normalizeNextcloudTalkAllowlist(params.allowFrom);
@@ -455,7 +456,7 @@ function resolveNextcloudTalkAllowlistMatch(params) {
 		matchKey: "*",
 		matchSource: "wildcard"
 	};
-	const senderId = normalizeAllowEntry(params.senderId);
+	const senderId = normalizeNextcloudTalkAllowEntry(params.senderId);
 	if (allowFrom.includes(senderId)) return {
 		allowed: true,
 		matchKey: senderId,
@@ -503,39 +504,6 @@ function resolveNextcloudTalkRequireMention(params) {
 	if (typeof params.wildcardConfig?.requireMention === "boolean") return params.wildcardConfig.requireMention;
 	return true;
 }
-function resolveNextcloudTalkGroupAllow(params) {
-	const outerAllow = normalizeNextcloudTalkAllowlist(params.outerAllowFrom);
-	const innerAllow = normalizeNextcloudTalkAllowlist(params.innerAllowFrom);
-	const outerMatch = resolveNextcloudTalkAllowlistMatch({
-		allowFrom: params.outerAllowFrom,
-		senderId: params.senderId
-	});
-	const innerMatch = resolveNextcloudTalkAllowlistMatch({
-		allowFrom: params.innerAllowFrom,
-		senderId: params.senderId
-	});
-	return {
-		allowed: evaluateMatchedGroupAccessForPolicy({
-			groupPolicy: params.groupPolicy,
-			allowlistConfigured: outerAllow.length > 0 || innerAllow.length > 0,
-			allowlistMatched: resolveNestedAllowlistDecision({
-				outerConfigured: outerAllow.length > 0 || innerAllow.length > 0,
-				outerMatched: outerAllow.length > 0 ? outerMatch.allowed : true,
-				innerConfigured: innerAllow.length > 0,
-				innerMatched: innerMatch.allowed
-			})
-		}).allowed,
-		outerMatch: params.groupPolicy === "open" ? { allowed: true } : params.groupPolicy === "disabled" ? { allowed: false } : outerMatch,
-		innerMatch: params.groupPolicy === "open" ? { allowed: true } : params.groupPolicy === "disabled" ? { allowed: false } : innerMatch
-	};
-}
-function resolveNextcloudTalkMentionGate(params) {
-	const shouldBypassMention = params.isGroup && params.requireMention && !params.wasMentioned && params.allowTextCommands && params.commandAuthorized && params.hasControlCommand;
-	return {
-		shouldBypassMention,
-		shouldSkip: params.requireMention && !params.wasMentioned && !shouldBypassMention
-	};
-}
 //#endregion
 //#region extensions/nextcloud-talk/src/room-info.ts
 const ROOM_CACHE_TTL_MS = 300 * 1e3;
@@ -769,6 +737,40 @@ async function sendMessageNextcloudTalk(to, text, opts) {
 //#endregion
 //#region extensions/nextcloud-talk/src/inbound.ts
 const CHANNEL_ID = "nextcloud-talk";
+function hasAllowEntries(entries) {
+	return normalizeNextcloudTalkAllowlist(entries).length > 0;
+}
+function roomRoutes(params) {
+	if (!params.isGroup) return [];
+	const roomSenderConfigured = params.groupPolicy === "allowlist" && hasAllowEntries(params.roomAllowFrom);
+	return channelIngressRoutes(params.roomMatch.allowlistConfigured && {
+		id: "nextcloud-talk:room",
+		allowed: params.roomMatch.allowed,
+		precedence: 0,
+		matchId: "nextcloud-talk-room",
+		blockReason: "room_not_allowlisted"
+	}, params.roomConfig?.enabled === false && {
+		id: "nextcloud-talk:room-enabled",
+		enabled: false,
+		precedence: 10,
+		blockReason: "room_disabled"
+	}, roomSenderConfigured && {
+		id: "nextcloud-talk:room-sender",
+		kind: "nestedAllowlist",
+		precedence: 20,
+		blockReason: "room_sender_not_allowlisted",
+		...!hasAllowEntries(params.outerGroupAllowFrom) ? {
+			senderPolicy: "replace",
+			senderAllowFrom: params.roomAllowFrom
+		} : {
+			allowed: resolveNextcloudTalkAllowlistMatch({
+				allowFrom: params.roomAllowFrom,
+				senderId: params.senderId
+			}).allowed,
+			matchId: "nextcloud-talk-room-sender"
+		}
+	});
+}
 async function deliverNextcloudTalkReply(params) {
 	const { cfg, payload, roomToken, accountId, statusSink } = params;
 	await deliverFormattedTextWithAttachments({
@@ -804,83 +806,103 @@ async function handleNextcloudTalkInbound(params) {
 	const roomToken = message.roomToken;
 	const roomName = message.roomName;
 	statusSink?.({ lastInboundAt: message.timestamp });
-	const dmPolicy = account.config.dmPolicy ?? "pairing";
-	const defaultGroupPolicy = resolveDefaultGroupPolicy(config);
-	const { groupPolicy, providerMissingFallbackApplied } = resolveAllowlistProviderRuntimeGroupPolicy({
-		providerConfigPresent: (config.channels?.["nextcloud-talk"] ?? void 0) !== void 0,
-		groupPolicy: account.config.groupPolicy,
-		defaultGroupPolicy
-	});
-	warnMissingProviderGroupPolicyFallbackOnce({
-		providerMissingFallbackApplied,
-		providerKey: "nextcloud-talk",
-		accountId: account.accountId,
-		blockedLabel: GROUP_POLICY_BLOCKED_LABEL.room,
-		log: (message) => runtime.log?.(message)
-	});
-	const configAllowFrom = normalizeNextcloudTalkAllowlist(account.config.allowFrom);
-	const configGroupAllowFrom = normalizeNextcloudTalkAllowlist(account.config.groupAllowFrom);
-	const storeAllowList = normalizeNextcloudTalkAllowlist(await readStoreAllowFromForDmPolicy({
-		provider: CHANNEL_ID,
-		accountId: account.accountId,
-		dmPolicy,
-		readStore: pairing.readStoreForDmPolicy
-	}));
 	const roomMatch = resolveNextcloudTalkRoomMatch({
 		rooms: account.config.rooms,
 		roomToken
 	});
 	const roomConfig = roomMatch.roomConfig;
-	if (isGroup && !roomMatch.allowed) {
-		runtime.log?.(`nextcloud-talk: drop room ${roomToken} (not allowlisted)`);
-		return;
-	}
-	if (roomConfig?.enabled === false) {
-		runtime.log?.(`nextcloud-talk: drop room ${roomToken} (disabled)`);
-		return;
-	}
-	const roomAllowFrom = normalizeNextcloudTalkAllowlist(roomConfig?.allowFrom);
 	const allowTextCommands = core.channel.commands.shouldHandleTextCommands({
 		cfg: config,
 		surface: CHANNEL_ID
 	});
-	const useAccessGroups = config.commands?.useAccessGroups !== false;
 	const hasControlCommand = core.channel.text.hasControlCommand(rawBody, config);
-	const access = resolveDmGroupAccessWithCommandGate({
-		isGroup,
-		dmPolicy,
+	const shouldRequireMention = isGroup ? resolveNextcloudTalkRequireMention({
+		roomConfig,
+		wildcardConfig: roomMatch.wildcardConfig
+	}) : false;
+	const { groupPolicy, providerMissingFallbackApplied } = resolveAllowlistProviderRuntimeGroupPolicy({
+		providerConfigPresent: (config.channels?.[CHANNEL_ID] ?? void 0) !== void 0,
+		groupPolicy: account.config.groupPolicy,
+		defaultGroupPolicy: resolveDefaultGroupPolicy(config)
+	});
+	const allowFrom = normalizeStringEntries(account.config.allowFrom);
+	const outerGroupAllowFrom = account.config.groupAllowFrom?.length ? normalizeStringEntries(account.config.groupAllowFrom) : allowFrom;
+	const roomAllowFrom = normalizeStringEntries(roomConfig?.allowFrom);
+	const resolveAccess = async (wasMentioned) => await resolveStableChannelMessageIngress({
+		channelId: CHANNEL_ID,
+		accountId: account.accountId,
+		identity: {
+			key: "nextcloud-talk-user-id",
+			normalize: (value) => normalizeNextcloudTalkAllowEntry(value) || null,
+			sensitivity: "pii",
+			entryIdPrefix: "nextcloud-talk-entry"
+		},
+		cfg: config,
+		readStoreAllowFrom: async () => await pairing.readStoreForDmPolicy(CHANNEL_ID, account.accountId),
+		subject: { stableId: senderId },
+		conversation: {
+			kind: isGroup ? "group" : "direct",
+			id: isGroup ? roomToken : senderId
+		},
+		route: roomRoutes({
+			isGroup,
+			groupPolicy,
+			roomMatch,
+			roomConfig,
+			senderId,
+			outerGroupAllowFrom,
+			roomAllowFrom
+		}),
+		dmPolicy: account.config.dmPolicy ?? "pairing",
 		groupPolicy,
-		allowFrom: configAllowFrom,
-		groupAllowFrom: configGroupAllowFrom,
-		storeAllowFrom: storeAllowList,
-		isSenderAllowed: (allowFrom) => resolveNextcloudTalkAllowlistMatch({
-			allowFrom,
-			senderId
-		}).allowed,
+		policy: {
+			groupAllowFromFallbackToAllowFrom: true,
+			activation: {
+				requireMention: isGroup && shouldRequireMention,
+				allowTextCommands
+			}
+		},
+		mentionFacts: isGroup && wasMentioned !== void 0 ? {
+			canDetectMention: true,
+			wasMentioned,
+			hasAnyMention: wasMentioned
+		} : void 0,
+		allowFrom,
+		groupAllowFrom: account.config.groupAllowFrom,
 		command: {
-			useAccessGroups,
 			allowTextCommands,
 			hasControlCommand
 		}
 	});
-	const commandAuthorized = access.commandAuthorized;
-	const effectiveGroupAllowFrom = access.effectiveGroupAllowFrom;
+	let access = await resolveAccess();
+	warnMissingProviderGroupPolicyFallbackOnce({
+		providerMissingFallbackApplied,
+		providerKey: "nextcloud-talk",
+		accountId: account.accountId,
+		blockedLabel: GROUP_POLICY_BLOCKED_LABEL.room,
+		log: (message) => runtime.log?.(message)
+	});
+	const commandAuthorized = access.commandAccess.authorized;
+	const accessReason = access.ingress.reasonCode === "route_blocked" ? "route blocked" : access.senderAccess.reasonCode;
 	if (isGroup) {
-		if (access.decision !== "allow") {
-			runtime.log?.(`nextcloud-talk: drop group sender ${senderId} (reason=${access.reason})`);
+		if (access.routeAccess.reason === "room_not_allowlisted") {
+			runtime.log?.(`nextcloud-talk: drop room ${roomToken} (not allowlisted)`);
 			return;
 		}
-		if (!resolveNextcloudTalkGroupAllow({
-			groupPolicy,
-			outerAllowFrom: effectiveGroupAllowFrom,
-			innerAllowFrom: roomAllowFrom,
-			senderId
-		}).allowed) {
+		if (access.routeAccess.reason === "room_disabled") {
+			runtime.log?.(`nextcloud-talk: drop room ${roomToken} (disabled)`);
+			return;
+		}
+		if (access.routeAccess.reason === "room_sender_not_allowlisted") {
 			runtime.log?.(`nextcloud-talk: drop group sender ${senderId} (policy=${groupPolicy})`);
 			return;
 		}
-	} else if (access.decision !== "allow") {
-		if (access.decision === "pairing") await pairing.issueChallenge({
+		if (access.senderAccess.decision !== "allow") {
+			runtime.log?.(`nextcloud-talk: drop group sender ${senderId} (reason=${accessReason})`);
+			return;
+		}
+	} else if (access.senderAccess.decision !== "allow") {
+		if (access.senderAccess.decision === "pairing") await pairing.issueChallenge({
 			senderId,
 			senderIdLine: `Your Nextcloud user id: ${senderId}`,
 			meta: { name: senderName || void 0 },
@@ -895,10 +917,10 @@ async function handleNextcloudTalkInbound(params) {
 				runtime.error?.(`nextcloud-talk: pairing reply failed for ${senderId}: ${String(err)}`);
 			}
 		});
-		runtime.log?.(`nextcloud-talk: drop DM sender ${senderId} (reason=${access.reason})`);
+		runtime.log?.(`nextcloud-talk: drop DM sender ${senderId} (reason=${accessReason})`);
 		return;
 	}
-	if (access.shouldBlockControlCommand) {
+	if (access.commandAccess.shouldBlockControlCommand) {
 		logInboundDrop({
 			log: (message) => runtime.log?.(message),
 			channel: CHANNEL_ID,
@@ -909,43 +931,27 @@ async function handleNextcloudTalkInbound(params) {
 	}
 	const mentionRegexes = core.channel.mentions.buildMentionRegexes(config);
 	const wasMentioned = mentionRegexes.length ? core.channel.mentions.matchesMentionPatterns(rawBody, mentionRegexes) : false;
-	const mentionGate = resolveNextcloudTalkMentionGate({
-		isGroup,
-		requireMention: isGroup ? resolveNextcloudTalkRequireMention({
-			roomConfig,
-			wildcardConfig: roomMatch.wildcardConfig
-		}) : false,
-		wasMentioned,
-		allowTextCommands,
-		hasControlCommand,
-		commandAuthorized
-	});
-	if (isGroup && mentionGate.shouldSkip) {
+	if (isGroup) access = await resolveAccess(wasMentioned);
+	if (isGroup && access.activationAccess.shouldSkip) {
 		runtime.log?.(`nextcloud-talk: drop room ${roomToken} (no mention)`);
 		return;
 	}
-	const route = core.channel.routing.resolveAgentRoute({
+	const { route, buildEnvelope } = resolveInboundRouteEnvelopeBuilderWithRuntime({
 		cfg: config,
 		channel: CHANNEL_ID,
 		accountId: account.accountId,
 		peer: {
 			kind: isGroup ? "group" : "direct",
 			id: isGroup ? roomToken : senderId
-		}
+		},
+		runtime: core.channel,
+		sessionStore: config.session?.store
 	});
 	const fromLabel = isGroup ? `room:${roomName || roomToken}` : senderName || `user:${senderId}`;
-	const storePath = core.channel.session.resolveStorePath(config.session?.store, { agentId: route.agentId });
-	const envelopeOptions = core.channel.reply.resolveEnvelopeFormatOptions(config);
-	const previousTimestamp = core.channel.session.readSessionUpdatedAt({
-		storePath,
-		sessionKey: route.sessionKey
-	});
-	const body = core.channel.reply.formatAgentEnvelope({
+	const { storePath, body } = buildEnvelope({
 		channel: "Nextcloud Talk",
 		from: fromLabel,
 		timestamp: message.timestamp,
-		previousTimestamp,
-		envelope: envelopeOptions,
 		body: rawBody
 	});
 	const groupSystemPrompt = normalizeOptionalString(roomConfig?.systemPrompt);
@@ -973,43 +979,35 @@ async function handleNextcloudTalkInbound(params) {
 		OriginatingTo: `nextcloud-talk:${roomToken}`,
 		CommandAuthorized: commandAuthorized
 	});
-	const { onModelSelected, ...replyPipeline } = createChannelMessageReplyPipeline({
+	await core.channel.turn.runAssembled({
 		cfg: config,
-		agentId: route.agentId,
-		channel: CHANNEL_ID,
-		accountId: account.accountId
-	});
-	await core.channel.turn.runPrepared({
 		channel: CHANNEL_ID,
 		accountId: account.accountId,
+		agentId: route.agentId,
 		routeSessionKey: route.sessionKey,
 		storePath,
 		ctxPayload,
 		recordInboundSession: core.channel.session.recordInboundSession,
-		runDispatch: async () => await core.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
-			ctx: ctxPayload,
-			cfg: config,
-			dispatcherOptions: {
-				...replyPipeline,
-				deliver: async (payload) => {
-					await deliverNextcloudTalkReply({
-						cfg: config,
-						payload,
-						roomToken,
-						accountId: account.accountId,
-						statusSink
-					});
-				},
-				onError: (err, info) => {
-					runtime.error?.(`nextcloud-talk ${info.kind} reply failed: ${String(err)}`);
-				}
+		dispatchReplyWithBufferedBlockDispatcher: core.channel.reply.dispatchReplyWithBufferedBlockDispatcher,
+		delivery: {
+			deliver: async (payload) => {
+				await deliverNextcloudTalkReply({
+					cfg: config,
+					payload,
+					roomToken,
+					accountId: account.accountId,
+					statusSink
+				});
 			},
-			replyOptions: {
-				onModelSelected,
-				skillFilter: roomConfig?.skills,
-				disableBlockStreaming: typeof account.config.blockStreaming === "boolean" ? !account.config.blockStreaming : void 0
+			onError: (err, info) => {
+				runtime.error?.(`nextcloud-talk ${info.kind} reply failed: ${String(err)}`);
 			}
-		}),
+		},
+		replyPipeline: {},
+		replyOptions: {
+			skillFilter: roomConfig?.skills,
+			disableBlockStreaming: typeof account.config.blockStreaming === "boolean" ? !account.config.blockStreaming : void 0
+		},
 		record: { onRecordError: (err) => {
 			runtime.error?.(`nextcloud-talk: failed updating session meta: ${String(err)}`);
 		} }

package/dist/channel-plugin-api.js

@@ -1,2 +1,2 @@
-import { t as nextcloudTalkPlugin } from "./channel-DOIJGKcg.js";
+import { t as nextcloudTalkPlugin } from "./channel-DSNSV1Y5.js";
 export { nextcloudTalkPlugin };

package/dist/{runtime-api-Cy4XTpP2.js → runtime-api-D_apwxTv.js}

@@ -1,5 +1,4 @@
 import { createChannelPairingController } from "openclaw/plugin-sdk/channel-pairing";
-import { readStoreAllowFromForDmPolicy, resolveDmGroupAccessWithCommandGate } from "openclaw/plugin-sdk/channel-policy";
 import { logInboundDrop } from "openclaw/plugin-sdk/channel-logging";
 import { GROUP_POLICY_BLOCKED_LABEL, resolveAllowlistProviderRuntimeGroupPolicy, resolveDefaultGroupPolicy, warnMissingProviderGroupPolicyFallbackOnce } from "openclaw/plugin-sdk/runtime-group-policy";
 import { createChannelMessageReplyPipeline } from "openclaw/plugin-sdk/channel-message";
@@ -12,4 +11,4 @@ const { setRuntime: setNextcloudTalkRuntime, getRuntime: getNextcloudTalkRuntime
 	errorMessage: "Nextcloud Talk runtime not initialized"
 });
 //#endregion
-export { fetchWithSsrFGuard as a, resolveAllowlistProviderRuntimeGroupPolicy as c, warnMissingProviderGroupPolicyFallbackOnce as d, getNextcloudTalkRuntime as f, deliverFormattedTextWithAttachments as i, resolveDefaultGroupPolicy as l, createChannelMessageReplyPipeline as n, logInboundDrop as o, setNextcloudTalkRuntime as p, createChannelPairingController as r, readStoreAllowFromForDmPolicy as s, GROUP_POLICY_BLOCKED_LABEL as t, resolveDmGroupAccessWithCommandGate as u };
+export { fetchWithSsrFGuard as a, resolveDefaultGroupPolicy as c, setNextcloudTalkRuntime as d, deliverFormattedTextWithAttachments as i, warnMissingProviderGroupPolicyFallbackOnce as l, createChannelMessageReplyPipeline as n, logInboundDrop as o, createChannelPairingController as r, resolveAllowlistProviderRuntimeGroupPolicy as s, GROUP_POLICY_BLOCKED_LABEL as t, getNextcloudTalkRuntime as u };

package/dist/runtime-api.js

@@ -1,2 +1,2 @@
-import { a as fetchWithSsrFGuard, c as resolveAllowlistProviderRuntimeGroupPolicy, d as warnMissingProviderGroupPolicyFallbackOnce, i as deliverFormattedTextWithAttachments, l as resolveDefaultGroupPolicy, n as createChannelMessageReplyPipeline, o as logInboundDrop, p as setNextcloudTalkRuntime, r as createChannelPairingController, s as readStoreAllowFromForDmPolicy, t as GROUP_POLICY_BLOCKED_LABEL, u as resolveDmGroupAccessWithCommandGate } from "./runtime-api-Cy4XTpP2.js";
-export { GROUP_POLICY_BLOCKED_LABEL, createChannelMessageReplyPipeline, createChannelPairingController, deliverFormattedTextWithAttachments, fetchWithSsrFGuard, logInboundDrop, readStoreAllowFromForDmPolicy, resolveAllowlistProviderRuntimeGroupPolicy, resolveDefaultGroupPolicy, resolveDmGroupAccessWithCommandGate, setNextcloudTalkRuntime, warnMissingProviderGroupPolicyFallbackOnce };
+import { a as fetchWithSsrFGuard, c as resolveDefaultGroupPolicy, d as setNextcloudTalkRuntime, i as deliverFormattedTextWithAttachments, l as warnMissingProviderGroupPolicyFallbackOnce, n as createChannelMessageReplyPipeline, o as logInboundDrop, r as createChannelPairingController, s as resolveAllowlistProviderRuntimeGroupPolicy, t as GROUP_POLICY_BLOCKED_LABEL } from "./runtime-api-D_apwxTv.js";
+export { GROUP_POLICY_BLOCKED_LABEL, createChannelMessageReplyPipeline, createChannelPairingController, deliverFormattedTextWithAttachments, fetchWithSsrFGuard, logInboundDrop, resolveAllowlistProviderRuntimeGroupPolicy, resolveDefaultGroupPolicy, setNextcloudTalkRuntime, warnMissingProviderGroupPolicyFallbackOnce };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/nextcloud-talk",
-  "version": "2026.5.9-beta.1",
+  "version": "2026.5.10-beta.1",
   "description": "OpenClaw Nextcloud Talk channel plugin",
   "repository": {
     "type": "git",
@@ -12,7 +12,7 @@
     "openclaw": "workspace:*"
   },
   "peerDependencies": {
-    "openclaw": ">=2026.5.9-beta.1"
+    "openclaw": ">=2026.5.10-beta.1"
   },
   "peerDependenciesMeta": {
     "openclaw": {
@@ -44,10 +44,10 @@
       "minHostVersion": ">=2026.4.10"
     },
     "compat": {
-      "pluginApi": ">=2026.5.9-beta.1"
+      "pluginApi": ">=2026.5.10-beta.1"
     },
     "build": {
-      "openclawVersion": "2026.5.9-beta.1"
+      "openclawVersion": "2026.5.10-beta.1"
     },
     "release": {
       "publishToClawHub": true,