@openclaw/line 2026.9.4 → 2026.9.6

package/dist/{monitor-2lOtBpg-.js → .setup/monitor-morJPcPd.mjs}

@@ -1,58 +1,43 @@
-import { i as resolveLineAccount, r as resolveDefaultLineAccountId } from "./accounts-BBEFMYbY.js";
-import { f as resolveLineGroupConfigEntry, h as getLineRuntime, i as prepareLineReplyPayload, n as createLineQuickReply, u as buildLineQuickReplyFallbackText } from "./rich-messages-HS8pNeOa.js";
-import { n as findLineHttpError, r as resolveLineNonDispatchRetryable, t as explainLineRefusal, w as buildLineMediaMessage } from "./send-retry-ChpfJ-LM.js";
-import { a as eventIdFor, n as LINE_WEBHOOK_SPOOL_INVALID_PAYLOAD_MESSAGE, o as laneKeyFor, r as LineWebhookPayloadError, t as LINE_WEBHOOK_SPOOL_INVALID_EVENT_REASON } from "./webhook-spool-contract-1rY8OJw8.js";
-import { a as buildTemplateMessageFromPayload, r as processLineMessage } from "./markdown-to-line-DR3sFH6H.js";
-import { _ as showLoadingAnimation, a as getLineGroupName, d as pushMessageLine, f as pushMessagesLine, h as replyMessageLine, n as createLocationMessage, o as getUserDisplayName, s as getUserProfile, t as createFlexMessage, v as quotesLineBotMessage } from "./send-CQQxpxPp.js";
+import { i as resolveLineAccount, r as resolveDefaultLineAccountId } from "./accounts-BBEFMYbY.mjs";
+import { b as normalizeAllowFrom, c as resolveLineQuestionPostback, f as buildLineQuickReplyFallbackText, g as resolveLineGroupConfigEntry, i as prepareLineReplyPayload, n as createLineQuickReply, p as getLineRuntime, s as parseLineQuestionPostbackData, x as normalizeLineAllowEntry, y as firstDefined } from "./rich-messages-d8CmBVJj.mjs";
+import { D as recordLineQuoteToken, E as readLineQuoteToken, O as reportLineQuoteCarrierMissing, T as canCarryLineQuoteToken, j as buildLineMediaMessage, k as resolveLineQuoteToken, n as findLineHttpError, r as resolveLineNonDispatchRetryable, t as explainLineRefusal, w as applyLineQuoteToken } from "./send-retry-DbfiHBPd.mjs";
+import { a as eventIdFor, n as LINE_WEBHOOK_SPOOL_INVALID_PAYLOAD_MESSAGE, o as laneKeyFor, r as LineWebhookPayloadError, t as LINE_WEBHOOK_SPOOL_INVALID_EVENT_REASON } from "./webhook-spool-contract-1rY8OJw8.mjs";
+import { a as buildTemplateMessageFromPayload, r as processLineMessage } from "./markdown-to-line-CRfEHFs0.mjs";
+import { _ as showLoadingAnimation, a as getLineGroupName, d as pushMessageLine, f as pushMessagesLine, h as replyMessageLine, n as createLocationMessage, o as getUserDisplayName, s as getUserProfile, t as createFlexMessage, v as quotesLineBotMessage } from "./send-BmsHY4WC.mjs";
 import { createChannelPairingChallengeIssuer } from "openclaw/plugin-sdk/channel-pairing";
 import { resolveChannelGroupsConfigPath } from "openclaw/plugin-sdk/channel-policy";
 import { normalizeOptionalString, normalizeStringEntries, readNonEmptyStringPreservingWhitespace } 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 { DEFAULT_INGRESS_ADOPTION_STALL_MS, DEFAULT_INGRESS_RETRY_MAX_ATTEMPTS, bindIngressLifecycleToReplyOptions, createChannelIngressMonitor, resolveChannelStreamingBlockEnabled } from "openclaw/plugin-sdk/channel-outbound";
 import { buildChannelInboundEventContext, buildMentionRegexes, formatInboundEnvelope, formatInboundMediaUnavailableText, formatLocationText, hasFinalInboundReplyDispatch, implicitMentionKindWhen, isChannelPartialDeliveryError, logInboundDrop, matchesMentionPatterns, resolveInboundSessionEnvelopeContext, toInboundMediaFactsWithMetadata, toLocationContext } from "openclaw/plugin-sdk/channel-inbound";
 import { collectErrorGraphCandidates, extractErrorCode, formatErrorMessage, readErrorName, toErrorObject } from "openclaw/plugin-sdk/error-runtime";
 import { resolveSendableOutboundReplyParts } from "openclaw/plugin-sdk/reply-payload";
 import { sanitizeAssistantVisibleText } from "openclaw/plugin-sdk/text-chunking";
+import { createNonExitingRuntime, danger, logVerbose, shouldLogVerbose, waitForAbortSignal, warn } from "openclaw/plugin-sdk/runtime-env";
 import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 import { classifyTransientNetworkErrorCode } from "openclaw/plugin-sdk/retry-runtime";
 import { fetchWithRuntimeDispatcherOrMockedGlobal } from "openclaw/plugin-sdk/runtime-fetch";
-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 { saveMediaStream } from "openclaw/plugin-sdk/media-store";
-import { createNonExitingRuntime, danger, logVerbose, shouldLogVerbose, waitForAbortSignal, warn } from "openclaw/plugin-sdk/runtime-env";
 import crypto from "node:crypto";
 import { recordChannelActivity } from "openclaw/plugin-sdk/channel-activity-runtime";
 import { resolveHumanDelayConfig } from "openclaw/plugin-sdk/agent-runtime";
 import { channelReadyPatch, channelStoppedPatch } from "openclaw/plugin-sdk/gateway-runtime";
-import { chunkMarkdownText } from "openclaw/plugin-sdk/reply-runtime";
-import { canonicalizeWebhookRouteKey, normalizePluginHttpPath, normalizeWebhookPath, registerWebhookTargetWithPluginRoute, resolveSingleWebhookTarget } from "openclaw/plugin-sdk/webhook-ingress";
+import { canonicalizeWebhookRouteKey, registerWebhookTargetWithPluginRoute, resolveSingleWebhookTarget, resolveWebhookPath } from "openclaw/plugin-sdk/webhook-ingress";
 import { beginWebhookRequestPipelineOrReject, createWebhookInFlightLimiter, isRequestBodyLimitError, readRequestBodyWithLimit, requestBodyErrorToText, runDetachedWebhookWork, sendHttpRequestRejection } from "openclaw/plugin-sdk/webhook-request-guards";
 import { expectDefined } from "openclaw/plugin-sdk/expect-runtime";
-import { DEFAULT_GROUP_HISTORY_LIMIT, createChannelHistoryWindow } from "openclaw/plugin-sdk/reply-history";
+import { chunkMarkdownText } from "openclaw/plugin-sdk/reply-runtime";
+import { resolvePromptHistoryLimit } from "openclaw/plugin-sdk/number-runtime";
 import { getRuntimeConfig, getRuntimeConfigSnapshot, getRuntimeConfigSourceSnapshot, selectApplicableRuntimeConfig } from "openclaw/plugin-sdk/runtime-config-snapshot";
-import { resolveChannelImplicitMentions, resolveStableChannelMessageIngress } from "openclaw/plugin-sdk/channel-ingress-runtime";
+import { fanInChannelIngressLifecycles, resolveChannelImplicitMentions } from "openclaw/plugin-sdk/channel-ingress-runtime";
 import { reportChannelRoomJoin } from "openclaw/plugin-sdk/channel-join-intro-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 { DEFAULT_GROUP_HISTORY_LIMIT, createChannelHistoryWindow } from "openclaw/plugin-sdk/reply-history";
 import { resolveAgentRoute, resolveInboundLastRouteSessionKey } from "openclaw/plugin-sdk/routing";
 import { resolveAllowlistProviderRuntimeGroupPolicy, resolveDefaultGroupPolicy, warnMissingProviderGroupPolicyFallbackOnce } from "openclaw/plugin-sdk/runtime-group-policy";
+import { enqueueKeyedTask } from "openclaw/plugin-sdk/keyed-async-queue";
 import { safeEqualSecret } from "openclaw/plugin-sdk/security-runtime";
-//#region extensions/line/src/bot-access.ts
-function normalizeLineAllowEntry(value) {
-	const trimmed = String(value).trim();
-	if (!trimmed) return "";
-	if (trimmed === "*") return "*";
-	return trimmed.replace(/^line:(?:user:)?/i, "");
-}
-const normalizeAllowFrom = (list) => {
-	const entries = (list ?? []).map((value) => normalizeLineAllowEntry(value)).filter(Boolean);
-	return {
-		entries,
-		hasWildcard: entries.includes("*"),
-		hasEntries: entries.length > 0
-	};
-};
-//#endregion
 //#region extensions/line/src/download.ts
 const CONTENT_READY_MAX_ATTEMPTS = 6;
 const CONTENT_READY_BASE_DELAY_MS = 500;
@@ -187,7 +172,7 @@ function markLineVisibleDeliveryError(error) {
 	return visibleError;
 }
 async function deliverLineAutoReply(params) {
-	const { payload, lineData, replyToken, accountId, to, textLimit, deps } = params;
+	const { payload, lineData, replyToken, accountId, to, textLimit } = params;
 	let replyTokenUsed = params.replyTokenUsed;
 	let visibleReplySent = false;
 	const sendVisible = async (send) => {
@@ -201,14 +186,14 @@ async function deliverLineAutoReply(params) {
 			throw error;
 		}
 	};
-	const replyVisible = (...args) => sendVisible(() => deps.replyMessageLine(...args));
+	const replyVisible = (...args) => sendVisible(() => replyMessageLine(...args));
 	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) {
 			const batch = messages.slice(i, i + 5);
 			try {
-				await sendVisible(() => deps.pushMessagesLine(to, batch, {
+				await sendVisible(() => pushMessagesLine(to, batch, {
 					cfg: params.cfg,
 					accountId
 				}));
@@ -234,7 +219,7 @@ async function deliverLineAutoReply(params) {
 				});
 			} catch (err) {
 				if (isChannelPartialDeliveryError(err) || !canFallbackAfterLineReplyFailure(err)) throw err;
-				deps.onReplyError?.(err);
+				params.onReplyError?.(err);
 				await pushLineMessages(replyBatch, findLineHttpError(err)?.status === 400, remaining.slice(replyBatch.length));
 			} finally {
 				replyTokenUsed = true;
@@ -253,23 +238,23 @@ async function deliverLineAutoReply(params) {
 	}));
 	const quickReplyLabels = quickReplyItems.map((item) => item.label);
 	const hasQuickReplies = quickReplyItems.length > 0;
-	if (lineData.flexMessage) richMessages.push(deps.createFlexMessage(lineData.flexMessage.altText, lineData.flexMessage.contents));
+	if (lineData.flexMessage) richMessages.push(createFlexMessage(lineData.flexMessage.altText, lineData.flexMessage.contents));
 	if (lineData.templateMessage) {
-		const templateMsg = deps.buildTemplateMessageFromPayload(lineData.templateMessage);
+		const templateMsg = buildTemplateMessageFromPayload(lineData.templateMessage);
 		if (templateMsg) richMessages.push(templateMsg);
 	}
-	if (lineData.location) richMessages.push(deps.createLocationMessage(lineData.location));
+	if (lineData.location) richMessages.push(createLocationMessage(lineData.location));
 	const visibleText = payload.text ? sanitizeAssistantVisibleText(payload.text) : "";
-	const processed = visibleText ? deps.processLineMessage(visibleText) : {
+	const processed = visibleText ? processLineMessage(visibleText) : {
 		text: "",
 		flexMessages: []
 	};
-	if (!processed.segments) for (const flexMsg of processed.flexMessages) richMessages.push(deps.createFlexMessage(flexMsg.altText, flexMsg.contents));
-	const orderedMessages = processed.segments?.flatMap((segment) => segment.type === "flex" ? [deps.createFlexMessage(segment.message.altText, segment.message.contents)] : deps.chunkMarkdownText(segment.text, textLimit).map((text) => ({
+	if (!processed.segments) for (const flexMsg of processed.flexMessages) richMessages.push(createFlexMessage(flexMsg.altText, flexMsg.contents));
+	const orderedMessages = processed.segments?.flatMap((segment) => segment.type === "flex" ? [createFlexMessage(segment.message.altText, segment.message.contents)] : chunkMarkdownText(segment.text, textLimit).map((text) => ({
 		type: "text",
 		text
 	})));
-	const chunks = orderedMessages ? orderedMessages.flatMap((message) => message.type === "text" ? [message.text] : []) : processed.text ? deps.chunkMarkdownText(processed.text, textLimit) : [];
+	const chunks = orderedMessages ? orderedMessages.flatMap((message) => message.type === "text" ? [message.text] : []) : processed.text ? chunkMarkdownText(processed.text, textLimit) : [];
 	const mediaUrls = resolveSendableOutboundReplyParts(payload).mediaUrls;
 	const mediaOpts = {
 		mediaKind: lineData.mediaKind,
@@ -283,7 +268,7 @@ async function deliverLineAutoReply(params) {
 		const url = rawUrl?.trim();
 		if (!url) continue;
 		try {
-			mediaMessages.push(await deps.buildMediaMessage(url, mediaOpts, to));
+			mediaMessages.push(await buildLineMediaMessage(url, mediaOpts, to));
 		} catch (err) {
 			deliveryError ??= err;
 		}
@@ -310,7 +295,15 @@ async function deliverLineAutoReply(params) {
 			quickReply: createLineQuickReply(quickReplyItems)
 		};
 	}
-	const messages = hasQuickReplies ? [...richMediaMessages, ...orderedDeliveryMessages ?? textMessages] : [...orderedDeliveryMessages ?? textMessages, ...richMediaMessages];
+	const ordered = hasQuickReplies ? [...richMediaMessages, ...orderedDeliveryMessages ?? textMessages] : [...orderedDeliveryMessages ?? textMessages, ...richMediaMessages];
+	const replyQuoteToken = resolveLineQuoteToken({
+		cfg: params.cfg,
+		accountId,
+		chatId: to,
+		messageId: payload.replyToId
+	});
+	if (replyQuoteToken && !ordered.some(canCarryLineQuoteToken)) reportLineQuoteCarrierMissing(to);
+	const messages = applyLineQuoteToken(ordered, replyQuoteToken);
 	try {
 		await sendLineMessages(messages, true);
 	} catch (err) {
@@ -573,9 +566,7 @@ async function finalizeLineInboundContext(params) {
 			label: conversationLabel
 		},
 		route: {
-			agentId: params.route.agentId,
-			dmScope: params.route.dmScope,
-			accountId: params.route.accountId,
+			...params.route,
 			routeSessionKey: params.route.sessionKey
 		},
 		reply: {
@@ -660,11 +651,22 @@ async function buildLineMessageContext(params) {
 		kind: nativeMediaKind
 	})) : nativeMediaKind ? [{ kind: nativeMediaKind }] : [];
 	const rawBody = textContent;
-	const agentBody = mediaUnavailable ? formatInboundMediaUnavailableText({
+	const shortfallNotice = params.missingParts ? `[line: ${params.missingParts === 1 ? "1 more image in this send was" : `${params.missingParts} more images in this send were`} not delivered]` : void 0;
+	const withShortfall = shortfallNotice ? formatInboundMediaUnavailableText({
 		body: rawBody,
-		notice: "[line attachment unavailable]"
+		notice: shortfallNotice
 	}) : rawBody;
+	const agentBody = mediaUnavailable ? formatInboundMediaUnavailableText({
+		body: withShortfall,
+		notice: "[line attachment unavailable]"
+	}) : withShortfall;
 	if (!agentBody && mediaFacts.length === 0) return null;
+	recordLineQuoteToken({
+		accountId: account.accountId,
+		chatId: peerId,
+		messageId,
+		quoteToken: readLineQuoteToken(message)
+	});
 	let locationContext;
 	if (message.type === "location") {
 		const loc = message;
@@ -836,6 +838,39 @@ function isDownloadableLineMessageType(messageType) {
 function normalizeLineIngressEntry(value) {
 	return normalizeLineAllowEntry(value) || null;
 }
+/**
+* Say one line back to a sender, preferring their reply token so the answer costs no
+* push quota, and falling back to a push when no token is usable. A partial-delivery
+* failure means the reply was seen, so it never falls back.
+*/
+async function sendLineHandlerText(params) {
+	const { context, logLabel, text } = params;
+	const sendOptions = {
+		cfg: context.cfg,
+		accountId: context.account.accountId,
+		channelAccessToken: context.account.channelAccessToken,
+		...params.authorize ? { authorize: params.authorize } : {}
+	};
+	if (params.replyToken) {
+		if (params.authorize && !await params.authorize()) return;
+		try {
+			await replyMessageLine(params.replyToken, [{
+				type: "text",
+				text
+			}], sendOptions);
+			return;
+		} catch (err) {
+			logVerbose(`${logLabel}: ${String(err)}`);
+			if (isChannelPartialDeliveryError(err)) return;
+		}
+	}
+	if (params.authorize && !await params.authorize()) return;
+	try {
+		await pushMessageLine(params.pushTarget, text, sendOptions);
+	} catch (err) {
+		logVerbose(`${logLabel}: ${String(err)}`);
+	}
+}
 async function sendLinePairingReply(params) {
 	const { senderId, replyToken, context } = params;
 	const idLabel = (() => {
@@ -860,33 +895,18 @@ async function sendLinePairingReply(params) {
 		onCreated: () => {
 			logVerbose(`line pairing request sender=${senderId}`);
 		},
-		sendPairingReply: async (text) => {
-			if (replyToken) try {
-				await replyMessageLine(replyToken, [{
-					type: "text",
-					text
-				}], {
-					cfg: context.cfg,
-					accountId: context.account.accountId,
-					channelAccessToken: context.account.channelAccessToken
-				});
-				return;
-			} catch (err) {
-				logVerbose(`line pairing reply failed for ${senderId}: ${String(err)}`);
-				if (isChannelPartialDeliveryError(err)) return;
-			}
-			try {
-				await pushMessageLine(`line:${senderId}`, text, {
-					cfg: context.cfg,
-					accountId: context.account.accountId,
-					channelAccessToken: context.account.channelAccessToken
-				});
-			} catch (err) {
-				logVerbose(`line pairing reply failed for ${senderId}: ${String(err)}`);
-			}
-		}
+		sendPairingReply: async (text) => await sendLineHandlerText({
+			context,
+			text,
+			replyToken,
+			pushTarget: `line:${senderId}`,
+			logLabel: `line pairing reply failed for ${senderId}`
+		})
 	});
 }
+function isLineEventAdmitted(access) {
+	return access.senderAccess.decision === "allow" && (access.ingress.admission === "dispatch" || access.ingress.admission === "observe" || access.ingress.admission === "skip");
+}
 async function resolveLineEventAdmission(event, context) {
 	const { cfg, account } = context;
 	const { userId, groupId, roomId, isGroup } = getLineSourceInfo(event.source);
@@ -928,7 +948,7 @@ async function resolveLineEventAdmission(event, context) {
 			implicitMentionKinds: implicitMentionKindWhen("quoted_bot", quotesLineBotMessage(account.accountId, resolveLineQuotedMessageId(event.message)))
 		};
 	})();
-	const resolveAccess = async (contextBinding) => await resolveStableChannelMessageIngress({
+	const resolveAccess = async (contextBinding) => await getLineRuntime().channel.inbound.ingress.resolveStable({
 		channelId: "line",
 		accountId: account.accountId,
 		identity: {
@@ -983,7 +1003,7 @@ async function resolveLineEventAdmission(event, context) {
 		access,
 		resolveBoundAccess: resolveAccess
 	} : null;
-	if (access.senderAccess.decision === "allow" && (access.ingress.admission === "dispatch" || access.ingress.admission === "observe" || access.ingress.admission === "skip")) return {
+	if (isLineEventAdmitted(access)) return {
 		access,
 		resolveBoundAccess: resolveAccess,
 		mentions: mentionFacts ? {
@@ -1048,7 +1068,7 @@ function resolveEventRawText(event) {
 	if (event.type === "postback") return event.postback?.data?.trim() ?? "";
 	return "";
 }
-async function handleMessageEvent(event, context) {
+async function handleMessageEvent(event, context, setParts) {
 	const { cfg, account, runtime, mediaMaxBytes, processMessage } = context;
 	const message = event.message;
 	const decision = await resolveLineEventAdmission(event, context);
@@ -1098,11 +1118,12 @@ async function handleMessageEvent(event, context) {
 	try {
 		const allMedia = [];
 		let mediaUnavailable = false;
-		if (isDownloadableLineMessageType(message.type)) {
-			const abortSignal = context.turnAdoptionLifecycle?.abortSignal;
+		const abortSignal = context.turnAdoptionLifecycle?.abortSignal;
+		for (const part of orderedLineSetMessages(message, setParts)) {
+			if (!isDownloadableLineMessageType(part.type)) continue;
 			try {
-				const originalFilename = message.type === "file" ? normalizeOptionalString(message.fileName) : void 0;
-				const media = await downloadLineMedia(message.id, account.channelAccessToken, mediaMaxBytes, {
+				const originalFilename = part.type === "file" ? normalizeOptionalString(part.fileName) : void 0;
+				const media = await downloadLineMedia(part.id, account.channelAccessToken, mediaMaxBytes, {
 					originalFilename,
 					...abortSignal ? { signal: abortSignal } : {}
 				});
@@ -1117,14 +1138,15 @@ async function handleMessageEvent(event, context) {
 				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}`);
+				if (errMsg.includes("exceeds") && errMsg.includes("limit")) logVerbose(`line: media exceeds size limit for message ${part.id}`);
 				else runtime.error?.(danger(`line: failed to download media: ${errMsg}`));
 			}
 		}
 		const messageContext = await buildLineMessageContext({
-			event,
-			allMedia,
+			event: setParts.reduce((freshest, part) => part.timestamp > freshest.timestamp ? part : freshest, event),
+			allMedia: [...allMedia],
 			mediaUnavailable,
+			...context.missingParts === void 0 ? {} : { missingParts: context.missingParts },
 			cfg,
 			account,
 			commandAuthorized: decision.access.commandAccess.authorized,
@@ -1133,15 +1155,14 @@ async function handleMessageEvent(event, context) {
 			mentions: decision.mentions,
 			buildContext: context.buildContext
 		});
-		if (!messageContext) {
-			logVerbose("line: skipping empty message");
-			return;
+		if (!messageContext) logVerbose("line: skipping empty message");
+		else {
+			await processMessage(messageContext, {
+				cfg: context.cfg,
+				...context.turnAdoptionLifecycle ? { turnAdoptionLifecycle: context.turnAdoptionLifecycle } : {}
+			});
+			historyReservation.commit();
 		}
-		await processMessage(messageContext, {
-			cfg,
-			...context.turnAdoptionLifecycle ? { turnAdoptionLifecycle: context.turnAdoptionLifecycle } : {}
-		});
-		historyReservation.commit();
 	} finally {
 		historyReservation.release();
 	}
@@ -1195,11 +1216,39 @@ async function handleLeaveEvent(event, _context) {
 	const { groupId, roomId } = getLineSourceInfo(event.source);
 	logVerbose(`line: bot left ${groupId ? `group ${groupId}` : `room ${roomId}`}`);
 }
+/** What a tap that did not answer the question has to tell the person who tapped. */
+function lineQuestionOutcomeNotice(status) {
+	if (status === "already-terminal") return "That question is no longer waiting for an answer.";
+	return "Could not record that answer. Reply with the option text instead.";
+}
 async function handlePostbackEvent(event, context) {
 	const data = event.postback.data;
 	logVerbose(`line: received postback: ${data}`);
 	const decision = await resolveLineEventAdmission(event, context);
 	if (!decision) return;
+	const question = parseLineQuestionPostbackData(data ?? "");
+	if (question) {
+		const { userId, groupId, roomId } = getLineSourceInfo(event.source);
+		const authorize = async () => isLineEventAdmitted(await decision.resolveBoundAccess());
+		const outcome = await resolveLineQuestionPostback({
+			cfg: context.cfg,
+			callback: question,
+			accountId: context.account.accountId,
+			...userId ? { senderId: userId } : {},
+			authorize
+		});
+		const pushTarget = groupId ?? roomId ?? (userId ? `line:${userId}` : void 0);
+		if (outcome.status === "answered" || outcome.status === "denied" || !pushTarget) return;
+		await sendLineHandlerText({
+			context,
+			replyToken: event.replyToken,
+			pushTarget,
+			logLabel: "line: question answer notice failed",
+			text: lineQuestionOutcomeNotice(outcome.status),
+			authorize
+		});
+		return;
+	}
 	const postbackContext = await buildLinePostbackContext({
 		event,
 		cfg: context.cfg,
@@ -1214,20 +1263,31 @@ async function handlePostbackEvent(event, context) {
 		...context.turnAdoptionLifecycle ? { turnAdoptionLifecycle: context.turnAdoptionLifecycle } : {}
 	});
 }
+/** Media reads in the order the sender picked, whatever order LINE delivered. */
+function orderedLineSetMessages(message, setParts) {
+	const messages = [message, ...setParts.map((partEvent) => partEvent.message)];
+	const indexOf = (part) => part.type === "image" ? part.imageSet?.index ?? Number.MAX_SAFE_INTEGER : 0;
+	return messages.toSorted((left, right) => indexOf(left) - indexOf(right));
+}
+/**
+* Answers one delivery as one turn. The ingress spool decides which events share
+* a turn - a multi-image send is handed over as one delivery - so the first
+* event is the turn's own and the rest are the set parts behind it.
+*/
 async function handleLineWebhookEvents(events, context) {
-	let firstError;
-	for (const event of events) try {
-		await handleLineWebhookEvent(event, context);
+	const [event, ...setParts] = events;
+	if (!event) return;
+	try {
+		await handleLineWebhookEvent(event, context, setParts);
 	} catch (err) {
 		context.runtime.error?.(danger(`line: event handler failed: ${String(err)}`));
-		firstError ??= err;
+		throw toErrorObject(err, "Non-Error thrown");
 	}
-	if (firstError) throw toErrorObject(firstError, "Non-Error thrown");
 }
-async function handleLineWebhookEvent(event, context) {
+async function handleLineWebhookEvent(event, context, setParts = []) {
 	switch (event.type) {
 		case "message":
-			await handleMessageEvent(event, context);
+			await handleMessageEvent(event, context, setParts.filter((part) => part.type === "message"));
 			break;
 		case "follow":
 			await handleFollowEvent(event, context);
@@ -1248,6 +1308,125 @@ async function handleLineWebhookEvent(event, context) {
 	}
 }
 //#endregion
+//#region extensions/line/src/inbound-image-set.ts
+const IMAGE_SET_FLUSH_DELAY_MS = 4e3;
+/**
+* Ordered by the index the sender picked, falling back to arrival.
+*
+* `index` is optional per part in LINE's contract, so a set can arrive partly
+* indexed. Choosing the key per pair would make the comparator intransitive and
+* the resulting order depend on insertion; ranking unindexed parts last keeps
+* one total order for every mix.
+*/
+function orderedParts(pending) {
+	return [...pending.parts.values()].toSorted((left, right) => (left.index ?? Number.MAX_SAFE_INTEGER) - (right.index ?? Number.MAX_SAFE_INTEGER) || left.arrivedAt - right.arrivedAt);
+}
+/**
+* Buffers the parts of a LINE image set until the set is whole.
+*
+* The first part becomes the set's holder: its call does not resolve until the
+* set completes or its wait expires, and it is the one that delivers. Keeping
+* that call open is what keeps the combined turn inside a live ingress
+* adoption - a turn dispatched after every part had returned is refused by
+* admission, so a set that never completes would never be delivered at all.
+*/
+function createLineImageSetIngressBuffer() {
+	const pendingBySet = /* @__PURE__ */ new Map();
+	const deliveredBySet = /* @__PURE__ */ new Map();
+	const pendingKey = (laneKey, senderKey, setId) => `${laneKey}\u0000${senderKey}\u0000${setId}`;
+	const laneChain = /* @__PURE__ */ new Map();
+	const enterLane = async (laneKey) => {
+		let release = () => {};
+		const held = new Promise((resolve) => {
+			release = resolve;
+		});
+		let entered = () => {};
+		const turn = new Promise((resolve) => {
+			entered = resolve;
+		});
+		enqueueKeyedTask({
+			tails: laneChain,
+			key: laneKey,
+			task: async () => {
+				entered();
+				await held;
+			}
+		});
+		await turn;
+		return release;
+	};
+	const admit = async (input) => {
+		const part = {
+			index: input.index,
+			arrivedAt: Date.now(),
+			event: input.event,
+			lifecycle: input.lifecycle
+		};
+		const key = pendingKey(input.laneKey, input.senderKey, input.setId);
+		const forming = pendingBySet.get(key);
+		if (forming) {
+			forming.parts.set(input.messageId, part);
+			forming.total ??= input.total;
+			if (forming.total !== void 0 && forming.parts.size >= forming.total) {
+				forming.release();
+				return null;
+			}
+			if (forming.timer) {
+				clearTimeout(forming.timer);
+				forming.timer = setTimeout(forming.release, forming.flushDelayMs);
+				forming.timer.unref?.();
+			}
+			return null;
+		}
+		let release = () => {};
+		const whole = new Promise((resolve) => {
+			release = resolve;
+		});
+		const pending = {
+			parts: /* @__PURE__ */ new Map([[input.messageId, part]]),
+			total: input.total,
+			flushDelayMs: input.flushDelayMs ?? IMAGE_SET_FLUSH_DELAY_MS,
+			release: () => {
+				clearTimeout(pending.timer);
+				release();
+			}
+		};
+		pendingBySet.set(key, pending);
+		const carried = deliveredBySet.get(key);
+		if (carried) {
+			clearTimeout(carried.timer);
+			deliveredBySet.delete(key);
+		}
+		const carriedMessageIds = carried?.messageIds ?? /* @__PURE__ */ new Set();
+		const releaseLane = await enterLane(input.laneKey);
+		pending.timer = setTimeout(pending.release, pending.flushDelayMs);
+		pending.timer.unref?.();
+		if (pending.total !== void 0 && pending.parts.size >= pending.total) pending.release();
+		await whole;
+		pendingBySet.delete(key);
+		const ordered = orderedParts(pending);
+		const deliveredMessageIds = /* @__PURE__ */ new Set([...carriedMessageIds, ...pending.parts.keys()]);
+		const missing = pending.total === void 0 ? 0 : pending.total - deliveredMessageIds.size;
+		if (missing > 0) {
+			const carry = { messageIds: deliveredMessageIds };
+			carry.timer = setTimeout(() => deliveredBySet.delete(key), pending.flushDelayMs * 5);
+			carry.timer.unref?.();
+			deliveredBySet.set(key, carry);
+		}
+		return {
+			events: ordered.map((entry) => entry.event),
+			lifecycles: ordered.map((entry) => entry.lifecycle),
+			...missing > 0 ? { missing } : {},
+			finish: releaseLane
+		};
+	};
+	return {
+		admit,
+		enterLane,
+		isBusy: (laneKey) => laneChain.has(laneKey)
+	};
+}
+//#endregion
 //#region extensions/line/src/webhook-spool.ts
 const LINE_WEBHOOK_DRAIN_INTERVAL_MS = 500;
 const LINE_WEBHOOK_MAX_CONCURRENT_DELIVERIES = 8;
@@ -1285,7 +1464,24 @@ async function waitForActiveDeliveriesBeforeDispose(activeDeliveries) {
 		if (timeout) clearTimeout(timeout);
 	}
 }
+/** The imageSet a LINE inbound event belongs to, when it reported one. */
+function senderKeyFor(event) {
+	const source = event.source;
+	return source && "userId" in source && source.userId ? `user:${source.userId}` : "anonymous";
+}
+function resolveLineInboundImageSet(event) {
+	if (event.type !== "message" || event.message.type !== "image") return;
+	const imageSet = event.message.imageSet;
+	return imageSet?.id ? {
+		setId: imageSet.id,
+		senderKey: senderKeyFor(event),
+		messageId: event.message.id,
+		...imageSet.index === void 0 ? {} : { index: imageSet.index },
+		...imageSet.total === void 0 ? {} : { total: imageSet.total }
+	} : void 0;
+}
 function createLineWebhookSpool(options) {
+	const imageSets = createLineImageSetIngressBuffer();
 	const queue = options.queue ?? getLineRuntime().state.openChannelIngressQueue({ accountId: options.accountId });
 	const activeDeliveries = /* @__PURE__ */ new Set();
 	let acceptsDeferredClaims = true;
@@ -1326,39 +1522,90 @@ function createLineWebhookSpool(options) {
 			createClaimError: (kind) => new LineWebhookPayloadError(kind === "invalid-version" ? LINE_WEBHOOK_SPOOL_INVALID_PAYLOAD_MESSAGE : "LINE webhook event identity changed after durable admission.")
 		},
 		deliver: async ({ event, destination }, lifecycle) => {
-			const boundLifecycle = bindIngressLifecycleToReplyOptions(lifecycle).turnAdoptionLifecycle;
+			const laneKey = laneKeyFor(event, eventIdFor(event));
+			const imageSet = resolveLineInboundImageSet(event);
+			let turnEvents = [event];
+			let turnLifecycles = [lifecycle];
+			let releaseLane;
+			let missingParts;
+			if (imageSet) {
+				if (!acceptsDeferredClaims) {
+					await lifecycle.onAbandoned();
+					return;
+				}
+				lifecycle.onDeferred();
+				const set = await imageSets.admit({
+					laneKey,
+					setId: imageSet.setId,
+					senderKey: imageSet.senderKey,
+					messageId: imageSet.messageId,
+					event,
+					lifecycle,
+					...imageSet.index === void 0 ? {} : { index: imageSet.index },
+					...imageSet.total === void 0 ? {} : { total: imageSet.total }
+				});
+				if (!set) return;
+				if (set.missing) {
+					missingParts = set.missing;
+					options.runtime.error?.(danger(`line: image set ${imageSet.setId} delivered ${set.events.length} of the send's parts, ${set.missing} still missing`));
+				}
+				turnEvents = set.events;
+				turnLifecycles = set.lifecycles;
+				releaseLane = set.finish;
+			} else if (imageSets.isBusy(laneKey)) {
+				if (!acceptsDeferredClaims) {
+					await lifecycle.onAbandoned();
+					return;
+				}
+				lifecycle.onDeferred();
+				releaseLane = await imageSets.enterLane(laneKey);
+			}
+			const fannedIn = fanInChannelIngressLifecycles(turnLifecycles);
+			const boundLifecycle = bindIngressLifecycleToReplyOptions(fannedIn.lifecycle ?? lifecycle).turnAdoptionLifecycle;
 			let handedOff = false;
-			const delivery = options.deliver(event, destination, { turnAdoptionLifecycle: {
-				...boundLifecycle,
-				onAdopted: async () => {
-					handedOff = true;
-					await boundLifecycle.onAdopted();
-				},
-				onDeferred: () => {
-					handedOff = true;
-					if (!acceptsDeferredClaims) {
-						Promise.resolve().then(() => boundLifecycle.onAbandoned()).catch((error) => {
-							options.runtime.error?.(danger(`line: failed to abandon a late webhook delivery: ${formatErrorMessage(error)}`));
-						});
-						return;
+			const delivery = options.deliver(turnEvents, destination, {
+				...missingParts === void 0 ? {} : { missingParts },
+				turnAdoptionLifecycle: {
+					...boundLifecycle,
+					onAdopted: async () => {
+						handedOff = true;
+						await boundLifecycle.onAdopted();
+					},
+					onDeferred: () => {
+						handedOff = true;
+						if (!acceptsDeferredClaims) {
+							Promise.resolve().then(() => boundLifecycle.onAbandoned()).catch((error) => {
+								options.runtime.error?.(danger(`line: failed to abandon a late webhook delivery: ${formatErrorMessage(error)}`));
+							});
+							return;
+						}
+						boundLifecycle.onDeferred();
+					},
+					onAbandoned: async () => {
+						handedOff = true;
+						await boundLifecycle.onAbandoned();
 					}
-					boundLifecycle.onDeferred();
-				},
-				onAbandoned: async () => {
-					handedOff = true;
-					await boundLifecycle.onAbandoned();
 				}
-			} });
+			});
 			activeDeliveries.add(delivery);
 			try {
 				await delivery;
+			} catch (error) {
+				await fannedIn.abandon(error);
+				handedOff = true;
+				throw error;
 			} finally {
 				activeDeliveries.delete(delivery);
+				releaseLane?.();
+			}
+			if (!handedOff && !stopTask) {
+				await fannedIn.settle();
+				handedOff = true;
+			}
+			if (stopTask && !handedOff) {
+				await fannedIn.abandon();
+				return;
 			}
-			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: {
@@ -1374,6 +1621,7 @@ function createLineWebhookSpool(options) {
 		admissionMode: "durable-after-stop",
 		drain: {
 			adoptionStallTimeoutMs: DEFAULT_INGRESS_ADOPTION_STALL_MS,
+			deferredLaneOccupancy: "release",
 			orderBy: "received",
 			scanLimit: LINE_WEBHOOK_DRAIN_SCAN_LIMIT,
 			startLimit: LINE_WEBHOOK_MAX_CONCURRENT_DELIVERIES,
@@ -1457,9 +1705,9 @@ function createLineBot(opts) {
 	const spool = createLineWebhookSpool({
 		accountId: account.accountId,
 		runtime,
-		deliver: async (event, _destination, control) => {
+		deliver: async (events, _destination, control) => {
 			const cfg = resolveTurnConfig();
-			await handleLineWebhookEvents([event], {
+			await handleLineWebhookEvents([...events], {
 				cfg,
 				account,
 				runtime,
@@ -1467,8 +1715,9 @@ function createLineBot(opts) {
 				mediaMaxBytes,
 				processMessage,
 				...control.turnAdoptionLifecycle ? { turnAdoptionLifecycle: control.turnAdoptionLifecycle } : {},
+				...control.missingParts === void 0 ? {} : { missingParts: control.missingParts },
 				groupHistories,
-				historyLimit: account.config.historyLimit ?? cfg.messages?.groupChat?.historyLimit ?? DEFAULT_GROUP_HISTORY_LIMIT
+				historyLimit: resolvePromptHistoryLimit(account.config.historyLimit ?? cfg.messages?.groupChat?.historyLimit)
 			});
 		}
 	});
@@ -1501,6 +1750,18 @@ function validateLineSignature(body, signature, channelSecret) {
 }
 //#endregion
 //#region extensions/line/src/webhook-utils.ts
+/** Route the gateway serves when an account configures no `webhookPath`. */
+const LINE_DEFAULT_WEBHOOK_PATH = "/line/webhook";
+/** The route this account's monitor serves, which is the one an operator has to register
+*  with LINE. Every surface resolves it here so a warning cannot name a path the gateway
+*  does not answer on. Route registration canonicalizes further, and matches requests the
+*  same way, so a path resolved here always reaches the route the monitor registered. */
+function resolveLineWebhookPath(webhookPath) {
+	return resolveWebhookPath({
+		webhookPath,
+		defaultPath: LINE_DEFAULT_WEBHOOK_PATH
+	}) ?? LINE_DEFAULT_WEBHOOK_PATH;
+}
 function parseLineWebhookBody(rawBody) {
 	try {
 		return JSON.parse(rawBody);
@@ -1661,9 +1922,15 @@ async function monitorLineProvider(opts) {
 			const ingressLifecycle = deliveryControl.turnAdoptionLifecycle;
 			const turnAbortSignal = ingressLifecycle?.abortSignal;
 			const skillFilter = ctx.skillFilter;
-			const replyOptions = turnAbortSignal || skillFilter ? {
+			const blockStreaming = resolveChannelStreamingBlockEnabled(resolveLineAccount({
+				cfg: turnConfig,
+				accountId: route.accountId
+			}).config) ?? resolveChannelStreamingBlockEnabled(turnConfig.channels?.line);
+			const disableBlockStreaming = typeof blockStreaming === "boolean" ? !blockStreaming : void 0;
+			const replyOptions = turnAbortSignal || skillFilter || disableBlockStreaming !== void 0 ? {
 				...turnAbortSignal ? { abortSignal: turnAbortSignal } : {},
-				...skillFilter ? { skillFilter } : {}
+				...skillFilter ? { skillFilter } : {},
+				...disableBlockStreaming !== void 0 ? { disableBlockStreaming } : {}
 			} : void 0;
 			try {
 				const textLimit = 5e3;
@@ -1698,7 +1965,7 @@ async function monitorLineProvider(opts) {
 							dispatcherOptions: { humanDelay: resolveHumanDelayConfig(turnConfig, route.agentId) },
 							...replyOptions ? { replyOptions } : {},
 							delivery: {
-								preparePayload: prepareLineReplyPayload,
+								preparePayload: (payload) => prepareLineReplyPayload(payload, ctxPayload.From),
 								durable: (payload, info) => resolveLineDurableReplyOptions({
 									payload,
 									infoKind: info.kind,
@@ -1721,18 +1988,8 @@ async function monitorLineProvider(opts) {
 										accountId: ctx.accountId,
 										cfg: turnConfig,
 										textLimit,
-										deps: {
-											buildTemplateMessageFromPayload,
-											processLineMessage,
-											chunkMarkdownText,
-											replyMessageLine,
-											pushMessagesLine,
-											createFlexMessage,
-											buildMediaMessage: buildLineMediaMessage,
-											createLocationMessage,
-											onReplyError: (replyErr) => {
-												logVerbose(`line: reply token failed, falling back to push: ${String(replyErr)}`);
-											}
+										onReplyError: (replyErr) => {
+											logVerbose(`line: reply token failed, falling back to push: ${String(replyErr)}`);
 										}
 									});
 									replyTokenUsed = deliveryResult.replyTokenUsed;
@@ -1757,7 +2014,7 @@ async function monitorLineProvider(opts) {
 			}
 		}
 	});
-	const normalizedPath = normalizeWebhookPath(normalizePluginHttpPath(webhookPath, "/line/webhook") ?? "/line/webhook");
+	const normalizedPath = resolveLineWebhookPath(webhookPath);
 	const webhookRouteKey = canonicalizeWebhookRouteKey(normalizedPath);
 	const createScopedLineWebhookHandler = (target) => createLineNodeWebhookHandler({
 		channelSecret: target.channelSecret,
@@ -1885,4 +2142,4 @@ async function monitorLineProvider(opts) {
 	};
 }
 //#endregion
-export { validateLineSignature as a, normalizeAllowFrom as c, parseLineWebhookBody as i, createLineNodeWebhookHandler as n, downloadLineMedia as o, readLineWebhookRequestBody as r, firstDefined as s, monitorLineProvider as t };
+export { resolveLineWebhookPath as a, parseLineWebhookBody as i, createLineNodeWebhookHandler as n, validateLineSignature as o, readLineWebhookRequestBody as r, downloadLineMedia as s, monitorLineProvider as t };