@openclaw/msteams 2026.7.2-beta.2 → 2026.7.2-beta.3

package/dist/{src-20YasZEp.cjs → src-BQM9QUTF.cjs}

@@ -1,30 +1,28 @@
-const require_rolldown_runtime = require("./rolldown-runtime-D6vf50IK.cjs");
+const require_delegated_state = require("./delegated-state-DOSCHaAB.cjs");
 const require_runtime = require("./runtime-gZTAuFux.cjs");
 require("./runtime-api.cjs");
-const require_resolve_allowlist = require("./resolve-allowlist-DXd097EP.cjs");
-const require_channel = require("./channel-BKc8zroK.cjs");
-const require_setup_surface = require("./setup-surface-D4f6x5cx.cjs");
-const require_polls = require("./polls-BhoI4VaN.cjs");
-const require_sso_token_store = require("./sso-token-store-CktCz88k.cjs");
-const require_messenger = require("./messenger-BVcKl6dv.cjs");
+const require_resolve_allowlist = require("./resolve-allowlist-Dk-1CqBm.cjs");
+const require_channel = require("./channel-oNBYNcJT.cjs");
+const require_setup_surface = require("./setup-surface-BcRVoUY8.cjs");
+const require_polls = require("./polls-CWExq2xZ.cjs");
+const require_sso_token_store = require("./sso-token-store-OSg229re.cjs");
+const require_messenger = require("./messenger-Do4oje4J.cjs");
 let openclaw_plugin_sdk_allow_from = require("openclaw/plugin-sdk/allow-from");
 let openclaw_plugin_sdk_channel_outbound = require("openclaw/plugin-sdk/channel-outbound");
 let openclaw_plugin_sdk_string_coerce_runtime = require("openclaw/plugin-sdk/string-coerce-runtime");
 let openclaw_plugin_sdk_media_runtime = require("openclaw/plugin-sdk/media-runtime");
-let openclaw_plugin_sdk_channel_inbound = require("openclaw/plugin-sdk/channel-inbound");
 let openclaw_plugin_sdk_ssrf_runtime = require("openclaw/plugin-sdk/ssrf-runtime");
 let openclaw_plugin_sdk_provider_http = require("openclaw/plugin-sdk/provider-http");
 let openclaw_plugin_sdk_number_runtime = require("openclaw/plugin-sdk/number-runtime");
 let openclaw_plugin_sdk_text_utility_runtime = require("openclaw/plugin-sdk/text-utility-runtime");
-let node_path = require("node:path");
-node_path = require_rolldown_runtime.__toESM(node_path, 1);
-let openclaw_plugin_sdk_security_runtime = require("openclaw/plugin-sdk/security-runtime");
 let openclaw_plugin_sdk_routing = require("openclaw/plugin-sdk/routing");
 let node_crypto = require("node:crypto");
-node_crypto = require_rolldown_runtime.__toESM(node_crypto, 1);
+node_crypto = require_delegated_state.__toESM(node_crypto, 1);
+let openclaw_plugin_sdk_channel_inbound = require("openclaw/plugin-sdk/channel-inbound");
 let openclaw_plugin_sdk_channel_ingress_runtime = require("openclaw/plugin-sdk/channel-ingress-runtime");
 let openclaw_plugin_sdk_context_visibility_runtime = require("openclaw/plugin-sdk/context-visibility-runtime");
 let openclaw_plugin_sdk_reply_history = require("openclaw/plugin-sdk/reply-history");
+let openclaw_plugin_sdk_agent_runtime = require("openclaw/plugin-sdk/agent-runtime");
 let openclaw_plugin_sdk_dedupe_runtime = require("openclaw/plugin-sdk/dedupe-runtime");
 let openclaw_plugin_sdk_collection_runtime = require("openclaw/plugin-sdk/collection-runtime");
 let openclaw_plugin_sdk_channel_pairing = require("openclaw/plugin-sdk/channel-pairing");
@@ -33,100 +31,24 @@ let openclaw_plugin_sdk_runtime_group_policy = require("openclaw/plugin-sdk/runt
 let openclaw_plugin_sdk_dangerous_name_runtime = require("openclaw/plugin-sdk/dangerous-name-runtime");
 let openclaw_plugin_sdk_reply_payload = require("openclaw/plugin-sdk/reply-payload");
 let openclaw_plugin_sdk_webhook_ingress = require("openclaw/plugin-sdk/webhook-ingress");
-//#region extensions/msteams/src/feedback-reflection-prompt.ts
-/** Max chars of the thumbed-down response to include in the reflection prompt. */
-const MAX_RESPONSE_CHARS = 500;
-function buildReflectionPrompt(params) {
-	const parts = ["A user indicated your previous response wasn't helpful."];
-	if (params.thumbedDownResponse) {
-		const truncated = params.thumbedDownResponse.length > MAX_RESPONSE_CHARS ? `${(0, openclaw_plugin_sdk_text_utility_runtime.truncateUtf16Safe)(params.thumbedDownResponse, MAX_RESPONSE_CHARS)}...` : params.thumbedDownResponse;
-		parts.push(`\nYour response was:\n> ${truncated}`);
-	}
-	if (params.userComment) parts.push(`\nUser's comment: "${params.userComment}"`);
-	parts.push("\nBriefly reflect: what could you improve? Consider tone, length, accuracy, relevance, and specificity. Reply with a single JSON object only, no markdown or prose, using this exact shape:\n{\"learning\":\"...\",\"followUp\":false,\"userMessage\":\"\"}\n- learning: a short internal adjustment note (1-2 sentences) for your future behavior in this conversation.\n- followUp: true only if the user needs a direct follow-up message.\n- userMessage: only the exact user-facing message to send; empty string when followUp is false.");
-	return parts.join("\n");
-}
-function parseBooleanLike(value) {
-	if (typeof value === "boolean") return value;
-	if (typeof value === "string") {
-		const normalized = (0, openclaw_plugin_sdk_string_coerce_runtime.normalizeOptionalLowercaseString)(value);
-		if (normalized === "true" || normalized === "yes") return true;
-		if (normalized === "false" || normalized === "no") return false;
-	}
-}
-function parseStructuredReflectionValue(value) {
-	if (value == null || typeof value !== "object" || Array.isArray(value)) return null;
-	const candidate = value;
-	const learning = typeof candidate.learning === "string" ? candidate.learning.trim() : void 0;
-	if (!learning) return null;
-	return {
-		learning,
-		followUp: parseBooleanLike(candidate.followUp) ?? false,
-		userMessage: typeof candidate.userMessage === "string" && candidate.userMessage.trim() ? candidate.userMessage.trim() : void 0
-	};
-}
-function parseReflectionResponse(text) {
-	const trimmed = text.trim();
-	if (!trimmed) return null;
-	const candidates = [trimmed, ...trimmed.match(/```(?:json)?\s*([\s\S]*?)```/i)?.slice(1, 2) ?? []];
-	for (const candidateText of candidates) {
-		const candidate = candidateText.trim();
-		if (!candidate) continue;
-		try {
-			const parsed = parseStructuredReflectionValue(JSON.parse(candidate));
-			if (parsed) return parsed;
-		} catch {}
-	}
-	return {
-		learning: trimmed,
-		followUp: false
-	};
-}
-/** Tracks last reflection time per session to enforce cooldown. */
-const lastReflectionBySession = /* @__PURE__ */ new Map();
-/** Maximum cooldown entries before pruning expired ones. */
-const MAX_COOLDOWN_ENTRIES = 500;
+//#region extensions/msteams/src/feedback-reflection-store.ts
 const LEARNINGS_NAMESPACE = "feedback-learnings";
 const MAX_LEARNING_ENTRIES = 1e4;
 function learningStoreKey(storePath, sessionKey) {
 	return node_crypto.default.createHash("sha256").update(`${storePath}\0${sessionKey}`, "utf8").digest("hex");
 }
-function openLearningStore() {
-	return require_runtime.getMSTeamsRuntime().state.openKeyedStore({
+async function storeSessionLearning(params) {
+	const store = require_runtime.getMSTeamsRuntime().state.openKeyedStore({
 		namespace: LEARNINGS_NAMESPACE,
 		maxEntries: MAX_LEARNING_ENTRIES
 	});
-}
-/** Prune expired cooldown entries to prevent unbounded memory growth. */
-function pruneExpiredCooldowns(cooldownMs) {
-	if (lastReflectionBySession.size <= MAX_COOLDOWN_ENTRIES) return;
-	const now = Date.now();
-	for (const [key, time] of lastReflectionBySession) if (now - time >= cooldownMs) lastReflectionBySession.delete(key);
-}
-/** Check if a reflection is allowed (cooldown not active). */
-function isReflectionAllowed(sessionKey, cooldownMs) {
-	const cooldown = cooldownMs ?? 3e5;
-	const lastTime = lastReflectionBySession.get(sessionKey);
-	if (lastTime == null) return true;
-	return Date.now() - lastTime >= cooldown;
-}
-/** Record that a reflection was run for a session. */
-function recordReflectionTime(sessionKey, cooldownMs) {
-	lastReflectionBySession.set(sessionKey, Date.now());
-	pruneExpiredCooldowns(cooldownMs ?? 3e5);
-}
-/** Store a learning derived from feedback reflection. */
-async function storeSessionLearning(params) {
-	const store = openLearningStore();
 	const key = learningStoreKey(params.storePath, params.sessionKey);
-	let learnings = (await store.lookup(key))?.learnings ?? [];
-	learnings.push(params.learning);
-	if (learnings.length > 10) learnings = learnings.slice(-10);
-	await store.register(key, {
+	if (!store.update) throw new Error("plugin state atomic update is unavailable");
+	await store.update(key, (existing) => ({
 		sessionKey: params.sessionKey,
-		learnings,
+		learnings: [...existing?.learnings ?? [], params.learning].slice(-10),
 		updatedAt: Date.now()
-	});
+	}));
 }
 //#endregion
 //#region extensions/msteams/src/feedback-reflection.ts
@@ -143,144 +65,68 @@ function buildFeedbackEvent(params) {
 		conversationId: params.conversationId
 	};
 }
-function buildReflectionContext(params) {
-	const core = require_runtime.getMSTeamsRuntime();
-	const envelopeOptions = core.channel.reply.resolveEnvelopeFormatOptions(params.cfg);
-	const body = core.channel.reply.formatAgentEnvelope({
-		channel: "Teams",
-		from: "system",
-		body: params.reflectionPrompt,
-		envelope: envelopeOptions
-	});
-	return { ctxPayload: core.channel.reply.finalizeInboundContext({
-		Body: body,
-		BodyForAgent: params.reflectionPrompt,
-		RawBody: params.reflectionPrompt,
-		CommandBody: params.reflectionPrompt,
-		From: `msteams:system:${params.conversationId}`,
-		To: `conversation:${params.conversationId}`,
-		SessionKey: params.sessionKey,
-		ChatType: "direct",
-		SenderName: "system",
-		SenderId: "system",
-		Provider: "msteams",
-		Surface: "msteams",
-		Timestamp: Date.now(),
-		WasMentioned: true,
-		CommandAuthorized: false,
-		OriginatingChannel: "msteams",
-		OriginatingTo: `conversation:${params.conversationId}`
-	}) };
-}
-function createReflectionCaptureDispatcher(params) {
-	const core = require_runtime.getMSTeamsRuntime();
-	let response = "";
-	const { dispatcher, replyOptions } = core.channel.reply.createReplyDispatcherWithTyping({
-		deliver: async (payload) => {
-			if (payload.text) response += (response ? "\n" : "") + payload.text;
-		},
-		typingCallbacks: {
-			onReplyStart: async () => {},
-			onIdle: () => {},
-			onCleanup: () => {}
-		},
-		humanDelay: core.channel.reply.resolveHumanDelayConfig(params.cfg, params.agentId),
-		onError: (err) => {
-			params.log.debug?.("reflection reply error", { error: require_setup_surface.formatUnknownError(err) });
-		}
-	});
-	return {
-		dispatcher,
-		replyOptions,
-		readResponse: () => response
-	};
-}
-async function sendReflectionFollowUp(params) {
-	const baseRef = require_messenger.buildConversationReference(params.conversationRef);
-	await require_messenger.sendMSTeamsActivityWithReference(params.app, baseRef, {
-		type: "message",
-		text: params.userMessage
-	}, { serviceUrlBoundary: require_resolve_allowlist.resolveMSTeamsSdkCloudOptions(params.cfg.channels?.msteams) });
-}
 /**
 * Run a background reflection after negative feedback.
 * This is designed to be called fire-and-forget (don't await in the invoke handler).
 */
 async function runFeedbackReflection(params) {
 	const { cfg, log, sessionKey } = params;
-	const cooldownMs = cfg.channels?.msteams?.feedbackReflectionCooldownMs ?? 3e5;
-	if (!isReflectionAllowed(sessionKey, cooldownMs)) {
-		log.debug?.("skipping reflection (cooldown active)", { sessionKey });
-		return;
-	}
-	const reflectionPrompt = buildReflectionPrompt({
-		thumbedDownResponse: params.thumbedDownResponse,
-		userComment: params.userComment
-	});
-	const storePath = require_runtime.getMSTeamsRuntime().channel.session.resolveStorePath(cfg.session?.store, { agentId: params.agentId });
-	const { ctxPayload } = buildReflectionContext({
-		cfg,
-		conversationId: params.conversationId,
-		sessionKey: params.sessionKey,
-		reflectionPrompt
-	});
-	const capture = createReflectionCaptureDispatcher({
-		cfg,
-		agentId: params.agentId,
-		log
-	});
+	const cooldownMs = cfg.channels?.msteams?.feedbackReflectionCooldownMs ?? openclaw_plugin_sdk_channel_inbound.DEFAULT_CHANNEL_FEEDBACK_REFLECTION_COOLDOWN_MS;
+	let reflection;
 	try {
-		await (0, openclaw_plugin_sdk_channel_inbound.dispatchReplyFromConfigWithSettledDispatcher)({
-			ctxPayload,
+		reflection = await (0, openclaw_plugin_sdk_channel_inbound.runChannelFeedbackReflection)({
 			cfg,
-			dispatcher: capture.dispatcher,
-			onSettled: () => {},
-			replyOptions: capture.replyOptions
+			channel: "msteams",
+			channelLabel: "Teams",
+			agentId: params.agentId,
+			sessionKey,
+			conversationId: params.conversationId,
+			conversationKind: params.conversationKind,
+			thumbedDownResponse: params.thumbedDownResponse,
+			userComment: params.userComment,
+			cooldownMs,
+			onRecordError: (err) => log.debug?.("reflection session record failed", { error: require_setup_surface.formatUnknownError(err) }),
+			onDispatchError: (err) => log.debug?.("reflection reply error", { error: require_setup_surface.formatUnknownError(err) })
 		});
 	} catch (err) {
 		log.error("reflection dispatch failed", { error: require_setup_surface.formatUnknownError(err) });
 		return;
 	}
-	const reflectionResponse = capture.readResponse().trim();
-	if (!reflectionResponse) {
-		log.debug?.("reflection produced no output");
+	if (reflection.status === "cooldown") {
+		log.debug?.("skipping reflection (cooldown active)", { sessionKey });
 		return;
 	}
-	const parsedReflection = parseReflectionResponse(reflectionResponse);
-	if (!parsedReflection) {
-		log.debug?.("reflection produced no structured output");
+	if (reflection.status === "empty") {
+		log.debug?.("reflection produced no output");
 		return;
 	}
-	recordReflectionTime(sessionKey, cooldownMs);
 	log.info("reflection complete", {
 		sessionKey,
-		responseLength: reflectionResponse.length,
-		followUp: parsedReflection.followUp
+		responseLength: reflection.responseLength,
+		followUp: reflection.followUp
 	});
 	try {
 		await storeSessionLearning({
-			storePath,
-			sessionKey: params.sessionKey,
-			learning: parsedReflection.learning
+			storePath: reflection.storePath,
+			sessionKey,
+			learning: reflection.learning
 		});
 	} catch (err) {
 		log.debug?.("failed to store reflection learning", { error: require_setup_surface.formatUnknownError(err) });
 	}
 	const conversationType = (0, openclaw_plugin_sdk_string_coerce_runtime.normalizeOptionalLowercaseString)(params.conversationRef.conversation?.conversationType);
-	if (!(conversationType === "personal" && parsedReflection.followUp && Boolean(parsedReflection.userMessage))) {
-		if (parsedReflection.followUp && conversationType !== "personal") log.debug?.("skipping reflection follow-up outside direct message", {
+	if (!(conversationType === "personal" && reflection.followUp && Boolean(reflection.userMessage))) {
+		if (reflection.followUp && conversationType !== "personal") log.debug?.("skipping reflection follow-up outside direct message", {
 			sessionKey,
 			conversationType
 		});
 		return;
 	}
 	try {
-		await sendReflectionFollowUp({
-			cfg,
-			app: params.app,
-			conversationRef: params.conversationRef,
-			userMessage: parsedReflection.userMessage
-		});
+		await require_messenger.sendMSTeamsActivityWithReference(params.app, require_messenger.buildConversationReference(params.conversationRef), {
+			type: "message",
+			text: reflection.userMessage
+		}, { serviceUrlBoundary: require_resolve_allowlist.resolveMSTeamsSdkCloudOptions(cfg.channels?.msteams) });
 		log.info("sent reflection follow-up", { sessionKey });
 	} catch (err) {
 		log.debug?.("failed to send reflection follow-up", { error: require_setup_surface.formatUnknownError(err) });
@@ -1815,14 +1661,16 @@ function createMSTeamsReplyDispatcher(params) {
 		}
 		if (ids.length > 0) params.onSentMessageIds?.(ids);
 	};
-	const { dispatcher, replyOptions, markDispatchIdle: baseMarkDispatchIdle } = core.channel.reply.createReplyDispatcherWithTyping({
+	const dispatcherOptions = {
 		...replyPipeline,
-		humanDelay: core.channel.reply.resolveHumanDelayConfig(params.cfg, params.agentId),
+		humanDelay: (0, openclaw_plugin_sdk_agent_runtime.resolveHumanDelayConfig)(params.cfg, params.agentId),
 		onReplyStart: async () => {
 			await streamController.onReplyStart();
 			if (typingIndicatorEnabled) await typingCallbacks?.onReplyStart?.();
 		},
-		typingCallbacks,
+		typingCallbacks
+	};
+	const delivery = {
 		deliver: async (payload) => {
 			const preparedPayload = streamController.preparePayload(payload);
 			if (!preparedPayload) return;
@@ -1841,8 +1689,8 @@ function createMSTeamsReplyDispatcher(params) {
 				hint
 			});
 		}
-	});
-	const markDispatchIdle = () => {
+	};
+	const settleDelivery = () => {
 		return flushPendingMessages().catch((err) => {
 			const errMsg = require_setup_surface.formatUnknownError(err);
 			const classification = require_setup_surface.classifyMSTeamsSendError(err);
@@ -1861,8 +1709,6 @@ function createMSTeamsReplyDispatcher(params) {
 				queueReplyPayload(fallbackPayload);
 				await flushPendingMessages();
 			}
-		}).finally(() => {
-			baseMarkDispatchIdle();
 		});
 	};
 	const previewToolProgressEnabled = (0, openclaw_plugin_sdk_channel_outbound.resolveChannelStreamingPreviewToolProgress)(msteamsCfg);
@@ -1913,7 +1759,7 @@ function createMSTeamsReplyDispatcher(params) {
 		},
 		onPlanUpdate: async (payload) => {
 			if (payload?.phase !== "update") return;
-			await streamController.pushPlanProgress((0, openclaw_plugin_sdk_channel_outbound.normalizeAgentPlanSteps)(payload.planSteps), { explanation: typeof payload.explanation === "string" ? payload.explanation : void 0 });
+			await streamController.pushPlanProgress((0, openclaw_plugin_sdk_channel_outbound.normalizeAgentPlanSteps)(payload.steps), { explanation: typeof payload.explanation === "string" ? payload.explanation : void 0 });
 		},
 		onApprovalEvent: async (payload) => {
 			if (payload?.phase !== "requested") return;
@@ -1956,16 +1802,18 @@ function createMSTeamsReplyDispatcher(params) {
 		}
 	} : {};
 	return {
-		dispatcher,
+		dispatcherOptions: {
+			...dispatcherOptions,
+			onSettled: settleDelivery
+		},
+		delivery,
 		replyOptions: {
-			...replyOptions,
 			...streamController.hasStream() ? { onPartialReply: (payload) => streamController.onPartialReply(payload) } : {},
 			...progressCallbacks,
 			...shouldSuppressDefaultToolProgressMessages ? { suppressDefaultToolProgressMessages: true } : {},
 			disableBlockStreaming: blockStreamingResolved == null ? void 0 : !blockStreamingResolved,
 			onModelSelected
-		},
-		markDispatchIdle
+		}
 	};
 }
 //#endregion
@@ -2581,12 +2429,17 @@ function createMSTeamsMessageHandler(deps) {
 			const replies = repliesResult.status === "fulfilled" ? repliesResult.value : [];
 			if (parentResult.status === "rejected") log.debug?.("failed to fetch parent message", { error: require_setup_surface.formatUnknownError(parentResult.reason) });
 			if (repliesResult.status === "rejected") log.debug?.("failed to fetch thread replies", { error: require_setup_surface.formatUnknownError(repliesResult.reason) });
-			const isThreadSenderAllowed = (msg) => groupPolicy === "allowlist" ? require_channel.resolveMSTeamsAllowlistMatch({
+			const isThreadSenderAllowed = (msg) => (0, openclaw_plugin_sdk_channel_inbound.resolveInboundSupplementalSenderAllowed)({
+				isGroup: isChannel,
+				groupPolicy,
 				allowFrom: effectiveGroupAllowFrom,
-				senderId: msg.from?.user?.id ?? "",
-				senderName: msg.from?.user?.displayName,
-				allowNameMatching
-			}).allowed : true;
+				isSenderAllowed: (allowFrom) => require_channel.resolveMSTeamsAllowlistMatch({
+					allowFrom,
+					senderId: msg.from?.user?.id ?? "",
+					senderName: msg.from?.user?.displayName,
+					allowNameMatching
+				}).allowed
+			});
 			const parentSummary = summarizeParentMessage(parentMsg);
 			const visibleParentMessages = parentMsg ? (0, openclaw_plugin_sdk_context_visibility_runtime.filterSupplementalContextItems)({
 				items: [parentMsg],
@@ -2617,17 +2470,14 @@ function createMSTeamsMessageHandler(deps) {
 		}
 		quoteSenderName ??= quoteInfo?.sender;
 		const envelopeFrom = isDirectMessage ? senderName : conversationType;
-		const { storePath, envelopeOptions, previousTimestamp } = (0, openclaw_plugin_sdk_channel_inbound.resolveInboundSessionEnvelopeContext)({
+		const buildEnvelope = (0, openclaw_plugin_sdk_channel_inbound.createChannelInboundEnvelopeBuilder)({
 			cfg,
-			agentId: route.agentId,
-			sessionKey: route.sessionKey
+			route
 		});
-		let combinedBody = core.channel.reply.formatAgentEnvelope({
+		let combinedBody = buildEnvelope({
 			channel: "Teams",
 			from: envelopeFrom,
 			timestamp,
-			previousTimestamp,
-			envelope: envelopeOptions,
 			body: agentBody
 		});
 		const isRoomish = !isDirectMessage;
@@ -2636,12 +2486,12 @@ function createMSTeamsMessageHandler(deps) {
 			historyKey,
 			limit: historyLimit,
 			currentMessage: combinedBody,
-			formatEntry: (entry) => core.channel.reply.formatAgentEnvelope({
+			formatEntry: (entry) => buildEnvelope({
 				channel: "Teams",
 				from: conversationType,
 				timestamp: entry.timestamp,
-				body: `${entry.sender}: ${entry.body}${entry.messageId ? ` [id:${entry.messageId}]` : ""}`,
-				envelope: envelopeOptions
+				previousTimestamp: null,
+				body: `${entry.sender}: ${entry.body}${entry.messageId ? ` [id:${entry.messageId}]` : ""}`
 			})
 		});
 		const inboundHistory = isRoomish && historyKey && historyLimit > 0 ? (0, openclaw_plugin_sdk_reply_history.createChannelHistoryWindow)({ historyMap: conversationHistories }).buildInboundHistory({
@@ -2649,17 +2499,21 @@ function createMSTeamsMessageHandler(deps) {
 			limit: historyLimit
 		}) : void 0;
 		const commandBody = text.trim();
-		const quoteSenderAllowed = quoteInfo && quoteInfo.sender ? !isChannel || groupPolicy !== "allowlist" ? true : require_channel.resolveMSTeamsAllowlistMatch({
+		const quoteSenderAllowed = quoteInfo && quoteInfo.sender ? (0, openclaw_plugin_sdk_channel_inbound.resolveInboundSupplementalSenderAllowed)({
+			isGroup: !isDirectMessage,
+			groupPolicy,
 			allowFrom: effectiveGroupAllowFrom,
-			senderId: quoteSenderId ?? "",
-			senderName: quoteSenderName,
-			allowNameMatching
-		}).allowed : true;
+			isSenderAllowed: (allowFrom) => require_channel.resolveMSTeamsAllowlistMatch({
+				allowFrom,
+				senderId: quoteSenderId ?? "",
+				senderName: quoteSenderName,
+				allowNameMatching
+			}).allowed
+		}) : true;
 		const bodyForAgent = threadContext ? `[Thread history]\n${threadContext}\n[/Thread history]\n\n${agentBody}` : agentBody;
 		const nativeChannelId = isChannel && teamAadGroupId ? `${teamAadGroupId}/${graphChannelId}` : void 0;
 		const ctxPayload = (0, openclaw_plugin_sdk_channel_inbound.buildChannelInboundEventContext)({
 			channel: "msteams",
-			finalize: core.channel.reply.finalizeInboundContext,
 			contextVisibility: contextVisibilityMode,
 			supplemental: { quote: quoteInfo ? {
 				id: quoteInfo.id ?? activity.replyToId ?? void 0,
@@ -2684,6 +2538,7 @@ function createMSTeamsMessageHandler(deps) {
 			},
 			route: {
 				agentId: route.agentId,
+				dmScope: route.dmScope,
 				accountId: route.accountId,
 				routeSessionKey: route.sessionKey
 			},
@@ -2714,7 +2569,7 @@ function createMSTeamsMessageHandler(deps) {
 		});
 		logVerboseMessage(`msteams inbound: from=${ctxPayload.From} preview="${preview}"`);
 		const sharePointSiteId = msteamsCfg?.sharePointSiteId;
-		const { dispatcher, replyOptions, markDispatchIdle } = createMSTeamsReplyDispatcher({
+		const { dispatcherOptions, delivery, replyOptions } = createMSTeamsReplyDispatcher({
 			cfg,
 			agentId: route.agentId,
 			sessionKey: route.sessionKey,
@@ -2734,10 +2589,16 @@ function createMSTeamsMessageHandler(deps) {
 			sharePointSiteId
 		});
 		const senderTimezone = (activity.entities?.find((e) => e.type === "clientInfo"))?.timezone || conversationRef.timezone;
-		const configOverride = senderTimezone && !cfg.agents?.defaults?.userTimezone ? { agents: { defaults: {
-			...cfg.agents?.defaults,
-			userTimezone: senderTimezone
-		} } } : void 0;
+		const turnConfig = senderTimezone && !cfg.agents?.defaults?.userTimezone ? {
+			...cfg,
+			agents: {
+				...cfg.agents,
+				defaults: {
+					...cfg.agents?.defaults,
+					userTimezone: senderTimezone
+				}
+			}
+		} : cfg;
 		log.info("dispatching to agent", { sessionKey: route.sessionKey });
 		try {
 			const turnResult = await core.channel.inbound.run({
@@ -2754,12 +2615,14 @@ function createMSTeamsMessageHandler(deps) {
 						raw: activity
 					}),
 					resolveTurn: () => ({
+						cfg: turnConfig,
 						channel: "msteams",
 						accountId: route.accountId,
-						routeSessionKey: route.sessionKey,
-						storePath,
+						route: {
+							agentId: route.agentId,
+							sessionKey: route.sessionKey
+						},
 						ctxPayload,
-						recordInboundSession: core.channel.session.recordInboundSession,
 						record: { onRecordError: (err) => {
 							logVerboseMessage(`msteams: failed updating session meta: ${require_setup_surface.formatUnknownError(err)}`);
 						} },
@@ -2769,18 +2632,12 @@ function createMSTeamsMessageHandler(deps) {
 							historyMap: conversationHistories,
 							limit: historyLimit
 						},
-						onPreDispatchFailure: () => core.channel.reply.settleReplyDispatcher({
-							dispatcher,
-							onSettled: () => markDispatchIdle()
-						}),
-						runDispatch: () => (0, openclaw_plugin_sdk_channel_inbound.dispatchReplyFromConfigWithSettledDispatcher)({
-							cfg,
-							ctxPayload,
-							dispatcher,
-							onSettled: () => markDispatchIdle(),
-							replyOptions,
-							configOverride
-						})
+						dispatcherOptions,
+						delivery,
+						replyOptions: {
+							...replyOptions,
+							...params.turnAdoptionLifecycle ? (0, openclaw_plugin_sdk_channel_outbound.bindIngressLifecycleToReplyOptions)(params.turnAdoptionLifecycle) : {}
+						}
 					})
 				}
 			});
@@ -2798,11 +2655,47 @@ function createMSTeamsMessageHandler(deps) {
 		} catch (err) {
 			log.error("dispatch failed", { error: require_setup_surface.formatUnknownError(err) });
 			runtime.error(`msteams dispatch failed: ${require_setup_surface.formatUnknownError(err)}`);
+			if (params.turnAdoptionLifecycle) throw err;
 			try {
 				await context.sendActivity("⚠️ Something went wrong. Please try again.");
 			} catch {}
 		}
 	};
+	function buildFlushIngressLifecycle(entries) {
+		const lifecycles = entries.map((entry) => entry.turnAdoptionLifecycle).filter((lifecycle) => lifecycle !== void 0);
+		const [firstLifecycle] = lifecycles;
+		if (!firstLifecycle) return {
+			lifecycle: void 0,
+			settle: async () => {}
+		};
+		let handedOff = false;
+		const adoptAll = async () => {
+			for (const lifecycle of lifecycles) await lifecycle.onAdopted();
+		};
+		return {
+			lifecycle: {
+				abortSignal: lifecycles.length === 1 ? firstLifecycle.abortSignal : AbortSignal.any(lifecycles.map((lifecycle) => lifecycle.abortSignal)),
+				onAdopted: async () => {
+					handedOff = true;
+					await adoptAll();
+				},
+				onDeferred: () => {
+					handedOff = true;
+					for (const lifecycle of lifecycles) lifecycle.onDeferred();
+				},
+				onAdoptionFinalizing: () => {
+					for (const lifecycle of lifecycles) lifecycle.onAdoptionFinalizing();
+				},
+				onAbandoned: async () => {
+					handedOff = true;
+					for (const lifecycle of lifecycles) await lifecycle.onAbandoned();
+				}
+			},
+			settle: async () => {
+				if (!handedOff) await adoptAll();
+			}
+		};
+	}
 	const inboundDebouncer = core.channel.debounce.createInboundDebouncer({
 		debounceMs: inboundDebounceMs,
 		buildKey: (entry) => {
@@ -2819,29 +2712,40 @@ function createMSTeamsMessageHandler(deps) {
 		onFlush: async (entries) => {
 			const last = entries.at(-1);
 			if (!last) return;
-			if (entries.length === 1) {
-				await handleTeamsMessageNow(last);
-				return;
+			const { lifecycle, settle } = buildFlushIngressLifecycle(entries);
+			try {
+				if (entries.length === 1) await handleTeamsMessageNow(lifecycle ? {
+					...last,
+					turnAdoptionLifecycle: lifecycle
+				} : last);
+				else {
+					const combinedText = entries.map((entry) => entry.text).filter(Boolean).join("\n");
+					if (combinedText.trim()) {
+						const combinedRawText = entries.map((entry) => entry.rawText).filter(Boolean).join("\n");
+						const wasMentioned = entries.some((entry) => entry.wasMentioned);
+						const implicitMentionKinds = entries.flatMap((entry) => entry.implicitMentionKinds);
+						await handleTeamsMessageNow({
+							context: last.context,
+							rawText: combinedRawText,
+							text: combinedText,
+							attachments: [],
+							wasMentioned,
+							implicitMentionKinds,
+							...lifecycle ? { turnAdoptionLifecycle: lifecycle } : {}
+						});
+					}
+				}
+				await settle();
+			} catch (err) {
+				await lifecycle?.onAbandoned();
+				throw err;
 			}
-			const combinedText = entries.map((entry) => entry.text).filter(Boolean).join("\n");
-			if (!combinedText.trim()) return;
-			const combinedRawText = entries.map((entry) => entry.rawText).filter(Boolean).join("\n");
-			const wasMentioned = entries.some((entry) => entry.wasMentioned);
-			const implicitMentionKinds = entries.flatMap((entry) => entry.implicitMentionKinds);
-			await handleTeamsMessageNow({
-				context: last.context,
-				rawText: combinedRawText,
-				text: combinedText,
-				attachments: [],
-				wasMentioned,
-				implicitMentionKinds
-			});
 		},
 		onError: (err) => {
 			runtime.error(`msteams debounce flush failed: ${require_setup_surface.formatUnknownError(err)}`);
 		}
 	});
-	return async function handleTeamsMessage(context) {
+	return async function handleTeamsMessage(context, turnAdoptionLifecycle) {
 		const activity = context.activity;
 		const attachments = Array.isArray(activity.attachments) ? activity.attachments : [];
 		const rawText = activity.text?.trim() ?? "";
@@ -2861,8 +2765,10 @@ function createMSTeamsMessageHandler(deps) {
 			text,
 			attachments,
 			wasMentioned,
-			implicitMentionKinds
+			implicitMentionKinds,
+			turnAdoptionLifecycle
 		});
+		if (turnAdoptionLifecycle) return { kind: "deferred" };
 	};
 }
 //#endregion
@@ -3059,29 +2965,37 @@ function registerMSTeamsHandlers(handler, deps) {
 	const handleTeamsMessage = createMSTeamsMessageHandler(deps);
 	const handleReaction = createMSTeamsReactionHandler(deps);
 	const originalRun = handler.run;
-	if (originalRun) handler.run = async (context) => {
+	if (originalRun) handler.run = async (context, turnAdoptionLifecycle) => {
 		const ctx = context;
 		if (ctx.activity?.type === "invoke" && ctx.activity?.name === "adaptiveCard/action") {
 			const text = serializeMSTeamsAdaptiveCardActionValue(ctx.activity?.value);
-			if (text) await handleTeamsMessage({
+			if (text) return await handleTeamsMessage({
 				...ctx,
 				activity: {
 					...ctx.activity,
 					type: "message",
 					text
 				}
-			});
+			}, turnAdoptionLifecycle);
 			return;
 		}
-		return originalRun.call(handler, context);
+		return originalRun.call(handler, context, turnAdoptionLifecycle);
 	};
-	handler.onMessage(async (context, next) => {
+	handler.onMessage(async (context, next, turnAdoptionLifecycle) => {
+		let nextRan = false;
+		const runNext = async () => {
+			nextRan = true;
+			await next();
+		};
 		try {
-			await handleTeamsMessage(context);
+			const result = await handleTeamsMessage(context, turnAdoptionLifecycle);
+			await runNext();
+			return result;
 		} catch (err) {
+			if (turnAdoptionLifecycle) throw err;
 			deps.runtime.error(`msteams handler failed: ${require_setup_surface.formatUnknownError(err)}`);
 		}
-		await next();
+		if (!nextRan) await runNext();
 	});
 	handler.onMembersAdded(async (context, next) => {
 		const ctx = context;
@@ -3182,8 +3096,7 @@ async function runMSTeamsFeedbackInvokeHandler(context, deps) {
 	const convType = (0, openclaw_plugin_sdk_string_coerce_runtime.normalizeOptionalLowercaseString)(activity.conversation?.conversationType);
 	const isDirectMessage = convType === "personal" || !convType && !activity.conversation?.isGroup;
 	const isChannel = convType === "channel";
-	const core = require_runtime.getMSTeamsRuntime();
-	const route = core.channel.routing.resolveAgentRoute({
+	const route = require_runtime.getMSTeamsRuntime().channel.routing.resolveAgentRoute({
 		cfg: deps.cfg,
 		channel: "msteams",
 		peer: {
@@ -3212,13 +3125,12 @@ async function runMSTeamsFeedbackInvokeHandler(context, deps) {
 		hasComment: Boolean(userComment)
 	});
 	try {
-		const storePath = core.channel.session.resolveStorePath(deps.cfg.session?.store, { agentId: route.agentId });
-		const safeKey = route.sessionKey.replace(/[^a-zA-Z0-9_-]/g, "_");
-		await (0, openclaw_plugin_sdk_security_runtime.appendRegularFile)({
-			filePath: node_path.default.join(storePath, `${safeKey}.jsonl`),
-			content: `${JSON.stringify(feedbackEvent)}\n`,
-			rejectSymlinkParents: true
-		}).catch(() => {});
+		await (0, openclaw_plugin_sdk_channel_inbound.recordChannelFeedbackEvent)({
+			cfg: deps.cfg,
+			agentId: route.agentId,
+			sessionKey: route.sessionKey,
+			event: feedbackEvent
+		});
 	} catch {}
 	const conversationRef = {
 		activityId: activity.id,
@@ -3243,12 +3155,11 @@ async function runMSTeamsFeedbackInvokeHandler(context, deps) {
 	if (isNegative && msteamsCfg?.feedbackReflection !== false) runFeedbackReflection({
 		cfg: deps.cfg,
 		app: deps.app,
-		appId: deps.appId,
 		conversationRef,
 		sessionKey: route.sessionKey,
 		agentId: route.agentId,
 		conversationId,
-		feedbackMessageId: messageId,
+		conversationKind: isDirectMessage ? "direct" : isChannel ? "channel" : "group",
 		userComment,
 		log: deps.log
 	}).catch((err) => {
@@ -3366,6 +3277,175 @@ async function runMSTeamsFileConsentInvokeHandler(context, log) {
 	}
 }
 //#endregion
+//#region extensions/msteams/src/msteams-ingress.ts
+const MSTEAMS_INGRESS_VERSION = 1;
+const MSTEAMS_INGRESS_DRAIN_INTERVAL_MS = 500;
+const MSTEAMS_INGRESS_MAX_CONCURRENT_DELIVERIES = 8;
+const MSTEAMS_INGRESS_SCAN_LIMIT = 100;
+const MSTEAMS_INGRESS_TOMBSTONE_TTL_MS = 720 * 60 * 6e4;
+const MSTEAMS_INGRESS_COMPLETED_MAX_ENTRIES = 2e4;
+const MSTEAMS_INGRESS_FAILED_MAX_ENTRIES = 4096;
+var MSTeamsIngressPayloadError = class extends Error {
+	constructor(reason, message, options) {
+		super(message, options);
+		this.reason = reason;
+		this.name = "MSTeamsIngressPayloadError";
+	}
+};
+function nonEmptyString(value) {
+	return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function isDispatchableActivity(activity) {
+	return activity.type === "message" || activity.type === "invoke" && activity.name === "adaptiveCard/action";
+}
+function inspectMSTeamsIngressActivity(activity) {
+	if (!isDispatchableActivity(activity)) return null;
+	const eventId = nonEmptyString(activity.id);
+	if (!eventId) throw new MSTeamsIngressPayloadError("invalid-activity", "Microsoft Teams dispatchable activity is missing activity.id.");
+	const laneKey = nonEmptyString(activity.conversation?.id);
+	if (!laneKey) throw new MSTeamsIngressPayloadError("invalid-activity", "Microsoft Teams dispatchable activity is missing conversation.id.");
+	return {
+		eventId,
+		laneKey
+	};
+}
+function parseClaimedActivity(payload, claimedId) {
+	if (payload.version !== MSTEAMS_INGRESS_VERSION || typeof payload.rawActivity !== "string" || !Number.isFinite(payload.receivedAt)) throw new MSTeamsIngressPayloadError("invalid-activity", "Microsoft Teams ingress payload is invalid.");
+	let activity;
+	try {
+		activity = JSON.parse(payload.rawActivity);
+	} catch (error) {
+		throw new MSTeamsIngressPayloadError("invalid-json", "Microsoft Teams ingress activity JSON is invalid.", { cause: error });
+	}
+	if (!activity || typeof activity !== "object" || Array.isArray(activity)) throw new MSTeamsIngressPayloadError("invalid-activity", "Microsoft Teams ingress activity must be an object.");
+	const parsed = activity;
+	const facts = inspectMSTeamsIngressActivity(parsed);
+	if (!facts) throw new MSTeamsIngressPayloadError("unsupported-activity", "Microsoft Teams ingress row is not an agent-turn activity.");
+	if (facts.eventId !== claimedId) throw new MSTeamsIngressPayloadError("invalid-activity", "Microsoft Teams activity id changed after durable admission.");
+	return parsed;
+}
+function errorText(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+function createMSTeamsIngress(options) {
+	const queue = options.queue ?? require_runtime.getMSTeamsRuntime().state.openChannelIngressQueue({ accountId: options.accountId });
+	const shutdown = new AbortController();
+	const liveContexts = /* @__PURE__ */ new Map();
+	const activeDeliveries = /* @__PURE__ */ new Set();
+	const drain = (0, openclaw_plugin_sdk_channel_outbound.createChannelIngressDrain)({
+		queue,
+		abortSignal: shutdown.signal,
+		orderBy: "received",
+		scanLimit: MSTEAMS_INGRESS_SCAN_LIMIT,
+		startLimit: MSTEAMS_INGRESS_MAX_CONCURRENT_DELIVERIES,
+		retryPolicy: {
+			maxAttempts: openclaw_plugin_sdk_channel_outbound.DEFAULT_INGRESS_RETRY_MAX_ATTEMPTS,
+			deadLetterMinAgeMs: openclaw_plugin_sdk_channel_outbound.DEFAULT_INGRESS_RETRY_DEAD_LETTER_MIN_AGE_MS
+		},
+		resolveNonRetryableFailure: (error) => {
+			if (error instanceof MSTeamsIngressPayloadError) return {
+				reason: error.reason,
+				message: error.message
+			};
+			return require_setup_surface.classifyMSTeamsSendError(error).kind === "auth" ? {
+				reason: "authentication-failed",
+				message: errorText(error)
+			} : null;
+		},
+		onLog: (message) => options.runtime.error?.(`msteams: ${message}`),
+		dispatchClaimedEvent: async (claimed, lifecycle) => {
+			const activity = parseClaimedActivity(claimed.payload, claimed.id);
+			const liveContext = liveContexts.get(claimed.id);
+			liveContexts.delete(claimed.id);
+			const delivery = Promise.resolve(options.dispatch(activity, lifecycle, liveContext));
+			activeDeliveries.add(delivery);
+			try {
+				return await delivery;
+			} finally {
+				activeDeliveries.delete(delivery);
+			}
+		}
+	});
+	let running = false;
+	let stopped = false;
+	let drainRequested = false;
+	let drainTask;
+	let drainTimer;
+	const requestDrain = () => {
+		if (!running || shutdown.signal.aborted) return;
+		drainRequested = true;
+		if (drainTask) return;
+		drainTask = (async () => {
+			while (drainRequested && !shutdown.signal.aborted) {
+				if (!running) break;
+				drainRequested = false;
+				await drain.drainOnce({ shouldStop: () => !running || shutdown.signal.aborted || activeDeliveries.size >= MSTEAMS_INGRESS_MAX_CONCURRENT_DELIVERIES });
+			}
+		})().catch((error) => {
+			options.runtime.error?.(`msteams ingress drain failed: ${errorText(error)}`);
+		}).finally(() => {
+			drainTask = void 0;
+			if (running && drainRequested && !shutdown.signal.aborted) requestDrain();
+		});
+	};
+	return {
+		accept: async (activity, liveContext) => {
+			const facts = inspectMSTeamsIngressActivity(activity);
+			if (!facts) return;
+			await queue.prune({
+				completedTtlMs: MSTEAMS_INGRESS_TOMBSTONE_TTL_MS,
+				completedMaxEntries: MSTEAMS_INGRESS_COMPLETED_MAX_ENTRIES,
+				failedTtlMs: MSTEAMS_INGRESS_TOMBSTONE_TTL_MS,
+				failedMaxEntries: MSTEAMS_INGRESS_FAILED_MAX_ENTRIES
+			});
+			const receivedAt = Date.now();
+			const installedLiveContext = Boolean(liveContext) && !liveContexts.has(facts.eventId);
+			if (liveContext && installedLiveContext) liveContexts.set(facts.eventId, liveContext);
+			const uninstallLiveContext = () => {
+				if (installedLiveContext && liveContexts.get(facts.eventId) === liveContext) liveContexts.delete(facts.eventId);
+			};
+			let result;
+			try {
+				result = await queue.enqueue(facts.eventId, {
+					version: MSTEAMS_INGRESS_VERSION,
+					receivedAt,
+					rawActivity: JSON.stringify(activity)
+				}, {
+					receivedAt,
+					laneKey: facts.laneKey
+				});
+			} catch (error) {
+				uninstallLiveContext();
+				throw error;
+			}
+			if (!(result.kind === "accepted" || result.kind === "pending")) uninstallLiveContext();
+			requestDrain();
+		},
+		start: () => {
+			if (running || stopped) return;
+			running = true;
+			requestDrain();
+			drainTimer = setInterval(requestDrain, MSTEAMS_INGRESS_DRAIN_INTERVAL_MS);
+			drainTimer.unref?.();
+		},
+		stop: async () => {
+			if (stopped) return;
+			stopped = true;
+			running = false;
+			if (drainTimer) {
+				clearInterval(drainTimer);
+				drainTimer = void 0;
+			}
+			await drainTask;
+			await Promise.allSettled(activeDeliveries);
+			await drain.waitForIdle();
+			shutdown.abort();
+			drain.dispose();
+			liveContexts.clear();
+		}
+	};
+}
+//#endregion
 //#region extensions/msteams/src/webhook-timeouts.ts
 const MSTEAMS_WEBHOOK_INACTIVITY_TIMEOUT_MS = 3e4;
 const MSTEAMS_WEBHOOK_REQUEST_TIMEOUT_MS = 3e4;
@@ -3548,6 +3628,15 @@ async function monitorMSTeamsProvider(opts) {
 		log
 	};
 	registerMSTeamsHandlers(handler, handlerDeps);
+	const ingress = createMSTeamsIngress({
+		accountId: appId,
+		runtime,
+		dispatch: async (activity, lifecycle, liveContext) => {
+			if (liveContext) liveContext.activity = activity;
+			const context = liveContext ?? createMSTeamsReplayContext(activity, app, require_resolve_allowlist.resolveMSTeamsSdkCloudOptions(msteamsCfg));
+			return await handler.run(context, lifecycle);
+		}
+	});
 	app.on("card.action", async (ctx) => {
 		const adaptedCtx = adaptSdkContext(ctx, app);
 		try {
@@ -3624,9 +3713,7 @@ async function monitorMSTeamsProvider(opts) {
 					};
 				}
 			}
-			handler.run(adaptedCtx).catch((err) => {
-				log.error("msteams card.action dispatch failed", { error: require_setup_surface.formatUnknownError(err) });
-			});
+			await ingress.accept(activity, adaptedCtx);
 			return {
 				statusCode: 200,
 				type: "application/vnd.microsoft.activity.message",
@@ -3708,24 +3795,30 @@ async function monitorMSTeamsProvider(opts) {
 		if (!await runMSTeamsFeedbackInvokeHandler(adaptSdkContext(ctx, app), handlerDeps)) await ctx.next?.call(ctx);
 	});
 	app.on("activity", async (ctx) => {
+		const adaptedCtx = adaptSdkContext(ctx, app);
+		const activity = adaptedCtx.activity;
+		if (activity?.type === "invoke") {
+			if (activity?.name === "adaptiveCard/action") return;
+			if (activity?.name === "fileConsent/invoke") return;
+			if (activity?.name === "signin/tokenExchange" || activity?.name === "signin/verifyState") return;
+		}
+		if (activity?.type === "message") {
+			await ingress.accept(activity, adaptedCtx);
+			return;
+		}
 		try {
-			const adaptedCtx = adaptSdkContext(ctx, app);
-			const activity = adaptedCtx.activity;
-			if (activity?.type === "invoke") {
-				if (activity?.name === "adaptiveCard/action") return;
-				if (activity?.name === "fileConsent/invoke") return;
-				if (activity?.name === "signin/tokenExchange" || activity?.name === "signin/verifyState") return;
-			}
 			await handler.run(adaptedCtx);
 		} catch (err) {
-			log.error("msteams webhook failed", { error: require_setup_surface.formatUnknownError(err) });
+			log.error("msteams non-turn activity failed", { error: require_setup_surface.formatUnknownError(err) });
 		}
 	});
 	await app.initialize();
+	ingress.start();
 	const httpServer = await new Promise((resolve, reject) => {
 		const server = expressApp.listen(port, (err) => err ? reject(err) : resolve(server));
-	}).catch((err) => {
+	}).catch(async (err) => {
 		log.error("msteams server error", { error: require_setup_surface.formatUnknownError(err) });
+		await ingress.stop();
 		throw err;
 	});
 	log.info(`msteams provider started on port ${port}`);
@@ -3735,12 +3828,13 @@ async function monitorMSTeamsProvider(opts) {
 	});
 	const shutdown = async () => {
 		log.info("shutting down msteams provider");
-		return new Promise((resolve) => {
+		await new Promise((resolve) => {
 			httpServer.close((err) => {
 				if (err) log.debug?.("msteams server close error", { error: require_setup_surface.formatUnknownError(err) });
 				resolve();
 			});
 		});
+		await ingress.stop();
 	};
 	await (0, openclaw_plugin_sdk_channel_outbound.keepHttpServerTaskAlive)({
 		server: httpServer,
@@ -3778,11 +3872,14 @@ function buildActivityHandler() {
 			reactionsRemovedHandlers.push(cb);
 			return handler;
 		},
-		async run(context) {
+		async run(context, turnAdoptionLifecycle) {
 			const ctx = context;
 			const activityType = ctx?.activity?.type;
 			const noop = async () => {};
-			if (activityType === "message") for (const h of messageHandlers) await h(context, noop);
+			if (activityType === "message") for (const h of messageHandlers) {
+				const result = await h(context, noop, turnAdoptionLifecycle);
+				if (result) return result;
+			}
 			else if (activityType === "conversationUpdate") for (const h of membersAddedHandlers) await h(context, noop);
 			else if (activityType === "messageReaction") {
 				const activity = ctx?.activity;
@@ -3793,6 +3890,47 @@ function buildActivityHandler() {
 	};
 	return handler;
 }
+function createMSTeamsReplayContext(activity, app, serviceUrlBoundary) {
+	const rawConversationId = activity.conversation?.id ?? "";
+	const conversationId = require_channel.normalizeMSTeamsConversationId(rawConversationId);
+	const conversationType = activity.conversation?.conversationType ?? "personal";
+	const threadActivityId = conversationType.toLowerCase() === "channel" ? require_channel.extractMSTeamsConversationMessageId(rawConversationId) ?? activity.replyToId : void 0;
+	const tenantId = activity.channelData?.tenant?.id ?? activity.conversation?.tenantId;
+	const reference = {
+		activityId: activity.id,
+		user: activity.from,
+		agent: activity.recipient,
+		conversation: {
+			id: conversationId,
+			conversationType,
+			...tenantId ? { tenantId } : {}
+		},
+		channelId: activity.channelId,
+		serviceUrl: activity.serviceUrl,
+		locale: activity.locale,
+		...tenantId ? { tenantId } : {},
+		...activity.from?.aadObjectId ? { aadObjectId: activity.from.aadObjectId } : {}
+	};
+	const proactiveOptions = {
+		...threadActivityId ? { threadActivityId } : {},
+		serviceUrlBoundary
+	};
+	const sendActivity = (outbound) => require_messenger.sendMSTeamsActivityWithReference(app, reference, outbound, proactiveOptions);
+	return {
+		activity,
+		sendActivity,
+		sendActivities: async (activities) => {
+			const results = [];
+			for (const outbound of activities) results.push(await sendActivity(outbound));
+			return results;
+		},
+		updateActivity: async (outbound) => await require_messenger.updateMSTeamsActivityWithReference(app, reference, typeof outbound.id === "string" ? outbound.id : "", outbound, proactiveOptions),
+		deleteActivity: async (activityId) => {
+			await require_messenger.deleteMSTeamsActivityWithReference(app, reference, activityId, proactiveOptions);
+		},
+		getTeamDetails: (teamId) => app.api.teams.getById(teamId)
+	};
+}
 /**
 * Adapt a new @microsoft/teams.apps SDK context to the MSTeamsTurnContext interface
 * our handlers expect. The new SDK uses reply()/send() instead of sendActivity().