@openclaw/nextcloud-talk 2026.7.1 → 2026.7.2-beta.2

package/dist/api.js

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

package/dist/{channel-BMKRTDSP.js → channel-BSnehBf6.js}

@@ -1,47 +1,47 @@
 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-BKsxTw4J.js";
-import { n as normalizeCompatibilityConfig, t as legacyConfigRules } from "./doctor-contract-BY7I5-v9.js";
-import { n as collectRuntimeConfigAssignments, r as secretTargetRegistryEntries } from "./secret-contract-CsCJ-vOP.js";
+import { n as normalizeCompatibilityConfig, t as legacyConfigRules } from "./doctor-contract-fNhK1wag.js";
+import { n as collectRuntimeConfigAssignments, r as secretTargetRegistryEntries } from "./secret-contract-DGgvfVqm.js";
 import { describeWebhookAccountSnapshot } from "openclaw/plugin-sdk/account-helpers";
 import { createChatChannelPlugin } from "openclaw/plugin-sdk/channel-core";
 import { createLoggedPairingApprovalNotifier, createPairingPrefixStripper } from "openclaw/plugin-sdk/channel-pairing";
-import { createAllowlistProviderRouteAllowlistWarningCollector } from "openclaw/plugin-sdk/channel-policy";
+import { createAllowlistProviderRouteAllowlistWarningCollector, resolveScopeRequireMention, resolveScopeToolsPolicy } from "openclaw/plugin-sdk/channel-policy";
 import { buildWebhookChannelStatusSummary, createComputedAccountStatusAdapter, createDefaultChannelRuntimeState } from "openclaw/plugin-sdk/status-helpers";
+import { convertMarkdownTables, sanitizeAssistantVisibleText } from "openclaw/plugin-sdk/text-chunking";
+import { createChannelApprovalAuth } from "openclaw/plugin-sdk/approval-auth-runtime";
+import { normalizeLowercaseStringOrEmpty, normalizeOptionalLowercaseString, normalizeOptionalString, normalizeStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { DEFAULT_ACCOUNT_ID, createAccountListHelpers, hasConfiguredAccountValue, normalizeAccountId, resolveAccountWithDefaultFallback, resolveMergedAccountConfig } from "openclaw/plugin-sdk/account-core";
 import { tryReadSecretFileSync } from "openclaw/plugin-sdk/secret-file-runtime";
-import { normalizeLowercaseStringOrEmpty, normalizeOptionalLowercaseString, normalizeOptionalString, normalizeStringEntries } from "openclaw/plugin-sdk/string-coerce-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";
 import { parseStrictNonNegativeInteger, parseStrictPositiveInteger } from "openclaw/plugin-sdk/number-runtime";
 import { readProviderJsonResponse, readResponseTextLimited } from "openclaw/plugin-sdk/provider-http";
-import { createAccountStatusSink, createMessageReceiptFromOutboundResults, defineChannelMessageAdapter } from "openclaw/plugin-sdk/channel-outbound";
+import { createAccountStatusSink, createMessageReceiptFromOutboundResults, defineChannelMessageAdapter, resolveChannelStreamingBlockEnabled } from "openclaw/plugin-sdk/channel-outbound";
 import { ssrfPolicyFromPrivateNetworkOptIn, ssrfPolicyFromPrivateNetworkOptIn as ssrfPolicyFromPrivateNetworkOptIn$1 } from "openclaw/plugin-sdk/ssrf-runtime";
-import { readFileSync } from "node:fs";
 import { requireRuntimeConfig } from "openclaw/plugin-sdk/plugin-config-runtime";
 import { resolveMarkdownTableMode } from "openclaw/plugin-sdk/markdown-table-runtime";
-import { convertMarkdownTables } from "openclaw/plugin-sdk/text-chunking";
-import { createHmac, randomBytes, timingSafeEqual } from "node:crypto";
+import { createHmac, randomBytes } from "node:crypto";
+import { fileExists, safeEqualSecret } from "openclaw/plugin-sdk/security-runtime";
 import { clearAccountEntryFields } from "openclaw/plugin-sdk/channel-plugin-common";
 import { DEFAULT_ACCOUNT_ID as DEFAULT_ACCOUNT_ID$2 } from "openclaw/plugin-sdk/account-id";
-import { DmPolicySchema, GroupPolicySchema, MarkdownConfigSchema, ReplyRuntimeConfigSchemaShape, ToolPolicySchema, buildChannelConfigSchema, requireOpenAllowFrom } from "openclaw/plugin-sdk/channel-config-schema";
+import { DmPolicySchema, GroupPolicySchema, MarkdownConfigSchema, ReplyRuntimeConfigSchemaShape, buildChannelConfigSchema, buildGroupEntrySchema, buildMultiAccountChannelSchema, requireOpenAllowFrom } from "openclaw/plugin-sdk/channel-config-schema";
 import { formatAllowFromLowercase } from "openclaw/plugin-sdk/allow-from";
 import { adaptScopedAccountAccessor, createScopedChannelConfigAdapter, createScopedDmSecurityResolver } from "openclaw/plugin-sdk/channel-config-helpers";
 import { requireChannelOpenAllowFrom, resolveLoggerBackedRuntime, runStoppablePassiveMonitor, safeParseJsonWithSchema } from "openclaw/plugin-sdk/extension-shared";
 import { z } from "zod";
-import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
-import { createClaimableDedupe, migratePersistentDedupeLegacyJsonFile } from "openclaw/plugin-sdk/persistent-dedupe";
+import { createChannelReplayGuard, migratePersistentDedupeLegacyJsonFile } from "openclaw/plugin-sdk/persistent-dedupe";
 import { resolveStateDir } from "openclaw/plugin-sdk/state-paths";
 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 { buildChannelKeyCandidates, normalizeChannelSlug, resolveChannelEntryMatchWithFallback } from "openclaw/plugin-sdk/channel-targets";
 import { pruneMapToMaxSize } from "openclaw/plugin-sdk/collection-runtime";
+import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 import { createServer } from "node:http";
 import { WEBHOOK_RATE_LIMIT_DEFAULTS, createAuthRateLimiter, isRequestBodyLimitError, readRequestBodyWithLimit, requestBodyErrorToText } from "openclaw/plugin-sdk/webhook-ingress";
 import { jsonResult, readStringParam, resolveReactionMessageId } from "openclaw/plugin-sdk/channel-actions";
 import { DEFAULT_ACCOUNT_ID as DEFAULT_ACCOUNT_ID$1, buildOutboundBaseSessionKey, normalizeAccountId as normalizeAccountId$1 } from "openclaw/plugin-sdk/routing";
-import { applyAccountNameToChannelSection, createSetupTranslator, createStandardChannelSetupStatus, formatDocsLink, patchScopedAccountConfig, setSetupChannelEnabled } from "openclaw/plugin-sdk/setup";
+import { applyAccountNameToChannelSection, baseUrlTextInput, createSetupTranslator, createStandardChannelSetupStatus, defineTokenCredential, formatDocsLink, patchScopedAccountConfig, setSetupChannelEnabled } from "openclaw/plugin-sdk/setup";
 import { createSetupInputPresenceValidator, createSetupTranslator as createSetupTranslator$1, mergeAllowFromEntries, promptParsedAllowFromForAccount, resolveSetupAccountId } from "openclaw/plugin-sdk/setup-runtime";
 import { formatDocsLink as formatDocsLink$1 } from "openclaw/plugin-sdk/setup-tools";
 //#region extensions/nextcloud-talk/src/accounts.ts
@@ -139,19 +139,16 @@ function resolveNextcloudTalkAccount(params) {
 function normalizeNextcloudTalkApproverId(value) {
 	return normalizeOptionalLowercaseString(String(value).trim().replace(/^(nextcloud-talk|nc-talk|nc):/i, ""));
 }
-const nextcloudTalkApprovalAuth = createResolvedApproverActionAuthAdapter({
+const nextcloudTalkApprovalAuth = createChannelApprovalAuth({
 	channelLabel: "Nextcloud Talk",
-	resolveApprovers: ({ cfg, accountId }) => {
-		return resolveApprovalApprovers({
-			allowFrom: resolveNextcloudTalkAccount({
-				cfg,
-				accountId
-			}).config.allowFrom,
-			normalizeApprover: normalizeNextcloudTalkApproverId
-		});
+	resolveInputs: ({ cfg, accountId }) => {
+		return { allowFrom: resolveNextcloudTalkAccount({
+			cfg,
+			accountId
+		}).config.allowFrom };
 	},
-	normalizeSenderId: (value) => normalizeNextcloudTalkApproverId(value)
-});
+	normalizeApprover: normalizeNextcloudTalkApproverId
+}).approvalAuth;
 //#endregion
 //#region extensions/nextcloud-talk/src/api-credentials.ts
 function resolveNextcloudTalkApiCredentials(params) {
@@ -167,10 +164,10 @@ function resolveNextcloudTalkApiCredentials(params) {
 	};
 	if (!params.apiPasswordFile) return;
 	try {
-		const filePassword = readFileSync(params.apiPasswordFile, "utf-8").trim();
-		return filePassword ? {
+		const fileValue = tryReadSecretFileSync(params.apiPasswordFile, "Nextcloud Talk API password", { rejectHardlinks: false });
+		return fileValue ? {
 			apiUser,
-			apiPassword: filePassword
+			apiPassword: fileValue
 		} : void 0;
 	} catch {
 		return;
@@ -188,16 +185,7 @@ const BACKEND_HEADER = "x-nextcloud-talk-backend";
 function verifyNextcloudTalkSignature(params) {
 	const { signature, random, body, secret } = params;
 	if (!signature || !random || !secret) return false;
-	const expected = createHmac("sha256", secret).update(random + body).digest("hex");
-	const expectedBuf = Buffer.from(expected, "utf8");
-	const signatureBuf = Buffer.from(signature, "utf8");
-	const maxLen = Math.max(expectedBuf.length, signatureBuf.length);
-	const paddedExpected = Buffer.alloc(maxLen);
-	const paddedSignature = Buffer.alloc(maxLen);
-	expectedBuf.copy(paddedExpected);
-	signatureBuf.copy(paddedSignature);
-	const timingResult = timingSafeEqual(paddedExpected, paddedSignature);
-	return expectedBuf.length === signatureBuf.length && timingResult;
+	return safeEqualSecret(signature, createHmac("sha256", secret).update(random + body).digest("hex"));
 }
 /**
 * Extract webhook headers from an incoming request.
@@ -372,18 +360,11 @@ const nextcloudTalkPairingTextAdapter = {
 };
 //#endregion
 //#region extensions/nextcloud-talk/src/config-schema.ts
-const NextcloudTalkRoomSchema = z.object({
-	requireMention: z.boolean().optional(),
-	tools: ToolPolicySchema,
-	skills: z.array(z.string()).optional(),
-	enabled: z.boolean().optional(),
-	allowFrom: z.array(z.string()).optional(),
-	systemPrompt: z.string().optional()
-}).strict();
+const NextcloudTalkRoomSchema = buildGroupEntrySchema({ allowFrom: z.array(z.string()).optional() }).omit({ toolsBySender: true });
 const NextcloudTalkNetworkSchema = z.object({ 
 /** Dangerous opt-in for self-hosted Nextcloud Talk on trusted private/internal hosts. */
 dangerouslyAllowPrivateNetwork: z.boolean().optional() }).strict().optional();
-const NextcloudTalkAccountSchemaBase = z.object({
+const NextcloudTalkConfigSchema = buildMultiAccountChannelSchema(z.object({
 	name: z.string().optional(),
 	enabled: z.boolean().optional(),
 	markdown: MarkdownConfigSchema,
@@ -405,27 +386,17 @@ const NextcloudTalkAccountSchemaBase = z.object({
 	/** Network policy overrides for self-hosted Nextcloud Talk on trusted private/internal hosts. */
 	network: NextcloudTalkNetworkSchema,
 	...ReplyRuntimeConfigSchemaShape
-}).strict();
-const NextcloudTalkAccountSchema = NextcloudTalkAccountSchemaBase.superRefine((value, ctx) => {
-	requireChannelOpenAllowFrom({
-		channel: "nextcloud-talk",
-		policy: value.dmPolicy,
-		allowFrom: value.allowFrom,
-		ctx,
-		requireOpenAllowFrom
-	});
-});
-const NextcloudTalkConfigSchema = NextcloudTalkAccountSchemaBase.extend({
-	accounts: z.record(z.string(), NextcloudTalkAccountSchema.optional()).optional(),
-	defaultAccount: z.string().optional()
-}).superRefine((value, ctx) => {
-	requireChannelOpenAllowFrom({
-		channel: "nextcloud-talk",
-		policy: value.dmPolicy,
-		allowFrom: value.allowFrom,
-		ctx,
-		requireOpenAllowFrom
-	});
+}).strict(), {
+	optionalAccount: true,
+	refine: (value, ctx) => {
+		requireChannelOpenAllowFrom({
+			channel: "nextcloud-talk",
+			policy: value.dmPolicy,
+			allowFrom: value.allowFrom,
+			ctx,
+			requireOpenAllowFrom
+		});
+	}
 });
 //#endregion
 //#region extensions/nextcloud-talk/src/replay-guard.ts
@@ -434,7 +405,7 @@ const NEXTCLOUD_TALK_REPLAY_DEDUPE_NAMESPACE_PREFIX = "replay-dedupe";
 const DEFAULT_REPLAY_TTL_MS = 1440 * 60 * 1e3;
 const DEFAULT_MEMORY_MAX_SIZE = 1e3;
 const DEFAULT_STATE_MAX_ENTRIES = 1e4;
-function buildReplayKey(params) {
+function buildNextcloudTalkReplayKey(params) {
 	const roomToken = params.roomToken.trim();
 	const messageId = params.messageId.trim();
 	if (!roomToken || !messageId) return null;
@@ -446,55 +417,21 @@ function createNextcloudTalkReplayGuard(options) {
 		ttlMs: options.ttlMs ?? DEFAULT_REPLAY_TTL_MS,
 		memoryMaxSize: options.memoryMaxSize ?? DEFAULT_MEMORY_MAX_SIZE
 	};
-	const dedupe = createClaimableDedupe(stateDir ? {
-		...baseOptions,
-		pluginId: NEXTCLOUD_TALK_PLUGIN_ID,
-		namespacePrefix: NEXTCLOUD_TALK_REPLAY_DEDUPE_NAMESPACE_PREFIX,
-		stateMaxEntries: options.stateMaxEntries ?? options.fileMaxEntries ?? DEFAULT_STATE_MAX_ENTRIES,
-		env: {
-			...process.env,
-			OPENCLAW_STATE_DIR: stateDir
-		},
-		onDiskError: options.onDiskError
-	} : baseOptions);
-	return {
-		claimMessage: async ({ accountId, roomToken, messageId }) => {
-			const replayKey = buildReplayKey({
-				roomToken,
-				messageId
-			});
-			if (!replayKey) return "invalid";
-			return (await dedupe.claim(replayKey, { namespace: accountId })).kind;
-		},
-		commitMessage: async ({ accountId, roomToken, messageId }) => {
-			const replayKey = buildReplayKey({
-				roomToken,
-				messageId
-			});
-			if (!replayKey) return true;
-			return await dedupe.commit(replayKey, { namespace: accountId });
-		},
-		releaseMessage: ({ accountId, roomToken, messageId, error }) => {
-			const replayKey = buildReplayKey({
-				roomToken,
-				messageId
-			});
-			if (!replayKey) return;
-			dedupe.release(replayKey, {
-				namespace: accountId,
-				error
-			});
-		},
-		shouldProcessMessage: async ({ accountId, roomToken, messageId }) => {
-			const replayKey = buildReplayKey({
-				roomToken,
-				messageId
-			});
-			if (!replayKey) return true;
-			if ((await dedupe.claim(replayKey, { namespace: accountId })).kind !== "claimed") return false;
-			return await dedupe.commit(replayKey, { namespace: accountId });
-		}
-	};
+	return createChannelReplayGuard({
+		dedupe: stateDir ? {
+			...baseOptions,
+			pluginId: NEXTCLOUD_TALK_PLUGIN_ID,
+			namespacePrefix: NEXTCLOUD_TALK_REPLAY_DEDUPE_NAMESPACE_PREFIX,
+			stateMaxEntries: options.stateMaxEntries ?? options.fileMaxEntries ?? DEFAULT_STATE_MAX_ENTRIES,
+			env: {
+				...process.env,
+				OPENCLAW_STATE_DIR: stateDir
+			},
+			onDiskError: options.onDiskError
+		} : baseOptions,
+		buildReplayKey: buildNextcloudTalkReplayKey,
+		namespace: (event) => event.accountId
+	});
 }
 //#endregion
 //#region extensions/nextcloud-talk/src/doctor.ts
@@ -505,14 +442,6 @@ function sanitizeLegacyReplaySegment(value) {
 	if (!trimmed) return "default";
 	return trimmed.replace(/[^a-zA-Z0-9_-]/g, "_");
 }
-async function fileExists(filePath) {
-	try {
-		await fs.access(filePath);
-		return true;
-	} catch {
-		return false;
-	}
-}
 async function collectNextcloudTalkBotResponseWarnings(params) {
 	const warnings = [];
 	for (const accountId of listNextcloudTalkAccountIds(params.cfg)) {
@@ -537,7 +466,7 @@ async function repairNextcloudTalkReplayDedupeState(params) {
 	const replayDir = path.join(stateDir, "nextcloud-talk", "replay-dedupe");
 	for (const accountId of listNextcloudTalkAccountIds(params.cfg)) {
 		const legacyPath = path.join(replayDir, `${sanitizeLegacyReplaySegment(accountId)}.json`);
-		if (!await fileExists(legacyPath)) continue;
+		if (!fileExists(legacyPath)) continue;
 		try {
 			const result = await migratePersistentDedupeLegacyJsonFile({
 				filePath: legacyPath,
@@ -592,12 +521,11 @@ function resolveNextcloudTalkAllowlistMatch(params) {
 		matchSource: "wildcard"
 	};
 	const senderId = normalizeNextcloudTalkAllowEntry(params.senderId);
-	if (allowFrom.includes(senderId)) return {
+	return allowFrom.includes(senderId) ? {
 		allowed: true,
 		matchKey: senderId,
 		matchSource: "id"
-	};
-	return { allowed: false };
+	} : { allowed: false };
 }
 function resolveNextcloudTalkRoomMatch(params) {
 	const rooms = params.rooms ?? {};
@@ -609,12 +537,7 @@ function resolveNextcloudTalkRoomMatch(params) {
 		normalizeKey: normalizeChannelSlug
 	});
 	const roomConfig = match.entry;
-	const allowed = resolveNestedAllowlistDecision({
-		outerConfigured: allowlistConfigured,
-		outerMatched: Boolean(roomConfig),
-		innerConfigured: false,
-		innerMatched: false
-	});
+	const allowed = !allowlistConfigured || Boolean(roomConfig);
 	return {
 		roomConfig,
 		wildcardConfig: match.wildcardEntry,
@@ -625,25 +548,52 @@ function resolveNextcloudTalkRoomMatch(params) {
 	};
 }
 function resolveNextcloudTalkGroupToolPolicy(params) {
-	const cfg = params.cfg;
 	const roomToken = params.groupId?.trim();
 	if (!roomToken) return;
-	const match = resolveNextcloudTalkRoomMatch({
-		rooms: cfg.channels?.["nextcloud-talk"]?.rooms,
-		roomToken
+	const { tree, toolsPath } = buildNextcloudTalkRoomScope(resolveNextcloudTalkAccount({
+		cfg: params.cfg,
+		accountId: params.accountId
+	}).config.rooms, roomToken);
+	return resolveScopeToolsPolicy({
+		tree,
+		path: toolsPath
 	});
-	return match.roomConfig?.tools ?? match.wildcardConfig?.tools;
 }
-function resolveNextcloudTalkRequireMention(params) {
-	if (typeof params.roomConfig?.requireMention === "boolean") return params.roomConfig.requireMention;
-	if (typeof params.wildcardConfig?.requireMention === "boolean") return params.wildcardConfig.requireMention;
-	return true;
+function buildNextcloudTalkRoomScope(rooms, roomToken) {
+	const { "*": defaults, ...scopes } = rooms ?? {};
+	const tree = {
+		defaults,
+		scopes
+	};
+	const exactPath = Object.hasOwn(scopes, roomToken) ? [roomToken] : [];
+	const toolsMatch = resolveChannelEntryMatchWithFallback({
+		entries: scopes,
+		keys: buildChannelKeyCandidates(roomToken),
+		normalizeKey: normalizeChannelSlug
+	});
+	return {
+		tree,
+		exactPath,
+		toolsPath: toolsMatch.matchKey ? [toolsMatch.matchKey] : []
+	};
+}
+function resolveNextcloudTalkGroupRequireMention(params) {
+	if (!params.groupId) return true;
+	const { tree, exactPath } = buildNextcloudTalkRoomScope(resolveNextcloudTalkAccount({
+		cfg: params.cfg,
+		accountId: params.accountId
+	}).config.rooms, params.groupId);
+	return resolveScopeRequireMention({
+		tree,
+		path: exactPath
+	});
 }
 //#endregion
 //#region extensions/nextcloud-talk/src/room-info.ts
 const ROOM_CACHE_TTL_MS = 300 * 1e3;
 const ROOM_CACHE_ERROR_TTL_MS = 30 * 1e3;
 const ROOM_CACHE_MAX_ENTRIES = 1e3;
+const NEXTCLOUD_TALK_ROOM_INFO_TIMEOUT_MS = 3e4;
 const roomCache = /* @__PURE__ */ new Map();
 function resolveRoomCacheKey(params) {
 	return `${params.accountId}:${params.roomToken}`;
@@ -695,7 +645,8 @@ async function resolveNextcloudTalkRoomKind(params) {
 				}
 			},
 			auditContext: "nextcloud-talk.room-info",
-			policy: ssrfPolicyFromPrivateNetworkOptIn(account.config)
+			policy: ssrfPolicyFromPrivateNetworkOptIn(account.config),
+			timeoutMs: params.timeoutMs ?? NEXTCLOUD_TALK_ROOM_INFO_TIMEOUT_MS
 		});
 		try {
 			if (!response.ok) {
@@ -730,10 +681,10 @@ function stripNextcloudTalkTargetPrefix(raw) {
 	const trimmed = raw.trim();
 	if (!trimmed) return;
 	let normalized = trimmed;
-	if (normalized.startsWith("nextcloud-talk:")) normalized = normalized.slice(15).trim();
-	else if (normalized.startsWith("nc-talk:")) normalized = normalized.slice(8).trim();
-	else if (normalized.startsWith("nc:")) normalized = normalized.slice(3).trim();
-	if (normalized.startsWith("room:")) normalized = normalized.slice(5).trim();
+	if (/^nextcloud-talk:/i.test(normalized)) normalized = normalized.slice(15).trim();
+	else if (/^nc-talk:/i.test(normalized)) normalized = normalized.slice(8).trim();
+	else if (/^nc:/i.test(normalized)) normalized = normalized.slice(3).trim();
+	if (/^room:/i.test(normalized)) normalized = normalized.slice(5).trim();
 	if (!normalized) return;
 	return normalized;
 }
@@ -744,17 +695,18 @@ function normalizeNextcloudTalkMessagingTarget(raw) {
 function looksLikeNextcloudTalkTargetId(raw) {
 	const trimmed = raw.trim();
 	if (!trimmed) return false;
-	if (/^(nextcloud-talk|nc-talk|nc):/i.test(trimmed)) return true;
+	if (/^(nextcloud-talk|nc-talk|nc|room):/i.test(trimmed)) return true;
 	return /^[a-z0-9]{8,}$/i.test(trimmed);
 }
 //#endregion
 //#region extensions/nextcloud-talk/src/send.ts
 const NEXTCLOUD_TALK_ERROR_SNIPPET_MAX_BYTES = 8 * 1024;
 const NEXTCLOUD_TALK_ERROR_SNIPPET_MAX_CHARS = 200;
+const NEXTCLOUD_TALK_SEND_TIMEOUT_MS = 3e4;
 /** Collapses whitespace and caps an error-body prefix to a short, log-safe snippet. */
 function collapseErrorSnippet(text) {
 	const collapsed = text.replace(/\s+/g, " ").trim();
-	if (collapsed.length > NEXTCLOUD_TALK_ERROR_SNIPPET_MAX_CHARS) return `${collapsed.slice(0, NEXTCLOUD_TALK_ERROR_SNIPPET_MAX_CHARS)}…`;
+	if (collapsed.length > NEXTCLOUD_TALK_ERROR_SNIPPET_MAX_CHARS) return `${truncateUtf16Safe(collapsed, NEXTCLOUD_TALK_ERROR_SNIPPET_MAX_CHARS)}…`;
 	return collapsed;
 }
 /** Reads a bounded, collapsed error-body snippet without buffering hostile responses. */
@@ -850,7 +802,8 @@ async function sendMessageNextcloudTalk(to, text, opts) {
 			body: bodyStr
 		},
 		auditContext: "nextcloud-talk-send",
-		policy: ssrfPolicyFromPrivateNetworkOptIn$1(account.config)
+		policy: ssrfPolicyFromPrivateNetworkOptIn$1(account.config),
+		timeoutMs: opts.timeoutMs ?? NEXTCLOUD_TALK_SEND_TIMEOUT_MS
 	});
 	try {
 		if (!response.ok) {
@@ -908,7 +861,8 @@ async function sendReactionNextcloudTalk(roomToken, messageId, reaction, opts) {
 			body
 		},
 		auditContext: "nextcloud-talk-reaction",
-		policy: ssrfPolicyFromPrivateNetworkOptIn$1(account.config)
+		policy: ssrfPolicyFromPrivateNetworkOptIn$1(account.config),
+		timeoutMs: opts.timeoutMs ?? NEXTCLOUD_TALK_SEND_TIMEOUT_MS
 	});
 	try {
 		if (!response.ok) {
@@ -959,7 +913,7 @@ function roomRoutes(params) {
 }
 async function deliverNextcloudTalkReply(params) {
 	const { cfg, payload, roomToken, accountId, statusSink } = params;
-	await deliverFormattedTextWithAttachments({
+	return { visibleReplySent: await deliverFormattedTextWithAttachments({
 		payload,
 		send: async ({ text, replyToId }) => {
 			await sendMessageNextcloudTalk(roomToken, text, {
@@ -969,7 +923,7 @@ async function deliverNextcloudTalkReply(params) {
 			});
 			statusSink?.({ lastOutboundAt: Date.now() });
 		}
-	});
+	}) };
 }
 async function handleNextcloudTalkInbound(params) {
 	const { message, account, config, runtime, statusSink } = params;
@@ -1002,9 +956,10 @@ async function handleNextcloudTalkInbound(params) {
 		surface: CHANNEL_ID
 	});
 	const hasControlCommand = core.channel.text.hasControlCommand(rawBody, config);
-	const shouldRequireMention = isGroup ? resolveNextcloudTalkRequireMention({
-		roomConfig,
-		wildcardConfig: roomMatch.wildcardConfig
+	const shouldRequireMention = isGroup ? resolveNextcloudTalkGroupRequireMention({
+		cfg: config,
+		accountId: account.accountId,
+		groupId: roomToken
 	}) : false;
 	const { groupPolicy, providerMissingFallbackApplied } = resolveAllowlistProviderRuntimeGroupPolicy({
 		providerConfigPresent: (config.channels?.[CHANNEL_ID] ?? void 0) !== void 0,
@@ -1141,6 +1096,7 @@ async function handleNextcloudTalkInbound(params) {
 		body: rawBody
 	});
 	const groupSystemPrompt = normalizeOptionalString(roomConfig?.systemPrompt);
+	const blockStreamingEnabled = resolveChannelStreamingBlockEnabled(account.config);
 	const ctxPayload = core.channel.reply.finalizeInboundContext({
 		Body: body,
 		BodyForAgent: rawBody,
@@ -1176,8 +1132,12 @@ async function handleNextcloudTalkInbound(params) {
 		recordInboundSession: core.channel.session.recordInboundSession,
 		dispatchReplyWithBufferedBlockDispatcher: core.channel.reply.dispatchReplyWithBufferedBlockDispatcher,
 		delivery: {
+			preparePayload: (payload) => payload.text === void 0 ? payload : {
+				...payload,
+				text: sanitizeAssistantVisibleText(payload.text)
+			},
 			deliver: async (payload) => {
-				await deliverNextcloudTalkReply({
+				return await deliverNextcloudTalkReply({
 					cfg: config,
 					payload,
 					roomToken,
@@ -1192,7 +1152,7 @@ async function handleNextcloudTalkInbound(params) {
 		replyPipeline: {},
 		replyOptions: {
 			skillFilter: roomConfig?.skills,
-			disableBlockStreaming: typeof account.config.blockStreaming === "boolean" ? !account.config.blockStreaming : void 0
+			disableBlockStreaming: typeof blockStreamingEnabled === "boolean" ? !blockStreamingEnabled : void 0
 		},
 		record: { onRecordError: (err) => {
 			runtime.error?.(`nextcloud-talk: failed updating session meta: ${String(err)}`);
@@ -1242,40 +1202,12 @@ const WEBHOOK_ERRORS = {
 	payloadTooLarge: "Payload too large",
 	internalServerError: "Internal server error"
 };
-var NextcloudTalkRetryableWebhookError = class extends Error {
-	constructor(message, options) {
-		super(message, options);
-		this.name = "NextcloudTalkRetryableWebhookError";
-	}
-};
 async function processNextcloudTalkReplayGuardedMessage(params) {
-	if (await params.replayGuard.claimMessage({
+	return (await params.replayGuard.processGuarded({
 		accountId: params.accountId,
 		roomToken: params.message.roomToken,
 		messageId: params.message.messageId
-	}) !== "claimed") return "duplicate";
-	try {
-		await params.handleMessage();
-		await params.replayGuard.commitMessage({
-			accountId: params.accountId,
-			roomToken: params.message.roomToken,
-			messageId: params.message.messageId
-		});
-		return "processed";
-	} catch (error) {
-		if (error instanceof NextcloudTalkRetryableWebhookError) params.replayGuard.releaseMessage({
-			accountId: params.accountId,
-			roomToken: params.message.roomToken,
-			messageId: params.message.messageId,
-			error
-		});
-		else await params.replayGuard.commitMessage({
-			accountId: params.accountId,
-			roomToken: params.message.roomToken,
-			messageId: params.message.messageId
-		});
-		throw error;
-	}
+	}, params.handleMessage, { onError: "commit" })).kind === "processed" ? "processed" : "duplicate";
 }
 function formatError(err) {
 	if (err instanceof Error) return err.message;
@@ -1651,7 +1583,7 @@ const nextcloudTalkMessageActions = {
 		if (!hasConfiguredAccount(cfg, accountId)) return null;
 		return { actions: ["send", "react"] };
 	},
-	supportsAction: ({ action }) => action !== "send",
+	supportsAction: ({ action }) => action === "react",
 	handleAction: async ({ action, params, cfg, accountId, toolContext }) => {
 		if (action === "send") throw new Error("Send should be handled by outbound, not actions handler.");
 		if (action === "react") {
@@ -1938,8 +1870,10 @@ const nextcloudTalkSetupWizard = {
 			[CONFIGURE_API_FLAG]: "1"
 		} };
 	},
-	credentials: [{
+	credentials: [defineTokenCredential({
 		inputKey: "token",
+		configKey: "botSecret",
+		configuredFields: ["botSecret", "botSecretFile"],
 		providerHint: channel,
 		credentialLabel: t("wizard.nextcloudTalk.botSecret"),
 		preferredEnvVar: "NEXTCLOUD_TALK_BOT_SECRET",
@@ -1947,61 +1881,56 @@ const nextcloudTalkSetupWizard = {
 		keepPrompt: t("wizard.nextcloudTalk.botSecretKeep"),
 		inputPrompt: t("wizard.nextcloudTalk.botSecretInput"),
 		allowEnv: ({ accountId }) => accountId === DEFAULT_ACCOUNT_ID$1,
-		inspect: ({ cfg, accountId }) => {
-			const resolvedAccount = resolveNextcloudTalkAccount({
-				cfg,
-				accountId
-			});
-			return {
-				accountConfigured: Boolean(resolvedAccount.secret && resolvedAccount.baseUrl),
-				hasConfiguredValue: Boolean(hasConfiguredSecretInput(resolvedAccount.config.botSecret) || resolvedAccount.config.botSecretFile),
-				resolvedValue: resolvedAccount.secret || void 0,
-				envValue: accountId === DEFAULT_ACCOUNT_ID$1 ? normalizeOptionalString(process.env.NEXTCLOUD_TALK_BOT_SECRET) : void 0
-			};
+		resolveAccount: ({ cfg, accountId }) => resolveNextcloudTalkAccount({
+			cfg,
+			accountId
+		}),
+		accountConfigured: (account) => Boolean(account.secret && account.baseUrl),
+		hasConfiguredValue: (account) => Boolean(hasConfiguredSecretInput(account.config.botSecret) || account.config.botSecretFile),
+		resolvedValue: (account) => account.secret || void 0,
+		envValue: ({ accountId }) => accountId === DEFAULT_ACCOUNT_ID$1 ? normalizeOptionalString(process.env.NEXTCLOUD_TALK_BOT_SECRET) : void 0,
+		patchAccount: ({ cfg, accountId, patch, clearFields }) => {
+			return setNextcloudTalkAccountConfig(clearNextcloudTalkAccountFields(cfg, accountId, clearFields), accountId, patch);
 		},
-		applyUseEnv: async (params) => {
-			const resolvedAccount = resolveNextcloudTalkAccount({
-				cfg: params.cfg,
-				accountId: params.accountId
-			});
-			return setNextcloudTalkAccountConfig(clearNextcloudTalkAccountFields(params.cfg, params.accountId, ["botSecret", "botSecretFile"]), params.accountId, { baseUrl: resolvedAccount.baseUrl });
+		useEnv: {
+			clearFields: ["botSecret", "botSecretFile"],
+			patch: (account) => ({ baseUrl: account.baseUrl })
 		},
-		applySet: async (params) => setNextcloudTalkAccountConfig(clearNextcloudTalkAccountFields(params.cfg, params.accountId, ["botSecret", "botSecretFile"]), params.accountId, { botSecret: params.value })
-	}, {
+		set: { clearFields: ["botSecret", "botSecretFile"] }
+	}), defineTokenCredential({
 		inputKey: "password",
+		configKey: "apiPassword",
+		configuredFields: ["apiPassword", "apiPasswordFile"],
 		providerHint: "nextcloud-talk-api",
 		credentialLabel: t("wizard.nextcloudTalk.apiPassword"),
 		preferredEnvVar: "NEXTCLOUD_TALK_API_PASSWORD",
 		envPrompt: "",
 		keepPrompt: t("wizard.nextcloudTalk.apiPasswordKeep"),
 		inputPrompt: t("wizard.nextcloudTalk.apiPasswordInput"),
-		inspect: ({ cfg, accountId }) => {
-			const resolvedAccount = resolveNextcloudTalkAccount({
-				cfg,
-				accountId
-			});
-			const apiUser = resolvedAccount.config.apiUser?.trim();
-			const apiPasswordConfigured = Boolean(hasConfiguredSecretInput(resolvedAccount.config.apiPassword) || resolvedAccount.config.apiPasswordFile);
-			return {
-				accountConfigured: Boolean(apiUser && apiPasswordConfigured),
-				hasConfiguredValue: apiPasswordConfigured
-			};
-		},
+		resolveAccount: ({ cfg, accountId }) => resolveNextcloudTalkAccount({
+			cfg,
+			accountId
+		}),
+		accountConfigured: (account) => Boolean(account.config.apiUser?.trim() && (hasConfiguredSecretInput(account.config.apiPassword) || account.config.apiPasswordFile)),
+		hasConfiguredValue: (account) => Boolean(hasConfiguredSecretInput(account.config.apiPassword) || account.config.apiPasswordFile),
 		shouldPrompt: ({ credentialValues }) => credentialValues[CONFIGURE_API_FLAG] === "1",
-		applySet: async (params) => setNextcloudTalkAccountConfig(clearNextcloudTalkAccountFields(params.cfg, params.accountId, ["apiPassword", "apiPasswordFile"]), params.accountId, { apiPassword: params.value })
-	}],
-	textInputs: [{
+		patchAccount: ({ cfg, accountId, patch, clearFields }) => setNextcloudTalkAccountConfig(clearNextcloudTalkAccountFields(cfg, accountId, clearFields), accountId, patch),
+		set: { clearFields: ["apiPassword", "apiPasswordFile"] }
+	})],
+	textInputs: [baseUrlTextInput({
 		inputKey: "httpUrl",
+		configKey: "baseUrl",
 		message: t("wizard.nextcloudTalk.instanceUrlPrompt"),
-		currentValue: ({ cfg, accountId }) => resolveNextcloudTalkAccount({
+		resolveAccount: ({ cfg, accountId }) => resolveNextcloudTalkAccount({
 			cfg,
 			accountId
-		}).baseUrl || void 0,
+		}),
+		currentValue: (account) => account.baseUrl || void 0,
 		shouldPrompt: ({ currentValue }) => !currentValue,
-		validate: ({ value }) => validateNextcloudTalkBaseUrl(value),
-		normalizeValue: ({ value }) => normalizeNextcloudTalkBaseUrl(value),
-		applySet: async (params) => setNextcloudTalkAccountConfig(params.cfg, params.accountId, { baseUrl: params.value })
-	}, {
+		validate: validateNextcloudTalkBaseUrl,
+		normalize: normalizeNextcloudTalkBaseUrl,
+		patchAccount: ({ cfg, accountId, patch }) => setNextcloudTalkAccountConfig(cfg, accountId, patch)
+	}), {
 		inputKey: "userId",
 		message: t("wizard.nextcloudTalk.apiUserPrompt"),
 		currentValue: ({ cfg, accountId }) => resolveNextcloudTalkAccount({
@@ -2076,18 +2005,7 @@ const nextcloudTalkPlugin = createChatChannelPlugin({
 		approvalCapability: nextcloudTalkApprovalAuth,
 		doctor: nextcloudTalkDoctor,
 		groups: {
-			resolveRequireMention: ({ cfg, accountId, groupId }) => {
-				const rooms = resolveNextcloudTalkAccount({
-					cfg,
-					accountId
-				}).config.rooms;
-				if (!rooms || !groupId) return true;
-				const roomConfig = rooms[groupId];
-				if (roomConfig?.requireMention !== void 0) return roomConfig.requireMention;
-				const wildcardConfig = rooms["*"];
-				if (wildcardConfig?.requireMention !== void 0) return wildcardConfig.requireMention;
-				return true;
-			},
+			resolveRequireMention: resolveNextcloudTalkGroupRequireMention,
 			resolveToolPolicy: resolveNextcloudTalkGroupToolPolicy
 		},
 		messaging: {
@@ -2155,7 +2073,8 @@ const nextcloudTalkPlugin = createChatChannelPlugin({
 			deliveryMode: "direct",
 			chunker: (text, limit) => getNextcloudTalkRuntime().channel.text.chunkMarkdownText(text, limit),
 			chunkerMode: "markdown",
-			textChunkLimit: 4e3
+			textChunkLimit: 4e3,
+			sanitizeText: ({ text }) => sanitizeAssistantVisibleText(text)
 		},
 		attachedResults: {
 			channel: "nextcloud-talk",

package/dist/channel-plugin-api.js

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

package/dist/doctor-contract-api.js

@@ -1,2 +1,2 @@
-import { n as normalizeCompatibilityConfig, t as legacyConfigRules } from "./doctor-contract-BY7I5-v9.js";
+import { n as normalizeCompatibilityConfig, t as legacyConfigRules } from "./doctor-contract-fNhK1wag.js";
 export { legacyConfigRules, normalizeCompatibilityConfig };

package/dist/doctor-contract-fNhK1wag.js

@@ -0,0 +1,22 @@
+import { createLegacyPrivateNetworkDoctorContract } from "openclaw/plugin-sdk/ssrf-runtime";
+import { defineChannelAliasMigration } from "openclaw/plugin-sdk/runtime-doctor";
+//#region extensions/nextcloud-talk/src/doctor-contract.ts
+const networkContract = createLegacyPrivateNetworkDoctorContract({ channelKey: "nextcloud-talk" });
+const streamingAliasMigration = defineChannelAliasMigration({
+	channelId: "nextcloud-talk",
+	streaming: {
+		defaultMode: "partial",
+		deliveryOnly: true
+	},
+	accountStreamingReplacesRoot: true
+});
+const legacyConfigRules = [...networkContract.legacyConfigRules, ...streamingAliasMigration.legacyConfigRules];
+function normalizeCompatibilityConfig({ cfg }) {
+	const network = networkContract.normalizeCompatibilityConfig({ cfg });
+	return streamingAliasMigration.normalizeChannelConfig({
+		cfg: network.config,
+		changes: network.changes
+	});
+}
+//#endregion
+export { normalizeCompatibilityConfig as n, legacyConfigRules as t };

package/dist/{secret-contract-CsCJ-vOP.js → secret-contract-DGgvfVqm.js}

@@ -1,51 +1,10 @@
-import { collectConditionalChannelFieldAssignments, getChannelSurface, hasOwnProperty } from "openclaw/plugin-sdk/channel-secret-basic-runtime";
+import { collectConditionalChannelFieldAssignments, createChannelSecretTargetRegistryEntries, getChannelSurface, hasOwnProperty } from "openclaw/plugin-sdk/channel-secret-basic-runtime";
 //#region extensions/nextcloud-talk/src/secret-contract.ts
-const secretTargetRegistryEntries = [
-	{
-		id: "channels.nextcloud-talk.accounts.*.apiPassword",
-		targetType: "channels.nextcloud-talk.accounts.*.apiPassword",
-		configFile: "openclaw.json",
-		pathPattern: "channels.nextcloud-talk.accounts.*.apiPassword",
-		secretShape: "secret_input",
-		expectedResolvedValue: "string",
-		includeInPlan: true,
-		includeInConfigure: true,
-		includeInAudit: true
-	},
-	{
-		id: "channels.nextcloud-talk.accounts.*.botSecret",
-		targetType: "channels.nextcloud-talk.accounts.*.botSecret",
-		configFile: "openclaw.json",
-		pathPattern: "channels.nextcloud-talk.accounts.*.botSecret",
-		secretShape: "secret_input",
-		expectedResolvedValue: "string",
-		includeInPlan: true,
-		includeInConfigure: true,
-		includeInAudit: true
-	},
-	{
-		id: "channels.nextcloud-talk.apiPassword",
-		targetType: "channels.nextcloud-talk.apiPassword",
-		configFile: "openclaw.json",
-		pathPattern: "channels.nextcloud-talk.apiPassword",
-		secretShape: "secret_input",
-		expectedResolvedValue: "string",
-		includeInPlan: true,
-		includeInConfigure: true,
-		includeInAudit: true
-	},
-	{
-		id: "channels.nextcloud-talk.botSecret",
-		targetType: "channels.nextcloud-talk.botSecret",
-		configFile: "openclaw.json",
-		pathPattern: "channels.nextcloud-talk.botSecret",
-		secretShape: "secret_input",
-		expectedResolvedValue: "string",
-		includeInPlan: true,
-		includeInConfigure: true,
-		includeInAudit: true
-	}
-];
+const secretTargetRegistryEntries = createChannelSecretTargetRegistryEntries({
+	channelKey: "nextcloud-talk",
+	account: ["apiPassword", "botSecret"],
+	channel: ["apiPassword", "botSecret"]
+});
 function collectRuntimeConfigAssignments(params) {
 	const resolved = getChannelSurface(params.config, "nextcloud-talk");
 	if (!resolved) return;

package/dist/secret-contract-api.js

@@ -1,2 +1,2 @@
-import { n as collectRuntimeConfigAssignments, r as secretTargetRegistryEntries, t as channelSecrets } from "./secret-contract-CsCJ-vOP.js";
+import { n as collectRuntimeConfigAssignments, r as secretTargetRegistryEntries, t as channelSecrets } from "./secret-contract-DGgvfVqm.js";
 export { channelSecrets, collectRuntimeConfigAssignments, secretTargetRegistryEntries };

package/npm-shrinkwrap.json

@@ -1,17 +1,17 @@
 {
   "name": "@openclaw/nextcloud-talk",
-  "version": "2026.7.1",
+  "version": "2026.7.2-beta.2",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@openclaw/nextcloud-talk",
-      "version": "2026.7.1",
+      "version": "2026.7.2-beta.2",
       "dependencies": {
         "zod": "4.4.3"
       },
       "peerDependencies": {
-        "openclaw": ">=2026.7.1"
+        "openclaw": ">=2026.7.2-beta.2"
       },
       "peerDependenciesMeta": {
         "openclaw": {

package/openclaw.plugin.json

@@ -366,33 +366,45 @@
             "exclusiveMinimum": 0,
             "maximum": 9007199254740991
           },
-          "chunkMode": {
-            "type": "string",
-            "enum": [
-              "length",
-              "newline"
-            ]
-          },
-          "blockStreaming": {
-            "type": "boolean"
-          },
-          "blockStreamingCoalesce": {
+          "streaming": {
             "type": "object",
             "properties": {
-              "minChars": {
-                "type": "integer",
-                "exclusiveMinimum": 0,
-                "maximum": 9007199254740991
-              },
-              "maxChars": {
-                "type": "integer",
-                "exclusiveMinimum": 0,
-                "maximum": 9007199254740991
+              "chunkMode": {
+                "type": "string",
+                "enum": [
+                  "length",
+                  "newline"
+                ]
               },
-              "idleMs": {
-                "type": "integer",
-                "minimum": 0,
-                "maximum": 9007199254740991
+              "block": {
+                "type": "object",
+                "properties": {
+                  "enabled": {
+                    "type": "boolean"
+                  },
+                  "coalesce": {
+                    "type": "object",
+                    "properties": {
+                      "minChars": {
+                        "type": "integer",
+                        "exclusiveMinimum": 0,
+                        "maximum": 9007199254740991
+                      },
+                      "maxChars": {
+                        "type": "integer",
+                        "exclusiveMinimum": 0,
+                        "maximum": 9007199254740991
+                      },
+                      "idleMs": {
+                        "type": "integer",
+                        "minimum": 0,
+                        "maximum": 9007199254740991
+                      }
+                    },
+                    "additionalProperties": false
+                  }
+                },
+                "additionalProperties": false
               }
             },
             "additionalProperties": false
@@ -752,33 +764,45 @@
                   "exclusiveMinimum": 0,
                   "maximum": 9007199254740991
                 },
-                "chunkMode": {
-                  "type": "string",
-                  "enum": [
-                    "length",
-                    "newline"
-                  ]
-                },
-                "blockStreaming": {
-                  "type": "boolean"
-                },
-                "blockStreamingCoalesce": {
+                "streaming": {
                   "type": "object",
                   "properties": {
-                    "minChars": {
-                      "type": "integer",
-                      "exclusiveMinimum": 0,
-                      "maximum": 9007199254740991
-                    },
-                    "maxChars": {
-                      "type": "integer",
-                      "exclusiveMinimum": 0,
-                      "maximum": 9007199254740991
+                    "chunkMode": {
+                      "type": "string",
+                      "enum": [
+                        "length",
+                        "newline"
+                      ]
                     },
-                    "idleMs": {
-                      "type": "integer",
-                      "minimum": 0,
-                      "maximum": 9007199254740991
+                    "block": {
+                      "type": "object",
+                      "properties": {
+                        "enabled": {
+                          "type": "boolean"
+                        },
+                        "coalesce": {
+                          "type": "object",
+                          "properties": {
+                            "minChars": {
+                              "type": "integer",
+                              "exclusiveMinimum": 0,
+                              "maximum": 9007199254740991
+                            },
+                            "maxChars": {
+                              "type": "integer",
+                              "exclusiveMinimum": 0,
+                              "maximum": 9007199254740991
+                            },
+                            "idleMs": {
+                              "type": "integer",
+                              "minimum": 0,
+                              "maximum": 9007199254740991
+                            }
+                          },
+                          "additionalProperties": false
+                        }
+                      },
+                      "additionalProperties": false
                     }
                   },
                   "additionalProperties": false

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/nextcloud-talk",
-  "version": "2026.7.1",
+  "version": "2026.7.2-beta.2",
   "description": "OpenClaw Nextcloud Talk channel plugin for conversations.",
   "repository": {
     "type": "git",
@@ -8,7 +8,7 @@
   },
   "type": "module",
   "peerDependencies": {
-    "openclaw": ">=2026.7.1"
+    "openclaw": ">=2026.7.2-beta.2"
   },
   "peerDependenciesMeta": {
     "openclaw": {
@@ -40,10 +40,10 @@
       "minHostVersion": ">=2026.4.10"
     },
     "compat": {
-      "pluginApi": ">=2026.7.1"
+      "pluginApi": ">=2026.7.2-beta.2"
     },
     "build": {
-      "openclawVersion": "2026.7.1"
+      "openclawVersion": "2026.7.2-beta.2"
     },
     "release": {
       "publishToClawHub": true,

package/dist/doctor-contract-BY7I5-v9.js

@@ -1,7 +0,0 @@
-import { createLegacyPrivateNetworkDoctorContract } from "openclaw/plugin-sdk/ssrf-runtime";
-//#region extensions/nextcloud-talk/src/doctor-contract.ts
-const contract = createLegacyPrivateNetworkDoctorContract({ channelKey: "nextcloud-talk" });
-const legacyConfigRules = contract.legacyConfigRules;
-const normalizeCompatibilityConfig = contract.normalizeCompatibilityConfig;
-//#endregion
-export { normalizeCompatibilityConfig as n, legacyConfigRules as t };