@openclaw/msteams 2026.8.1-beta.2 → 2026.8.1

package/dist/{adapter.runtime-DEYjslFX.cjs → adapter.runtime-8g-MOPfb.cjs}

@@ -1,16 +1,17 @@
 const require_rolldown_runtime = require("./rolldown-runtime-D6vf50IK.cjs");
 let openclaw_plugin_sdk_ssrf_runtime = require("openclaw/plugin-sdk/ssrf-runtime");
-let openclaw_plugin_sdk_error_runtime = require("openclaw/plugin-sdk/error-runtime");
 let node_crypto = require("node:crypto");
 let node_fs_promises = require("node:fs/promises");
 node_fs_promises = require_rolldown_runtime.__toESM(node_fs_promises, 1);
 let node_path = require("node:path");
 node_path = require_rolldown_runtime.__toESM(node_path, 1);
+let openclaw_plugin_sdk_error_runtime = require("openclaw/plugin-sdk/error-runtime");
 let node_timers_promises = require("node:timers/promises");
 let node_url = require("node:url");
 let node_events = require("node:events");
 let node_http = require("node:http");
 //#region extensions/msteams/src/qa/bot-framework-server.ts
+const AMBIGUOUS_GATEWAY_TIMEOUT_MARKER = "QA-MSTEAMS-AMBIGUOUS-504";
 async function readJson(request) {
 	const chunks = [];
 	for await (const chunk of request) chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
@@ -53,7 +54,8 @@ async function startMSTeamsQaBotFrameworkServer(options) {
 				conversationId: route.conversationId,
 				...route.threadId ? { threadId: route.threadId } : {}
 			});
-			sendJson(response, 200, { id: activityId });
+			const acceptedButTimedOut = typeof activity.text === "string" && activity.text.includes(AMBIGUOUS_GATEWAY_TIMEOUT_MARKER);
+			sendJson(response, acceptedButTimedOut ? 504 : 200, acceptedButTimedOut ? { error: "gateway timeout after acceptance" } : { id: activityId });
 		})().catch((error) => {
 			sendJson(response, 500, { error: (0, openclaw_plugin_sdk_error_runtime.coerceErrorMessage)(error) });
 		});

package/dist/api.cjs

@@ -1,8 +1,8 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_channel = require("./channel-DfCbi0d_.cjs");
-const require_setup_surface = require("./setup-surface-DAhGL2h8.cjs");
-exports.createMSTeamsSetupWizardBase = require_setup_surface.createMSTeamsSetupWizardBase;
+const require_channel = require("./channel-ChmCvkuA.cjs");
+const require_channel_setup = require("./channel.setup-CKb8aKCV.cjs");
+exports.createMSTeamsSetupWizardBase = require_channel_setup.createMSTeamsSetupWizardBase;
 exports.msteamsPlugin = require_channel.msteamsPlugin;
-exports.msteamsSetupAdapter = require_setup_surface.msteamsSetupAdapter;
-exports.msteamsSetupWizard = require_setup_surface.msteamsSetupWizard;
-exports.openDelegatedOAuthUrl = require_setup_surface.openDelegatedOAuthUrl;
+exports.msteamsSetupAdapter = require_channel_setup.msteamsSetupAdapter;
+exports.msteamsSetupWizard = require_channel_setup.msteamsSetupWizard;
+exports.openDelegatedOAuthUrl = require_channel_setup.openDelegatedOAuthUrl;

package/dist/approval-card-B6ZIMO83.cjs

@@ -0,0 +1,303 @@
+const require_rolldown_runtime = require("./rolldown-runtime-D6vf50IK.cjs");
+let openclaw_plugin_sdk_string_coerce_runtime = require("openclaw/plugin-sdk/string-coerce-runtime");
+let node_crypto = require("node:crypto");
+node_crypto = require_rolldown_runtime.__toESM(node_crypto, 1);
+let openclaw_plugin_sdk_collection_runtime = require("openclaw/plugin-sdk/collection-runtime");
+//#region extensions/msteams/src/approval-card-actions.ts
+const approvalCardBindings = /* @__PURE__ */ new Map();
+const approvalCardResolvingTokens = /* @__PURE__ */ new Set();
+const MSTEAMS_APPROVAL_CARD_BINDING_MAX_ENTRIES = 1024;
+function createMSTeamsApprovalToken() {
+	return node_crypto.default.randomBytes(18).toString("base64url");
+}
+function readMSTeamsApprovalActionToken(value) {
+	if (!(0, openclaw_plugin_sdk_string_coerce_runtime.isRecord)(value)) return null;
+	const action = (0, openclaw_plugin_sdk_string_coerce_runtime.isRecord)(value.action) ? value.action : void 0;
+	const submitted = action && (0, openclaw_plugin_sdk_string_coerce_runtime.normalizeOptionalLowercaseString)(action.type) === "action.submit" && (0, openclaw_plugin_sdk_string_coerce_runtime.isRecord)(action.data) ? action.data : value;
+	if (submitted.openclawAction !== "approval") return null;
+	return (0, openclaw_plugin_sdk_string_coerce_runtime.normalizeOptionalString)(submitted.token) ?? null;
+}
+function registerMSTeamsApprovalCardBinding(binding) {
+	if (binding.expiresAtMs <= Date.now()) return false;
+	approvalCardBindings.delete(binding.token);
+	approvalCardBindings.set(binding.token, binding);
+	(0, openclaw_plugin_sdk_collection_runtime.pruneMapToMaxSize)(approvalCardBindings, MSTEAMS_APPROVAL_CARD_BINDING_MAX_ENTRIES);
+	return true;
+}
+function getMSTeamsApprovalCardBinding(token) {
+	const binding = approvalCardBindings.get(token);
+	if (!binding) return null;
+	if (binding.expiresAtMs <= Date.now()) {
+		approvalCardBindings.delete(token);
+		approvalCardResolvingTokens.delete(token);
+		return null;
+	}
+	return binding;
+}
+function claimMSTeamsApprovalCardBinding(token) {
+	const binding = getMSTeamsApprovalCardBinding(token);
+	if (!binding) return { kind: "missing" };
+	if (approvalCardResolvingTokens.has(token)) return { kind: "in-flight" };
+	approvalCardResolvingTokens.add(token);
+	return {
+		kind: "claimed",
+		binding
+	};
+}
+function completeMSTeamsApprovalCardBinding(token) {
+	approvalCardResolvingTokens.delete(token);
+	approvalCardBindings.delete(token);
+}
+function releaseMSTeamsApprovalCardBinding(token) {
+	approvalCardResolvingTokens.delete(token);
+}
+function unregisterMSTeamsApprovalCardBindings(tokens) {
+	for (const token of tokens) completeMSTeamsApprovalCardBinding(token);
+}
+//#endregion
+//#region extensions/msteams/src/approval-card.ts
+function buildCardHeading(title, subtitle) {
+	return [{
+		type: "TextBlock",
+		text: title,
+		weight: "Bolder",
+		size: "Medium",
+		wrap: true
+	}, {
+		type: "TextBlock",
+		text: subtitle,
+		isSubtle: true,
+		wrap: true
+	}];
+}
+function buildApprovalSubject(view) {
+	if (view.approvalKind === "exec") return [
+		{
+			type: "TextBlock",
+			text: "Command",
+			weight: "Bolder",
+			wrap: true
+		},
+		{
+			type: "TextBlock",
+			text: view.commandText,
+			fontType: "Monospace",
+			wrap: true
+		},
+		...view.commandPreview && view.commandPreview !== view.commandText ? [{
+			type: "TextBlock",
+			text: "Preview",
+			weight: "Bolder",
+			wrap: true
+		}, {
+			type: "TextBlock",
+			text: view.commandPreview,
+			fontType: "Monospace",
+			wrap: true
+		}] : []
+	];
+	return [
+		{
+			type: "TextBlock",
+			text: "Request",
+			weight: "Bolder",
+			wrap: true
+		},
+		{
+			type: "TextBlock",
+			text: view.title,
+			weight: "Bolder",
+			wrap: true
+		},
+		...view.description ? [{
+			type: "TextBlock",
+			text: view.description,
+			wrap: true
+		}] : []
+	];
+}
+function buildApprovalMetadata(approvalId, metadata) {
+	return {
+		type: "FactSet",
+		facts: [{
+			title: "Approval ID:",
+			value: approvalId
+		}].concat(metadata.map(({ label, value }) => ({
+			title: `${label}:`,
+			value
+		})))
+	};
+}
+function buildAdaptiveCard(body, actions) {
+	return {
+		type: "AdaptiveCard",
+		version: "1.5",
+		body,
+		...actions?.length ? { actions } : {}
+	};
+}
+function formatApprovalDecision(decision) {
+	return decision === "allow-once" ? "Allowed once" : decision === "allow-always" ? "Allowed always" : "Denied";
+}
+function buildMSTeamsPendingApprovalCard(params) {
+	const { view, nowMs } = params;
+	const kindLabel = view.approvalKind === "plugin" ? "Plugin" : "Exec";
+	const actionTokens = [];
+	const actions = view.actions.map(({ decision, label }) => {
+		const token = createMSTeamsApprovalToken();
+		actionTokens.push({
+			token,
+			decision
+		});
+		return {
+			type: "Action.Submit",
+			title: label,
+			data: {
+				openclawAction: "approval",
+				token
+			}
+		};
+	});
+	const remainingSeconds = Math.max(0, Math.ceil((view.expiresAtMs - nowMs) / 1e3));
+	const body = [
+		...buildCardHeading(`${kindLabel} Approval Required`, `Expires in ${remainingSeconds}s`),
+		...buildApprovalSubject(view),
+		buildApprovalMetadata(view.approvalId, view.metadata)
+	];
+	return {
+		approvalId: view.approvalId,
+		approvalKind: view.approvalKind,
+		expiresAtMs: view.expiresAtMs,
+		card: buildAdaptiveCard(body, actions),
+		actionTokens,
+		allowedDecisions: view.actions.map(({ decision }) => decision)
+	};
+}
+function buildMSTeamsResolvedApprovalCard(view) {
+	const kindLabel = view.approvalKind === "plugin" ? "Plugin" : "Exec";
+	const resolvedBy = (0, openclaw_plugin_sdk_string_coerce_runtime.normalizeOptionalString)(view.resolvedBy);
+	return buildAdaptiveCard([
+		...buildCardHeading(`${kindLabel} Approval: ${formatApprovalDecision(view.decision)}`, resolvedBy ? `Resolved by ${resolvedBy}` : "Resolved"),
+		...buildApprovalSubject(view),
+		buildApprovalMetadata(view.approvalId, view.metadata)
+	]);
+}
+function buildMSTeamsExpiredApprovalCard(view) {
+	return buildAdaptiveCard([
+		...buildCardHeading(`${view.approvalKind === "plugin" ? "Plugin" : "Exec"} Approval Expired`, "This approval request expired before it was resolved."),
+		...buildApprovalSubject(view),
+		buildApprovalMetadata(view.approvalId, view.metadata)
+	]);
+}
+function buildMSTeamsCanonicalApprovalTerminalCard(result) {
+	const { approval } = result;
+	const { presentation } = approval;
+	const kindLabel = presentation.kind === "exec" ? "Exec" : presentation.kind === "plugin" ? "Plugin" : "System Agent";
+	const outcome = approval.status === "allowed" ? formatApprovalDecision(approval.decision) : approval.status === "denied" ? "Denied" : approval.status === "expired" ? "Expired" : "Cancelled";
+	const subject = presentation.kind === "exec" ? [{
+		type: "TextBlock",
+		text: "Command",
+		weight: "Bolder",
+		wrap: true
+	}, {
+		type: "TextBlock",
+		text: presentation.commandPreview ?? presentation.commandText,
+		fontType: "Monospace",
+		wrap: true
+	}] : [{
+		type: "TextBlock",
+		text: presentation.title,
+		weight: "Bolder",
+		wrap: true
+	}, {
+		type: "TextBlock",
+		text: presentation.description,
+		wrap: true
+	}];
+	const metadata = [
+		{
+			label: "Status",
+			value: approval.status
+		},
+		..."decision" in approval ? [{
+			label: "Decision",
+			value: approval.decision
+		}] : [],
+		{
+			label: "Reason",
+			value: approval.reason
+		}
+	];
+	return buildAdaptiveCard([
+		...buildCardHeading(`${kindLabel} Approval: ${outcome}`, result.applied ? "Resolved by this action" : "Already resolved"),
+		...subject,
+		buildApprovalMetadata(approval.id, metadata)
+	]);
+}
+//#endregion
+Object.defineProperty(exports, "buildMSTeamsCanonicalApprovalTerminalCard", {
+	enumerable: true,
+	get: function() {
+		return buildMSTeamsCanonicalApprovalTerminalCard;
+	}
+});
+Object.defineProperty(exports, "buildMSTeamsExpiredApprovalCard", {
+	enumerable: true,
+	get: function() {
+		return buildMSTeamsExpiredApprovalCard;
+	}
+});
+Object.defineProperty(exports, "buildMSTeamsPendingApprovalCard", {
+	enumerable: true,
+	get: function() {
+		return buildMSTeamsPendingApprovalCard;
+	}
+});
+Object.defineProperty(exports, "buildMSTeamsResolvedApprovalCard", {
+	enumerable: true,
+	get: function() {
+		return buildMSTeamsResolvedApprovalCard;
+	}
+});
+Object.defineProperty(exports, "claimMSTeamsApprovalCardBinding", {
+	enumerable: true,
+	get: function() {
+		return claimMSTeamsApprovalCardBinding;
+	}
+});
+Object.defineProperty(exports, "completeMSTeamsApprovalCardBinding", {
+	enumerable: true,
+	get: function() {
+		return completeMSTeamsApprovalCardBinding;
+	}
+});
+Object.defineProperty(exports, "getMSTeamsApprovalCardBinding", {
+	enumerable: true,
+	get: function() {
+		return getMSTeamsApprovalCardBinding;
+	}
+});
+Object.defineProperty(exports, "readMSTeamsApprovalActionToken", {
+	enumerable: true,
+	get: function() {
+		return readMSTeamsApprovalActionToken;
+	}
+});
+Object.defineProperty(exports, "registerMSTeamsApprovalCardBinding", {
+	enumerable: true,
+	get: function() {
+		return registerMSTeamsApprovalCardBinding;
+	}
+});
+Object.defineProperty(exports, "releaseMSTeamsApprovalCardBinding", {
+	enumerable: true,
+	get: function() {
+		return releaseMSTeamsApprovalCardBinding;
+	}
+});
+Object.defineProperty(exports, "unregisterMSTeamsApprovalCardBindings", {
+	enumerable: true,
+	get: function() {
+		return unregisterMSTeamsApprovalCardBindings;
+	}
+});

package/dist/approval-handler.runtime-B-ZA6Vjp.cjs

@@ -0,0 +1,107 @@
+const require_resolve_allowlist = require("./resolve-allowlist-CWbvAW4v.cjs");
+const require_channel = require("./channel-ChmCvkuA.cjs");
+const require_approval_card = require("./approval-card-B6ZIMO83.cjs");
+const require_send = require("./send-Bym7IH-v.cjs");
+let openclaw_plugin_sdk_account_id = require("openclaw/plugin-sdk/account-id");
+let openclaw_plugin_sdk_approval_native_runtime = require("openclaw/plugin-sdk/approval-native-runtime");
+let openclaw_plugin_sdk_approval_handler_runtime = require("openclaw/plugin-sdk/approval-handler-runtime");
+//#region extensions/msteams/src/approval-handler.runtime.ts
+const log = (0, require("openclaw/plugin-sdk/runtime-env").createSubsystemLogger)("msteams/approvals");
+const msTeamsApprovalNativeRuntime = (0, openclaw_plugin_sdk_approval_handler_runtime.createChannelApprovalNativeRuntimeAdapter)({
+	eventKinds: ["exec", "plugin"],
+	availability: {
+		isConfigured: ({ cfg, accountId }) => require_channel.isMSTeamsNativeApprovalClientEnabled({
+			cfg,
+			accountId
+		}),
+		shouldHandle: ({ cfg, accountId, approvalKind, request }) => require_channel.shouldHandleMSTeamsNativeApprovalRequest({
+			cfg,
+			accountId,
+			approvalKind,
+			request
+		})
+	},
+	presentation: {
+		buildPendingPayload: ({ view, nowMs }) => require_approval_card.buildMSTeamsPendingApprovalCard({
+			view,
+			nowMs
+		}),
+		buildResolvedResult: ({ view }) => ({
+			kind: "update",
+			payload: require_approval_card.buildMSTeamsResolvedApprovalCard(view)
+		}),
+		buildExpiredResult: ({ view }) => ({
+			kind: "update",
+			payload: require_approval_card.buildMSTeamsExpiredApprovalCard(view)
+		})
+	},
+	transport: {
+		prepareTarget: ({ plannedTarget }) => {
+			const normalizedTarget = require_resolve_allowlist.normalizeMSTeamsMessagingTarget(plannedTarget.target.to);
+			if (!normalizedTarget) throw new Error("Microsoft Teams approval delivery target is missing");
+			const threadId = plannedTarget.target.threadId;
+			const to = threadId != null && require_channel.inferMSTeamsTargetChatType(normalizedTarget) === "channel" && !require_resolve_allowlist.extractMSTeamsConversationMessageId(normalizedTarget) ? `${normalizedTarget};messageid=${threadId}` : normalizedTarget;
+			return {
+				dedupeKey: (0, openclaw_plugin_sdk_approval_native_runtime.buildChannelApprovalNativeTargetKey)({
+					...plannedTarget.target,
+					to: normalizedTarget
+				}),
+				target: { to }
+			};
+		},
+		deliverPending: async ({ cfg, accountId, preparedTarget, pendingPayload }) => {
+			const sent = await require_send.sendAdaptiveCardMSTeams({
+				cfg,
+				to: preparedTarget.to,
+				card: pendingPayload.card
+			});
+			if (!sent.messageId || sent.messageId === "unknown" || !sent.conversationId) return null;
+			return {
+				accountId: accountId ?? openclaw_plugin_sdk_account_id.DEFAULT_ACCOUNT_ID,
+				conversationId: sent.conversationId,
+				activityId: sent.messageId,
+				actionTokens: pendingPayload.actionTokens
+			};
+		},
+		updateEntry: async ({ cfg, entry, payload }) => {
+			await require_send.editAdaptiveCardMSTeams({
+				cfg,
+				to: entry.conversationId,
+				activityId: entry.activityId,
+				card: payload
+			});
+		}
+	},
+	interactions: {
+		bindPending: ({ entry, request, approvalKind, view, pendingPayload }) => {
+			const tokens = [];
+			for (const actionToken of entry.actionTokens) if (require_approval_card.registerMSTeamsApprovalCardBinding({
+				token: actionToken.token,
+				accountId: entry.accountId,
+				approvalId: request.id,
+				approvalKind,
+				decision: actionToken.decision,
+				allowedDecisions: pendingPayload.allowedDecisions,
+				conversationId: entry.conversationId,
+				activityId: entry.activityId,
+				expiresAtMs: view.expiresAtMs
+			})) tokens.push(actionToken.token);
+			return tokens.length > 0 ? tokens : null;
+		},
+		unbindPending: ({ binding }) => require_approval_card.unregisterMSTeamsApprovalCardBindings(binding),
+		cancelDelivered: ({ entry }) => require_approval_card.unregisterMSTeamsApprovalCardBindings(entry.actionTokens.map(({ token }) => token))
+	},
+	observe: { onDeliveryError: ({ cfg, error, plannedTarget, request, approvalKind, pendingPayload }) => {
+		log.error(`msteams approvals: failed to deliver request ${request.id}: ${String(error)}`);
+		const decisions = pendingPayload.allowedDecisions.join("|");
+		require_send.sendMessageMSTeams({
+			cfg,
+			to: plannedTarget.target.to,
+			text: `⚠️ Could not deliver the ${approvalKind} approval card for ${request.id}. Reply "/approve ${request.id} <${decisions}>" to resolve it.`
+		}).catch((fallbackError) => {
+			log.error(`msteams approvals: fallback prompt for ${request.id} also failed: ${String(fallbackError)}`);
+		});
+	} }
+});
+//#endregion
+exports.msTeamsApprovalNativeRuntime = msTeamsApprovalNativeRuntime;