@openclaw/line 2026.7.2-beta.1 → 2026.7.2-beta.3

package/dist/{monitor-q3UE2J1g.js → monitor-Bk-lpoOZ.js}

@@ -1,27 +1,30 @@
-import { i as resolveLineAccount, r as resolveDefaultLineAccountId } from "./accounts-DJVOv1JI.js";
-import { f as resolveLineGroupConfigEntry, i as buildLineQuickReplyFallbackText, s as getLineRuntime } from "./reply-payload-transform-BsbwCJGH.js";
-import { A as buildTemplateMessageFromPayload, C as pushMessagesLine, E as replyMessageLine, O as showLoadingAnimation, S as pushMessageLine, T as pushTextMessageWithQuickReplies, _ as getUserDisplayName, c as processLineMessage, d as createFlexMessage, f as createImageMessage, h as createTextMessageWithQuickReplies, m as createQuickReplyItems, p as createLocationMessage } from "./markdown-to-line-CixmAKiG.js";
+import { i as resolveLineAccount, r as resolveDefaultLineAccountId } from "./accounts-BUBOoW5Q.js";
+import { a as buildLineMediaMessage, i as buildLineQuickReplyFallbackText, l as getLineRuntime, m as resolveLineGroupConfigEntry, o as hasLineSpecificMediaOptions } from "./reply-payload-transform-r9sa-TYT.js";
+import { A as buildTemplateMessageFromPayload, C as pushMessagesLine, E as replyMessageLine, O as showLoadingAnimation, S as pushMessageLine, T as pushTextMessageWithQuickReplies, _ as getUserDisplayName, c as processLineMessage, d as createFlexMessage, h as createTextMessageWithQuickReplies, m as createQuickReplyItems, p as createLocationMessage } from "./markdown-to-line-D1vapcdP.js";
 import { createChannelPairingChallengeIssuer } from "openclaw/plugin-sdk/channel-pairing";
 import { normalizeOptionalString, normalizeStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { createMessageReceiveContext } from "openclaw/plugin-sdk/channel-outbound";
+import { DEFAULT_INGRESS_ADOPTION_STALL_MS, DEFAULT_INGRESS_RETRY_MAX_ATTEMPTS, bindIngressLifecycleToReplyOptions, createChannelIngressDrain } from "openclaw/plugin-sdk/channel-outbound";
 import { resolveSendableOutboundReplyParts } from "openclaw/plugin-sdk/reply-payload";
+import { sanitizeAssistantVisibleText } from "openclaw/plugin-sdk/text-chunking";
 import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 import { expectDefined } from "openclaw/plugin-sdk/expect-runtime";
 import { firstDefined } from "openclaw/plugin-sdk/allow-from";
-import { messagingApi } from "@line/bot-sdk";
+import { Readable } from "node:stream";
+import { finished } from "node:stream/promises";
+import { setTimeout as setTimeout$1 } from "node:timers/promises";
 import { saveMediaStream } from "openclaw/plugin-sdk/media-store";
 import { createNonExitingRuntime, danger, logVerbose, shouldLogVerbose, waitForAbortSignal } from "openclaw/plugin-sdk/runtime-env";
+import { fetchWithRuntimeDispatcherOrMockedGlobal } from "openclaw/plugin-sdk/runtime-fetch";
 import { recordChannelActivity } from "openclaw/plugin-sdk/channel-activity-runtime";
 import { buildMentionRegexes, formatInboundEnvelope, formatInboundMediaUnavailableText, formatLocationText, hasFinalInboundReplyDispatch, matchesMentionPatterns, resolveInboundSessionEnvelopeContext, toLocationContext } from "openclaw/plugin-sdk/channel-inbound";
 import { chunkMarkdownText } from "openclaw/plugin-sdk/reply-runtime";
 import { isRequestBodyLimitError, normalizePluginHttpPath, normalizeWebhookPath, registerWebhookTargetWithPluginRoute, requestBodyErrorToText, resolveSingleWebhookTarget } from "openclaw/plugin-sdk/webhook-ingress";
-import { beginWebhookRequestPipelineOrReject, createWebhookInFlightLimiter, isRequestBodyLimitError as isRequestBodyLimitError$1, readRequestBodyWithLimit, requestBodyErrorToText as requestBodyErrorToText$1 } from "openclaw/plugin-sdk/webhook-request-guards";
+import { beginWebhookRequestPipelineOrReject, createWebhookInFlightLimiter, isRequestBodyLimitError as isRequestBodyLimitError$1, readRequestBodyWithLimit, requestBodyErrorToText as requestBodyErrorToText$1, runDetachedWebhookWork } from "openclaw/plugin-sdk/webhook-request-guards";
 import { DEFAULT_GROUP_HISTORY_LIMIT, createChannelHistoryWindow } from "openclaw/plugin-sdk/reply-history";
 import { getRuntimeConfig } from "openclaw/plugin-sdk/runtime-config-snapshot";
 import { resolveStableChannelMessageIngress } from "openclaw/plugin-sdk/channel-ingress-runtime";
-import { shouldComputeCommandAuthorized } from "openclaw/plugin-sdk/command-auth-native";
+import { hasControlCommand } from "openclaw/plugin-sdk/command-auth-native";
 import { ensureConfiguredBindingRouteReady, readChannelAllowFromStore, resolveConfiguredBindingRoute, resolvePairingIdLabel, resolvePinnedMainDmOwnerFromAllowlist, resolveRuntimeConversationBindingRoute, upsertChannelPairingRequest } from "openclaw/plugin-sdk/conversation-runtime";
-import { createClaimableDedupe } from "openclaw/plugin-sdk/persistent-dedupe";
 import { resolveAgentRoute, resolveInboundLastRouteSessionKey } from "openclaw/plugin-sdk/routing";
 import { resolveAllowlistProviderRuntimeGroupPolicy, resolveDefaultGroupPolicy, warnMissingProviderGroupPolicyFallbackOnce } from "openclaw/plugin-sdk/runtime-group-policy";
 import { finalizeInboundContext } from "openclaw/plugin-sdk/reply-dispatch-runtime";
@@ -44,8 +47,51 @@ const normalizeAllowFrom = (list) => {
 };
 //#endregion
 //#region extensions/line/src/download.ts
+const CONTENT_READY_MAX_ATTEMPTS = 6;
+const CONTENT_READY_BASE_DELAY_MS = 500;
+const CONTENT_READY_MAX_DELAY_MS = 4e3;
+const CONTENT_READY_TIMEOUT_MS = 15e3;
+const LINE_CONTENT_BASE_URL = "https://api-data.line.me/v2/bot/message";
+function contentBackoffDelayMs(attempt) {
+	return Math.min(CONTENT_READY_BASE_DELAY_MS * 2 ** attempt, CONTENT_READY_MAX_DELAY_MS);
+}
+async function fetchLineContentWhenReady(messageId, channelAccessToken) {
+	const controller = new AbortController();
+	const deadline = setTimeout(() => controller.abort(), CONTENT_READY_TIMEOUT_MS);
+	deadline.unref();
+	try {
+		for (let attempt = 0; attempt < CONTENT_READY_MAX_ATTEMPTS; attempt++) {
+			const response = await fetchWithRuntimeDispatcherOrMockedGlobal(`${LINE_CONTENT_BASE_URL}/${encodeURIComponent(messageId)}/content`, {
+				headers: { Authorization: `Bearer ${channelAccessToken}` },
+				redirect: "error",
+				signal: controller.signal
+			});
+			if (response.status === 200) {
+				if (!response.body) throw new Error(`LINE media response for message ${messageId} had no body`);
+				return Readable.fromWeb(response.body);
+			}
+			await response.body?.cancel();
+			if (response.status !== 202) throw new Error(`LINE media download failed for message ${messageId} (HTTP ${response.status})`);
+			if (attempt < CONTENT_READY_MAX_ATTEMPTS - 1) await setTimeout$1(contentBackoffDelayMs(attempt), void 0, { signal: controller.signal });
+		}
+	} catch (err) {
+		if (controller.signal.aborted) throw new Error(`LINE media for message ${messageId} did not become ready within ${CONTENT_READY_TIMEOUT_MS / 1e3} seconds`, { cause: err });
+		throw err;
+	} finally {
+		clearTimeout(deadline);
+	}
+	throw new Error(`LINE media for message ${messageId} was still preparing (HTTP 202) after ${CONTENT_READY_MAX_ATTEMPTS} attempts`);
+}
 async function downloadLineMedia(messageId, channelAccessToken, maxBytes = 10 * 1024 * 1024, options) {
-	const saved = await saveMediaStream(await new messagingApi.MessagingApiBlobClient({ channelAccessToken }).getMessageContent(messageId), void 0, "inbound", maxBytes, options?.originalFilename);
+	const content = await fetchLineContentWhenReady(messageId, channelAccessToken);
+	let saved;
+	try {
+		saved = await saveMediaStream(content, void 0, "inbound", maxBytes, options?.originalFilename);
+	} catch (err) {
+		content.destroy();
+		await finished(content).catch(() => void 0);
+		throw err;
+	}
 	logVerbose(`line: persisted media ${messageId} to ${saved.path} (${saved.size} bytes)`);
 	return {
 		path: saved.path,
@@ -55,15 +101,19 @@ async function downloadLineMedia(messageId, channelAccessToken, maxBytes = 10 *
 }
 //#endregion
 //#region extensions/line/src/auto-reply-delivery.ts
+function toLineDeliveryError(error) {
+	return error instanceof Error ? error : new Error("LINE rich or media message send failed", { cause: error });
+}
 function markLineVisibleDeliveryError(error) {
-	if (error instanceof Error && Object.isExtensible(error)) {
-		Object.assign(error, {
+	const deliveryError = toLineDeliveryError(error);
+	if (Object.isExtensible(deliveryError)) {
+		Object.assign(deliveryError, {
 			sentBeforeError: true,
 			visibleReplySent: true
 		});
-		return error;
+		return deliveryError;
 	}
-	const visibleError = new Error("LINE rich or media message send failed", { cause: error });
+	const visibleError = new Error("LINE rich or media message send failed", { cause: deliveryError });
 	Object.assign(visibleError, {
 		sentBeforeError: true,
 		visibleReplySent: true
@@ -73,12 +123,26 @@ function markLineVisibleDeliveryError(error) {
 async function deliverLineAutoReply(params) {
 	const { payload, lineData, replyToken, accountId, to, textLimit, deps } = params;
 	let replyTokenUsed = params.replyTokenUsed;
+	let visibleReplySent = false;
+	const sendVisible = async (send) => {
+		try {
+			const result = await send();
+			visibleReplySent = true;
+			return result;
+		} catch (error) {
+			if (visibleReplySent) throw markLineVisibleDeliveryError(error);
+			throw error;
+		}
+	};
+	const replyVisible = (...args) => sendVisible(() => deps.replyMessageLine(...args));
+	const pushTextVisible = (...args) => sendVisible(() => deps.pushMessageLine(...args));
+	const pushQuickRepliesVisible = (...args) => sendVisible(() => deps.pushTextMessageWithQuickReplies(...args));
 	const pushLineMessages = async (messages) => {
 		if (messages.length === 0) return;
-		for (let i = 0; i < messages.length; i += 5) await deps.pushMessagesLine(to, messages.slice(i, i + 5), {
+		for (let i = 0; i < messages.length; i += 5) await sendVisible(() => deps.pushMessagesLine(to, messages.slice(i, i + 5), {
 			cfg: params.cfg,
 			accountId
-		});
+		}));
 	};
 	const sendLineMessages = async (messages, allowReplyToken) => {
 		if (messages.length === 0) return;
@@ -86,7 +150,7 @@ async function deliverLineAutoReply(params) {
 		if (allowReplyToken && replyToken && !replyTokenUsed) {
 			const replyBatch = remaining.slice(0, 5);
 			try {
-				await deps.replyMessageLine(replyToken, replyBatch, {
+				await replyVisible(replyToken, replyBatch, {
 					cfg: params.cfg,
 					accountId
 				});
@@ -107,21 +171,38 @@ async function deliverLineAutoReply(params) {
 		if (templateMsg) richMessages.push(templateMsg);
 	}
 	if (lineData.location) richMessages.push(deps.createLocationMessage(lineData.location));
-	const processed = payload.text ? deps.processLineMessage(payload.text) : {
+	const visibleText = payload.text ? sanitizeAssistantVisibleText(payload.text) : "";
+	const processed = visibleText ? deps.processLineMessage(visibleText) : {
 		text: "",
 		flexMessages: []
 	};
 	for (const flexMsg of processed.flexMessages) richMessages.push(deps.createFlexMessage(truncateUtf16Safe(flexMsg.altText, 400), flexMsg.contents));
 	const chunks = processed.text ? deps.chunkMarkdownText(processed.text, textLimit) : [];
-	const mediaMessages = resolveSendableOutboundReplyParts(payload).mediaUrls.map((url) => url?.trim()).filter((url) => Boolean(url)).map((url) => deps.createImageMessage(url));
+	const mediaUrls = resolveSendableOutboundReplyParts(payload).mediaUrls;
+	const mediaOpts = {
+		mediaKind: hasLineSpecificMediaOptions(lineData) ? lineData.mediaKind : "image",
+		previewImageUrl: lineData.previewImageUrl,
+		durationMs: lineData.durationMs,
+		trackingId: lineData.trackingId
+	};
+	const mediaMessages = [];
+	let richMediaError;
+	for (const rawUrl of mediaUrls) {
+		const url = rawUrl?.trim();
+		if (!url) continue;
+		try {
+			mediaMessages.push(await deps.buildMediaMessage(url, mediaOpts, to));
+		} catch (err) {
+			richMediaError ??= err;
+		}
+	}
 	if (chunks.length > 0) {
 		const hasRichOrMedia = richMessages.length > 0 || mediaMessages.length > 0;
 		const sendRichBeforeText = hasQuickReplies && hasRichOrMedia;
-		let richMediaError;
 		if (sendRichBeforeText) try {
 			await sendLineMessages([...richMessages, ...mediaMessages], false);
 		} catch (err) {
-			richMediaError = err;
+			richMediaError ??= err;
 		}
 		const { replyTokenUsed: nextReplyTokenUsed } = await deps.sendLineReplyChunks({
 			to,
@@ -131,23 +212,19 @@ async function deliverLineAutoReply(params) {
 			replyTokenUsed,
 			cfg: params.cfg,
 			accountId,
-			replyMessageLine: deps.replyMessageLine,
-			pushMessageLine: deps.pushMessageLine,
-			pushTextMessageWithQuickReplies: deps.pushTextMessageWithQuickReplies,
-			createTextMessageWithQuickReplies: deps.createTextMessageWithQuickReplies
+			replyMessageLine: replyVisible,
+			pushMessageLine: pushTextVisible,
+			pushTextMessageWithQuickReplies: pushQuickRepliesVisible,
+			createTextMessageWithQuickReplies: deps.createTextMessageWithQuickReplies,
+			onReplyError: deps.onReplyError
 		});
 		replyTokenUsed = nextReplyTokenUsed;
 		if (!sendRichBeforeText) try {
 			await sendLineMessages(richMessages, false);
 			if (mediaMessages.length > 0) await sendLineMessages(mediaMessages, false);
 		} catch (err) {
-			richMediaError = err;
+			richMediaError ??= err;
 		}
-		if (richMediaError !== void 0) return {
-			status: "partial",
-			replyTokenUsed,
-			error: markLineVisibleDeliveryError(richMediaError)
-		};
 	} else {
 		const combined = [...richMessages, ...mediaMessages];
 		if (hasQuickReplies && combined.length === 0) {
@@ -159,9 +236,9 @@ async function deliverLineAutoReply(params) {
 				replyTokenUsed,
 				cfg: params.cfg,
 				accountId,
-				replyMessageLine: deps.replyMessageLine,
-				pushMessageLine: deps.pushMessageLine,
-				pushTextMessageWithQuickReplies: deps.pushTextMessageWithQuickReplies,
+				replyMessageLine: replyVisible,
+				pushMessageLine: pushTextVisible,
+				pushTextMessageWithQuickReplies: pushQuickRepliesVisible,
 				createTextMessageWithQuickReplies: deps.createTextMessageWithQuickReplies,
 				onReplyError: deps.onReplyError
 			});
@@ -178,9 +255,19 @@ async function deliverLineAutoReply(params) {
 			await sendLineMessages(combined, true);
 		}
 	}
+	if (richMediaError !== void 0) {
+		if (!visibleReplySent) throw toLineDeliveryError(richMediaError);
+		return {
+			status: "partial",
+			replyTokenUsed,
+			visibleReplySent: true,
+			error: markLineVisibleDeliveryError(richMediaError)
+		};
+	}
 	return {
 		status: "delivered",
-		replyTokenUsed
+		replyTokenUsed,
+		visibleReplySent
 	};
 }
 //#endregion
@@ -370,6 +457,7 @@ async function finalizeLineInboundContext(params) {
 		From: fromAddress,
 		To: toAddress,
 		SessionKey: params.route.sessionKey,
+		DmScope: params.route.dmScope,
 		AccountId: params.route.accountId,
 		ChatType: params.source.isGroup ? "group" : "direct",
 		ConversationLabel: conversationLabel,
@@ -436,7 +524,7 @@ async function finalizeLineInboundContext(params) {
 	};
 }
 async function buildLineMessageContext(params) {
-	const { event, allMedia, mediaUnavailable, cfg, account, commandAuthorized, groupHistories, historyLimit } = params;
+	const { event, allMedia, mediaUnavailable, cfg, account, commandAuthorized, inboundHistory } = params;
 	const source = event.source;
 	const { userId, groupId, roomId, isGroup, peerId, route } = await resolveLineInboundRoute({
 		source,
@@ -466,11 +554,6 @@ async function buildLineMessageContext(params) {
 			address: loc.address
 		});
 	}
-	const historyKey = isGroup ? peerId : void 0;
-	const inboundHistory = historyKey && groupHistories && (historyLimit ?? 0) > 0 ? createChannelHistoryWindow({ historyMap: groupHistories }).buildInboundHistory({
-		historyKey,
-		limit: historyLimit ?? 0
-	}) : void 0;
 	const finalized = await finalizeLineInboundContext({
 		cfg,
 		account,
@@ -571,6 +654,41 @@ async function buildLinePostbackContext(params) {
 	};
 }
 //#endregion
+//#region extensions/line/src/group-history.ts
+const reservedEntries = /* @__PURE__ */ new WeakSet();
+function reserveLineGroupHistory(historyMap, historyKey, limit) {
+	if (!historyMap || !historyKey || limit <= 0) return {
+		commit: () => {},
+		release: () => {}
+	};
+	const consumedEntries = (historyMap.get(historyKey) ?? []).filter((entry) => !reservedEntries.has(entry));
+	for (const entry of consumedEntries) reservedEntries.add(entry);
+	const inboundHistory = createChannelHistoryWindow({ historyMap: /* @__PURE__ */ new Map([[historyKey, consumedEntries]]) }).buildInboundHistory({
+		historyKey,
+		limit
+	});
+	let settled = false;
+	const settle = () => {
+		if (settled) return false;
+		settled = true;
+		for (const entry of consumedEntries) reservedEntries.delete(entry);
+		return true;
+	};
+	return {
+		inboundHistory,
+		commit: () => {
+			if (!settle() || consumedEntries.length === 0) return;
+			const consumed = new Set(consumedEntries);
+			const kept = (historyMap.get(historyKey) ?? []).filter((entry) => !consumed.has(entry));
+			if (kept.length > 0) historyMap.set(historyKey, kept);
+			else historyMap.delete(historyKey);
+		},
+		release: () => {
+			settle();
+		}
+	};
+}
+//#endregion
 //#region extensions/line/src/bot-handlers.ts
 const LINE_DOWNLOADABLE_MESSAGE_TYPES = /* @__PURE__ */ new Set([
 	"image",
@@ -581,57 +699,9 @@ const LINE_DOWNLOADABLE_MESSAGE_TYPES = /* @__PURE__ */ new Set([
 function isDownloadableLineMessageType(messageType) {
 	return LINE_DOWNLOADABLE_MESSAGE_TYPES.has(messageType);
 }
-const LINE_WEBHOOK_REPLAY_WINDOW_MS = 600 * 1e3;
-const LINE_WEBHOOK_REPLAY_MAX_ENTRIES = 4096;
 function normalizeLineIngressEntry(value) {
 	return normalizeLineAllowEntry(value) || null;
 }
-function createLineWebhookReplayCache() {
-	return createClaimableDedupe({
-		ttlMs: LINE_WEBHOOK_REPLAY_WINDOW_MS,
-		memoryMaxSize: LINE_WEBHOOK_REPLAY_MAX_ENTRIES
-	});
-}
-function buildLineWebhookReplayKey(event, accountId) {
-	if (event.type === "message") {
-		const messageId = event.message?.id?.trim();
-		if (messageId) return {
-			key: `${accountId}|message:${messageId}`,
-			eventId: `message:${messageId}`
-		};
-	}
-	const eventId = event.webhookEventId?.trim();
-	if (!eventId) return null;
-	const source = event.source;
-	const sourceId = source?.type === "group" ? `group:${source.groupId ?? ""}` : source?.type === "room" ? `room:${source.roomId ?? ""}` : `user:${source?.userId ?? ""}`;
-	return {
-		key: `${accountId}|${event.type}|${sourceId}|${eventId}`,
-		eventId: `event:${eventId}`
-	};
-}
-function getLineReplayCandidate(event, context) {
-	const replay = buildLineWebhookReplayKey(event, context.account.accountId);
-	const cache = context.replayCache;
-	if (!replay || !cache) return null;
-	return {
-		key: replay.key,
-		eventId: replay.eventId,
-		cache
-	};
-}
-async function claimLineReplayEvent(candidate) {
-	const claim = await candidate.cache.claim(candidate.key);
-	if (claim.kind === "claimed") return { skip: false };
-	if (claim.kind === "inflight") {
-		logVerbose(`line: skipped in-flight replayed webhook event ${candidate.eventId}`);
-		return {
-			skip: true,
-			inFlightResult: claim.pending.then(() => void 0)
-		};
-	}
-	logVerbose(`line: skipped replayed webhook event ${candidate.eventId}`);
-	return { skip: true };
-}
 function resolveLineGroupConfig(params) {
 	return resolveLineGroupConfigEntry(params.config.groups, {
 		groupId: params.groupId,
@@ -771,7 +841,7 @@ async function shouldProcessLineEvent(event, context) {
 		allowFrom: normalizeStringEntries(account.config.allowFrom),
 		groupAllowFrom,
 		command: {
-			hasControlCommand: shouldComputeCommandAuthorized(rawText, cfg),
+			hasControlCommand: hasControlCommand(rawText, cfg),
 			groupOwnerAllowFrom: "none"
 		}
 	});
@@ -869,42 +939,41 @@ async function handleMessageEvent(event, context) {
 		});
 		return;
 	}
-	const allMedia = [];
-	let mediaUnavailable = false;
-	if (isDownloadableLineMessageType(message.type)) try {
-		const originalFilename = message.type === "file" ? normalizeOptionalString(message.fileName) : void 0;
-		const media = await downloadLineMedia(message.id, account.channelAccessToken, mediaMaxBytes, { originalFilename });
-		allMedia.push({
-			path: media.path,
-			contentType: media.contentType
-		});
-	} catch (err) {
-		mediaUnavailable = true;
-		const errMsg = String(err);
-		if (errMsg.includes("exceeds") && errMsg.includes("limit")) logVerbose(`line: media exceeds size limit for message ${message.id}`);
-		else runtime.error?.(danger(`line: failed to download media: ${errMsg}`));
-	}
-	const messageContext = await buildLineMessageContext({
-		event,
-		allMedia,
-		mediaUnavailable,
-		cfg,
-		account,
-		commandAuthorized: decision.commandAccess.authorized,
-		groupHistories: context.groupHistories,
-		historyLimit: context.historyLimit ?? DEFAULT_GROUP_HISTORY_LIMIT
-	});
-	if (!messageContext) {
-		logVerbose("line: skipping empty message");
-		return;
-	}
-	await processMessage(messageContext);
-	if (isGroup && context.groupHistories) {
-		const historyKey = groupId ?? roomId;
-		if (historyKey && context.groupHistories.has(historyKey)) createChannelHistoryWindow({ historyMap: context.groupHistories }).clear({
-			historyKey,
-			limit: context.historyLimit ?? DEFAULT_GROUP_HISTORY_LIMIT
+	const groupHistoryKey = isGroup ? groupId ?? roomId : void 0;
+	const historyReservation = reserveLineGroupHistory(context.groupHistories, groupHistoryKey, context.historyLimit ?? DEFAULT_GROUP_HISTORY_LIMIT);
+	try {
+		const allMedia = [];
+		let mediaUnavailable = false;
+		if (isDownloadableLineMessageType(message.type)) try {
+			const originalFilename = message.type === "file" ? normalizeOptionalString(message.fileName) : void 0;
+			const media = await downloadLineMedia(message.id, account.channelAccessToken, mediaMaxBytes, { originalFilename });
+			allMedia.push({
+				path: media.path,
+				contentType: media.contentType
+			});
+		} catch (err) {
+			mediaUnavailable = true;
+			const errMsg = String(err);
+			if (errMsg.includes("exceeds") && errMsg.includes("limit")) logVerbose(`line: media exceeds size limit for message ${message.id}`);
+			else runtime.error?.(danger(`line: failed to download media: ${errMsg}`));
+		}
+		const messageContext = await buildLineMessageContext({
+			event,
+			allMedia,
+			mediaUnavailable,
+			cfg,
+			account,
+			commandAuthorized: decision.commandAccess.authorized,
+			inboundHistory: historyReservation.inboundHistory
 		});
+		if (!messageContext) {
+			logVerbose("line: skipping empty message");
+			return;
+		}
+		await processMessage(messageContext, context.turnAdoptionLifecycle ? { turnAdoptionLifecycle: context.turnAdoptionLifecycle } : {});
+		historyReservation.commit();
+	} finally {
+		historyReservation.release();
 	}
 }
 async function handleFollowEvent(event, _context) {
@@ -935,53 +1004,41 @@ async function handlePostbackEvent(event, context) {
 		commandAuthorized: decision.commandAccess.authorized
 	});
 	if (!postbackContext) return;
-	await context.processMessage(postbackContext);
+	await context.processMessage(postbackContext, context.turnAdoptionLifecycle ? { turnAdoptionLifecycle: context.turnAdoptionLifecycle } : {});
 }
 async function handleLineWebhookEvents(events, context) {
 	let firstError;
-	for (const event of events) {
-		const replayCandidate = getLineReplayCandidate(event, context);
-		const replaySkip = replayCandidate ? await claimLineReplayEvent(replayCandidate) : null;
-		if (replaySkip?.skip) {
-			if (replaySkip.inFlightResult) try {
-				await replaySkip.inFlightResult;
-			} catch (err) {
-				context.runtime.error?.(danger(`line: replayed in-flight event failed: ${String(err)}`));
-				firstError ??= err;
-			}
-			continue;
-		}
-		try {
-			switch (event.type) {
-				case "message":
-					await handleMessageEvent(event, context);
-					break;
-				case "follow":
-					await handleFollowEvent(event, context);
-					break;
-				case "unfollow":
-					await handleUnfollowEvent(event, context);
-					break;
-				case "join":
-					await handleJoinEvent(event, context);
-					break;
-				case "leave":
-					await handleLeaveEvent(event, context);
-					break;
-				case "postback":
-					await handlePostbackEvent(event, context);
-					break;
-				default: logVerbose(`line: unhandled event type: ${event.type}`);
-			}
-			if (replayCandidate) await replayCandidate.cache.commit(replayCandidate.key);
-		} catch (err) {
-			if (replayCandidate) await replayCandidate.cache.commit(replayCandidate.key);
-			context.runtime.error?.(danger(`line: event handler failed: ${String(err)}`));
-			firstError ??= err;
-		}
+	for (const event of events) try {
+		await handleLineWebhookEvent(event, context);
+	} catch (err) {
+		context.runtime.error?.(danger(`line: event handler failed: ${String(err)}`));
+		firstError ??= err;
 	}
 	if (firstError) throw toLintErrorObject(firstError, "Non-Error thrown");
 }
+async function handleLineWebhookEvent(event, context) {
+	switch (event.type) {
+		case "message":
+			await handleMessageEvent(event, context);
+			break;
+		case "follow":
+			await handleFollowEvent(event, context);
+			break;
+		case "unfollow":
+			await handleUnfollowEvent(event, context);
+			break;
+		case "join":
+			await handleJoinEvent(event, context);
+			break;
+		case "leave":
+			await handleLeaveEvent(event, context);
+			break;
+		case "postback":
+			await handlePostbackEvent(event, context);
+			break;
+		default: logVerbose(`line: unhandled event type: ${event.type}`);
+	}
+}
 function toLintErrorObject(value, fallbackMessage) {
 	if (value instanceof Error) return value;
 	if (typeof value === "string") return new Error(value);
@@ -990,6 +1047,221 @@ function toLintErrorObject(value, fallbackMessage) {
 	return error;
 }
 //#endregion
+//#region extensions/line/src/webhook-spool.ts
+const LINE_WEBHOOK_SPOOL_VERSION = 1;
+const LINE_WEBHOOK_DRAIN_INTERVAL_MS = 500;
+const LINE_WEBHOOK_MAX_CONCURRENT_DELIVERIES = 8;
+const LINE_WEBHOOK_DRAIN_SCAN_LIMIT = 100;
+const LINE_WEBHOOK_TOMBSTONE_TTL_MS = 720 * 60 * 6e4;
+const LINE_WEBHOOK_TOMBSTONE_MAX_ENTRIES = 4096;
+var LineWebhookPayloadError = class extends Error {
+	constructor(message, options) {
+		super(message, options);
+		this.name = "LineWebhookPayloadError";
+	}
+};
+var LineWebhookTerminalDeliveryError = class extends Error {
+	constructor(message, options) {
+		super(message, options);
+		this.reason = "delivery-side-effects-committed";
+		this.name = "LineWebhookTerminalDeliveryError";
+	}
+};
+function nonEmptyString(value) {
+	return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+/** Message ids preserve the shipped replay-guard keyspace; other events use LINE's delivery id. */
+function eventIdFor(event) {
+	if (!event || typeof event !== "object") throw new LineWebhookPayloadError("LINE webhook event must be an object.");
+	const candidate = event;
+	if (candidate.type === "message") {
+		const messageId = nonEmptyString(candidate.message?.id);
+		if (messageId) return `message:${messageId}`;
+	}
+	const webhookEventId = nonEmptyString(candidate.webhookEventId);
+	if (webhookEventId) return `event:${webhookEventId}`;
+	throw new LineWebhookPayloadError("LINE webhook event is missing a stable delivery id.");
+}
+function laneKeyFor(event, eventId) {
+	if (!event || typeof event !== "object") return eventId;
+	const source = event.source;
+	if (source?.type === "group") {
+		const groupId = nonEmptyString(source.groupId);
+		if (groupId) return `group:${groupId}`;
+	}
+	if (source?.type === "room") {
+		const roomId = nonEmptyString(source.roomId);
+		if (roomId) return `room:${roomId}`;
+	}
+	if (source?.type === "user") {
+		const userId = nonEmptyString(source.userId);
+		if (userId) return `user:${userId}`;
+	}
+	return eventId;
+}
+function parseClaimedEvent(payload, claimedId) {
+	if (payload.version !== LINE_WEBHOOK_SPOOL_VERSION || typeof payload.rawEvent !== "string" || typeof payload.destination !== "string") throw new LineWebhookPayloadError("LINE webhook spool payload is invalid.");
+	let event;
+	try {
+		event = JSON.parse(payload.rawEvent);
+	} catch (error) {
+		throw new LineWebhookPayloadError("LINE webhook event JSON is invalid.", { cause: error });
+	}
+	if (eventIdFor(event) !== claimedId) throw new LineWebhookPayloadError("LINE webhook event id changed after durable admission.");
+	return event;
+}
+function errorText(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+function isLineAuthenticationFailure(error) {
+	if (!error || typeof error !== "object") return false;
+	const status = error.status;
+	return status === 401 || status === 403;
+}
+function createLineWebhookSpool(options) {
+	const queue = options.queue ?? getLineRuntime().state.openChannelIngressQueue({ accountId: options.accountId });
+	const shutdown = new AbortController();
+	const activeDeliveries = /* @__PURE__ */ new Set();
+	const deferredClaims = /* @__PURE__ */ new Map();
+	const drain = createChannelIngressDrain({
+		queue,
+		abortSignal: shutdown.signal,
+		adoptionStallTimeoutMs: DEFAULT_INGRESS_ADOPTION_STALL_MS,
+		orderBy: "received",
+		scanLimit: LINE_WEBHOOK_DRAIN_SCAN_LIMIT,
+		startLimit: LINE_WEBHOOK_MAX_CONCURRENT_DELIVERIES,
+		retryPolicy: {
+			maxAttempts: DEFAULT_INGRESS_RETRY_MAX_ATTEMPTS,
+			deadLetterMinAgeMs: 0
+		},
+		resolveNonRetryableFailure: (error) => {
+			if (error instanceof LineWebhookPayloadError) return {
+				reason: "invalid-event",
+				message: error.message
+			};
+			if (error instanceof LineWebhookTerminalDeliveryError) return {
+				reason: error.reason,
+				message: error.message
+			};
+			if (isLineAuthenticationFailure(error)) return {
+				reason: "authentication-failed",
+				message: errorText(error)
+			};
+			return null;
+		},
+		onLog: (message) => options.runtime.error?.(danger(`line: ${message}`)),
+		dispatchClaimedEvent: async (claimed, lifecycle) => {
+			const event = parseClaimedEvent(claimed.payload, claimed.id);
+			const boundLifecycle = bindIngressLifecycleToReplyOptions(lifecycle).turnAdoptionLifecycle;
+			let resolveDeferredClaim;
+			const deferredClaim = new Promise((resolve) => {
+				resolveDeferredClaim = resolve;
+			});
+			let deferredClaimSettled = false;
+			const settleDeferredClaim = () => {
+				if (deferredClaimSettled) return;
+				deferredClaimSettled = true;
+				if (deferredClaims.get(claimed.id) === deferredClaim) deferredClaims.delete(claimed.id);
+				resolveDeferredClaim();
+			};
+			const delivery = options.deliver(event, claimed.payload.destination, { turnAdoptionLifecycle: {
+				...boundLifecycle,
+				onAdopted: async () => {
+					try {
+						await boundLifecycle.onAdopted();
+					} finally {
+						settleDeferredClaim();
+					}
+				},
+				onDeferred: () => {
+					if (!deferredClaimSettled) deferredClaims.set(claimed.id, deferredClaim);
+					boundLifecycle.onDeferred();
+				},
+				onAbandoned: async () => {
+					try {
+						await boundLifecycle.onAbandoned();
+					} finally {
+						settleDeferredClaim();
+					}
+				}
+			} });
+			activeDeliveries.add(delivery);
+			try {
+				await delivery;
+			} finally {
+				activeDeliveries.delete(delivery);
+			}
+		}
+	});
+	let running = false;
+	let drainRequested = false;
+	let drainTask;
+	let drainTimer;
+	const requestDrain = () => {
+		if (!running || shutdown.signal.aborted) return;
+		drainRequested = true;
+		if (drainTask) return;
+		drainTask = runDetachedWebhookWork(async () => {
+			while (drainRequested && !shutdown.signal.aborted) {
+				if (!running) break;
+				drainRequested = false;
+				await drain.drainOnce({ shouldStop: () => !running || shutdown.signal.aborted || activeDeliveries.size >= LINE_WEBHOOK_MAX_CONCURRENT_DELIVERIES });
+			}
+		}).catch((error) => {
+			options.runtime.error?.(danger(`line: webhook spool drain failed: ${errorText(error)}`));
+		}).finally(() => {
+			drainTask = void 0;
+			if (running && drainRequested && !shutdown.signal.aborted) requestDrain();
+		});
+	};
+	return {
+		accept: async (body) => {
+			const events = body.events ?? [];
+			if (events.length === 0) return;
+			await queue.prune({
+				completedTtlMs: LINE_WEBHOOK_TOMBSTONE_TTL_MS,
+				completedMaxEntries: LINE_WEBHOOK_TOMBSTONE_MAX_ENTRIES,
+				failedTtlMs: LINE_WEBHOOK_TOMBSTONE_TTL_MS,
+				failedMaxEntries: LINE_WEBHOOK_TOMBSTONE_MAX_ENTRIES
+			});
+			const receivedAt = Date.now();
+			for (const event of events) {
+				const eventId = eventIdFor(event);
+				await queue.enqueue(eventId, {
+					version: LINE_WEBHOOK_SPOOL_VERSION,
+					rawEvent: JSON.stringify(event),
+					destination: body.destination ?? ""
+				}, {
+					receivedAt,
+					laneKey: laneKeyFor(event, eventId)
+				});
+			}
+			requestDrain();
+		},
+		start: () => {
+			if (running) return;
+			running = true;
+			requestDrain();
+			drainTimer = setInterval(requestDrain, LINE_WEBHOOK_DRAIN_INTERVAL_MS);
+			drainTimer.unref?.();
+		},
+		stop: async () => {
+			if (!running && shutdown.signal.aborted) return;
+			running = false;
+			if (drainTimer) {
+				clearInterval(drainTimer);
+				drainTimer = void 0;
+			}
+			shutdown.abort();
+			await drainTask;
+			await Promise.allSettled(activeDeliveries);
+			await Promise.allSettled(deferredClaims.values());
+			await drain.waitForIdle();
+			drain.dispose();
+		}
+	};
+}
+//#endregion
 //#region extensions/line/src/bot.ts
 function createLineBot(opts) {
 	const runtime = opts.runtime ?? createNonExitingRuntime();
@@ -1002,24 +1274,26 @@ function createLineBot(opts) {
 	const processMessage = opts.onMessage ?? (async () => {
 		logVerbose("line: no message handler configured");
 	});
-	const replayCache = createLineWebhookReplayCache();
 	const groupHistories = /* @__PURE__ */ new Map();
-	const handleWebhook = async (body) => {
-		if (!body.events || body.events.length === 0) return;
-		await handleLineWebhookEvents(body.events, {
+	const spool = createLineWebhookSpool({
+		accountId: account.accountId,
+		runtime,
+		deliver: async (event, _destination, control) => await handleLineWebhookEvents([event], {
 			cfg,
 			account,
 			runtime,
 			mediaMaxBytes,
 			processMessage,
-			replayCache,
+			...control.turnAdoptionLifecycle ? { turnAdoptionLifecycle: control.turnAdoptionLifecycle } : {},
 			groupHistories,
 			historyLimit: cfg.messages?.groupChat?.historyLimit ?? DEFAULT_GROUP_HISTORY_LIMIT
-		});
-	};
+		})
+	});
+	spool.start();
 	return {
-		handleWebhook,
-		account
+		handleWebhook: spool.accept,
+		account,
+		stop: spool.stop
 	};
 }
 //#endregion
@@ -1042,34 +1316,39 @@ async function sendLineReplyChunks(params) {
 	const quickReplies = params.quickReplies?.length ? params.quickReplies : void 0;
 	let replyTokenUsed = Boolean(params.replyTokenUsed);
 	if (params.chunks.length === 0) return { replyTokenUsed };
-	if (params.replyToken && !replyTokenUsed) try {
-		const replyBatch = params.chunks.slice(0, 5);
-		const remaining = params.chunks.slice(replyBatch.length);
-		const replyMessages = replyBatch.map((chunk) => ({
-			type: "text",
-			text: chunk
-		}));
-		if (quickReplies && remaining.length === 0 && replyMessages.length > 0) {
-			const lastIndex = replyMessages.length - 1;
-			replyMessages[lastIndex] = params.createTextMessageWithQuickReplies(expectDefined(replyBatch[lastIndex], "last non-empty LINE reply batch chunk"), quickReplies);
+	if (params.replyToken && !replyTokenUsed) {
+		let replySucceeded = false;
+		try {
+			const replyBatch = params.chunks.slice(0, 5);
+			const remaining = params.chunks.slice(replyBatch.length);
+			const replyMessages = replyBatch.map((chunk) => ({
+				type: "text",
+				text: chunk
+			}));
+			if (quickReplies && remaining.length === 0 && replyMessages.length > 0) {
+				const lastIndex = replyMessages.length - 1;
+				replyMessages[lastIndex] = params.createTextMessageWithQuickReplies(expectDefined(replyBatch[lastIndex], "last non-empty LINE reply batch chunk"), quickReplies);
+			}
+			await params.replyMessageLine(params.replyToken, replyMessages, {
+				cfg: params.cfg,
+				accountId: params.accountId
+			});
+			replyTokenUsed = true;
+			replySucceeded = true;
+			for (const [i, chunk] of remaining.entries()) if (i === remaining.length - 1 && quickReplies) await params.pushTextMessageWithQuickReplies(params.to, chunk, quickReplies, {
+				cfg: params.cfg,
+				accountId: params.accountId
+			});
+			else await params.pushMessageLine(params.to, chunk, {
+				cfg: params.cfg,
+				accountId: params.accountId
+			});
+			return { replyTokenUsed };
+		} catch (err) {
+			if (replySucceeded) throw err;
+			params.onReplyError?.(err);
+			replyTokenUsed = true;
 		}
-		await params.replyMessageLine(params.replyToken, replyMessages, {
-			cfg: params.cfg,
-			accountId: params.accountId
-		});
-		replyTokenUsed = true;
-		for (const [i, chunk] of remaining.entries()) if (i === remaining.length - 1 && quickReplies) await params.pushTextMessageWithQuickReplies(params.to, chunk, quickReplies, {
-			cfg: params.cfg,
-			accountId: params.accountId
-		});
-		else await params.pushMessageLine(params.to, chunk, {
-			cfg: params.cfg,
-			accountId: params.accountId
-		});
-		return { replyTokenUsed };
-	} catch (err) {
-		params.onReplyError?.(err);
-		replyTokenUsed = true;
 	}
 	for (const [i, chunk] of params.chunks.entries()) if (i === params.chunks.length - 1 && quickReplies) await params.pushTextMessageWithQuickReplies(params.to, chunk, quickReplies, {
 		cfg: params.cfg,
@@ -1106,9 +1385,6 @@ async function readLineWebhookRequestBody(req, maxBytes = LINE_WEBHOOK_MAX_BODY_
 		timeoutMs
 	});
 }
-function logLineWebhookDispatchError(runtime, err) {
-	runtime?.error?.(danger(`line webhook dispatch failed: ${String(err)}`));
-}
 function createLineNodeWebhookHandler(params) {
 	const maxBodyBytes = params.maxBodyBytes ?? LINE_WEBHOOK_MAX_BODY_BYTES;
 	const readBody = params.readBody ?? readLineWebhookRequestBody;
@@ -1131,7 +1407,6 @@ function createLineNodeWebhookHandler(params) {
 			res.end(JSON.stringify({ error: "Method Not Allowed" }));
 			return;
 		}
-		let receiveContext;
 		try {
 			const signatureHeader = req.headers["x-line-signature"];
 			const signature = typeof signatureHeader === "string" ? signatureHeader.trim() : Array.isArray(signatureHeader) ? (signatureHeader[0] ?? "").trim() : "";
@@ -1158,24 +1433,14 @@ function createLineNodeWebhookHandler(params) {
 				return;
 			}
 			params.onRequestAuthenticated?.();
-			receiveContext = createMessageReceiveContext({
-				id: `${Date.now()}:line:webhook`,
-				channel: "line",
-				message: body,
-				ackPolicy: "after_receive_record",
-				onAck: () => {
-					res.statusCode = 200;
-					res.setHeader("Content-Type", "application/json");
-					res.end(JSON.stringify({ status: "ok" }));
-				}
-			});
-			if (receiveContext.shouldAckAfter("receive_record")) await receiveContext.ack();
 			if (body.events && body.events.length > 0) {
 				logVerbose(`line: received ${body.events.length} webhook events`);
-				Promise.resolve().then(() => params.bot.handleWebhook(body)).catch((err) => logLineWebhookDispatchError(params.runtime, err));
+				await params.bot.handleWebhook(body);
 			}
+			res.statusCode = 200;
+			res.setHeader("Content-Type", "application/json");
+			res.end(JSON.stringify({ status: "ok" }));
 		} catch (err) {
-			await receiveContext?.nack(err);
 			if (isRequestBodyLimitError$1(err, "PAYLOAD_TOO_LARGE")) {
 				res.statusCode = 413;
 				res.setHeader("Content-Type", "application/json");
@@ -1236,7 +1501,7 @@ async function monitorLineProvider(opts) {
 		accountId,
 		runtime,
 		config,
-		onMessage: async (ctx) => {
+		onMessage: async (ctx, deliveryControl) => {
 			if (!ctx) return;
 			const { ctxPayload, replyToken, route } = ctx;
 			const shouldShowLoading = Boolean(ctx.userId && !ctx.isGroup);
@@ -1250,14 +1515,23 @@ async function monitorLineProvider(opts) {
 				accountId: ctx.accountId
 			}) : null;
 			logVerbose(`line: received message from ${await displayNamePromise} (${ctxPayload.From})`);
+			let replyTokenUsed = false;
+			let turnAdopted = false;
+			const ingressLifecycle = deliveryControl.turnAdoptionLifecycle;
 			try {
 				const textLimit = 5e3;
-				let replyTokenUsed = false;
-				const core = getLineRuntime();
-				const turnResult = await core.channel.inbound.run({
+				const turnResult = await getLineRuntime().channel.inbound.run({
 					channel: "line",
 					accountId: route.accountId,
 					raw: ctx,
+					turnAdoptionLifecycle: {
+						...ingressLifecycle,
+						admission: "exclusive",
+						onAdopted: async () => {
+							await ingressLifecycle?.onAdopted();
+							turnAdopted = true;
+						}
+					},
 					adapter: {
 						ingest: () => ({
 							id: ctxPayload.MessageSid ?? `${ctxPayload.From}:${Date.now()}`,
@@ -1267,14 +1541,14 @@ async function monitorLineProvider(opts) {
 							cfg: config,
 							channel: "line",
 							accountId: route.accountId,
-							agentId: route.agentId,
-							routeSessionKey: route.sessionKey,
-							storePath: ctx.turn.storePath,
+							route: {
+								agentId: route.agentId,
+								sessionKey: route.sessionKey
+							},
 							ctxPayload,
-							recordInboundSession: core.channel.session.recordInboundSession,
-							dispatchReplyWithBufferedBlockDispatcher: core.channel.reply.dispatchReplyWithBufferedBlockDispatcher,
 							record: ctx.turn.record,
 							replyPipeline: {},
+							...ingressLifecycle?.abortSignal ? { replyOptions: { abortSignal: ingressLifecycle.abortSignal } } : {},
 							delivery: {
 								durable: (payload, info) => resolveLineDurableReplyOptions({
 									payload,
@@ -1310,7 +1584,7 @@ async function monitorLineProvider(opts) {
 											createTextMessageWithQuickReplies,
 											pushMessagesLine,
 											createFlexMessage,
-											createImageMessage,
+											buildMediaMessage: buildLineMediaMessage,
 											createLocationMessage,
 											onReplyError: (replyErr) => {
 												logVerbose(`line: reply token failed, falling back to push: ${String(replyErr)}`);
@@ -1319,6 +1593,7 @@ async function monitorLineProvider(opts) {
 									});
 									replyTokenUsed = deliveryResult.replyTokenUsed;
 									if (deliveryResult.status === "partial") throw deliveryResult.error;
+									return { visibleReplySent: deliveryResult.visibleReplySent };
 								},
 								onError: (err, info) => {
 									runtime.error?.(danger(`line ${info.kind} reply failed: ${String(err)}`));
@@ -1330,17 +1605,8 @@ async function monitorLineProvider(opts) {
 				if (!hasFinalInboundReplyDispatch(turnResult.dispatched ? turnResult.dispatchResult : void 0)) logVerbose(`line: no response generated for message from ${ctxPayload.From}`);
 			} catch (err) {
 				runtime.error?.(danger(`line: auto-reply failed: ${String(err)}`));
-				if (replyToken) try {
-					await replyMessageLine(replyToken, [{
-						type: "text",
-						text: "Sorry, I encountered an error processing your message."
-					}], {
-						cfg: config,
-						accountId: ctx.accountId
-					});
-				} catch (replyErr) {
-					runtime.error?.(danger(`line: error reply failed: ${String(replyErr)}`));
-				}
+				if (turnAdopted || replyTokenUsed) throw new LineWebhookTerminalDeliveryError("LINE delivery failed after consuming the event reply token.", { cause: err });
+				throw err;
 			} finally {
 				stopLoading?.();
 			}
@@ -1418,16 +1684,13 @@ async function monitorLineProvider(opts) {
 						res.end(JSON.stringify({ error: "Invalid webhook payload" }));
 						return;
 					}
-					requestLifecycle.release();
-					res.statusCode = 200;
-					res.setHeader("Content-Type", "application/json");
-					res.end(JSON.stringify({ status: "ok" }));
 					if (body.events && body.events.length > 0) {
 						logVerbose(`line: received ${body.events.length} webhook events`);
-						Promise.resolve().then(() => match.target.bot.handleWebhook(body)).catch((err) => {
-							match.target.runtime.error?.(danger(`line webhook dispatch failed: ${String(err)}`));
-						});
+						await match.target.bot.handleWebhook(body);
 					}
+					res.statusCode = 200;
+					res.setHeader("Content-Type", "application/json");
+					res.end(JSON.stringify({ status: "ok" }));
 				} catch (err) {
 					if (isRequestBodyLimitError(err, "PAYLOAD_TOO_LARGE")) {
 						res.statusCode = 413;
@@ -1455,23 +1718,29 @@ async function monitorLineProvider(opts) {
 	});
 	logVerbose(`line: registered webhook handler at ${normalizedPath}`);
 	let stopped = false;
+	let stopPromise;
 	const stopHandler = () => {
-		if (stopped) return;
+		if (stopPromise) return stopPromise;
+		if (stopped) return Promise.resolve();
 		stopped = true;
 		logVerbose(`line: stopping provider for account ${resolvedAccountId}`);
 		unregisterHttp();
+		stopPromise = bot.stop();
+		return stopPromise;
 	};
-	if (abortSignal?.aborted) stopHandler();
+	const stopOnAbort = () => void stopHandler();
+	if (abortSignal?.aborted) await stopHandler();
 	else if (abortSignal) {
-		abortSignal.addEventListener("abort", stopHandler, { once: true });
+		abortSignal.addEventListener("abort", stopOnAbort, { once: true });
 		await waitForAbortSignal(abortSignal);
+		await stopHandler();
 	}
 	return {
 		account: bot.account,
 		handleWebhook: bot.handleWebhook,
-		stop: () => {
-			stopHandler();
-			abortSignal?.removeEventListener("abort", stopHandler);
+		stop: async () => {
+			await stopHandler();
+			abortSignal?.removeEventListener("abort", stopOnAbort);
 		}
 	};
 }