@openclaw/line 2026.9.1-beta.1 → 2026.9.2

package/dist/{send-receipt-CCPTalf9.js → send-retry-ChpfJ-LM.js}

@@ -1,8 +1,24 @@
-import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { i as resolveLineAccount } from "./accounts-BBEFMYbY.js";
+import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { createMessageReceiptFromOutboundResults } from "openclaw/plugin-sdk/channel-outbound";
+import { collectErrorGraphCandidates, extractErrorCode, formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
+import { getFileExtension, mimeTypeFromFilePath } from "openclaw/plugin-sdk/media-mime";
 import { resolvePinnedHostnameWithPolicy } from "openclaw/plugin-sdk/ssrf-runtime";
-import { isRecord as isRecord$1 } from "openclaw/plugin-sdk/channel-secret-basic-runtime";
-import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
+import { runChannelProbe, truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
+import { HTTPFetchError } from "@line/bot-sdk";
+import { classifyTransientNetworkErrorCode, createChannelApiRetryRunner } from "openclaw/plugin-sdk/retry-runtime";
+import { assertOkOrThrowHttpError, createProviderOperationDeadline, createProviderOperationTimeoutResolver, fetchWithTimeout, readProviderJsonResponse } from "openclaw/plugin-sdk/provider-http";
+import { fetchWithRuntimeDispatcherOrMockedGlobal } from "openclaw/plugin-sdk/runtime-fetch";
+//#region extensions/line/src/media-url.ts
+function isHttpsUrl(value) {
+	if (typeof value !== "string") return false;
+	try {
+		return new URL(value).protocol === "https:";
+	} catch {
+		return false;
+	}
+}
+//#endregion
 //#region extensions/line/src/outbound-media.ts
 const LINE_OUTBOUND_MEDIA_SSRF_POLICY = { allowPrivateNetwork: false };
 async function validateLineMediaUrl(url) {
@@ -16,22 +32,39 @@ async function validateLineMediaUrl(url) {
 	if (url.length > 2e3) throw new Error(`LINE outbound media URL must be 2000 chars or less (got ${url.length})`);
 	await resolvePinnedHostnameWithPolicy(parsed.hostname, { policy: LINE_OUTBOUND_MEDIA_SSRF_POLICY });
 }
-function isHttpsUrl(url) {
-	try {
-		return new URL(url).protocol === "https:";
-	} catch {
-		return false;
-	}
-}
+const LINE_MEDIA_KIND_BY_MIME = {
+	"image/jpeg": "image",
+	"image/png": "image",
+	"video/mp4": "video",
+	"audio/mpeg": "audio",
+	"audio/x-m4a": "audio"
+};
 function detectLineMediaKindFromUrl(url) {
-	try {
-		const pathname = normalizeLowercaseStringOrEmpty(new URL(url).pathname);
-		if (/\.(png|jpe?g|gif|webp|bmp|heic|heif|avif)$/i.test(pathname)) return "image";
-		if (/\.(mp4|mov|m4v|webm)$/i.test(pathname)) return "video";
-		if (/\.(mp3|m4a|aac|wav|ogg|oga)$/i.test(pathname)) return "audio";
-	} catch {
-		return;
-	}
+	const mimeType = mimeTypeFromFilePath(url);
+	if (mimeType === void 0) return getFileExtension(url) === void 0 ? void 0 : "unsupported";
+	return LINE_MEDIA_KIND_BY_MIME[mimeType] ?? "unsupported";
+}
+function resolveLineMediaKind(url, opts) {
+	if (opts.mediaKind !== void 0) return {
+		mediaKind: opts.mediaKind,
+		kindSource: "declared"
+	};
+	if (typeof opts.durationMs === "number") return {
+		mediaKind: "audio",
+		kindSource: "metadata"
+	};
+	if (opts.trackingId?.trim()) return {
+		mediaKind: "video",
+		kindSource: "metadata"
+	};
+	const detected = detectLineMediaKindFromUrl(url);
+	return detected === void 0 ? {
+		mediaKind: "image",
+		kindSource: "fallback"
+	} : {
+		mediaKind: detected,
+		kindSource: "url"
+	};
 }
 async function resolveLineOutboundMedia(mediaUrl, opts = {}) {
 	const trimmedUrl = mediaUrl.trim();
@@ -41,7 +74,7 @@ async function resolveLineOutboundMedia(mediaUrl, opts = {}) {
 		if (previewImageUrl) await validateLineMediaUrl(previewImageUrl);
 		return {
 			mediaUrl: trimmedUrl,
-			mediaKind: opts.mediaKind ?? (typeof opts.durationMs === "number" ? "audio" : void 0) ?? (opts.trackingId?.trim() ? "video" : void 0) ?? detectLineMediaKindFromUrl(trimmedUrl) ?? "image",
+			...resolveLineMediaKind(trimmedUrl, opts),
 			...previewImageUrl ? { previewImageUrl } : {},
 			...typeof opts.durationMs === "number" ? { durationMs: opts.durationMs } : {},
 			...opts.trackingId ? { trackingId: opts.trackingId } : {}
@@ -58,37 +91,65 @@ function isLineUserTarget(target) {
 	const normalized = target.trim().replace(/^line:(group|room|user):/i, "").replace(/^line:/i, "");
 	return /^U/i.test(normalized);
 }
-function hasLineSpecificMediaOptions(lineData) {
-	return lineData.mediaKind !== void 0 || Boolean(lineData.previewImageUrl?.trim()) || typeof lineData.durationMs === "number" || Boolean(lineData.trackingId?.trim());
+function createImageMessage(originalContentUrl, previewImageUrl) {
+	return {
+		type: "image",
+		originalContentUrl,
+		previewImageUrl: previewImageUrl ?? originalContentUrl
+	};
+}
+function createVideoMessage(originalContentUrl, previewImageUrl, trackingId) {
+	return {
+		type: "video",
+		originalContentUrl,
+		previewImageUrl,
+		...trackingId ? { trackingId } : {}
+	};
+}
+function createAudioMessage(originalContentUrl, durationMs) {
+	return {
+		type: "audio",
+		originalContentUrl,
+		duration: durationMs
+	};
+}
+function lineMediaUrlFallback(mediaUrl) {
+	return {
+		type: "text",
+		text: mediaUrl
+	};
 }
 function buildLineMediaMessageObject(resolved, opts) {
 	switch (resolved.mediaKind) {
+		case "unsupported": return lineMediaUrlFallback(resolved.mediaUrl);
 		case "video": {
 			const previewImageUrl = resolved.previewImageUrl?.trim();
-			if (!previewImageUrl) throw new Error("LINE video messages require previewImageUrl to reference an image URL");
-			return {
-				type: "video",
-				originalContentUrl: resolved.mediaUrl,
-				previewImageUrl,
-				...opts?.allowTrackingId && resolved.trackingId ? { trackingId: resolved.trackingId } : {}
-			};
+			if (previewImageUrl) return createVideoMessage(resolved.mediaUrl, previewImageUrl, opts?.allowTrackingId ? resolved.trackingId : void 0);
+			if (resolved.kindSource !== "url") throw new Error("LINE video messages require previewImageUrl to reference an image URL");
+			return lineMediaUrlFallback(resolved.mediaUrl);
 		}
-		case "audio": return {
-			type: "audio",
-			originalContentUrl: resolved.mediaUrl,
-			duration: resolved.durationMs ?? 6e4
-		};
-		default: return {
-			type: "image",
-			originalContentUrl: resolved.mediaUrl,
-			previewImageUrl: resolved.previewImageUrl ?? resolved.mediaUrl
-		};
+		case "audio": return createAudioMessage(resolved.mediaUrl, resolved.durationMs ?? 6e4);
+		default: return createImageMessage(resolved.mediaUrl, resolved.previewImageUrl);
 	}
 }
 async function buildLineMediaMessage(mediaUrl, opts, target) {
 	return buildLineMediaMessageObject(await resolveLineOutboundMedia(mediaUrl, opts), { allowTrackingId: isLineUserTarget(target) });
 }
 //#endregion
+//#region extensions/line/src/flex-templates/message.ts
+const LINE_FLEX_BUBBLE_MAX_BYTES = 3e4;
+const LINE_FLEX_CAROUSEL_MAX_BYTES = 5e4;
+function fitsLineFlexBubble(bubble) {
+	return Buffer.byteLength(JSON.stringify(bubble), "utf8") <= LINE_FLEX_BUBBLE_MAX_BYTES;
+}
+function toFlexMessage(altText, contents) {
+	return {
+		type: "flex",
+		altText,
+		contents
+	};
+}
+//#endregion
 //#region extensions/line/src/actions.ts
 const LINE_ACTION_LABEL_LIMIT = 20;
 const LINE_ACTION_DATA_LIMIT = 300;
@@ -117,6 +178,17 @@ function truncateLineActionLabel(label, limit = LINE_ACTION_LABEL_LIMIT) {
 function truncateLineActionData(data) {
 	return truncateUtf16Safe(data, LINE_ACTION_DATA_LIMIT);
 }
+const UNDELIVERABLE_IMAGE_WARNING = "Image unavailable: URL must use HTTPS.";
+function flexWarning(text) {
+	return {
+		type: "text",
+		text,
+		wrap: true,
+		size: "sm",
+		color: "#B45309",
+		margin: "md"
+	};
+}
 const unavailableActionMarker = Symbol("lineUnavailableAction");
 function unavailableAction(kind, reason) {
 	const action = {
@@ -139,18 +211,18 @@ const actionTypes = /* @__PURE__ */ new Set([
 	"uri"
 ]);
 function isLineAction(value) {
-	return isRecord$1(value) && typeof value.type === "string" && actionTypes.has(value.type);
+	return isRecord(value) && typeof value.type === "string" && actionTypes.has(value.type);
 }
 function isUnavailableAction(action) {
 	return action[unavailableActionMarker] === true;
 }
-function normalizeNestedActions(value, labelLimit, warnings) {
-	if (Array.isArray(value)) {
-		const normalized = [];
-		for (const item of value) normalized.push(normalizeNestedActions(item, labelLimit, warnings));
-		return normalized;
+function normalizeNestedContent(value, labelLimit, warnings) {
+	if (Array.isArray(value)) return value.map((item) => normalizeNestedContent(item, labelLimit, warnings)).filter((item) => item !== void 0);
+	if (!isRecord(value)) return value;
+	if (warnings && (value.type === "image" || value.type === "icon") && !isHttpsUrl(value.url)) {
+		warnings.push(UNDELIVERABLE_IMAGE_WARNING);
+		return;
 	}
-	if (!isRecord$1(value)) return value;
 	const normalized = { ...value };
 	for (const [key, nested] of Object.entries(value)) if ((key === "action" || key === "defaultAction") && isLineAction(nested)) {
 		const action = normalizeLineAction(nested, labelLimit);
@@ -159,42 +231,61 @@ function normalizeNestedActions(value, labelLimit, warnings) {
 			warnings.push(isUnavailableAction(action) ? action.text ?? "Action unavailable." : "Action unavailable in this video.");
 		} else normalized[key] = action;
 	} else if (key === "actions" && Array.isArray(nested)) normalized[key] = nested.map((action) => isLineAction(action) ? normalizeLineAction(action, labelLimit) : action);
-	else normalized[key] = normalizeNestedActions(nested, labelLimit, warnings);
+	else {
+		const content = normalizeNestedContent(nested, labelLimit, warnings);
+		if (content === void 0) delete normalized[key];
+		else normalized[key] = content;
+	}
+	if (warnings && value.type === "video") {
+		const altContent = normalized.altContent ?? {
+			type: "box",
+			layout: "vertical",
+			contents: [flexWarning(UNDELIVERABLE_IMAGE_WARNING)]
+		};
+		if (!isHttpsUrl(value.url) || !isHttpsUrl(value.previewUrl)) {
+			warnings.push("Video unavailable: video and preview URLs must use HTTPS.");
+			return altContent;
+		}
+		normalized.altContent = altContent;
+	}
 	return normalized;
 }
-function normalizeFlexBubbleActions(value) {
-	if (!isRecord$1(value) || value.type !== "bubble") return normalizeNestedActions(value, 40);
+function normalizeFlexBubble(value, maxBytes = LINE_FLEX_BUBBLE_MAX_BYTES) {
+	if (!isRecord(value) || value.type !== "bubble") return normalizeNestedContent(value, 40);
 	const warnings = [];
-	const normalized = normalizeNestedActions(value, 40, warnings);
-	if (!isRecord$1(normalized) || warnings.length === 0) return normalized;
-	const warning = {
-		type: "text",
-		text: [...new Set(warnings)].join("\n"),
-		wrap: true,
-		size: "sm",
-		color: "#B45309",
-		margin: "md"
-	};
+	const normalized = normalizeNestedContent(value, 40, warnings);
+	if (!isRecord(normalized) || warnings.length === 0) return normalized;
+	const warning = flexWarning([...new Set(warnings)].join("\n"));
 	const body = normalized.body;
-	if (isRecord$1(body) && Array.isArray(body.contents)) normalized.body = {
-		...body,
-		contents: [...body.contents, warning]
-	};
-	else normalized.body = {
-		type: "box",
-		layout: "vertical",
-		contents: [warning]
+	const withWarning = {
+		...normalized,
+		body: isRecord(body) && Array.isArray(body.contents) ? {
+			...body,
+			contents: [...body.contents, warning]
+		} : {
+			type: "box",
+			layout: "vertical",
+			contents: [warning]
+		}
 	};
-	return normalized;
+	return Buffer.byteLength(JSON.stringify(withWarning), "utf8") <= Math.min(maxBytes, 3e4) ? withWarning : normalized;
 }
-function normalizeFlexContainerActions(value) {
-	if (!isRecord$1(value)) return value;
-	if (value.type === "bubble") return normalizeFlexBubbleActions(value);
-	if (value.type === "carousel" && Array.isArray(value.contents)) return {
-		...value,
-		contents: value.contents.map((bubble) => normalizeFlexBubbleActions(bubble))
-	};
-	return normalizeNestedActions(value, 40);
+function normalizeFlexContainer(value) {
+	if (!isRecord(value)) return value;
+	if (value.type === "bubble") return normalizeFlexBubble(value);
+	if (value.type === "carousel" && Array.isArray(value.contents)) {
+		let remainingBytes = LINE_FLEX_CAROUSEL_MAX_BYTES - Buffer.byteLength(JSON.stringify(value), "utf8");
+		return {
+			...value,
+			contents: value.contents.map((bubble) => {
+				const originalBytes = Buffer.byteLength(JSON.stringify(bubble), "utf8");
+				const normalized = normalizeFlexBubble(bubble, originalBytes + remainingBytes);
+				remainingBytes += originalBytes - Buffer.byteLength(JSON.stringify(normalized), "utf8");
+				return normalized;
+			})
+		};
+	}
+	return normalizeNestedContent(value, 40);
 }
 function unavailableImagemapAction(kind, reason, area) {
 	return {
@@ -248,17 +339,20 @@ function normalizeImagemapVideo(video) {
 		}
 	} };
 }
-function normalizeLineMessageActions(message) {
+function normalizeLineMessage(message) {
 	let normalized;
 	if (message.type === "flex") normalized = {
 		...message,
-		contents: normalizeFlexContainerActions(message.contents)
+		contents: normalizeFlexContainer(message.contents)
 	};
 	else if (message.type === "template") {
 		const labelLimit = message.template.type === "image_carousel" ? 12 : 20;
+		const template = normalizeNestedContent(message.template, labelLimit);
+		const columns = template.type === "carousel" ? template.columns : template.type === "buttons" ? [template] : [];
+		if (columns.some((column) => !isHttpsUrl(column.thumbnailImageUrl))) for (const column of columns) delete column.thumbnailImageUrl;
 		normalized = {
 			...message,
-			template: normalizeNestedActions(message.template, labelLimit)
+			template
 		};
 	} else if (message.type === "imagemap") {
 		const actions = message.actions.map(normalizeImagemapAction);
@@ -274,7 +368,7 @@ function normalizeLineMessageActions(message) {
 	} else normalized = { ...message };
 	if (message.quickReply) normalized = {
 		...normalized,
-		quickReply: normalizeNestedActions(message.quickReply, 20)
+		quickReply: normalizeNestedContent(message.quickReply, 20)
 	};
 	return normalized;
 }
@@ -444,7 +538,7 @@ function createInfoCard(title, body, footer) {
 					flex: 1,
 					margin: "lg"
 				}]
-			}, {
+			}, ...body ? [{
 				type: "box",
 				layout: "vertical",
 				contents: [{
@@ -459,7 +553,7 @@ function createInfoCard(title, body, footer) {
 				paddingAll: "lg",
 				backgroundColor: "#F8F9FA",
 				cornerRadius: "lg"
-			}],
+			}] : []],
 			paddingAll: "xl",
 			backgroundColor: "#FFFFFF"
 		}
@@ -604,14 +698,14 @@ function createActionCard(title, body, actions, options) {
 				weight: "bold",
 				size: "xl",
 				wrap: true
-			}, {
+			}, ...body ? [{
 				type: "text",
 				text: body,
 				size: "md",
 				wrap: true,
 				margin: "md",
 				color: "#666666"
-			}],
+			}] : []],
 			paddingAll: "lg"
 		},
 		footer: {
@@ -702,7 +796,7 @@ function createReceiptCard(params) {
 			weight: item.highlight ? "bold" : "regular",
 			flex: 3,
 			wrap: true
-		}, {
+		}, ...item.value ? [{
 			type: "text",
 			text: item.value,
 			size: "sm",
@@ -711,7 +805,7 @@ function createReceiptCard(params) {
 			flex: 2,
 			align: "end",
 			wrap: true
-		}],
+		}] : []],
 		paddingAll: "md",
 		backgroundColor: index % 2 === 0 ? "#FFFFFF" : "#FAFAFA"
 	}));
@@ -993,4 +1087,150 @@ function createLineSendReceipt(params) {
 	});
 }
 //#endregion
-export { hasLineSpecificMediaOptions as _, createActionCard as a, createListCard as c, normalizeLineAction as d, normalizeLineMessageActions as f, buildLineMediaMessage as g, uriAction as h, createReceiptCard as i, datetimePickerAction as l, truncateLineActionLabel as m, createAgendaCard as n, createImageCard as o, postbackAction as p, createEventCard as r, createInfoCard as s, createLineSendReceipt as t, messageAction as u, resolveLineOutboundMedia as v, validateLineMediaUrl as y };
+//#region extensions/line/src/channel-access-token.ts
+function resolveLineChannelAccessToken(explicit, params) {
+	if (explicit?.trim()) return explicit.trim();
+	if (!params.channelAccessToken) throw new Error(`LINE channel access token missing for account "${params.accountId}" (set channels.line.channelAccessToken or LINE_CHANNEL_ACCESS_TOKEN).`);
+	return params.channelAccessToken.trim();
+}
+//#endregion
+//#region extensions/line/src/probe.ts
+const LINE_QUOTA_TIMEOUT_MS = 2e3;
+const LINE_JSON_MAX_BYTES = 16384;
+function createLineApiReader(channelAccessToken, timeoutMs) {
+	const remaining = createProviderOperationTimeoutResolver({
+		deadline: createProviderOperationDeadline({
+			timeoutMs,
+			label: "LINE API"
+		}),
+		defaultTimeoutMs: timeoutMs
+	});
+	const headers = { Authorization: `Bearer ${channelAccessToken}` };
+	return async (endpoint) => {
+		const response = await fetchWithTimeout(`https://api.line.me/v2/bot/${endpoint}`, { headers }, remaining(), fetchWithRuntimeDispatcherOrMockedGlobal);
+		await assertOkOrThrowHttpError(response, "LINE API", {
+			bodyTimeoutMs: remaining,
+			requestHeaders: headers
+		});
+		return await readProviderJsonResponse(response, "LINE API", {
+			maxBytes: LINE_JSON_MAX_BYTES,
+			timeoutMs: remaining,
+			requestHeaders: headers
+		});
+	};
+}
+async function readLineMessageQuota(channelAccessToken, budgetMs) {
+	if (!Number.isFinite(budgetMs) || budgetMs <= 0) return;
+	try {
+		const read = createLineApiReader(channelAccessToken, budgetMs);
+		const quota = await read("message/quota");
+		if (quota.type === "none") return { kind: "unlimited" };
+		if (quota.type !== "limited" || typeof quota.value !== "number" || !Number.isSafeInteger(quota.value) || quota.value < 0) return;
+		const { totalUsage } = await read("message/quota/consumption");
+		return typeof totalUsage === "number" && Number.isSafeInteger(totalUsage) && totalUsage >= 0 ? {
+			kind: "limited",
+			limit: quota.value,
+			used: totalUsage
+		} : void 0;
+	} catch {
+		return;
+	}
+}
+async function readLineAccountMessageQuota(params) {
+	try {
+		return await readLineMessageQuota(resolveLineChannelAccessToken(void 0, resolveLineAccount({
+			cfg: params.cfg,
+			accountId: params.accountId ?? void 0
+		})), LINE_QUOTA_TIMEOUT_MS);
+	} catch {
+		return;
+	}
+}
+async function probeLineBot(channelAccessToken, timeoutMs = 5e3) {
+	if (!channelAccessToken?.trim()) return {
+		ok: false,
+		error: "Channel access token not configured"
+	};
+	const token = channelAccessToken.trim();
+	return await runChannelProbe(timeoutMs, async ({ elapsedMs }) => {
+		const profile = await createLineApiReader(token, timeoutMs)("info");
+		const quota = await readLineMessageQuota(token, Math.floor(Math.max(timeoutMs - elapsedMs(), 0) / 2));
+		return {
+			ok: true,
+			bot: {
+				displayName: profile.displayName,
+				userId: profile.userId,
+				basicId: profile.basicId,
+				pictureUrl: profile.pictureUrl
+			},
+			...quota ? { quota } : {}
+		};
+	}, (error) => ({
+		ok: false,
+		error: formatErrorMessage(error)
+	}));
+}
+//#endregion
+//#region extensions/line/src/send-retry.ts
+/** The LINE HTTP response carried by an error graph, when the request reached LINE. */
+function findLineHttpError(error) {
+	return collectErrorGraphCandidates(error, (candidate) => [candidate.cause, candidate.error]).find((candidate) => candidate instanceof HTTPFetchError);
+}
+/**
+* LINE answered this attempt with a client error, so it rejected the request and
+* sent nothing.
+*
+* A 429 proves this attempt was refused but remains retryable by durable
+* delivery. A 408 stays ambiguous because the request may have reached LINE.
+*/
+function resolveAttemptNonDispatchRetryable(error) {
+	const status = findLineHttpError(error)?.status;
+	if (status === 429) return true;
+	if (status === 409) return;
+	return status !== void 0 && status >= 400 && status < 500 && status !== 408 ? false : void 0;
+}
+const pushErrorsWithAmbiguousAttempt = /* @__PURE__ */ new WeakSet();
+/** Retryability when LINE refused every attempt, or undefined when delivery is ambiguous. */
+function resolveLineNonDispatchRetryable(error) {
+	if (collectErrorGraphCandidates(error, (candidate) => [candidate.cause, candidate.error]).some((candidate) => typeof candidate === "object" && candidate !== null && pushErrorsWithAmbiguousAttempt.has(candidate))) return;
+	return resolveAttemptNonDispatchRetryable(error);
+}
+function isRetryableLinePushError(error) {
+	const httpError = findLineHttpError(error);
+	if (httpError) return httpError.status >= 500;
+	return collectErrorGraphCandidates(error, (candidate) => [candidate.cause, candidate.error]).some((candidate) => classifyTransientNetworkErrorCode(extractErrorCode(candidate)) !== void 0);
+}
+/**
+* Pushes are non-idempotent without a retry key, so the generic message-matching
+* fallback stays off and only the classification above may replay a request.
+*/
+const runLinePushAttempts = createChannelApiRetryRunner({
+	shouldRetry: isRetryableLinePushError,
+	strictShouldRetry: true,
+	verbose: true
+});
+const runLinePushWithRetries = (fn, label) => {
+	let sawAmbiguousAttempt = false;
+	return runLinePushAttempts(async () => {
+		try {
+			return await fn();
+		} catch (error) {
+			sawAmbiguousAttempt ||= resolveAttemptNonDispatchRetryable(error) === void 0;
+			throw error;
+		}
+	}, label).catch((error) => {
+		if (sawAmbiguousAttempt && typeof error === "object" && error !== null) pushErrorsWithAmbiguousAttempt.add(error);
+		throw error;
+	});
+};
+async function explainLineRefusal(params) {
+	const retryable = resolveLineNonDispatchRetryable(params.error);
+	const quota = retryable === true && findLineHttpError(params.error)?.status === 429 ? await readLineAccountMessageQuota(params) : void 0;
+	const exhausted = quota?.kind === "limited" && quota.used >= quota.limit;
+	return {
+		retryable: exhausted ? false : retryable,
+		reason: exhausted ? `LINE refused the push: ${quota.used}/${quota.limit} monthly messages used. Check the account allowance or plan before retrying.` : params.error instanceof Error ? params.error.message : "LINE rejected the message"
+	};
+}
+//#endregion
+export { toFlexMessage as C, createVideoMessage as D, createImageMessage as E, fitsLineFlexBubble as S, createAudioMessage as T, normalizeLineAction as _, probeLineBot as a, truncateLineActionLabel as b, createAgendaCard as c, createActionCard as d, createImageCard as f, messageAction as g, datetimePickerAction as h, runLinePushWithRetries as i, createEventCard as l, createListCard as m, findLineHttpError as n, resolveLineChannelAccessToken as o, createInfoCard as p, resolveLineNonDispatchRetryable as r, createLineSendReceipt as s, explainLineRefusal as t, createReceiptCard as u, normalizeLineMessage as v, buildLineMediaMessage as w, uriAction as x, postbackAction as y };

package/dist/setup-api.js

@@ -1,2 +1,2 @@
-import { n as lineSetupAdapter, t as lineSetupWizard } from "./setup-surface-W0Dbgu58.js";
+import { n as lineSetupAdapter, t as lineSetupWizard } from "./setup-surface-CDlgkTKi.js";
 export { lineSetupAdapter, lineSetupWizard };

package/dist/{setup-surface-W0Dbgu58.js → setup-surface-CDlgkTKi.js}

@@ -1,19 +1,9 @@
-import { i as resolveLineAccount, n as normalizeAccountId, r as resolveDefaultLineAccountId, t as listLineAccountIds } from "./accounts-BqEVsDoB.js";
+import { i as resolveLineAccount, n as normalizeAccountId, r as resolveDefaultLineAccountId, t as listLineAccountIds } from "./accounts-BBEFMYbY.js";
+import { n as parseLineAllowFromId, t as hasLineCredentials } from "./account-helpers-BSUyZwLm.js";
 import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { defineChannelSetupContract } from "openclaw/plugin-sdk/channel-setup";
 import { DEFAULT_ACCOUNT_ID, createAllowFromSection, createPromptParsedAllowFromForAccount, createSetupInputPresenceValidator, createSetupTranslator, createStandardChannelSetupStatus, defineTokenCredential, formatDocsLink, parseSetupEntriesWithParser, patchScopedAccountConfig, setSetupChannelEnabled, splitSetupEntries } from "openclaw/plugin-sdk/setup";
 import { createChannelDmPolicy } from "openclaw/plugin-sdk/channel-dm-policy";
-//#region extensions/line/src/account-helpers.ts
-function hasLineCredentials(account) {
-	if (account.tokenStatus && account.signingSecretStatus) return account.tokenStatus !== "missing" && account.signingSecretStatus !== "missing";
-	return Boolean(account.channelAccessToken?.trim() && account.channelSecret?.trim());
-}
-function parseLineAllowFromId(raw) {
-	const trimmed = raw.trim().replace(/^line:(?:user:)?/i, "");
-	if (!/^U[a-f0-9]{32}$/i.test(trimmed)) return null;
-	return trimmed;
-}
-//#endregion
 //#region extensions/line/src/setup-core.ts
 function patchLineAccountConfig(params) {
 	return patchScopedAccountConfig({
@@ -62,6 +52,26 @@ const lineSetupAdapter = {
 		const accessToken = typedInput.channelAccessToken ?? typedInput.token;
 		const normalizedAccountId = normalizeAccountId(accountId);
 		const useEnv = normalizedAccountId === DEFAULT_ACCOUNT_ID && Boolean(typedInput.useEnv);
+		const credentials = [{
+			fileKey: "tokenFile",
+			file: typedInput.tokenFile,
+			inlineKey: "channelAccessToken",
+			inline: accessToken
+		}, {
+			fileKey: "secretFile",
+			file: typedInput.secretFile,
+			inlineKey: "channelSecret",
+			inline: typedInput.channelSecret
+		}];
+		const patch = {};
+		const retired = [];
+		for (const credential of credentials) if (credential.file) {
+			patch[credential.fileKey] = credential.file;
+			retired.push(credential.inlineKey);
+		} else if (credential.inline) {
+			patch[credential.inlineKey] = credential.inline;
+			retired.push(credential.fileKey);
+		}
 		return patchLineAccountConfig({
 			cfg,
 			accountId: normalizedAccountId,
@@ -71,11 +81,8 @@ const lineSetupAdapter = {
 				"channelSecret",
 				"tokenFile",
 				"secretFile"
-			] : void 0,
-			patch: useEnv ? {} : {
-				...typedInput.tokenFile ? { tokenFile: typedInput.tokenFile } : accessToken ? { channelAccessToken: accessToken } : {},
-				...typedInput.secretFile ? { secretFile: typedInput.secretFile } : typedInput.channelSecret ? { channelSecret: typedInput.channelSecret } : {}
-			}
+			] : retired.length > 0 ? retired : void 0,
+			patch: useEnv ? {} : patch
 		});
 	}
 };
@@ -152,6 +159,27 @@ const LINE_ALLOW_FROM_HELP_LINES = [
 	t("wizard.line.multipleEntries"),
 	t("wizard.channels.docs", { link: formatDocsLink("/channels/line", "channels/line") })
 ];
+const promptLineAllowFrom = createPromptParsedAllowFromForAccount({
+	defaultAccountId: resolveDefaultLineAccountId,
+	noteTitle: t("wizard.line.allowlistTitle"),
+	noteLines: LINE_ALLOW_FROM_HELP_LINES,
+	message: t("wizard.line.allowFromPrompt"),
+	placeholder: "U1234567890abcdef1234567890abcdef",
+	parseEntries: (raw) => parseSetupEntriesWithParser(raw, (entry) => {
+		const id = parseLineAllowFromId(entry);
+		return id ? { value: id } : { error: t("wizard.line.allowFromInvalid") };
+	}),
+	getExistingAllowFrom: ({ cfg, accountId }) => resolveLineAccount({
+		cfg,
+		accountId
+	}).config.allowFrom ?? [],
+	applyAllowFrom: ({ cfg, accountId, allowFrom }) => patchLineAccountConfig({
+		cfg,
+		accountId,
+		enabled: true,
+		patch: { allowFrom }
+	})
+});
 const lineDmPolicy = createChannelDmPolicy({
 	label: "LINE",
 	channel,
@@ -166,27 +194,7 @@ const lineDmPolicy = createChannelDmPolicy({
 		patch,
 		clearFields: patch.dmPolicy === "pairing" || patch.dmPolicy === "disabled" ? ["allowFrom"] : void 0
 	}),
-	promptAllowFrom: createPromptParsedAllowFromForAccount({
-		defaultAccountId: resolveDefaultLineAccountId,
-		noteTitle: t("wizard.line.allowlistTitle"),
-		noteLines: LINE_ALLOW_FROM_HELP_LINES,
-		message: t("wizard.line.allowFromPrompt"),
-		placeholder: "U1234567890abcdef1234567890abcdef",
-		parseEntries: (raw) => parseSetupEntriesWithParser(raw, (entry) => {
-			const id = parseLineAllowFromId(entry);
-			return id ? { value: id } : { error: t("wizard.line.allowFromInvalid") };
-		}),
-		getExistingAllowFrom: ({ cfg, accountId }) => resolveLineAccount({
-			cfg,
-			accountId
-		}).config.allowFrom ?? [],
-		applyAllowFrom: ({ cfg, accountId, allowFrom }) => patchLineAccountConfig({
-			cfg,
-			accountId,
-			enabled: true,
-			patch: { allowFrom }
-		})
-	})
+	promptAllowFrom: promptLineAllowFrom
 });
 function createLineTokenCredential(params) {
 	return defineTokenCredential({
@@ -295,4 +303,4 @@ const lineSetupWizard = {
 	disable: (cfg) => setSetupChannelEnabled(cfg, channel, false)
 };
 //#endregion
-export { hasLineCredentials as i, lineSetupAdapter as n, lineSetupContract as r, lineSetupWizard as t };
+export { lineSetupAdapter as n, lineSetupContract as r, lineSetupWizard as t };