@spacebar_ai/moldclaw-core 2026.3.14 → 2026.3.16

package/dist/channel-N616f4gZ.js

@@ -0,0 +1,306 @@
+import { d as isRecord } from "./utils-rjVNXUns.js";
+import { DT as isWhatsAppGroupJid, OT as normalizeWhatsAppTarget, ST as looksLikeWhatsAppTargetId, _w as listWhatsAppDirectoryGroupsFromConfig, bt as collectIssuesForEnabledAccounts, dr as resolveWhatsAppHeartbeatRecipients, fr as createWhatsAppOutboundBase, hT as formatWhatsAppConfigAllowFromEntries, lr as resolveWhatsAppAccount, lw as resolveWhatsAppOutboundTarget, mr as resolveWhatsAppMentionStripRegexes, vw as listWhatsAppDirectoryPeersFromConfig, wT as normalizeWhatsAppMessagingTarget, yt as asString } from "./auth-profiles-9zZdaXJK.js";
+import { t as DEFAULT_ACCOUNT_ID } from "./account-id-O4Og6DrK.js";
+import { R as readStringParam, k as createActionGate } from "./provider-web-search-BJhXD5dH.js";
+import { t as formatCliCommand } from "./command-format-DIDjlImI.js";
+import { t as createPluginRuntimeStore } from "./runtime-store-BIrp4FYB.js";
+import { t as buildAccountScopedAllowlistConfigEditor } from "./allowlist-config-edit-MRjQSRMS.js";
+import { t as whatsappSetupAdapter } from "./setup-core-Cj0sLkpP.js";
+import { i as whatsappSetupWizardProxy, n as createWhatsAppPluginBase, r as loadWhatsAppChannelRuntime, t as WHATSAPP_CHANNEL } from "./shared-UIjWb_3B.js";
+//#region extensions/whatsapp/src/runtime.ts
+const { setRuntime: setWhatsAppRuntime, getRuntime: getWhatsAppRuntime } = createPluginRuntimeStore("WhatsApp runtime not initialized");
+//#endregion
+//#region extensions/whatsapp/src/status-issues.ts
+function readWhatsAppAccountStatus(value) {
+	if (!isRecord(value)) return null;
+	return {
+		accountId: value.accountId,
+		enabled: value.enabled,
+		linked: value.linked,
+		connected: value.connected,
+		running: value.running,
+		reconnectAttempts: value.reconnectAttempts,
+		lastError: value.lastError
+	};
+}
+function collectWhatsAppStatusIssues(accounts) {
+	return collectIssuesForEnabledAccounts({
+		accounts,
+		readAccount: readWhatsAppAccountStatus,
+		collectIssues: ({ account, accountId, issues }) => {
+			const linked = account.linked === true;
+			const running = account.running === true;
+			const connected = account.connected === true;
+			const reconnectAttempts = typeof account.reconnectAttempts === "number" ? account.reconnectAttempts : null;
+			const lastError = asString(account.lastError);
+			if (!linked) {
+				issues.push({
+					channel: "whatsapp",
+					accountId,
+					kind: "auth",
+					message: "Not linked (no WhatsApp Web session).",
+					fix: `Run: ${formatCliCommand("moldclaw channels login")} (scan QR on the gateway host).`
+				});
+				return;
+			}
+			if (running && !connected) issues.push({
+				channel: "whatsapp",
+				accountId,
+				kind: "runtime",
+				message: `Linked but disconnected${reconnectAttempts != null ? ` (reconnectAttempts=${reconnectAttempts})` : ""}${lastError ? `: ${lastError}` : "."}`,
+				fix: `Run: ${formatCliCommand("moldclaw doctor")} (or restart the gateway). If it persists, relink via channels login and check logs.`
+			});
+		}
+	});
+}
+//#endregion
+//#region extensions/whatsapp/src/channel.ts
+function normalizeWhatsAppPayloadText(text) {
+	return (text ?? "").replace(/^(?:[ \t]*\r?\n)+/, "");
+}
+function parseWhatsAppExplicitTarget(raw) {
+	const normalized = normalizeWhatsAppTarget(raw);
+	if (!normalized) return null;
+	return {
+		to: normalized,
+		chatType: isWhatsAppGroupJid(normalized) ? "group" : "direct"
+	};
+}
+const whatsappPlugin = {
+	...createWhatsAppPluginBase({
+		setupWizard: whatsappSetupWizardProxy,
+		setup: whatsappSetupAdapter,
+		isConfigured: async (account) => await getWhatsAppRuntime().channel.whatsapp.webAuthExists(account.authDir)
+	}),
+	agentTools: () => [getWhatsAppRuntime().channel.whatsapp.createLoginTool()],
+	pairing: { idLabel: "whatsappSenderId" },
+	allowlist: {
+		supportsScope: ({ scope }) => scope === "dm" || scope === "group" || scope === "all",
+		readConfig: ({ cfg, accountId }) => {
+			const account = resolveWhatsAppAccount({
+				cfg,
+				accountId
+			});
+			return {
+				dmAllowFrom: (account.allowFrom ?? []).map(String),
+				groupAllowFrom: (account.groupAllowFrom ?? []).map(String),
+				dmPolicy: account.dmPolicy,
+				groupPolicy: account.groupPolicy
+			};
+		},
+		applyConfigEdit: buildAccountScopedAllowlistConfigEditor({
+			channelId: "whatsapp",
+			normalize: ({ values }) => formatWhatsAppConfigAllowFromEntries(values),
+			resolvePaths: (scope) => ({
+				readPaths: [[scope === "dm" ? "allowFrom" : "groupAllowFrom"]],
+				writePath: [scope === "dm" ? "allowFrom" : "groupAllowFrom"]
+			})
+		})
+	},
+	mentions: { stripRegexes: ({ ctx }) => resolveWhatsAppMentionStripRegexes(ctx) },
+	commands: {
+		enforceOwnerForCommands: true,
+		skipWhenConfigEmpty: true
+	},
+	messaging: {
+		normalizeTarget: normalizeWhatsAppMessagingTarget,
+		parseExplicitTarget: ({ raw }) => parseWhatsAppExplicitTarget(raw),
+		inferTargetChatType: ({ to }) => parseWhatsAppExplicitTarget(to)?.chatType,
+		targetResolver: {
+			looksLikeId: looksLikeWhatsAppTargetId,
+			hint: "<E.164|group JID>"
+		}
+	},
+	directory: {
+		self: async ({ cfg, accountId }) => {
+			const account = resolveWhatsAppAccount({
+				cfg,
+				accountId
+			});
+			const { e164, jid } = (await loadWhatsAppChannelRuntime()).readWebSelfId(account.authDir);
+			const id = e164 ?? jid;
+			if (!id) return null;
+			return {
+				kind: "user",
+				id,
+				name: account.name,
+				raw: {
+					e164,
+					jid
+				}
+			};
+		},
+		listPeers: async (params) => listWhatsAppDirectoryPeersFromConfig(params),
+		listGroups: async (params) => listWhatsAppDirectoryGroupsFromConfig(params)
+	},
+	actions: {
+		listActions: ({ cfg }) => {
+			if (!cfg.channels?.whatsapp) return [];
+			const gate = createActionGate(cfg.channels.whatsapp.actions);
+			const actions = /* @__PURE__ */ new Set();
+			if (gate("reactions")) actions.add("react");
+			if (gate("polls")) actions.add("poll");
+			return Array.from(actions);
+		},
+		supportsAction: ({ action }) => action === "react",
+		handleAction: async ({ action, params, cfg, accountId }) => {
+			if (action !== "react") throw new Error(`Action ${action} is not supported for provider ${WHATSAPP_CHANNEL}.`);
+			const messageId = readStringParam(params, "messageId", { required: true });
+			const emoji = readStringParam(params, "emoji", { allowEmpty: true });
+			const remove = typeof params.remove === "boolean" ? params.remove : void 0;
+			return await getWhatsAppRuntime().channel.whatsapp.handleWhatsAppAction({
+				action: "react",
+				chatJid: readStringParam(params, "chatJid") ?? readStringParam(params, "to", { required: true }),
+				messageId,
+				emoji,
+				remove,
+				participant: readStringParam(params, "participant"),
+				accountId: accountId ?? void 0,
+				fromMe: typeof params.fromMe === "boolean" ? params.fromMe : void 0
+			}, cfg);
+		}
+	},
+	outbound: {
+		...createWhatsAppOutboundBase({
+			chunker: (text, limit) => getWhatsAppRuntime().channel.text.chunkText(text, limit),
+			sendMessageWhatsApp: async (...args) => await getWhatsAppRuntime().channel.whatsapp.sendMessageWhatsApp(...args),
+			sendPollWhatsApp: async (...args) => await getWhatsAppRuntime().channel.whatsapp.sendPollWhatsApp(...args),
+			shouldLogVerbose: () => getWhatsAppRuntime().logging.shouldLogVerbose(),
+			resolveTarget: ({ to, allowFrom, mode }) => resolveWhatsAppOutboundTarget({
+				to,
+				allowFrom,
+				mode
+			})
+		}),
+		normalizePayload: ({ payload }) => ({
+			...payload,
+			text: normalizeWhatsAppPayloadText(payload.text)
+		})
+	},
+	auth: { login: async ({ cfg, accountId, runtime, verbose }) => {
+		const resolvedAccountId = accountId?.trim() || whatsappPlugin.config.defaultAccountId?.(cfg) || "default";
+		await (await loadWhatsAppChannelRuntime()).loginWeb(Boolean(verbose), void 0, runtime, resolvedAccountId);
+	} },
+	heartbeat: {
+		checkReady: async ({ cfg, accountId, deps }) => {
+			if (cfg.web?.enabled === false) return {
+				ok: false,
+				reason: "whatsapp-disabled"
+			};
+			const account = resolveWhatsAppAccount({
+				cfg,
+				accountId
+			});
+			if (!await (deps?.webAuthExists ?? (await loadWhatsAppChannelRuntime()).webAuthExists)(account.authDir)) return {
+				ok: false,
+				reason: "whatsapp-not-linked"
+			};
+			if (!(deps?.hasActiveWebListener ? deps.hasActiveWebListener() : Boolean((await loadWhatsAppChannelRuntime()).getActiveWebListener()))) return {
+				ok: false,
+				reason: "whatsapp-not-running"
+			};
+			return {
+				ok: true,
+				reason: "ok"
+			};
+		},
+		resolveRecipients: ({ cfg, opts }) => resolveWhatsAppHeartbeatRecipients(cfg, opts)
+	},
+	status: {
+		defaultRuntime: {
+			accountId: DEFAULT_ACCOUNT_ID,
+			running: false,
+			connected: false,
+			reconnectAttempts: 0,
+			lastConnectedAt: null,
+			lastDisconnect: null,
+			lastMessageAt: null,
+			lastEventAt: null,
+			lastError: null
+		},
+		collectStatusIssues: collectWhatsAppStatusIssues,
+		buildChannelSummary: async ({ account, snapshot }) => {
+			const authDir = account.authDir;
+			const linked = typeof snapshot.linked === "boolean" ? snapshot.linked : authDir ? await (await loadWhatsAppChannelRuntime()).webAuthExists(authDir) : false;
+			return {
+				configured: linked,
+				linked,
+				authAgeMs: linked && authDir ? (await loadWhatsAppChannelRuntime()).getWebAuthAgeMs(authDir) : null,
+				self: linked && authDir ? (await loadWhatsAppChannelRuntime()).readWebSelfId(authDir) : {
+					e164: null,
+					jid: null
+				},
+				running: snapshot.running ?? false,
+				connected: snapshot.connected ?? false,
+				lastConnectedAt: snapshot.lastConnectedAt ?? null,
+				lastDisconnect: snapshot.lastDisconnect ?? null,
+				reconnectAttempts: snapshot.reconnectAttempts,
+				lastMessageAt: snapshot.lastMessageAt ?? null,
+				lastEventAt: snapshot.lastEventAt ?? null,
+				lastError: snapshot.lastError ?? null
+			};
+		},
+		buildAccountSnapshot: async ({ account, runtime }) => {
+			const linked = await (await loadWhatsAppChannelRuntime()).webAuthExists(account.authDir);
+			return {
+				accountId: account.accountId,
+				name: account.name,
+				enabled: account.enabled,
+				configured: true,
+				linked,
+				running: runtime?.running ?? false,
+				connected: runtime?.connected ?? false,
+				reconnectAttempts: runtime?.reconnectAttempts,
+				lastConnectedAt: runtime?.lastConnectedAt ?? null,
+				lastDisconnect: runtime?.lastDisconnect ?? null,
+				lastMessageAt: runtime?.lastMessageAt ?? null,
+				lastEventAt: runtime?.lastEventAt ?? null,
+				lastError: runtime?.lastError ?? null,
+				dmPolicy: account.dmPolicy,
+				allowFrom: account.allowFrom
+			};
+		},
+		resolveAccountState: ({ configured }) => configured ? "linked" : "not linked",
+		logSelfId: ({ account, runtime, includeChannelPrefix }) => {
+			loadWhatsAppChannelRuntime().then((runtimeExports) => runtimeExports.logWebSelfId(account.authDir, runtime, includeChannelPrefix));
+		}
+	},
+	gateway: {
+		startAccount: async (ctx) => {
+			const account = ctx.account;
+			const { e164, jid } = (await loadWhatsAppChannelRuntime()).readWebSelfId(account.authDir);
+			const identity = e164 ? e164 : jid ? `jid ${jid}` : "unknown";
+			ctx.log?.info(`[${account.accountId}] starting provider (${identity})`);
+			return (await loadWhatsAppChannelRuntime()).monitorWebChannel(getWhatsAppRuntime().logging.shouldLogVerbose(), void 0, true, void 0, ctx.runtime, ctx.abortSignal, {
+				statusSink: (next) => ctx.setStatus({
+					accountId: ctx.accountId,
+					...next
+				}),
+				accountId: account.accountId
+			});
+		},
+		loginWithQrStart: async ({ accountId, force, timeoutMs, verbose }) => await (await loadWhatsAppChannelRuntime()).startWebLoginWithQr({
+			accountId,
+			force,
+			timeoutMs,
+			verbose
+		}),
+		loginWithQrWait: async ({ accountId, timeoutMs }) => await (await loadWhatsAppChannelRuntime()).waitForWebLogin({
+			accountId,
+			timeoutMs
+		}),
+		logoutAccount: async ({ account, runtime }) => {
+			const cleared = await (await loadWhatsAppChannelRuntime()).logoutWeb({
+				authDir: account.authDir,
+				isLegacyAuthDir: account.isLegacyAuthDir,
+				runtime
+			});
+			return {
+				cleared,
+				loggedOut: cleared
+			};
+		}
+	}
+};
+//#endregion
+export { setWhatsAppRuntime as n, whatsappPlugin as t };

package/dist/channel-NY7aU2Gj.js

@@ -0,0 +1,397 @@
+import { JC as buildRuntimeAccountStatusSnapshot, LT as collectAllowlistProviderRestrictSendersWarnings, ZC as createDefaultChannelRuntimeState, qC as buildProbeChannelStatusSummary, ww as PAIRING_APPROVED_MESSAGE } from "./auth-profiles-9zZdaXJK.js";
+import { t as DEFAULT_ACCOUNT_ID } from "./account-id-O4Og6DrK.js";
+import { A as MSTeamsConfigSchema } from "./io-C6XifaT4.js";
+import { n as createLazyRuntimeSurface } from "./lazy-runtime-DdzFA4b9.js";
+import { r as buildChannelConfigSchema } from "./config-schema-pPBCF4hz.js";
+import { t as formatAllowFromLowercase } from "./allow-from-CRBQe4aU.js";
+import { a as parseMSTeamsConversationId, c as resolveMSTeamsUserAllowlist, i as normalizeMSTeamsUserInput, m as resolveMSTeamsCredentials, n as msteamsSetupAdapter, o as parseMSTeamsTeamChannelInput, r as normalizeMSTeamsMessagingTarget, s as resolveMSTeamsChannelAllowlist, t as msteamsSetupWizard } from "./msteams-A6H_wv5F.js";
+import { r as resolveMSTeamsGroupToolPolicy } from "./policy-CcSolumc.js";
+import { t as getMSTeamsRuntime } from "./runtime-py8d-uva.js";
+//#region extensions/msteams/src/channel.ts
+const meta = {
+	id: "msteams",
+	label: "Microsoft Teams",
+	selectionLabel: "Microsoft Teams (Bot Framework)",
+	docsPath: "/channels/msteams",
+	docsLabel: "msteams",
+	blurb: "Bot Framework; enterprise support.",
+	aliases: ["teams"],
+	order: 60
+};
+const TEAMS_GRAPH_PERMISSION_HINTS = {
+	"ChannelMessage.Read.All": "channel history",
+	"Chat.Read.All": "chat history",
+	"Channel.ReadBasic.All": "channel list",
+	"Team.ReadBasic.All": "team list",
+	"TeamsActivity.Read.All": "teams activity",
+	"Sites.Read.All": "files (SharePoint)",
+	"Files.Read.All": "files (OneDrive)"
+};
+const loadMSTeamsChannelRuntime = createLazyRuntimeSurface(() => import("./channel.runtime-DdQ2mOVh.js"), ({ msTeamsChannelRuntime }) => msTeamsChannelRuntime);
+const msteamsPlugin = {
+	id: "msteams",
+	meta: {
+		...meta,
+		aliases: [...meta.aliases]
+	},
+	setupWizard: msteamsSetupWizard,
+	pairing: {
+		idLabel: "msteamsUserId",
+		normalizeAllowEntry: (entry) => entry.replace(/^(msteams|user):/i, ""),
+		notifyApproval: async ({ cfg, id }) => {
+			const { sendMessageMSTeams } = await loadMSTeamsChannelRuntime();
+			await sendMessageMSTeams({
+				cfg,
+				to: id,
+				text: PAIRING_APPROVED_MESSAGE
+			});
+		}
+	},
+	capabilities: {
+		chatTypes: [
+			"direct",
+			"channel",
+			"thread"
+		],
+		polls: true,
+		threads: true,
+		media: true
+	},
+	agentPrompt: { messageToolHints: () => ["- Adaptive Cards supported. Use `action=send` with `card={type,version,body}` to send rich cards.", "- MSTeams targeting: omit `target` to reply to the current conversation (auto-inferred). Explicit targets: `user:ID` or `user:Display Name` (requires Graph API) for DMs, `conversation:19:...@thread.tacv2` for groups/channels. Prefer IDs over display names for speed."] },
+	threading: { buildToolContext: ({ context, hasRepliedRef }) => ({
+		currentChannelId: context.To?.trim() || void 0,
+		currentThreadTs: context.ReplyToId,
+		hasRepliedRef
+	}) },
+	groups: { resolveToolPolicy: resolveMSTeamsGroupToolPolicy },
+	reload: { configPrefixes: ["channels.msteams"] },
+	configSchema: buildChannelConfigSchema(MSTeamsConfigSchema),
+	config: {
+		listAccountIds: () => [DEFAULT_ACCOUNT_ID],
+		resolveAccount: (cfg) => ({
+			accountId: DEFAULT_ACCOUNT_ID,
+			enabled: cfg.channels?.msteams?.enabled !== false,
+			configured: Boolean(resolveMSTeamsCredentials(cfg.channels?.msteams))
+		}),
+		defaultAccountId: () => DEFAULT_ACCOUNT_ID,
+		setAccountEnabled: ({ cfg, enabled }) => ({
+			...cfg,
+			channels: {
+				...cfg.channels,
+				msteams: {
+					...cfg.channels?.msteams,
+					enabled
+				}
+			}
+		}),
+		deleteAccount: ({ cfg }) => {
+			const next = { ...cfg };
+			const nextChannels = { ...cfg.channels };
+			delete nextChannels.msteams;
+			if (Object.keys(nextChannels).length > 0) next.channels = nextChannels;
+			else delete next.channels;
+			return next;
+		},
+		isConfigured: (_account, cfg) => Boolean(resolveMSTeamsCredentials(cfg.channels?.msteams)),
+		describeAccount: (account) => ({
+			accountId: account.accountId,
+			enabled: account.enabled,
+			configured: account.configured
+		}),
+		resolveAllowFrom: ({ cfg }) => cfg.channels?.msteams?.allowFrom ?? [],
+		formatAllowFrom: ({ allowFrom }) => formatAllowFromLowercase({ allowFrom }),
+		resolveDefaultTo: ({ cfg }) => cfg.channels?.msteams?.defaultTo?.trim() || void 0
+	},
+	security: { collectWarnings: ({ cfg }) => {
+		return collectAllowlistProviderRestrictSendersWarnings({
+			cfg,
+			providerConfigPresent: cfg.channels?.msteams !== void 0,
+			configuredGroupPolicy: cfg.channels?.msteams?.groupPolicy,
+			surface: "MS Teams groups",
+			openScope: "any member",
+			groupPolicyPath: "channels.msteams.groupPolicy",
+			groupAllowFromPath: "channels.msteams.groupAllowFrom"
+		});
+	} },
+	setup: msteamsSetupAdapter,
+	messaging: {
+		normalizeTarget: normalizeMSTeamsMessagingTarget,
+		targetResolver: {
+			looksLikeId: (raw) => {
+				const trimmed = raw.trim();
+				if (!trimmed) return false;
+				if (/^conversation:/i.test(trimmed)) return true;
+				if (/^user:/i.test(trimmed)) {
+					const id = trimmed.slice(5).trim();
+					return /^[0-9a-fA-F-]{16,}$/.test(id);
+				}
+				return trimmed.includes("@thread");
+			},
+			hint: "<conversationId|user:ID|conversation:ID>"
+		}
+	},
+	directory: {
+		self: async () => null,
+		listPeers: async ({ cfg, query, limit }) => {
+			const q = query?.trim().toLowerCase() || "";
+			const ids = /* @__PURE__ */ new Set();
+			for (const entry of cfg.channels?.msteams?.allowFrom ?? []) {
+				const trimmed = String(entry).trim();
+				if (trimmed && trimmed !== "*") ids.add(trimmed);
+			}
+			for (const userId of Object.keys(cfg.channels?.msteams?.dms ?? {})) {
+				const trimmed = userId.trim();
+				if (trimmed) ids.add(trimmed);
+			}
+			return Array.from(ids).map((raw) => raw.trim()).filter(Boolean).map((raw) => normalizeMSTeamsMessagingTarget(raw) ?? raw).map((raw) => {
+				const lowered = raw.toLowerCase();
+				if (lowered.startsWith("user:")) return raw;
+				if (lowered.startsWith("conversation:")) return raw;
+				return `user:${raw}`;
+			}).filter((id) => q ? id.toLowerCase().includes(q) : true).slice(0, limit && limit > 0 ? limit : void 0).map((id) => ({
+				kind: "user",
+				id
+			}));
+		},
+		listGroups: async ({ cfg, query, limit }) => {
+			const q = query?.trim().toLowerCase() || "";
+			const ids = /* @__PURE__ */ new Set();
+			for (const team of Object.values(cfg.channels?.msteams?.teams ?? {})) for (const channelId of Object.keys(team.channels ?? {})) {
+				const trimmed = channelId.trim();
+				if (trimmed && trimmed !== "*") ids.add(trimmed);
+			}
+			return Array.from(ids).map((raw) => raw.trim()).filter(Boolean).map((raw) => raw.replace(/^conversation:/i, "").trim()).map((id) => `conversation:${id}`).filter((id) => q ? id.toLowerCase().includes(q) : true).slice(0, limit && limit > 0 ? limit : void 0).map((id) => ({
+				kind: "group",
+				id
+			}));
+		},
+		listPeersLive: async ({ cfg, query, limit }) => (await loadMSTeamsChannelRuntime()).listMSTeamsDirectoryPeersLive({
+			cfg,
+			query,
+			limit
+		}),
+		listGroupsLive: async ({ cfg, query, limit }) => (await loadMSTeamsChannelRuntime()).listMSTeamsDirectoryGroupsLive({
+			cfg,
+			query,
+			limit
+		})
+	},
+	resolver: { resolveTargets: async ({ cfg, inputs, kind, runtime }) => {
+		const results = inputs.map((input) => ({
+			input,
+			resolved: false,
+			id: void 0,
+			name: void 0,
+			note: void 0
+		}));
+		const stripPrefix = (value) => normalizeMSTeamsUserInput(value);
+		const markPendingLookupFailed = (pending) => {
+			pending.forEach(({ index }) => {
+				const entry = results[index];
+				if (entry) entry.note = "lookup failed";
+			});
+		};
+		const resolvePending = async (pending, resolveEntries, applyResolvedEntry) => {
+			if (pending.length === 0) return;
+			try {
+				(await resolveEntries(pending.map((entry) => entry.query))).forEach((entry, idx) => {
+					const target = results[pending[idx]?.index ?? -1];
+					if (!target) return;
+					applyResolvedEntry(target, entry);
+				});
+			} catch (err) {
+				runtime.error?.(`msteams resolve failed: ${String(err)}`);
+				markPendingLookupFailed(pending);
+			}
+		};
+		if (kind === "user") {
+			const pending = [];
+			results.forEach((entry, index) => {
+				const trimmed = entry.input.trim();
+				if (!trimmed) {
+					entry.note = "empty input";
+					return;
+				}
+				const cleaned = stripPrefix(trimmed);
+				if (/^[0-9a-fA-F-]{16,}$/.test(cleaned) || cleaned.includes("@")) {
+					entry.resolved = true;
+					entry.id = cleaned;
+					return;
+				}
+				pending.push({
+					input: entry.input,
+					query: cleaned,
+					index
+				});
+			});
+			await resolvePending(pending, (entries) => resolveMSTeamsUserAllowlist({
+				cfg,
+				entries
+			}), (target, entry) => {
+				target.resolved = entry.resolved;
+				target.id = entry.id;
+				target.name = entry.name;
+				target.note = entry.note;
+			});
+			return results;
+		}
+		const pending = [];
+		results.forEach((entry, index) => {
+			const trimmed = entry.input.trim();
+			if (!trimmed) {
+				entry.note = "empty input";
+				return;
+			}
+			const conversationId = parseMSTeamsConversationId(trimmed);
+			if (conversationId !== null) {
+				entry.resolved = Boolean(conversationId);
+				entry.id = conversationId || void 0;
+				entry.note = conversationId ? "conversation id" : "empty conversation id";
+				return;
+			}
+			const parsed = parseMSTeamsTeamChannelInput(trimmed);
+			if (!parsed.team) {
+				entry.note = "missing team";
+				return;
+			}
+			const query = parsed.channel ? `${parsed.team}/${parsed.channel}` : parsed.team;
+			pending.push({
+				input: entry.input,
+				query,
+				index
+			});
+		});
+		await resolvePending(pending, (entries) => resolveMSTeamsChannelAllowlist({
+			cfg,
+			entries
+		}), (target, entry) => {
+			if (!entry.resolved || !entry.teamId) {
+				target.resolved = false;
+				target.note = entry.note;
+				return;
+			}
+			target.resolved = true;
+			if (entry.channelId) {
+				target.id = `${entry.teamId}/${entry.channelId}`;
+				target.name = entry.channelName && entry.teamName ? `${entry.teamName}/${entry.channelName}` : entry.channelName ?? entry.teamName;
+			} else {
+				target.id = entry.teamId;
+				target.name = entry.teamName;
+				target.note = "team id";
+			}
+			if (entry.note) target.note = entry.note;
+		});
+		return results;
+	} },
+	actions: {
+		listActions: ({ cfg }) => {
+			if (!(cfg.channels?.msteams?.enabled !== false && Boolean(resolveMSTeamsCredentials(cfg.channels?.msteams)))) return [];
+			return ["poll"];
+		},
+		getCapabilities: ({ cfg }) => {
+			return cfg.channels?.msteams?.enabled !== false && Boolean(resolveMSTeamsCredentials(cfg.channels?.msteams)) ? ["cards"] : [];
+		},
+		handleAction: async (ctx) => {
+			if (ctx.action === "send" && ctx.params.card) {
+				const card = ctx.params.card;
+				const to = typeof ctx.params.to === "string" ? ctx.params.to.trim() : typeof ctx.params.target === "string" ? ctx.params.target.trim() : "";
+				if (!to) return {
+					isError: true,
+					content: [{
+						type: "text",
+						text: "Card send requires a target (to)."
+					}],
+					details: { error: "Card send requires a target (to)." }
+				};
+				const { sendAdaptiveCardMSTeams } = await loadMSTeamsChannelRuntime();
+				const result = await sendAdaptiveCardMSTeams({
+					cfg: ctx.cfg,
+					to,
+					card
+				});
+				return {
+					content: [{
+						type: "text",
+						text: JSON.stringify({
+							ok: true,
+							channel: "msteams",
+							messageId: result.messageId,
+							conversationId: result.conversationId
+						})
+					}],
+					details: {
+						ok: true,
+						channel: "msteams",
+						messageId: result.messageId
+					}
+				};
+			}
+			return null;
+		}
+	},
+	outbound: {
+		deliveryMode: "direct",
+		chunker: (text, limit) => getMSTeamsRuntime().channel.text.chunkMarkdownText(text, limit),
+		chunkerMode: "markdown",
+		textChunkLimit: 4e3,
+		pollMaxOptions: 12,
+		sendText: async (params) => (await loadMSTeamsChannelRuntime()).msteamsOutbound.sendText(params),
+		sendMedia: async (params) => (await loadMSTeamsChannelRuntime()).msteamsOutbound.sendMedia(params),
+		sendPoll: async (params) => (await loadMSTeamsChannelRuntime()).msteamsOutbound.sendPoll(params)
+	},
+	status: {
+		defaultRuntime: createDefaultChannelRuntimeState(DEFAULT_ACCOUNT_ID, { port: null }),
+		buildChannelSummary: ({ snapshot }) => buildProbeChannelStatusSummary(snapshot, { port: snapshot.port ?? null }),
+		probeAccount: async ({ cfg }) => await (await loadMSTeamsChannelRuntime()).probeMSTeams(cfg.channels?.msteams),
+		formatCapabilitiesProbe: ({ probe }) => {
+			const teamsProbe = probe;
+			const lines = [];
+			const appId = typeof teamsProbe?.appId === "string" ? teamsProbe.appId.trim() : "";
+			if (appId) lines.push({ text: `App: ${appId}` });
+			const graph = teamsProbe?.graph;
+			if (graph) {
+				const roles = Array.isArray(graph.roles) ? graph.roles.map((role) => String(role).trim()).filter(Boolean) : [];
+				const scopes = Array.isArray(graph.scopes) ? graph.scopes.map((scope) => String(scope).trim()).filter(Boolean) : [];
+				const formatPermission = (permission) => {
+					const hint = TEAMS_GRAPH_PERMISSION_HINTS[permission];
+					return hint ? `${permission} (${hint})` : permission;
+				};
+				if (graph.ok === false) lines.push({
+					text: `Graph: ${graph.error ?? "failed"}`,
+					tone: "error"
+				});
+				else if (roles.length > 0 || scopes.length > 0) {
+					if (roles.length > 0) lines.push({ text: `Graph roles: ${roles.map(formatPermission).join(", ")}` });
+					if (scopes.length > 0) lines.push({ text: `Graph scopes: ${scopes.map(formatPermission).join(", ")}` });
+				} else if (graph.ok === true) lines.push({ text: "Graph: ok" });
+			}
+			return lines;
+		},
+		buildAccountSnapshot: ({ account, runtime, probe }) => ({
+			accountId: account.accountId,
+			enabled: account.enabled,
+			configured: account.configured,
+			...buildRuntimeAccountStatusSnapshot({
+				runtime,
+				probe
+			}),
+			port: runtime?.port ?? null
+		})
+	},
+	gateway: { startAccount: async (ctx) => {
+		const { monitorMSTeamsProvider } = await import("./src-0wtt7seR.js");
+		const port = ctx.cfg.channels?.msteams?.webhook?.port ?? 3978;
+		ctx.setStatus({
+			accountId: ctx.accountId,
+			port
+		});
+		ctx.log?.info(`starting provider (port ${port})`);
+		return monitorMSTeamsProvider({
+			cfg: ctx.cfg,
+			runtime: ctx.runtime,
+			abortSignal: ctx.abortSignal
+		});
+	} }
+};
+//#endregion
+export { msteamsPlugin as t };