@openclaw/line 2026.8.2 → 2026.9.1

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

@@ -1,11 +1,24 @@
+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 } from "openclaw/plugin-sdk/error-runtime";
+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 } 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) {
@@ -19,13 +32,6 @@ 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",
@@ -130,6 +136,20 @@ 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;
@@ -158,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 = {
@@ -185,13 +216,13 @@ function isLineAction(value) {
 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;
+	}
 	const normalized = { ...value };
 	for (const [key, nested] of Object.entries(value)) if ((key === "action" || key === "defaultAction") && isLineAction(nested)) {
 		const action = normalizeLineAction(nested, labelLimit);
@@ -200,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(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);
+	const normalized = normalizeNestedContent(value, 40, warnings);
 	if (!isRecord(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 warning = flexWarning([...new Set(warnings)].join("\n"));
 	const body = normalized.body;
-	if (isRecord(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) {
+function normalizeFlexContainer(value) {
 	if (!isRecord(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);
+	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 {
@@ -289,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);
@@ -315,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;
 }
@@ -1034,6 +1087,90 @@ function createLineSendReceipt(params) {
 	});
 }
 //#endregion
+//#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) {
@@ -1086,5 +1223,14 @@ const runLinePushWithRetries = (fn, label) => {
 		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 { createVideoMessage as S, truncateLineActionLabel as _, createAgendaCard as a, createAudioMessage as b, createActionCard as c, createListCard as d, datetimePickerAction as f, postbackAction as g, normalizeLineMessageActions as h, createLineSendReceipt as i, createImageCard as l, normalizeLineAction as m, resolveLineNonDispatchRetryable as n, createEventCard as o, messageAction as p, runLinePushWithRetries as r, createReceiptCard as s, findLineHttpError as t, createInfoCard as u, uriAction as v, createImageMessage as x, buildLineMediaMessage as y };
+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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/line",
-  "version": "2026.8.2",
+  "version": "2026.9.1",
   "description": "OpenClaw LINE channel plugin for LINE Bot API chats.",
   "repository": {
     "type": "git",
@@ -13,7 +13,7 @@
     "zod": "4.4.3"
   },
   "peerDependencies": {
-    "openclaw": ">=2026.8.2"
+    "openclaw": ">=2026.9.1"
   },
   "peerDependenciesMeta": {
     "openclaw": {
@@ -112,10 +112,10 @@
       "minHostVersion": ">=2026.4.10"
     },
     "compat": {
-      "pluginApi": ">=2026.8.2"
+      "pluginApi": ">=2026.9.1"
     },
     "build": {
-      "openclawVersion": "2026.8.2"
+      "openclawVersion": "2026.9.1"
     },
     "release": {
       "publishToClawHub": true,

package/dist/monitor.runtime-CV8EjkIT.js

@@ -1,2 +0,0 @@
-import { t as monitorLineProvider } from "./monitor-CSpwQCBI.js";
-export { monitorLineProvider };

package/dist/probe-4gc_YQ2L.js

@@ -1,28 +0,0 @@
-import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
-import { runChannelProbe } from "openclaw/plugin-sdk/text-utility-runtime";
-import { messagingApi } from "@line/bot-sdk";
-//#region extensions/line/src/probe.ts
-async function probeLineBot(channelAccessToken, timeoutMs = 5e3) {
-	if (!channelAccessToken?.trim()) return {
-		ok: false,
-		error: "Channel access token not configured"
-	};
-	const client = new messagingApi.MessagingApiClient({ channelAccessToken: channelAccessToken.trim() });
-	return await runChannelProbe(timeoutMs, async () => {
-		const profile = await client.getBotInfo();
-		return {
-			ok: true,
-			bot: {
-				displayName: profile.displayName,
-				userId: profile.userId,
-				basicId: profile.basicId,
-				pictureUrl: profile.pictureUrl
-			}
-		};
-	}, (error) => ({
-		ok: false,
-		error: formatErrorMessage(error)
-	}));
-}
-//#endregion
-export { probeLineBot as t };

package/dist/probe.runtime-DTxBWvKz.js

@@ -1,2 +0,0 @@
-import { t as probeLineBot } from "./probe-4gc_YQ2L.js";
-export { probeLineBot };