@openclaw/qqbot 2026.5.2-beta.2 → 2026.5.3-beta.1

package/dist/config-D6545NkC.js

@@ -0,0 +1,94 @@
+import { c as getPlatformAdapter } from "./string-normalize-Ci6NM5DE.js";
+import { c as resolveDefaultAccountId, n as applyAccountConfig, o as listAccountIds, s as resolveAccountBase, t as DEFAULT_ACCOUNT_ID$1 } from "./resolve-D_06fV6-.js";
+import { coerceSecretRef, normalizeSecretInputString } from "openclaw/plugin-sdk/secret-input";
+import fs from "node:fs";
+import { resolveDefaultSecretProviderAlias } from "openclaw/plugin-sdk/provider-auth";
+//#region extensions/qqbot/src/bridge/config.ts
+const DEFAULT_ACCOUNT_ID = DEFAULT_ACCOUNT_ID$1;
+function assertNotLegacySecretRefMarker(value, path) {
+	const normalized = normalizeSecretInputString(value);
+	if (!normalized || !/^secretref(?:-env)?:/i.test(normalized)) return;
+	throw new Error(`${path}: legacy SecretRef marker strings are not valid QQ Bot clientSecret values; use a structured SecretRef object instead.`);
+}
+function resolveEnvSecretRefValue(params) {
+	const ref = coerceSecretRef(params.value, params.cfg.secrets?.defaults);
+	if (!ref || ref.source !== "env") return;
+	const providerConfig = params.cfg.secrets?.providers?.[ref.provider];
+	if (providerConfig) {
+		if (providerConfig.source !== "env") throw new Error(`Secret provider "${ref.provider}" has source "${providerConfig.source}" but ref requests "env".`);
+		if (providerConfig.allowlist && !providerConfig.allowlist.includes(ref.id)) throw new Error(`Environment variable "${ref.id}" is not allowlisted in secrets.providers.${ref.provider}.allowlist.`);
+	} else if (ref.provider !== resolveDefaultSecretProviderAlias(params.cfg, "env")) throw new Error(`Secret provider "${ref.provider}" is not configured (ref: env:${ref.provider}:${ref.id}).`);
+	return normalizeSecretInputString((params.env ?? process.env)[ref.id]);
+}
+function resolveQQBotClientSecretInput(params) {
+	assertNotLegacySecretRefMarker(params.value, params.path);
+	const envSecret = resolveEnvSecretRefValue({
+		cfg: params.cfg,
+		value: params.value
+	});
+	if (envSecret) return envSecret;
+	return getPlatformAdapter().resolveSecretInputString({
+		value: params.value,
+		path: params.path
+	});
+}
+/** List all configured QQBot account IDs. */
+function listQQBotAccountIds(cfg) {
+	return listAccountIds(cfg);
+}
+/** Resolve the default QQBot account ID. */
+function resolveDefaultQQBotAccountId(cfg) {
+	return resolveDefaultAccountId(cfg);
+}
+/** Resolve QQBot account config for runtime or setup flows. */
+function resolveQQBotAccount(cfg, accountId, opts) {
+	const base = resolveAccountBase(cfg, accountId);
+	const qqbot = cfg.channels?.qqbot;
+	/**
+	* Legacy top-level account uses `channels.qqbot` as the base, but per-account
+	* fields (allowFrom, streaming, …) often live under `accounts.default`.
+	* Merge that slice so runtime sees `config.streaming` etc.
+	*/
+	const accountConfig = base.accountId === DEFAULT_ACCOUNT_ID ? {
+		...qqbot,
+		...qqbot?.accounts?.[DEFAULT_ACCOUNT_ID]
+	} : qqbot?.accounts?.[base.accountId] ?? {};
+	let clientSecret = "";
+	let secretSource = "none";
+	const clientSecretPath = base.accountId === DEFAULT_ACCOUNT_ID ? "channels.qqbot.clientSecret" : `channels.qqbot.accounts.${base.accountId}.clientSecret`;
+	const adapter = getPlatformAdapter();
+	if (adapter.hasConfiguredSecret(accountConfig.clientSecret)) {
+		clientSecret = opts?.allowUnresolvedSecretRef ? adapter.normalizeSecretInputString(accountConfig.clientSecret) ?? "" : resolveQQBotClientSecretInput({
+			cfg,
+			value: accountConfig.clientSecret,
+			path: clientSecretPath
+		}) ?? "";
+		secretSource = "config";
+	} else if (accountConfig.clientSecretFile) try {
+		clientSecret = fs.readFileSync(accountConfig.clientSecretFile, "utf8").trim();
+		secretSource = "file";
+	} catch {
+		secretSource = "none";
+	}
+	else if (process.env.QQBOT_CLIENT_SECRET && base.accountId === DEFAULT_ACCOUNT_ID) {
+		clientSecret = process.env.QQBOT_CLIENT_SECRET;
+		secretSource = "env";
+	}
+	return {
+		accountId: base.accountId,
+		name: accountConfig.name,
+		enabled: base.enabled,
+		appId: base.appId,
+		clientSecret,
+		secretSource,
+		systemPrompt: base.systemPrompt,
+		markdownSupport: base.markdownSupport,
+		config: accountConfig
+	};
+}
+/** Apply account config updates back into the OpenClaw config object. */
+function applyQQBotAccountConfig(cfg, accountId, input) {
+	return applyAccountConfig(cfg, accountId, input);
+}
+//#endregion
+export { resolveQQBotAccount as a, resolveDefaultQQBotAccountId as i, applyQQBotAccountConfig as n, listQQBotAccountIds as r, DEFAULT_ACCOUNT_ID as t };

package/dist/config-schema-DFcjQw73.js

@@ -0,0 +1,309 @@
+import { n as normalizeLowercaseStringOrEmpty } from "./string-normalize-Ci6NM5DE.js";
+import { a as isAccountConfigured, i as formatAllowFrom, n as applyAccountConfig, r as describeAccount } from "./resolve-D_06fV6-.js";
+import { a as resolveQQBotAccount, i as resolveDefaultQQBotAccountId, n as applyQQBotAccountConfig, r as listQQBotAccountIds } from "./config-D6545NkC.js";
+import { buildSecretInputSchema } from "openclaw/plugin-sdk/secret-input";
+import { applyAccountNameToChannelSection, deleteAccountFromConfigSection, setAccountEnabledInConfigSection } from "openclaw/plugin-sdk/core";
+import { DEFAULT_ACCOUNT_ID, createStandardChannelSetupStatus, setSetupChannelEnabled } from "openclaw/plugin-sdk/setup";
+import { formatDocsLink } from "openclaw/plugin-sdk/setup-tools";
+import { AllowFromListSchema, buildChannelConfigSchema } from "openclaw/plugin-sdk/channel-config-schema";
+import { z } from "zod";
+//#region extensions/qqbot/src/engine/config/setup-logic.ts
+/**
+* QQBot setup business logic (pure layer).
+* QQBot setup 相关纯业务逻辑。
+*
+* Token parsing, input validation, and setup config application.
+* All functions are framework-agnostic and operate on plain objects.
+*/
+/** Parse an inline "appId:clientSecret" token string. */
+function parseInlineToken(token) {
+	const colonIdx = token.indexOf(":");
+	if (colonIdx <= 0 || colonIdx === token.length - 1) return null;
+	const appId = token.slice(0, colonIdx).trim();
+	const clientSecret = token.slice(colonIdx + 1).trim();
+	if (!appId || !clientSecret) return null;
+	return {
+		appId,
+		clientSecret
+	};
+}
+/** Validate setup input for a QQBot account. Returns an error string or null. */
+function validateSetupInput(accountId, input) {
+	if (!input.token && !input.tokenFile && !input.useEnv) return "QQBot requires --token (format: appId:clientSecret) or --use-env";
+	if (input.useEnv && accountId !== "default") return "QQBot --use-env only supports the default account";
+	if (input.token && !parseInlineToken(input.token)) return "QQBot --token must be in appId:clientSecret format";
+	return null;
+}
+/** Apply setup input to account config. Returns updated config. */
+function applySetupAccountConfig(cfg, accountId, input) {
+	if (input.useEnv && accountId !== "default") return cfg;
+	let appId = "";
+	let clientSecret = "";
+	if (input.token) {
+		const parsed = parseInlineToken(input.token);
+		if (!parsed) return cfg;
+		appId = parsed.appId;
+		clientSecret = parsed.clientSecret;
+	}
+	if (!appId && !input.tokenFile && !input.useEnv) return cfg;
+	return applyAccountConfig(cfg, accountId, {
+		appId,
+		clientSecret,
+		clientSecretFile: input.tokenFile,
+		name: input.name
+	});
+}
+//#endregion
+//#region extensions/qqbot/src/bridge/config-shared.ts
+const qqbotMeta = {
+	id: "qqbot",
+	label: "QQ Bot",
+	selectionLabel: "QQ Bot (Bot API)",
+	docsPath: "/channels/qqbot",
+	blurb: "Connect to QQ via official QQ Bot API",
+	order: 50
+};
+function validateQQBotSetupInput(params) {
+	return validateSetupInput(params.accountId, params.input);
+}
+function applyQQBotSetupAccountConfig(params) {
+	return applySetupAccountConfig(params.cfg, params.accountId, params.input);
+}
+function isQQBotConfigured(account) {
+	return isAccountConfigured(account);
+}
+function describeQQBotAccount(account) {
+	return describeAccount(account);
+}
+function formatQQBotAllowFrom(params) {
+	return formatAllowFrom(params.allowFrom);
+}
+const qqbotConfigAdapter = {
+	listAccountIds: (cfg) => listQQBotAccountIds(cfg),
+	resolveAccount: (cfg, accountId) => resolveQQBotAccount(cfg, accountId, { allowUnresolvedSecretRef: true }),
+	defaultAccountId: (cfg) => resolveDefaultQQBotAccountId(cfg),
+	setAccountEnabled: ({ cfg, accountId, enabled }) => setAccountEnabledInConfigSection({
+		cfg,
+		sectionKey: "qqbot",
+		accountId,
+		enabled,
+		allowTopLevel: true
+	}),
+	deleteAccount: ({ cfg, accountId }) => deleteAccountFromConfigSection({
+		cfg,
+		sectionKey: "qqbot",
+		accountId,
+		clearBaseFields: [
+			"appId",
+			"clientSecret",
+			"clientSecretFile",
+			"name"
+		]
+	}),
+	isConfigured: isQQBotConfigured,
+	describeAccount: describeQQBotAccount,
+	resolveAllowFrom: ({ cfg, accountId }) => resolveQQBotAccount(cfg, accountId, { allowUnresolvedSecretRef: true }).config?.allowFrom,
+	formatAllowFrom: ({ allowFrom }) => formatQQBotAllowFrom({ allowFrom })
+};
+const qqbotSetupAdapterShared = {
+	resolveAccountId: ({ cfg, accountId }) => normalizeLowercaseStringOrEmpty(accountId) || resolveDefaultQQBotAccountId(cfg),
+	applyAccountName: ({ cfg, accountId, name }) => applyAccountNameToChannelSection({
+		cfg,
+		channelKey: "qqbot",
+		accountId,
+		name
+	}),
+	validateInput: ({ accountId, input }) => validateQQBotSetupInput({
+		accountId,
+		input
+	}),
+	applyAccountConfig: ({ cfg, accountId, input }) => applyQQBotSetupAccountConfig({
+		cfg,
+		accountId,
+		input
+	})
+};
+//#endregion
+//#region extensions/qqbot/src/bridge/setup/finalize.ts
+function isQQBotAccountConfigured(cfg, accountId) {
+	const account = resolveQQBotAccount(cfg, accountId, { allowUnresolvedSecretRef: true });
+	return Boolean(account.appId && account.clientSecret);
+}
+async function linkViaQrCode(params) {
+	try {
+		const { qrConnect } = await import("@tencent-connect/qqbot-connector");
+		const accounts = await qrConnect({ source: "openclaw" });
+		if (accounts.length === 0) {
+			await params.prompter.note("未获取到任何 QQ Bot 账号信息。", "QQ Bot");
+			return params.cfg;
+		}
+		let next = params.cfg;
+		for (let i = 0; i < accounts.length; i++) {
+			const { appId, appSecret } = accounts[i];
+			const targetAccountId = i === 0 ? params.accountId : appId;
+			next = applyQQBotAccountConfig(next, targetAccountId, {
+				appId,
+				clientSecret: appSecret
+			});
+		}
+		if (accounts.length === 1) params.runtime.log(`✔ QQ Bot 绑定成功！(AppID: ${accounts[0].appId})`);
+		else {
+			const idList = accounts.map((a) => a.appId).join(", ");
+			params.runtime.log(`✔ ${accounts.length} 个 QQ Bot 绑定成功！(AppID: ${idList})`);
+		}
+		return next;
+	} catch (error) {
+		params.runtime.error(`QQ Bot 绑定失败: ${String(error)}`);
+		await params.prompter.note(["绑定失败，您可以稍后手动配置。", `文档: ${formatDocsLink("/channels/qqbot", "qqbot")}`].join("\n"), "QQ Bot");
+		return params.cfg;
+	}
+}
+async function linkViaManualInput(params) {
+	const appId = await params.prompter.text({
+		message: "请输入 QQ Bot AppID",
+		validate: (value) => value.trim() ? void 0 : "AppID 不能为空"
+	});
+	const appSecret = await params.prompter.text({
+		message: "请输入 QQ Bot AppSecret",
+		validate: (value) => value.trim() ? void 0 : "AppSecret 不能为空"
+	});
+	const next = applyQQBotAccountConfig(params.cfg, params.accountId, {
+		appId: appId.trim(),
+		clientSecret: appSecret.trim()
+	});
+	await params.prompter.note("✔ QQ Bot 配置完成！", "QQ Bot");
+	return next;
+}
+async function finalizeQQBotSetup(params) {
+	const accountId = params.accountId.trim() || DEFAULT_ACCOUNT_ID;
+	let next = params.cfg;
+	const configured = isQQBotAccountConfigured(next, accountId);
+	const mode = await params.prompter.select({
+		message: configured ? "QQ 已绑定，选择操作" : "选择 QQ 绑定方式",
+		options: [
+			{
+				value: "qr",
+				label: "扫码绑定（推荐）",
+				hint: "使用 QQ 扫描二维码自动完成绑定"
+			},
+			{
+				value: "manual",
+				label: "手动输入 QQ Bot AppID 和 AppSecret",
+				hint: "需到 QQ 开放平台 q.qq.com 查看"
+			},
+			{
+				value: "skip",
+				label: configured ? "保持当前配置" : "稍后配置"
+			}
+		]
+	});
+	if (mode === "qr") next = await linkViaQrCode({
+		cfg: next,
+		accountId,
+		prompter: params.prompter,
+		runtime: params.runtime
+	});
+	else if (mode === "manual") next = await linkViaManualInput({
+		cfg: next,
+		accountId,
+		prompter: params.prompter
+	});
+	else if (!configured) await params.prompter.note(["您可以稍后运行以下命令重新选择 QQ Bot 进行配置：", "  openclaw channels add"].join("\n"), "QQ Bot");
+	return { cfg: next };
+}
+//#endregion
+//#region extensions/qqbot/src/bridge/setup/surface.ts
+const channel = "qqbot";
+const qqbotSetupWizard = {
+	channel,
+	status: createStandardChannelSetupStatus({
+		channelLabel: "QQ Bot",
+		configuredLabel: "configured",
+		unconfiguredLabel: "needs AppID + AppSercet",
+		configuredHint: "configured",
+		unconfiguredHint: "needs AppID + AppSercet",
+		configuredScore: 1,
+		unconfiguredScore: 6,
+		resolveConfigured: ({ cfg, accountId }) => (accountId ? [accountId] : listQQBotAccountIds(cfg)).some((resolvedAccountId) => {
+			return isAccountConfigured(resolveQQBotAccount(cfg, resolvedAccountId, { allowUnresolvedSecretRef: true }));
+		})
+	}),
+	credentials: [],
+	finalize: async ({ cfg, accountId, forceAllowFrom, prompter, runtime }) => await finalizeQQBotSetup({
+		cfg,
+		accountId,
+		forceAllowFrom,
+		prompter,
+		runtime
+	}),
+	disable: (cfg) => setSetupChannelEnabled(cfg, channel, false)
+};
+//#endregion
+//#region extensions/qqbot/src/config-schema.ts
+const AudioFormatPolicySchema = z.object({
+	sttDirectFormats: z.array(z.string()).optional(),
+	uploadDirectFormats: z.array(z.string()).optional(),
+	transcodeEnabled: z.boolean().optional()
+}).optional();
+const QQBotSttSchema = z.object({
+	enabled: z.boolean().optional(),
+	provider: z.string().optional(),
+	baseUrl: z.string().optional(),
+	apiKey: z.string().optional(),
+	model: z.string().optional()
+}).strict().optional();
+/** When `true`, same as `mode: "partial"` and `c2cStreamApi: true` for C2C. Object form kept for legacy configs. */
+const QQBotStreamingSchema = z.union([z.boolean(), z.object({
+	/** "partial" (default) enables block streaming; "off" disables it. */
+	mode: z.enum(["off", "partial"]).default("partial"),
+	/** @deprecated Prefer `streaming: true`. */
+	c2cStreamApi: z.boolean().optional()
+}).passthrough()]).optional();
+const QQBotExecApprovalsSchema = z.object({
+	enabled: z.union([z.boolean(), z.literal("auto")]).optional(),
+	approvers: z.array(z.string()).optional(),
+	agentFilter: z.array(z.string()).optional(),
+	sessionFilter: z.array(z.string()).optional(),
+	target: z.enum([
+		"dm",
+		"channel",
+		"both"
+	]).optional()
+}).strict().optional();
+const QQBotDmPolicySchema = z.enum([
+	"open",
+	"allowlist",
+	"disabled"
+]).optional();
+const QQBotGroupPolicySchema = z.enum([
+	"open",
+	"allowlist",
+	"disabled"
+]).optional();
+const QQBotAccountSchema = z.object({
+	enabled: z.boolean().optional(),
+	name: z.string().optional(),
+	appId: z.string().optional(),
+	clientSecret: buildSecretInputSchema().optional(),
+	clientSecretFile: z.string().optional(),
+	allowFrom: AllowFromListSchema,
+	groupAllowFrom: AllowFromListSchema,
+	dmPolicy: QQBotDmPolicySchema,
+	groupPolicy: QQBotGroupPolicySchema,
+	systemPrompt: z.string().optional(),
+	markdownSupport: z.boolean().optional(),
+	voiceDirectUploadFormats: z.array(z.string()).optional(),
+	audioFormatPolicy: AudioFormatPolicySchema,
+	urlDirectUpload: z.boolean().optional(),
+	upgradeUrl: z.string().optional(),
+	upgradeMode: z.enum(["doc", "hot-reload"]).optional(),
+	streaming: QQBotStreamingSchema,
+	execApprovals: QQBotExecApprovalsSchema
+}).passthrough();
+const qqbotChannelConfigSchema = buildChannelConfigSchema(QQBotAccountSchema.extend({
+	stt: QQBotSttSchema,
+	accounts: z.object({}).catchall(QQBotAccountSchema.passthrough()).optional(),
+	defaultAccount: z.string().optional()
+}).passthrough());
+//#endregion
+export { qqbotSetupAdapterShared as a, qqbotMeta as i, qqbotSetupWizard as n, qqbotConfigAdapter as r, qqbotChannelConfigSchema as t };

package/dist/exec-approvals-COUsM6wZ.js

@@ -0,0 +1,138 @@
+import { a as resolveQQBotAccount, r as listQQBotAccountIds } from "./config-D6545NkC.js";
+import { resolveApprovalRequestChannelAccountId } from "openclaw/plugin-sdk/approval-native-runtime";
+import { normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "openclaw/plugin-sdk/text-runtime";
+import { resolveApprovalApprovers } from "openclaw/plugin-sdk/approval-auth-runtime";
+import { createChannelExecApprovalProfile, isChannelExecApprovalClientEnabledFromConfig, matchesApprovalRequestFilters } from "openclaw/plugin-sdk/approval-client-runtime";
+import { normalizeAccountId } from "openclaw/plugin-sdk/routing";
+//#region extensions/qqbot/src/exec-approvals.ts
+function normalizeApproverId(value) {
+	return normalizeOptionalString(String(value)) || void 0;
+}
+function resolveQQBotExecApprovalConfig(params) {
+	const account = resolveQQBotAccount(params.cfg, params.accountId);
+	const config = account.config.execApprovals;
+	if (!config) return;
+	return {
+		...config,
+		enabled: account.enabled && account.secretSource !== "none" ? config.enabled : false
+	};
+}
+function getQQBotExecApprovalApprovers(params) {
+	const accountConfig = resolveQQBotAccount(params.cfg, params.accountId).config;
+	return resolveApprovalApprovers({
+		explicit: resolveQQBotExecApprovalConfig(params)?.approvers,
+		allowFrom: accountConfig.allowFrom,
+		normalizeApprover: normalizeApproverId
+	});
+}
+function countQQBotExecApprovalEligibleAccounts(params) {
+	return listQQBotAccountIds(params.cfg).filter((accountId) => {
+		const account = resolveQQBotAccount(params.cfg, accountId);
+		if (!account.enabled || account.secretSource === "none") return false;
+		const config = resolveQQBotExecApprovalConfig({
+			cfg: params.cfg,
+			accountId
+		});
+		return isChannelExecApprovalClientEnabledFromConfig({
+			enabled: config?.enabled,
+			approverCount: getQQBotExecApprovalApprovers({
+				cfg: params.cfg,
+				accountId
+			}).length
+		}) && matchesApprovalRequestFilters({
+			request: params.request.request,
+			agentFilter: config?.agentFilter,
+			sessionFilter: config?.sessionFilter,
+			fallbackAgentIdFromSessionKey: true
+		});
+	}).length;
+}
+function matchesQQBotRequestAccount(params) {
+	const turnSourceChannel = normalizeLowercaseStringOrEmpty(params.request.request.turnSourceChannel);
+	const boundAccountId = resolveApprovalRequestChannelAccountId({
+		cfg: params.cfg,
+		request: params.request,
+		channel: "qqbot"
+	});
+	if (turnSourceChannel && turnSourceChannel !== "qqbot" && !boundAccountId) return countQQBotExecApprovalEligibleAccounts({
+		cfg: params.cfg,
+		request: params.request
+	}) <= 1;
+	return !boundAccountId || !params.accountId || normalizeAccountId(boundAccountId) === normalizeAccountId(params.accountId);
+}
+/**
+* Count QQBot accounts that could actually deliver a native approval
+* message — i.e. accounts that are enabled and have resolvable secrets.
+* Disabled or unconfigured accounts never spawn a handler, so they
+* must not contribute to the single-account shortcut in the fallback
+* ownership check below.
+*/
+function countQQBotFallbackEligibleAccounts(cfg) {
+	return listQQBotAccountIds(cfg).filter((accountId) => {
+		const account = resolveQQBotAccount(cfg, accountId);
+		return account.enabled && account.secretSource !== "none";
+	}).length;
+}
+/**
+* Fallback account-ownership check — applied when `execApprovals` is NOT
+* configured for any QQBot account. In this mode every enabled account
+* handler would otherwise race to deliver the same approval to its own
+* openid namespace, so we must enforce per-account isolation.
+*
+* Rules:
+*   - If the request carries a bound account (via `turnSourceAccountId`
+*     or session binding), only the handler whose `accountId` matches it
+*     delivers the approval. This is strict: a handler with an unknown
+*     `accountId` (null/undefined) must not claim a bound request.
+*   - If no account is bound, only deliver when there is a single
+*     *eligible* QQBot account (enabled + secret resolved). Disabled or
+*     unconfigured accounts never deliver anyway, so they shouldn't
+*     block the remaining single account from handling the approval.
+*     Multiple eligible accounts cannot safely race because openids are
+*     account-scoped — cross-account delivery hits the QQ Bot API with
+*     a mismatched token and fails.
+*/
+function matchesQQBotFallbackRequestAccount(params) {
+	const boundAccountId = resolveApprovalRequestChannelAccountId({
+		cfg: params.cfg,
+		request: params.request,
+		channel: "qqbot"
+	});
+	if (boundAccountId) {
+		if (!params.accountId) return false;
+		return normalizeAccountId(boundAccountId) === normalizeAccountId(params.accountId);
+	}
+	return countQQBotFallbackEligibleAccounts(params.cfg) <= 1;
+}
+/**
+* Unified per-account ownership check used by both the profile and
+* fallback approval paths. Dispatches to the profile rules when the
+* current account has `execApprovals` configured, otherwise uses the
+* fallback rules.
+*
+* This is the single source of truth for "does this QQBot handler own
+* this approval request?" and is consumed by both the capability
+* gate (shouldHandle) and the lazy native runtime adapter.
+*/
+function matchesQQBotApprovalAccount(params) {
+	const normalized = {
+		cfg: params.cfg,
+		accountId: params.accountId,
+		request: params.request
+	};
+	if (resolveQQBotExecApprovalConfig(normalized) !== void 0) return matchesQQBotRequestAccount(normalized);
+	return matchesQQBotFallbackRequestAccount(normalized);
+}
+const qqbotExecApprovalProfile = createChannelExecApprovalProfile({
+	resolveConfig: resolveQQBotExecApprovalConfig,
+	resolveApprovers: getQQBotExecApprovalApprovers,
+	matchesRequestAccount: matchesQQBotRequestAccount,
+	fallbackAgentIdFromSessionKey: true,
+	requireClientEnabledForLocalPromptSuppression: false
+});
+const isQQBotExecApprovalClientEnabled = qqbotExecApprovalProfile.isClientEnabled;
+const isQQBotExecApprovalApprover = qqbotExecApprovalProfile.isApprover;
+const isQQBotExecApprovalAuthorizedSender = qqbotExecApprovalProfile.isAuthorizedSender;
+const shouldHandleQQBotExecApprovalRequest = qqbotExecApprovalProfile.shouldHandleRequest;
+//#endregion
+export { resolveQQBotExecApprovalConfig as a, matchesQQBotApprovalAccount as i, isQQBotExecApprovalAuthorizedSender as n, shouldHandleQQBotExecApprovalRequest as o, isQQBotExecApprovalClientEnabled as r, isQQBotExecApprovalApprover as t };