@openclaw/line 2026.7.2-beta.2 → 2026.7.2-beta.4

package/dist/{monitor-Db2rZsSX.js → monitor-BinAXvIY.js}

@@ -1,22 +1,23 @@
-import { i as resolveLineAccount, r as resolveDefaultLineAccountId } from "./accounts-DJVOv1JI.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-XceqeKRP.js";
+import { i as resolveLineAccount, r as resolveDefaultLineAccountId } from "./accounts-BUBOoW5Q.js";
+import { a as resolveLineGroupConfigEntry, n as getLineRuntime, t as buildLineQuickReplyFallbackText } from "./quick-reply-fallback-D86FwAfr.js";
+import { n as buildLineMediaMessage, r as hasLineSpecificMediaOptions } from "./send-receipt-CY2ey8XH.js";
+import { E as buildTemplateMessageFromPayload, S as replyMessageLine, i as processLineMessage, l as createLocationMessage, p as getUserDisplayName, s as createFlexMessage, u as createQuickReplyItems, v as pushMessageLine, w as showLoadingAnimation, y as pushMessagesLine } from "./markdown-to-line-DWIdzBfy.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, createChannelIngressMonitor } 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 { Readable } from "node:stream";
-import { finished } from "node:stream/promises";
 import { setTimeout as setTimeout$1 } from "node:timers/promises";
+import { MediaFetchError } from "openclaw/plugin-sdk/media-runtime";
 import { saveMediaStream } from "openclaw/plugin-sdk/media-store";
-import { createNonExitingRuntime, danger, logVerbose, shouldLogVerbose, waitForAbortSignal } from "openclaw/plugin-sdk/runtime-env";
+import { createNonExitingRuntime, danger, logVerbose, shouldLogVerbose, waitForAbortSignal, warn } from "openclaw/plugin-sdk/runtime-env";
 import { fetchWithRuntimeDispatcherOrMockedGlobal } from "openclaw/plugin-sdk/runtime-fetch";
+import { HTTPFetchError } from "@line/bot-sdk";
 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 { buildMentionRegexes, formatInboundEnvelope, formatInboundMediaUnavailableText, formatLocationText, hasFinalInboundReplyDispatch, matchesMentionPatterns, resolveInboundSessionEnvelopeContext, toInboundMediaFacts, 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, runDetachedWebhookWork } from "openclaw/plugin-sdk/webhook-request-guards";
@@ -25,7 +26,6 @@ import { getRuntimeConfig } from "openclaw/plugin-sdk/runtime-config-snapshot";
 import { resolveStableChannelMessageIngress } from "openclaw/plugin-sdk/channel-ingress-runtime";
 import { hasControlCommand } from "openclaw/plugin-sdk/command-auth-native";
 import { ensureConfiguredBindingRouteReady, readChannelAllowFromStore, resolveConfiguredBindingRoute, resolvePairingIdLabel, resolvePinnedMainDmOwnerFromAllowlist, resolveRuntimeConversationBindingRoute, upsertChannelPairingRequest } from "openclaw/plugin-sdk/conversation-runtime";
-import { createChannelReplayGuard } 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";
@@ -53,44 +53,85 @@ 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";
+var RetryableLineMediaFetchError = class extends MediaFetchError {
+	constructor(message, options) {
+		super("fetch_failed", message, options);
+		this.name = "RetryableLineMediaFetchError";
+	}
+};
 function contentBackoffDelayMs(attempt) {
 	return Math.min(CONTENT_READY_BASE_DELAY_MS * 2 ** attempt, CONTENT_READY_MAX_DELAY_MS);
 }
+function lineContentUrl(messageId) {
+	return `${LINE_CONTENT_BASE_URL}/${encodeURIComponent(messageId)}/content`;
+}
+async function* lineResponseBodyChunks(response, messageId) {
+	const body = response.body;
+	if (!body) throw new RetryableLineMediaFetchError(`LINE media response for message ${messageId} had no body`);
+	const reader = body.getReader();
+	let completed = false;
+	try {
+		while (true) {
+			let chunk;
+			try {
+				chunk = await reader.read();
+			} catch (err) {
+				throw new RetryableLineMediaFetchError(`LINE media response stream failed for message ${messageId}`, { cause: err });
+			}
+			if (chunk.done) {
+				completed = true;
+				return;
+			}
+			if (chunk.value.byteLength > 0) yield chunk.value;
+		}
+	} finally {
+		if (!completed) await reader.cancel().catch(() => void 0);
+		try {
+			reader.releaseLock();
+		} catch {}
+	}
+}
 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`, {
+			const response = await fetchWithRuntimeDispatcherOrMockedGlobal(lineContentUrl(messageId), {
 				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);
+				if (!response.body) throw new RetryableLineMediaFetchError(`LINE media response for message ${messageId} had no body`);
+				return response;
 			}
-			await response.body?.cancel();
-			if (response.status !== 202) throw new Error(`LINE media download failed for message ${messageId} (HTTP ${response.status})`);
+			await response.body?.cancel().catch(() => void 0);
+			if (response.status !== 202) throw new MediaFetchError("http_error", `LINE media download failed for message ${messageId} (HTTP ${response.status})`, { status: 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;
+		if (controller.signal.aborted) throw new RetryableLineMediaFetchError(`LINE media for message ${messageId} did not become ready within ${CONTENT_READY_TIMEOUT_MS / 1e3} seconds`, { cause: err });
+		if (err instanceof MediaFetchError) throw err;
+		throw new RetryableLineMediaFetchError(`LINE media download failed for message ${messageId}`, { cause: err });
 	} finally {
 		clearTimeout(deadline);
 	}
-	throw new Error(`LINE media for message ${messageId} was still preparing (HTTP 202) after ${CONTENT_READY_MAX_ATTEMPTS} attempts`);
+	throw new MediaFetchError("http_error", `LINE media for message ${messageId} was still preparing (HTTP 202) after ${CONTENT_READY_MAX_ATTEMPTS} attempts`, { status: 202 });
+}
+function isRetryableLineInboundMediaError(err) {
+	if (err instanceof RetryableLineMediaFetchError) return true;
+	if (!(err instanceof MediaFetchError)) return false;
+	if (err.code === "http_error") return err.status === 202 || err.status === 408 || err.status === 429 || typeof err.status === "number" && err.status >= 500;
+	return false;
 }
 async function downloadLineMedia(messageId, channelAccessToken, maxBytes = 10 * 1024 * 1024, options) {
-	const content = await fetchLineContentWhenReady(messageId, channelAccessToken);
+	const response = await fetchLineContentWhenReady(messageId, channelAccessToken);
 	let saved;
 	try {
-		saved = await saveMediaStream(content, void 0, "inbound", maxBytes, options?.originalFilename);
+		saved = await saveMediaStream(lineResponseBodyChunks(response, messageId), response.headers.get("content-type") ?? void 0, "inbound", maxBytes, options?.originalFilename);
 	} catch (err) {
-		content.destroy();
-		await finished(content).catch(() => void 0);
+		await response.body?.cancel().catch(() => void 0);
 		throw err;
 	}
 	logVerbose(`line: persisted media ${messageId} to ${saved.path} (${saved.size} bytes)`);
@@ -103,7 +144,11 @@ 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 });
+	return error instanceof Error ? error : new Error("LINE message send failed", { cause: error });
+}
+function getLineHttpError(error) {
+	if (error instanceof HTTPFetchError) return error;
+	return error instanceof Error && error.cause instanceof HTTPFetchError ? error.cause : void 0;
 }
 function markLineVisibleDeliveryError(error) {
 	const deliveryError = toLineDeliveryError(error);
@@ -114,7 +159,7 @@ function markLineVisibleDeliveryError(error) {
 		});
 		return deliveryError;
 	}
-	const visibleError = new Error("LINE rich or media message send failed", { cause: deliveryError });
+	const visibleError = new Error("LINE message send failed", { cause: deliveryError });
 	Object.assign(visibleError, {
 		sentBeforeError: true,
 		visibleReplySent: true
@@ -136,14 +181,25 @@ async function deliverLineAutoReply(params) {
 		}
 	};
 	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) => {
+	const failedPushSegments = /* @__PURE__ */ new WeakMap();
+	const pushLineMessages = async (messages, allowFailedBatchTextRecovery, externalTail = []) => {
 		if (messages.length === 0) return;
-		for (let i = 0; i < messages.length; i += 5) await sendVisible(() => deps.pushMessagesLine(to, messages.slice(i, i + 5), {
-			cfg: params.cfg,
-			accountId
-		}));
+		for (let i = 0; i < messages.length; i += 5) {
+			const batch = messages.slice(i, i + 5);
+			try {
+				await sendVisible(() => deps.pushMessagesLine(to, batch, {
+					cfg: params.cfg,
+					accountId
+				}));
+			} catch (error) {
+				if (typeof error === "object" && error !== null) failedPushSegments.set(error, {
+					allowFailedBatchTextRecovery,
+					failedBatch: batch,
+					unattemptedTail: [...messages.slice(i + batch.length), ...externalTail]
+				});
+				throw error;
+			}
+		}
 	};
 	const sendLineMessages = async (messages, allowReplyToken) => {
 		if (messages.length === 0) return;
@@ -157,12 +213,13 @@ async function deliverLineAutoReply(params) {
 				});
 			} catch (err) {
 				deps.onReplyError?.(err);
-				await pushLineMessages(replyBatch);
+				await pushLineMessages(replyBatch, getLineHttpError(err)?.status === 400, remaining.slice(replyBatch.length));
+			} finally {
+				replyTokenUsed = true;
 			}
-			replyTokenUsed = true;
 			remaining = remaining.slice(replyBatch.length);
 		}
-		if (remaining.length > 0) await pushLineMessages(remaining);
+		if (remaining.length > 0) await pushLineMessages(remaining, true);
 	};
 	const richMessages = [];
 	const hasQuickReplies = Boolean(lineData.quickReplies?.length);
@@ -187,82 +244,59 @@ async function deliverLineAutoReply(params) {
 		trackingId: lineData.trackingId
 	};
 	const mediaMessages = [];
-	let richMediaError;
+	let deliveryError;
 	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;
+			deliveryError ??= err;
 		}
 	}
-	if (chunks.length > 0) {
-		const hasRichOrMedia = richMessages.length > 0 || mediaMessages.length > 0;
-		const sendRichBeforeText = hasQuickReplies && hasRichOrMedia;
-		if (sendRichBeforeText) try {
-			await sendLineMessages([...richMessages, ...mediaMessages], false);
-		} catch (err) {
-			richMediaError ??= err;
-		}
-		const { replyTokenUsed: nextReplyTokenUsed } = await deps.sendLineReplyChunks({
-			to,
-			chunks,
-			quickReplies: lineData.quickReplies,
-			replyToken,
-			replyTokenUsed,
-			cfg: params.cfg,
-			accountId,
-			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;
-		}
-	} else {
-		const combined = [...richMessages, ...mediaMessages];
-		if (hasQuickReplies && combined.length === 0) {
-			const { replyTokenUsed: nextReplyTokenUsed } = await deps.sendLineReplyChunks({
-				to,
-				chunks: [buildLineQuickReplyFallbackText(lineData.quickReplies)],
-				quickReplies: lineData.quickReplies,
-				replyToken,
-				replyTokenUsed,
-				cfg: params.cfg,
-				accountId,
-				replyMessageLine: replyVisible,
-				pushMessageLine: pushTextVisible,
-				pushTextMessageWithQuickReplies: pushQuickRepliesVisible,
-				createTextMessageWithQuickReplies: deps.createTextMessageWithQuickReplies,
-				onReplyError: deps.onReplyError
-			});
-			replyTokenUsed = nextReplyTokenUsed;
-		} else {
-			if (hasQuickReplies && combined.length > 0) {
-				const quickReply = deps.createQuickReplyItems(lineData.quickReplies);
-				const targetIndex = replyToken && !replyTokenUsed ? Math.min(4, combined.length - 1) : combined.length - 1;
-				combined[targetIndex] = {
-					...combined[targetIndex],
-					quickReply
-				};
-			}
-			await sendLineMessages(combined, true);
-		}
+	const textMessages = chunks.map((text) => ({
+		type: "text",
+		text
+	}));
+	const richMediaMessages = [...richMessages, ...mediaMessages];
+	if (hasQuickReplies && textMessages.length === 0 && richMediaMessages.length === 0) textMessages.push({
+		type: "text",
+		text: buildLineQuickReplyFallbackText(lineData.quickReplies)
+	});
+	if (hasQuickReplies) {
+		const targetMessages = textMessages.length > 0 ? textMessages : richMediaMessages;
+		const lastIndex = targetMessages.length - 1;
+		targetMessages[lastIndex] = {
+			...expectDefined(targetMessages[lastIndex], "last LINE auto-reply message"),
+			quickReply: deps.createQuickReplyItems(lineData.quickReplies)
+		};
+	}
+	const messages = hasQuickReplies ? [...richMediaMessages, ...textMessages] : [...textMessages, ...richMediaMessages];
+	try {
+		await sendLineMessages(messages, true);
+	} catch (err) {
+		deliveryError ??= err;
+		const failedSegment = typeof err === "object" && err !== null ? failedPushSegments.get(err) : void 0;
+		const httpError = getLineHttpError(err);
+		const retryCandidates = failedSegment ? [...failedSegment.allowFailedBatchTextRecovery ? failedSegment.failedBatch : [], ...failedSegment.unattemptedTail] : [];
+		const retryTextMessages = retryCandidates.filter((message) => message.type === "text");
+		const quickRepliesNeedCarrier = hasQuickReplies && retryCandidates.some((message) => "quickReply" in message);
+		const retryMessages = retryTextMessages.length > 0 ? retryTextMessages : quickRepliesNeedCarrier ? [{
+			type: "text",
+			text: buildLineQuickReplyFallbackText(lineData.quickReplies),
+			quickReply: deps.createQuickReplyItems(lineData.quickReplies)
+		}] : [];
+		if (retryMessages.length > 0 && failedSegment?.failedBatch.some((message) => message.type !== "text") && httpError?.status === 400) try {
+			await sendLineMessages(retryMessages, false);
+		} catch {}
 	}
-	if (richMediaError !== void 0) {
-		if (!visibleReplySent) throw toLineDeliveryError(richMediaError);
+	if (deliveryError !== void 0) {
+		if (!visibleReplySent) throw toLineDeliveryError(deliveryError);
 		return {
 			status: "partial",
 			replyTokenUsed,
 			visibleReplySent: true,
-			error: markLineVisibleDeliveryError(richMediaError)
+			error: markLineVisibleDeliveryError(deliveryError)
 		};
 	}
 	return {
@@ -398,13 +432,13 @@ function extractMessageText(message) {
 	}
 	return "";
 }
-function extractMediaPlaceholder(message) {
+function extractNativeMediaKind(message) {
 	switch (message.type) {
-		case "image": return "<media:image>";
-		case "video": return "<media:video>";
-		case "audio": return "<media:audio>";
-		case "file": return "<media:document>";
-		default: return "";
+		case "image": return "image";
+		case "video": return "video";
+		case "audio": return "audio";
+		case "file": return "document";
+		default: return;
 	}
 }
 function resolveLineConversationLabel(params) {
@@ -440,6 +474,7 @@ async function finalizeLineInboundContext(params) {
 		sessionKey: params.route.sessionKey
 	});
 	const agentBody = params.agentBody ?? params.rawBody;
+	const media = toInboundMediaFacts(params.media);
 	const body = formatInboundEnvelope({
 		channel: "LINE",
 		from: conversationLabel,
@@ -458,6 +493,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,
@@ -467,12 +503,7 @@ async function finalizeLineInboundContext(params) {
 		Surface: "line",
 		MessageSid: params.messageSid,
 		Timestamp: params.timestamp,
-		MediaPath: params.media.firstPath,
-		MediaType: params.media.firstContentType,
-		MediaUrl: params.media.firstPath,
-		MediaPaths: params.media.paths,
-		MediaUrls: params.media.paths,
-		MediaTypes: params.media.types,
+		media,
 		...params.locationContext,
 		CommandAuthorized: params.commandAuthorized,
 		OriginatingChannel: "line",
@@ -535,15 +566,17 @@ async function buildLineMessageContext(params) {
 	const messageId = message.id;
 	const timestamp = event.timestamp;
 	const textContent = extractMessageText(message);
-	const placeholder = extractMediaPlaceholder(message);
-	let rawBody = textContent || placeholder;
-	if (!rawBody && allMedia.length > 0) rawBody = `<media:image>${allMedia.length > 1 ? ` (${allMedia.length} images)` : ""}`;
+	const nativeMediaKind = extractNativeMediaKind(message);
+	const mediaFacts = allMedia.length > 0 ? allMedia.map((media) => ({
+		...media,
+		kind: nativeMediaKind
+	})) : nativeMediaKind ? [{ kind: nativeMediaKind }] : [];
+	const rawBody = textContent;
 	const agentBody = mediaUnavailable ? formatInboundMediaUnavailableText({
 		body: rawBody,
-		mediaPlaceholder: placeholder,
 		notice: "[line attachment unavailable]"
 	}) : rawBody;
-	if (!agentBody && allMedia.length === 0) return null;
+	if (!agentBody && mediaFacts.length === 0) return null;
 	let locationContext;
 	if (message.type === "location") {
 		const loc = message;
@@ -571,12 +604,7 @@ async function buildLineMessageContext(params) {
 		timestamp,
 		messageSid: messageId,
 		commandAuthorized,
-		media: {
-			firstPath: allMedia[0]?.path,
-			firstContentType: allMedia[0]?.contentType,
-			paths: allMedia.length > 0 ? allMedia.map((m) => m.path) : void 0,
-			types: allMedia.length > 0 ? allMedia.map((m) => m.contentType).filter(Boolean) : void 0
-		},
+		media: mediaFacts,
 		locationContext,
 		verboseLog: {
 			kind: "inbound",
@@ -632,12 +660,7 @@ async function buildLinePostbackContext(params) {
 		timestamp,
 		messageSid,
 		commandAuthorized,
-		media: {
-			firstPath: "",
-			firstContentType: void 0,
-			paths: void 0,
-			types: void 0
-		},
+		media: [],
 		verboseLog: { kind: "postback" }
 	});
 	return {
@@ -699,37 +722,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 createChannelReplayGuard({
-		dedupe: {
-			ttlMs: LINE_WEBHOOK_REPLAY_WINDOW_MS,
-			memoryMaxSize: LINE_WEBHOOK_REPLAY_MAX_ENTRIES
-		},
-		buildReplayKey: ({ event, accountId }) => buildLineWebhookReplayKey(event, accountId)?.key
-	});
-}
-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 resolveLineGroupConfig(params) {
 	return resolveLineGroupConfigEntry(params.config.groups, {
 		groupId: params.groupId,
@@ -980,6 +975,7 @@ async function handleMessageEvent(event, context) {
 				contentType: media.contentType
 			});
 		} catch (err) {
+			if (isRetryableLineInboundMediaError(err)) throw err;
 			mediaUnavailable = true;
 			const errMsg = String(err);
 			if (errMsg.includes("exceeds") && errMsg.includes("limit")) logVerbose(`line: media exceeds size limit for message ${message.id}`);
@@ -998,7 +994,7 @@ async function handleMessageEvent(event, context) {
 			logVerbose("line: skipping empty message");
 			return;
 		}
-		await processMessage(messageContext);
+		await processMessage(messageContext, context.turnAdoptionLifecycle ? { turnAdoptionLifecycle: context.turnAdoptionLifecycle } : {});
 		historyReservation.commit();
 	} finally {
 		historyReservation.release();
@@ -1032,30 +1028,12 @@ 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) try {
-		if (!context.replayCache) {
-			await handleLineWebhookEvent(event, context);
-			continue;
-		}
-		const replayEvent = {
-			event,
-			accountId: context.account.accountId
-		};
-		const result = await context.replayCache.processGuarded(replayEvent, async () => await handleLineWebhookEvent(event, context), { onError: "commit" });
-		const replayId = buildLineWebhookReplayKey(event, context.account.accountId)?.eventId;
-		if (result.kind === "inflight") {
-			logVerbose(`line: skipped in-flight replayed webhook event ${replayId ?? "unknown"}`);
-			try {
-				await result.pending;
-			} catch (err) {
-				context.runtime.error?.(danger(`line: replayed in-flight event failed: ${String(err)}`));
-				firstError ??= err;
-			}
-		} else if (result.kind === "duplicate") logVerbose(`line: skipped replayed webhook event ${replayId ?? "unknown"}`);
+		await handleLineWebhookEvent(event, context);
 	} catch (err) {
 		context.runtime.error?.(danger(`line: event handler failed: ${String(err)}`));
 		firstError ??= err;
@@ -1093,6 +1071,257 @@ 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_ACTIVE_DELIVERY_STOP_GRACE_MS = 5e3;
+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 parseStoredEvent(rawEvent) {
+	let event;
+	try {
+		event = JSON.parse(rawEvent);
+	} catch (error) {
+		throw new LineWebhookPayloadError("LINE webhook event JSON is invalid.", { cause: error });
+	}
+	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;
+}
+async function waitForActiveDeliveriesBeforeDispose(activeDeliveries) {
+	let timeout;
+	try {
+		return await Promise.race([Promise.allSettled(activeDeliveries).then(() => true), new Promise((resolve) => {
+			timeout = setTimeout(() => resolve(false), LINE_WEBHOOK_ACTIVE_DELIVERY_STOP_GRACE_MS);
+			timeout.unref?.();
+		})]);
+	} finally {
+		if (timeout) clearTimeout(timeout);
+	}
+}
+function createLineWebhookSpool(options) {
+	const queue = options.queue ?? getLineRuntime().state.openChannelIngressQueue({ accountId: options.accountId });
+	const activeDeliveries = /* @__PURE__ */ new Set();
+	const deferredClaims = /* @__PURE__ */ new Map();
+	let acceptsDeferredClaims = true;
+	const monitor = createChannelIngressMonitor({
+		queue,
+		inspect: ({ event }) => {
+			const eventId = eventIdFor(event);
+			return {
+				eventId,
+				laneKey: laneKeyFor(event, eventId)
+			};
+		},
+		payload: {
+			version: LINE_WEBHOOK_SPOOL_VERSION,
+			serialize: ({ event, destination }) => ({
+				rawEvent: JSON.stringify(event),
+				destination
+			}),
+			deserialize: ({ rawEvent, destination }) => ({
+				event: parseStoredEvent(rawEvent),
+				destination
+			}),
+			encode: ({ version, body }) => ({
+				version,
+				rawEvent: body.rawEvent,
+				destination: body.destination
+			}),
+			decode: (payload) => {
+				if (typeof payload.rawEvent !== "string" || typeof payload.destination !== "string") throw new LineWebhookPayloadError("LINE webhook spool payload is invalid.");
+				return {
+					version: payload.version,
+					body: {
+						rawEvent: payload.rawEvent,
+						destination: payload.destination
+					}
+				};
+			},
+			createClaimError: (kind) => new LineWebhookPayloadError(kind === "invalid-version" ? "LINE webhook spool payload is invalid." : "LINE webhook event identity changed after durable admission.")
+		},
+		deliver: async ({ event, destination }, lifecycle, claim) => {
+			const boundLifecycle = bindIngressLifecycleToReplyOptions(lifecycle).turnAdoptionLifecycle;
+			let handedOff = false;
+			let resolveDeferredClaim;
+			const deferredClaim = new Promise((resolve) => {
+				resolveDeferredClaim = resolve;
+			});
+			let deferredClaimSettled = false;
+			const settleDeferredClaim = () => {
+				if (deferredClaimSettled) return;
+				deferredClaimSettled = true;
+				if (deferredClaims.get(claim.id) === deferredClaim) deferredClaims.delete(claim.id);
+				resolveDeferredClaim();
+			};
+			const delivery = options.deliver(event, destination, { turnAdoptionLifecycle: {
+				...boundLifecycle,
+				onAdopted: async () => {
+					handedOff = true;
+					try {
+						await boundLifecycle.onAdopted();
+					} finally {
+						settleDeferredClaim();
+					}
+				},
+				onDeferred: () => {
+					handedOff = true;
+					if (!acceptsDeferredClaims) {
+						settleDeferredClaim();
+						Promise.resolve().then(() => boundLifecycle.onAbandoned()).catch((error) => {
+							options.runtime.error?.(danger(`line: failed to abandon a late webhook delivery: ${errorText(error)}`));
+						});
+						return;
+					}
+					if (!deferredClaimSettled) deferredClaims.set(claim.id, deferredClaim);
+					boundLifecycle.onDeferred();
+				},
+				onAbandoned: async () => {
+					handedOff = true;
+					try {
+						await boundLifecycle.onAbandoned();
+					} finally {
+						settleDeferredClaim();
+					}
+				}
+			} });
+			activeDeliveries.add(delivery);
+			try {
+				await delivery;
+			} finally {
+				activeDeliveries.delete(delivery);
+			}
+			if (stopTask && !handedOff) return {
+				kind: "failed-retryable",
+				error: /* @__PURE__ */ new Error("LINE webhook spool stopped before delivery handoff.")
+			};
+		},
+		pollIntervalMs: LINE_WEBHOOK_DRAIN_INTERVAL_MS,
+		retention: {
+			pruneIntervalMs: 0,
+			completedTtlMs: LINE_WEBHOOK_TOMBSTONE_TTL_MS,
+			completedMaxEntries: LINE_WEBHOOK_TOMBSTONE_MAX_ENTRIES,
+			failedTtlMs: LINE_WEBHOOK_TOMBSTONE_TTL_MS,
+			failedMaxEntries: LINE_WEBHOOK_TOMBSTONE_MAX_ENTRIES
+		},
+		appendRetryDelaysMs: [0],
+		waitForDeliveryIdleBeforeRepump: false,
+		waitForDeliveryIdleOnStop: false,
+		runPumpTask: runDetachedWebhookWork,
+		admissionMode: "durable-after-stop",
+		drain: {
+			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}`))
+		},
+		createStoppedError: () => /* @__PURE__ */ new Error("LINE webhook spool is stopped."),
+		onError: (error) => options.runtime.error?.(danger(`line: webhook spool drain failed: ${errorText(error)}`))
+	});
+	let stopTask;
+	return {
+		accept: async (body) => {
+			const events = body.events ?? [];
+			if (events.length === 0) return;
+			await monitor.admitBatch(events.map((event) => ({
+				event,
+				destination: body.destination ?? ""
+			})), { receivedAt: Date.now() });
+		},
+		start: () => {
+			if (!stopTask) monitor.start();
+		},
+		stop: () => {
+			stopTask ??= (async () => {
+				await monitor.pause();
+				try {
+					const deliveriesSettled = await waitForActiveDeliveriesBeforeDispose(activeDeliveries);
+					if (!deliveriesSettled) options.runtime.log(warn(`line: timed out after ${LINE_WEBHOOK_ACTIVE_DELIVERY_STOP_GRACE_MS}ms waiting for active webhook deliveries; releasing drain ownership`));
+					while (deferredClaims.size > 0) await Promise.allSettled(deferredClaims.values());
+					acceptsDeferredClaims = false;
+					if (deliveriesSettled) await monitor.waitForIdle();
+				} finally {
+					await monitor.stop();
+				}
+			})();
+			return stopTask;
+		}
+	};
+}
+//#endregion
 //#region extensions/line/src/bot.ts
 function createLineBot(opts) {
 	const runtime = opts.runtime ?? createNonExitingRuntime();
@@ -1105,24 +1334,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
@@ -1140,56 +1371,6 @@ function resolveLineDurableReplyOptions(params) {
 	return { to: params.to };
 }
 //#endregion
-//#region extensions/line/src/reply-chunks.ts
-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) {
-		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;
-		}
-	}
-	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,
-		accountId: params.accountId
-	});
-	else await params.pushMessageLine(params.to, chunk, {
-		cfg: params.cfg,
-		accountId: params.accountId
-	});
-	return { replyTokenUsed };
-}
-//#endregion
 //#region extensions/line/src/signature.ts
 function validateLineSignature(body, signature, channelSecret) {
 	return safeEqualSecret(signature, crypto.createHmac("SHA256", channelSecret).update(body).digest("base64"));
@@ -1214,9 +1395,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;
@@ -1239,7 +1417,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() : "";
@@ -1266,24 +1443,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`);
-				runDetachedWebhookWork(() => 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");
@@ -1344,7 +1511,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);
@@ -1358,14 +1525,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()}`,
@@ -1375,14 +1551,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,
@@ -1410,12 +1586,8 @@ async function monitorLineProvider(opts) {
 											buildTemplateMessageFromPayload,
 											processLineMessage,
 											chunkMarkdownText,
-											sendLineReplyChunks,
 											replyMessageLine,
-											pushMessageLine,
-											pushTextMessageWithQuickReplies,
 											createQuickReplyItems,
-											createTextMessageWithQuickReplies,
 											pushMessagesLine,
 											createFlexMessage,
 											buildMediaMessage: buildLineMediaMessage,
@@ -1439,17 +1611,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?.();
 			}
@@ -1527,16 +1690,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`);
-						runDetachedWebhookWork(() => 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;
@@ -1564,23 +1724,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);
 		}
 	};
 }