@openclaw/line 2026.7.2-beta.5 → 2026.7.33

package/dist/{monitor-DzFU5UPV.js → .setup/monitor-DpxjN6Ks.mjs}

@@ -1,35 +1,30 @@
-import { i as resolveLineAccount, r as resolveDefaultLineAccountId } from "./accounts-CSH5sk8U.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-Dn00k1bq.js";
+import { i as resolveLineAccount, r as resolveDefaultLineAccountId } from "./accounts-DJVOv1JI.mjs";
+import { f as resolveLineGroupConfigEntry, i as buildLineQuickReplyFallbackText, s as getLineRuntime } from "./reply-payload-transform-CYQIy_x8.mjs";
+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-o89GT1Qn.mjs";
 import { createChannelPairingChallengeIssuer } from "openclaw/plugin-sdk/channel-pairing";
 import { normalizeOptionalString, normalizeStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { DEFAULT_INGRESS_ADOPTION_STALL_MS, DEFAULT_INGRESS_RETRY_MAX_ATTEMPTS, bindIngressLifecycleToReplyOptions, createChannelIngressMonitor } from "openclaw/plugin-sdk/channel-outbound";
+import { createMessageReceiveContext } 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 { setTimeout as setTimeout$1 } from "node:timers/promises";
-import { MediaFetchError } from "openclaw/plugin-sdk/media-runtime";
+import { messagingApi } from "@line/bot-sdk";
 import { saveMediaStream } from "openclaw/plugin-sdk/media-store";
-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 { createNonExitingRuntime, danger, logVerbose, shouldLogVerbose, waitForAbortSignal } from "openclaw/plugin-sdk/runtime-env";
 import { recordChannelActivity } from "openclaw/plugin-sdk/channel-activity-runtime";
-import { buildChannelInboundEventContext, buildMentionRegexes, formatInboundEnvelope, formatInboundMediaUnavailableText, formatLocationText, hasFinalInboundReplyDispatch, matchesMentionPatterns, resolveInboundSessionEnvelopeContext, toInboundMediaFacts, toLocationContext } from "openclaw/plugin-sdk/channel-inbound";
+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, runDetachedWebhookWork } from "openclaw/plugin-sdk/webhook-request-guards";
+import { beginWebhookRequestPipelineOrReject, createWebhookInFlightLimiter, isRequestBodyLimitError as isRequestBodyLimitError$1, readRequestBodyWithLimit, requestBodyErrorToText as requestBodyErrorToText$1 } 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 { hasControlCommand } from "openclaw/plugin-sdk/command-auth-native";
+import { shouldComputeCommandAuthorized } 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";
 import crypto from "node:crypto";
-import { safeEqualSecret } from "openclaw/plugin-sdk/security-runtime";
 //#region extensions/line/src/bot-access.ts
 function normalizeLineAllowEntry(value) {
 	const trimmed = String(value).trim();
@@ -47,92 +42,9 @@ 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";
-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(lineContentUrl(messageId), {
-				headers: { Authorization: `Bearer ${channelAccessToken}` },
-				redirect: "error",
-				signal: controller.signal
-			});
-			if (response.status === 200) {
-				if (!response.body) throw new RetryableLineMediaFetchError(`LINE media response for message ${messageId} had no body`);
-				return response;
-			}
-			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 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 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 response = await fetchLineContentWhenReady(messageId, channelAccessToken);
-	let saved;
-	try {
-		saved = await saveMediaStream(lineResponseBodyChunks(response, messageId), response.headers.get("content-type") ?? void 0, "inbound", maxBytes, options?.originalFilename);
-	} catch (err) {
-		await response.body?.cancel().catch(() => void 0);
-		throw err;
-	}
+async function downloadLineMedia(messageId, channelAccessToken, maxBytes = 10485760, options) {
+	const response = await new messagingApi.MessagingApiBlobClient({ channelAccessToken }).getMessageContent(messageId);
+	const saved = await saveMediaStream(response, void 0, "inbound", maxBytes, options?.originalFilename);
 	logVerbose(`line: persisted media ${messageId} to ${saved.path} (${saved.size} bytes)`);
 	return {
 		path: saved.path,
@@ -142,23 +54,15 @@ 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 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);
-	if (Object.isExtensible(deliveryError)) {
-		Object.assign(deliveryError, {
+	if (error instanceof Error && Object.isExtensible(error)) {
+		Object.assign(error, {
 			sentBeforeError: true,
 			visibleReplySent: true
 		});
-		return deliveryError;
+		return error;
 	}
-	const visibleError = new Error("LINE message send failed", { cause: deliveryError });
+	const visibleError = new Error("LINE rich or media message send failed", { cause: error });
 	Object.assign(visibleError, {
 		sentBeforeError: true,
 		visibleReplySent: true
@@ -168,37 +72,12 @@ 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 failedPushSegments = /* @__PURE__ */ new WeakMap();
-	const pushLineMessages = async (messages, allowFailedBatchTextRecovery, externalTail = []) => {
+	const pushLineMessages = async (messages) => {
 		if (messages.length === 0) return;
-		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;
-			}
-		}
+		for (let i = 0; i < messages.length; i += 5) await deps.pushMessagesLine(to, messages.slice(i, i + 5), {
+			cfg: params.cfg,
+			accountId
+		});
 	};
 	const sendLineMessages = async (messages, allowReplyToken) => {
 		if (messages.length === 0) return;
@@ -206,19 +85,18 @@ async function deliverLineAutoReply(params) {
 		if (allowReplyToken && replyToken && !replyTokenUsed) {
 			const replyBatch = remaining.slice(0, 5);
 			try {
-				await replyVisible(replyToken, replyBatch, {
+				await deps.replyMessageLine(replyToken, replyBatch, {
 					cfg: params.cfg,
 					accountId
 				});
 			} catch (err) {
 				deps.onReplyError?.(err);
-				await pushLineMessages(replyBatch, getLineHttpError(err)?.status === 400, remaining.slice(replyBatch.length));
-			} finally {
-				replyTokenUsed = true;
+				await pushLineMessages(replyBatch);
 			}
+			replyTokenUsed = true;
 			remaining = remaining.slice(replyBatch.length);
 		}
-		if (remaining.length > 0) await pushLineMessages(remaining, true);
+		if (remaining.length > 0) await pushLineMessages(remaining);
 	};
 	const richMessages = [];
 	const hasQuickReplies = Boolean(lineData.quickReplies?.length);
@@ -228,80 +106,80 @@ async function deliverLineAutoReply(params) {
 		if (templateMsg) richMessages.push(templateMsg);
 	}
 	if (lineData.location) richMessages.push(deps.createLocationMessage(lineData.location));
-	const visibleText = payload.text ? sanitizeAssistantVisibleText(payload.text) : "";
-	const processed = visibleText ? deps.processLineMessage(visibleText) : {
+	const processed = payload.text ? deps.processLineMessage(payload.text) : {
 		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 mediaUrls = resolveSendableOutboundReplyParts(payload).mediaUrls;
-	const mediaOpts = {
-		mediaKind: hasLineSpecificMediaOptions(lineData) ? lineData.mediaKind : "image",
-		previewImageUrl: lineData.previewImageUrl,
-		durationMs: lineData.durationMs,
-		trackingId: lineData.trackingId
-	};
-	const mediaMessages = [];
-	let deliveryError;
-	for (const rawUrl of mediaUrls) {
-		const url = rawUrl?.trim();
-		if (!url) continue;
-		try {
-			mediaMessages.push(await deps.buildMediaMessage(url, mediaOpts, to));
+	const mediaMessages = resolveSendableOutboundReplyParts(payload).mediaUrls.map((url) => url?.trim()).filter((url) => Boolean(url)).map((url) => deps.createImageMessage(url));
+	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) {
-			deliveryError ??= err;
+			richMediaError = err;
 		}
-	}
-	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 (deliveryError !== void 0) {
-		if (!visibleReplySent) throw toLineDeliveryError(deliveryError);
-		return {
+		const { replyTokenUsed: nextReplyTokenUsed } = await deps.sendLineReplyChunks({
+			to,
+			chunks,
+			quickReplies: lineData.quickReplies,
+			replyToken,
+			replyTokenUsed,
+			cfg: params.cfg,
+			accountId,
+			replyMessageLine: deps.replyMessageLine,
+			pushMessageLine: deps.pushMessageLine,
+			pushTextMessageWithQuickReplies: deps.pushTextMessageWithQuickReplies,
+			createTextMessageWithQuickReplies: deps.createTextMessageWithQuickReplies
+		});
+		replyTokenUsed = nextReplyTokenUsed;
+		if (!sendRichBeforeText) try {
+			await sendLineMessages(richMessages, false);
+			if (mediaMessages.length > 0) await sendLineMessages(mediaMessages, false);
+		} catch (err) {
+			richMediaError = err;
+		}
+		if (richMediaError !== void 0) return {
 			status: "partial",
 			replyTokenUsed,
-			visibleReplySent: true,
-			error: markLineVisibleDeliveryError(deliveryError)
+			error: markLineVisibleDeliveryError(richMediaError)
 		};
+	} 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: deps.replyMessageLine,
+				pushMessageLine: deps.pushMessageLine,
+				pushTextMessageWithQuickReplies: deps.pushTextMessageWithQuickReplies,
+				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);
+		}
 	}
 	return {
 		status: "delivered",
-		replyTokenUsed,
-		visibleReplySent
+		replyTokenUsed
 	};
 }
 //#endregion
@@ -431,27 +309,48 @@ function extractMessageText(message) {
 	}
 	return "";
 }
-function extractNativeMediaKind(message) {
+function extractMediaPlaceholder(message) {
 	switch (message.type) {
-		case "image": return "image";
-		case "video": return "video";
-		case "audio": return "audio";
-		case "file": return "document";
-		default: return;
+		case "image": return "<media:image>";
+		case "video": return "<media:video>";
+		case "audio": return "<media:audio>";
+		case "file": return "<media:document>";
+		default: return "";
 	}
 }
+function resolveLineConversationLabel(params) {
+	return params.isGroup ? params.groupId ? `group:${params.groupId}` : params.roomId ? `room:${params.roomId}` : "unknown-group" : params.senderLabel;
+}
+function resolveLineAddresses(params) {
+	const fromAddress = params.isGroup ? params.groupId ? `line:group:${params.groupId}` : params.roomId ? `line:room:${params.roomId}` : `line:${params.peerId}` : `line:${params.userId ?? params.peerId}`;
+	return {
+		fromAddress,
+		toAddress: params.isGroup ? fromAddress : `line:${params.userId ?? params.peerId}`,
+		originatingTo: params.isGroup ? fromAddress : `line:${params.userId ?? params.peerId}`
+	};
+}
 async function finalizeLineInboundContext(params) {
+	const { fromAddress, toAddress, originatingTo } = resolveLineAddresses({
+		isGroup: params.source.isGroup,
+		groupId: params.source.groupId,
+		roomId: params.source.roomId,
+		userId: params.source.userId,
+		peerId: params.source.peerId
+	});
 	const senderId = params.source.userId ?? "unknown";
 	const senderLabel = params.source.userId ? `user:${params.source.userId}` : "unknown";
-	const conversationLabel = params.source.isGroup ? params.source.groupId ? `group:${params.source.groupId}` : params.source.roomId ? `room:${params.source.roomId}` : "unknown-group" : senderLabel;
-	const address = params.source.groupId ? `line:group:${params.source.groupId}` : params.source.roomId ? `line:room:${params.source.roomId}` : `line:${params.source.userId ?? params.source.peerId}`;
+	const conversationLabel = resolveLineConversationLabel({
+		isGroup: params.source.isGroup,
+		groupId: params.source.groupId,
+		roomId: params.source.roomId,
+		senderLabel
+	});
 	const { storePath, envelopeOptions, previousTimestamp } = resolveInboundSessionEnvelopeContext({
 		cfg: params.cfg,
 		agentId: params.route.agentId,
 		sessionKey: params.route.sessionKey
 	});
 	const agentBody = params.agentBody ?? params.rawBody;
-	const media = toInboundMediaFacts(params.media);
 	const body = formatInboundEnvelope({
 		channel: "LINE",
 		from: conversationLabel,
@@ -462,45 +361,38 @@ async function finalizeLineInboundContext(params) {
 		previousTimestamp,
 		envelope: envelopeOptions
 	});
-	const ctxPayload = buildChannelInboundEventContext({
-		channel: "line",
-		accountId: params.route.accountId,
-		messageId: params.messageSid,
-		timestamp: params.timestamp,
-		from: address,
-		sender: { id: senderId },
-		conversation: {
-			kind: params.source.isGroup ? "group" : "direct",
-			id: params.source.peerId,
-			label: conversationLabel
-		},
-		route: {
-			agentId: params.route.agentId,
-			dmScope: params.route.dmScope,
-			accountId: params.route.accountId,
-			routeSessionKey: params.route.sessionKey
-		},
-		reply: {
-			to: address,
-			originatingTo: address
-		},
-		message: {
-			body,
-			bodyForAgent: agentBody,
-			rawBody: params.rawBody,
-			commandBody: params.rawBody,
-			inboundHistory: params.inboundHistory
-		},
-		access: { commands: { authorized: params.commandAuthorized } },
-		media,
-		extra: {
-			...params.locationContext,
-			GroupSubject: params.source.isGroup ? params.source.groupId ?? params.source.roomId : void 0,
-			GroupSystemPrompt: params.source.isGroup ? normalizeOptionalString(resolveLineGroupConfigEntry(params.account.config.groups, {
-				groupId: params.source.groupId,
-				roomId: params.source.roomId
-			})?.systemPrompt) : void 0
-		}
+	const ctxPayload = finalizeInboundContext({
+		Body: body,
+		BodyForAgent: agentBody,
+		RawBody: params.rawBody,
+		CommandBody: params.rawBody,
+		From: fromAddress,
+		To: toAddress,
+		SessionKey: params.route.sessionKey,
+		AccountId: params.route.accountId,
+		ChatType: params.source.isGroup ? "group" : "direct",
+		ConversationLabel: conversationLabel,
+		GroupSubject: params.source.isGroup ? params.source.groupId ?? params.source.roomId : void 0,
+		SenderId: senderId,
+		Provider: "line",
+		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,
+		...params.locationContext,
+		CommandAuthorized: params.commandAuthorized,
+		OriginatingChannel: "line",
+		OriginatingTo: originatingTo,
+		GroupSystemPrompt: params.source.isGroup ? normalizeOptionalString(resolveLineGroupConfigEntry(params.account.config.groups, {
+			groupId: params.source.groupId,
+			roomId: params.source.roomId
+		})?.systemPrompt) : void 0,
+		InboundHistory: params.inboundHistory
 	});
 	const pinnedMainDmOwner = !params.source.isGroup ? resolvePinnedMainDmOwnerFromAllowlist({
 		dmScope: params.cfg.session?.dmScope,
@@ -514,7 +406,8 @@ async function finalizeLineInboundContext(params) {
 	if (shouldLogVerbose()) {
 		const preview = truncateUtf16Safe(body, 200).replace(/\n/g, "\\n");
 		const mediaInfo = params.verboseLog.kind === "inbound" && (params.verboseLog.mediaCount ?? 0) > 1 ? ` mediaCount=${params.verboseLog.mediaCount}` : "";
-		logVerbose(`${params.verboseLog.kind === "inbound" ? "line inbound" : "line postback"}: from=${ctxPayload.From} len=${body.length}${mediaInfo} preview="${preview}"`);
+		const label = params.verboseLog.kind === "inbound" ? "line inbound" : "line postback";
+		logVerbose(`${label}: from=${ctxPayload.From} len=${body.length}${mediaInfo} preview="${preview}"`);
 	}
 	return {
 		ctxPayload,
@@ -543,7 +436,7 @@ async function finalizeLineInboundContext(params) {
 	};
 }
 async function buildLineMessageContext(params) {
-	const { event, allMedia, mediaUnavailable, cfg, account, commandAuthorized, inboundHistory } = params;
+	const { event, allMedia, mediaUnavailable, cfg, account, commandAuthorized, groupHistories, historyLimit } = params;
 	const source = event.source;
 	const { userId, groupId, roomId, isGroup, peerId, route } = await resolveLineInboundRoute({
 		source,
@@ -554,17 +447,15 @@ async function buildLineMessageContext(params) {
 	const messageId = message.id;
 	const timestamp = event.timestamp;
 	const textContent = extractMessageText(message);
-	const nativeMediaKind = extractNativeMediaKind(message);
-	const mediaFacts = allMedia.length > 0 ? allMedia.map((media) => ({
-		...media,
-		kind: nativeMediaKind
-	})) : nativeMediaKind ? [{ kind: nativeMediaKind }] : [];
-	const rawBody = textContent;
+	const placeholder = extractMediaPlaceholder(message);
+	let rawBody = textContent || placeholder;
+	if (!rawBody && allMedia.length > 0) rawBody = `<media:image>${allMedia.length > 1 ? ` (${allMedia.length} images)` : ""}`;
 	const agentBody = mediaUnavailable ? formatInboundMediaUnavailableText({
 		body: rawBody,
+		mediaPlaceholder: placeholder,
 		notice: "[line attachment unavailable]"
 	}) : rawBody;
-	if (!agentBody && mediaFacts.length === 0) return null;
+	if (!agentBody && allMedia.length === 0) return null;
 	let locationContext;
 	if (message.type === "location") {
 		const loc = message;
@@ -575,6 +466,11 @@ 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,
@@ -592,7 +488,12 @@ async function buildLineMessageContext(params) {
 		timestamp,
 		messageSid: messageId,
 		commandAuthorized,
-		media: mediaFacts,
+		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
+		},
 		locationContext,
 		verboseLog: {
 			kind: "inbound",
@@ -622,14 +523,18 @@ async function buildLinePostbackContext(params) {
 		account
 	});
 	const timestamp = event.timestamp;
-	const rawData = event.postback?.data?.trim() ?? "";
-	if (!rawData) return null;
-	let rawBody = rawData;
-	if (rawData.includes("line.action=")) {
-		const searchParams = new URLSearchParams(rawData);
+	const rawBody = event.postback?.data?.trim() ?? "";
+	if (!rawBody) return null;
+	let agentBody = rawBody;
+	if (rawBody.includes("line.action=")) {
+		const searchParams = new URLSearchParams(rawBody);
 		const action = searchParams.get("line.action") ?? "";
 		const device = searchParams.get("line.device");
-		rawBody = device ? `line action ${action} device ${device}` : `line action ${action}`;
+		agentBody = device ? `line action ${action} device ${device}` : `line action ${action}`;
+	}
+	for (const [key, value] of Object.entries(event.postback.params ?? {}).toSorted(([left], [right]) => left < right ? -1 : left > right ? 1 : 0)) {
+		const picked = normalizeOptionalString(value);
+		if (picked) agentBody += ` ${key}=${picked}`;
 	}
 	const messageSid = event.replyToken ? `postback:${event.replyToken}` : `postback:${timestamp}`;
 	const finalized = await finalizeLineInboundContext({
@@ -645,10 +550,16 @@ async function buildLinePostbackContext(params) {
 			peerId
 		},
 		rawBody,
+		agentBody,
 		timestamp,
 		messageSid,
 		commandAuthorized,
-		media: [],
+		media: {
+			firstPath: "",
+			firstContentType: void 0,
+			paths: void 0,
+			types: void 0
+		},
 		verboseLog: { kind: "postback" }
 	});
 	return {
@@ -665,41 +576,6 @@ 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",
@@ -710,9 +586,63 @@ const LINE_DOWNLOADABLE_MESSAGE_TYPES = /* @__PURE__ */ new Set([
 function isDownloadableLineMessageType(messageType) {
 	return LINE_DOWNLOADABLE_MESSAGE_TYPES.has(messageType);
 }
+const LINE_WEBHOOK_REPLAY_WINDOW_MS = 6e5;
+const LINE_WEBHOOK_REPLAY_MAX_ENTRIES = 4096;
 function normalizeLineIngressEntry(value) {
 	return normalizeLineAllowEntry(value) || null;
 }
+var LineRetryableWebhookError = class extends Error {
+	constructor(message, options) {
+		super(message, options);
+		this.name = "LineRetryableWebhookError";
+	}
+};
+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,
@@ -787,7 +717,7 @@ async function shouldProcessLineEvent(event, context) {
 		defaultGroupPolicy: resolveDefaultGroupPolicy(cfg)
 	});
 	const groupPolicy = runtimeGroupPolicy === "disabled" ? "disabled" : groupConfig?.allowFrom !== void 0 ? "allowlist" : runtimeGroupPolicy;
-	const groupAllowFrom = normalizeStringEntries(firstDefined(groupConfig?.allowFrom, account.config.groupAllowFrom));
+	const groupAllowFrom = normalizeStringEntries(firstDefined(groupConfig?.allowFrom, account.config.groupAllowFrom, account.config.allowFrom?.length ? account.config.allowFrom : void 0));
 	const mentionFacts = (() => {
 		if (!isGroup || event.type !== "message") return {
 			canDetectMention: false,
@@ -852,7 +782,7 @@ async function shouldProcessLineEvent(event, context) {
 		allowFrom: normalizeStringEntries(account.config.allowFrom),
 		groupAllowFrom,
 		command: {
-			hasControlCommand: hasControlCommand(rawText, cfg),
+			hasControlCommand: shouldComputeCommandAuthorized(rawText, cfg),
 			groupOwnerAllowFrom: "none"
 		}
 	});
@@ -950,42 +880,42 @@ async function handleMessageEvent(event, context) {
 		});
 		return;
 	}
-	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) {
-			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}`);
-			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
+	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
 		});
-		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) {
@@ -1016,41 +946,56 @@ async function handlePostbackEvent(event, context) {
 		commandAuthorized: decision.commandAccess.authorized
 	});
 	if (!postbackContext) return;
-	await context.processMessage(postbackContext, context.turnAdoptionLifecycle ? { turnAdoptionLifecycle: context.turnAdoptionLifecycle } : {});
+	await context.processMessage(postbackContext);
 }
 async function handleLineWebhookEvents(events, context) {
 	let firstError;
-	for (const event of events) try {
-		await handleLineWebhookEvent(event, context);
-	} catch (err) {
-		context.runtime.error?.(danger(`line: event handler failed: ${String(err)}`));
-		firstError ??= err;
+	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) {
+				if (err instanceof LineRetryableWebhookError) replayCandidate.cache.release(replayCandidate.key, { error: err });
+				else await replayCandidate.cache.commit(replayCandidate.key);
+			}
+			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);
@@ -1059,257 +1004,6 @@ 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();
@@ -1322,26 +1016,24 @@ function createLineBot(opts) {
 	const processMessage = opts.onMessage ?? (async () => {
 		logVerbose("line: no message handler configured");
 	});
+	const replayCache = createLineWebhookReplayCache();
 	const groupHistories = /* @__PURE__ */ new Map();
-	const spool = createLineWebhookSpool({
-		accountId: account.accountId,
-		runtime,
-		deliver: async (event, _destination, control) => await handleLineWebhookEvents([event], {
+	const handleWebhook = async (body) => {
+		if (!body.events || body.events.length === 0) return;
+		await handleLineWebhookEvents(body.events, {
 			cfg,
 			account,
 			runtime,
 			mediaMaxBytes,
 			processMessage,
-			...control.turnAdoptionLifecycle ? { turnAdoptionLifecycle: control.turnAdoptionLifecycle } : {},
+			replayCache,
 			groupHistories,
 			historyLimit: cfg.messages?.groupChat?.historyLimit ?? DEFAULT_GROUP_HISTORY_LIMIT
-		})
-	});
-	spool.start();
+		});
+	};
 	return {
-		handleWebhook: spool.accept,
-		account,
-		stop: spool.stop
+		handleWebhook,
+		account
 	};
 }
 //#endregion
@@ -1359,9 +1051,63 @@ function resolveLineDurableReplyOptions(params) {
 	return { to: params.to };
 }
 //#endregion
+//#region extensions/line/src/reply-chunks.ts
+async function sendLineReplyChunks(params) {
+	const hasQuickReplies = Boolean(params.quickReplies?.length);
+	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 (hasQuickReplies && remaining.length === 0 && replyMessages.length > 0) {
+			const lastIndex = replyMessages.length - 1;
+			replyMessages[lastIndex] = params.createTextMessageWithQuickReplies(replyBatch[lastIndex], params.quickReplies);
+		}
+		await params.replyMessageLine(params.replyToken, replyMessages, {
+			cfg: params.cfg,
+			accountId: params.accountId
+		});
+		replyTokenUsed = true;
+		for (let i = 0; i < remaining.length; i += 1) if (i === remaining.length - 1 && hasQuickReplies) await params.pushTextMessageWithQuickReplies(params.to, remaining[i], params.quickReplies, {
+			cfg: params.cfg,
+			accountId: params.accountId
+		});
+		else await params.pushMessageLine(params.to, remaining[i], {
+			cfg: params.cfg,
+			accountId: params.accountId
+		});
+		return { replyTokenUsed };
+	} catch (err) {
+		params.onReplyError?.(err);
+		replyTokenUsed = true;
+	}
+	for (let i = 0; i < params.chunks.length; i += 1) if (i === params.chunks.length - 1 && hasQuickReplies) await params.pushTextMessageWithQuickReplies(params.to, params.chunks[i], params.quickReplies, {
+		cfg: params.cfg,
+		accountId: params.accountId
+	});
+	else await params.pushMessageLine(params.to, params.chunks[i], {
+		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"));
+	const hash = crypto.createHmac("SHA256", channelSecret).update(body).digest("base64");
+	const hashBuffer = Buffer.from(hash);
+	const signatureBuffer = Buffer.from(signature);
+	const maxLen = Math.max(hashBuffer.length, signatureBuffer.length);
+	const paddedHash = Buffer.alloc(maxLen);
+	const paddedSig = Buffer.alloc(maxLen);
+	hashBuffer.copy(paddedHash);
+	signatureBuffer.copy(paddedSig);
+	const timingResult = crypto.timingSafeEqual(paddedHash, paddedSig);
+	return hashBuffer.length === signatureBuffer.length && timingResult;
 }
 //#endregion
 //#region extensions/line/src/webhook-utils.ts
@@ -1374,8 +1120,8 @@ function parseLineWebhookBody(rawBody) {
 }
 //#endregion
 //#region extensions/line/src/webhook-node.ts
-const LINE_WEBHOOK_MAX_BODY_BYTES = 1024 * 1024;
-const LINE_WEBHOOK_PREAUTH_MAX_BODY_BYTES$1 = 64 * 1024;
+const LINE_WEBHOOK_MAX_BODY_BYTES = 1048576;
+const LINE_WEBHOOK_PREAUTH_MAX_BODY_BYTES$1 = 65536;
 const LINE_WEBHOOK_PREAUTH_BODY_TIMEOUT_MS$1 = 5e3;
 async function readLineWebhookRequestBody(req, maxBytes = LINE_WEBHOOK_MAX_BODY_BYTES, timeoutMs = LINE_WEBHOOK_PREAUTH_BODY_TIMEOUT_MS$1) {
 	return await readRequestBodyWithLimit(req, {
@@ -1383,6 +1129,9 @@ 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;
@@ -1405,6 +1154,7 @@ 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() : "";
@@ -1431,14 +1181,24 @@ 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`);
-				await params.bot.handleWebhook(body);
+				Promise.resolve().then(() => params.bot.handleWebhook(body)).catch((err) => logLineWebhookDispatchError(params.runtime, err));
 			}
-			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");
@@ -1462,10 +1222,24 @@ function createLineNodeWebhookHandler(params) {
 }
 //#endregion
 //#region extensions/line/src/monitor.ts
+const runtimeState = /* @__PURE__ */ new Map();
 const lineWebhookInFlightLimiter = createWebhookInFlightLimiter();
-const LINE_WEBHOOK_PREAUTH_MAX_BODY_BYTES = 64 * 1024;
+const LINE_WEBHOOK_PREAUTH_MAX_BODY_BYTES = 65536;
 const LINE_WEBHOOK_PREAUTH_BODY_TIMEOUT_MS = 5e3;
 const lineWebhookTargets = /* @__PURE__ */ new Map();
+function recordChannelRuntimeState(params) {
+	const key = `${params.channel}:${params.accountId}`;
+	const existing = runtimeState.get(key) ?? {
+		running: false,
+		lastStartAt: null,
+		lastStopAt: null,
+		lastError: null
+	};
+	runtimeState.set(key, {
+		...existing,
+		...params.state
+	});
+}
 function startLineLoadingKeepalive(params) {
 	const intervalMs = params.intervalMs ?? 18e3;
 	const loadingSeconds = params.loadingSeconds ?? 20;
@@ -1499,9 +1273,14 @@ async function monitorLineProvider(opts) {
 		accountId,
 		runtime,
 		config,
-		onMessage: async (ctx, deliveryControl) => {
+		onMessage: async (ctx) => {
 			if (!ctx) return;
 			const { ctxPayload, replyToken, route } = ctx;
+			recordChannelRuntimeState({
+				channel: "line",
+				accountId: resolvedAccountId,
+				state: { lastInboundAt: Date.now() }
+			});
 			const shouldShowLoading = Boolean(ctx.userId && !ctx.isGroup);
 			const displayNamePromise = ctx.userId ? getUserDisplayName(ctx.userId, {
 				cfg: config,
@@ -1512,24 +1291,16 @@ async function monitorLineProvider(opts) {
 				userId: ctx.userId,
 				accountId: ctx.accountId
 			}) : null;
-			logVerbose(`line: received message from ${await displayNamePromise} (${ctxPayload.From})`);
-			let replyTokenUsed = false;
-			let turnAdopted = false;
-			const ingressLifecycle = deliveryControl.turnAdoptionLifecycle;
+			const displayName = await displayNamePromise;
+			logVerbose(`line: received message from ${displayName} (${ctxPayload.From})`);
 			try {
 				const textLimit = 5e3;
-				const turnResult = await getLineRuntime().channel.inbound.run({
+				let replyTokenUsed = false;
+				const core = getLineRuntime();
+				const turnResult = await core.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()}`,
@@ -1539,14 +1310,14 @@ async function monitorLineProvider(opts) {
 							cfg: config,
 							channel: "line",
 							accountId: route.accountId,
-							route: {
-								agentId: route.agentId,
-								sessionKey: route.sessionKey
-							},
+							agentId: route.agentId,
+							routeSessionKey: route.sessionKey,
+							storePath: ctx.turn.storePath,
 							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,
@@ -1574,11 +1345,15 @@ async function monitorLineProvider(opts) {
 											buildTemplateMessageFromPayload,
 											processLineMessage,
 											chunkMarkdownText,
+											sendLineReplyChunks,
 											replyMessageLine,
+											pushMessageLine,
+											pushTextMessageWithQuickReplies,
 											createQuickReplyItems,
+											createTextMessageWithQuickReplies,
 											pushMessagesLine,
 											createFlexMessage,
-											buildMediaMessage: buildLineMediaMessage,
+											createImageMessage,
 											createLocationMessage,
 											onReplyError: (replyErr) => {
 												logVerbose(`line: reply token failed, falling back to push: ${String(replyErr)}`);
@@ -1587,7 +1362,11 @@ async function monitorLineProvider(opts) {
 									});
 									replyTokenUsed = deliveryResult.replyTokenUsed;
 									if (deliveryResult.status === "partial") throw deliveryResult.error;
-									return { visibleReplySent: deliveryResult.visibleReplySent };
+									recordChannelRuntimeState({
+										channel: "line",
+										accountId: resolvedAccountId,
+										state: { lastOutboundAt: Date.now() }
+									});
 								},
 								onError: (err, info) => {
 									runtime.error?.(danger(`line ${info.kind} reply failed: ${String(err)}`));
@@ -1596,11 +1375,21 @@ async function monitorLineProvider(opts) {
 						})
 					}
 				});
-				if (!hasFinalInboundReplyDispatch(turnResult.dispatched ? turnResult.dispatchResult : void 0)) logVerbose(`line: no response generated for message from ${ctxPayload.From}`);
+				const dispatchResult = turnResult.dispatched ? turnResult.dispatchResult : void 0;
+				if (!hasFinalInboundReplyDispatch(dispatchResult)) logVerbose(`line: no response generated for message from ${ctxPayload.From}`);
 			} catch (err) {
 				runtime.error?.(danger(`line: auto-reply failed: ${String(err)}`));
-				if (turnAdopted || replyTokenUsed) throw new LineWebhookTerminalDeliveryError("LINE delivery failed after consuming the event reply token.", { cause: err });
-				throw 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)}`));
+				}
 			} finally {
 				stopLoading?.();
 			}
@@ -1678,13 +1467,16 @@ async function monitorLineProvider(opts) {
 						res.end(JSON.stringify({ error: "Invalid webhook payload" }));
 						return;
 					}
-					if (body.events && body.events.length > 0) {
-						logVerbose(`line: received ${body.events.length} webhook events`);
-						await match.target.bot.handleWebhook(body);
-					}
+					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)}`));
+						});
+					}
 				} catch (err) {
 					if (isRequestBodyLimitError(err, "PAYLOAD_TOO_LARGE")) {
 						res.statusCode = 413;
@@ -1710,31 +1502,41 @@ async function monitorLineProvider(opts) {
 			}
 		}
 	});
+	recordChannelRuntimeState({
+		channel: "line",
+		accountId: resolvedAccountId,
+		state: {
+			running: true,
+			lastStartAt: Date.now()
+		}
+	});
 	logVerbose(`line: registered webhook handler at ${normalizedPath}`);
 	let stopped = false;
-	let stopPromise;
 	const stopHandler = () => {
-		if (stopPromise) return stopPromise;
-		if (stopped) return Promise.resolve();
+		if (stopped) return;
 		stopped = true;
 		logVerbose(`line: stopping provider for account ${resolvedAccountId}`);
 		unregisterHttp();
-		stopPromise = bot.stop();
-		return stopPromise;
+		recordChannelRuntimeState({
+			channel: "line",
+			accountId: resolvedAccountId,
+			state: {
+				running: false,
+				lastStopAt: Date.now()
+			}
+		});
 	};
-	const stopOnAbort = () => void stopHandler();
-	if (abortSignal?.aborted) await stopHandler();
+	if (abortSignal?.aborted) stopHandler();
 	else if (abortSignal) {
-		abortSignal.addEventListener("abort", stopOnAbort, { once: true });
+		abortSignal.addEventListener("abort", stopHandler, { once: true });
 		await waitForAbortSignal(abortSignal);
-		await stopHandler();
 	}
 	return {
 		account: bot.account,
 		handleWebhook: bot.handleWebhook,
-		stop: async () => {
-			await stopHandler();
-			abortSignal?.removeEventListener("abort", stopOnAbort);
+		stop: () => {
+			stopHandler();
+			abortSignal?.removeEventListener("abort", stopHandler);
 		}
 	};
 }