@gakr-gakr/line 0.1.0

package/src/reply-payload-transform.ts

@@ -0,0 +1,317 @@
+import type { ReplyPayload } from "autobot/plugin-sdk/reply-runtime";
+import { normalizeLowercaseStringOrEmpty } from "autobot/plugin-sdk/string-coerce-runtime";
+import {
+  createAgendaCard,
+  createAppleTvRemoteCard,
+  createDeviceControlCard,
+  createEventCard,
+  createMediaPlayerCard,
+} from "./flex-templates.js";
+import type { LineChannelData } from "./types.js";
+
+/**
+ * Parse LINE-specific directives from text and extract them into ReplyPayload fields.
+ *
+ * Supported directives:
+ * - [[quick_replies: option1, option2, option3]]
+ * - [[location: title | address | latitude | longitude]]
+ * - [[confirm: question | yes_label | no_label]]
+ * - [[buttons: title | text | btn1:data1, btn2:data2]]
+ * - [[media_player: title | artist | source | imageUrl | playing/paused]]
+ * - [[event: title | date | time | location | description]]
+ * - [[agenda: title | event1_title:event1_time, event2_title:event2_time, ...]]
+ * - [[device: name | type | status | ctrl1:data1, ctrl2:data2]]
+ * - [[appletv_remote: name | status]]
+ */
+export function parseLineDirectives(payload: ReplyPayload): ReplyPayload {
+  let text = payload.text;
+  if (!text) {
+    return payload;
+  }
+
+  const result: ReplyPayload = { ...payload };
+  const lineData: LineChannelData = {
+    ...(result.channelData?.line as LineChannelData | undefined),
+  };
+  const toSlug = (value: string): string =>
+    normalizeLowercaseStringOrEmpty(value)
+      .replace(/[^a-z0-9]+/g, "_")
+      .replace(/^_+|_+$/g, "") || "device";
+  const lineActionData = (action: string, extras?: Record<string, string>): string => {
+    const base = [`line.action=${encodeURIComponent(action)}`];
+    if (extras) {
+      for (const [key, value] of Object.entries(extras)) {
+        base.push(`${encodeURIComponent(key)}=${encodeURIComponent(value)}`);
+      }
+    }
+    return base.join("&");
+  };
+
+  const quickRepliesMatch = text.match(/\[\[quick_replies:\s*([^\]]+)\]\]/i);
+  if (quickRepliesMatch) {
+    const options = quickRepliesMatch[1]
+      .split(",")
+      .map((s) => s.trim())
+      .filter(Boolean);
+    if (options.length > 0) {
+      lineData.quickReplies = [...(lineData.quickReplies || []), ...options];
+    }
+    text = text.replace(quickRepliesMatch[0], "").trim();
+  }
+
+  const locationMatch = text.match(/\[\[location:\s*([^\]]+)\]\]/i);
+  if (locationMatch && !lineData.location) {
+    const parts = locationMatch[1].split("|").map((s) => s.trim());
+    if (parts.length >= 4) {
+      const [title, address, latStr, lonStr] = parts;
+      const latitude = Number.parseFloat(latStr);
+      const longitude = Number.parseFloat(lonStr);
+      if (!Number.isNaN(latitude) && !Number.isNaN(longitude)) {
+        lineData.location = {
+          title: title || "Location",
+          address: address || "",
+          latitude,
+          longitude,
+        };
+      }
+    }
+    text = text.replace(locationMatch[0], "").trim();
+  }
+
+  const confirmMatch = text.match(/\[\[confirm:\s*([^\]]+)\]\]/i);
+  if (confirmMatch && !lineData.templateMessage) {
+    const parts = confirmMatch[1].split("|").map((s) => s.trim());
+    if (parts.length >= 3) {
+      const [question, yesPart, noPart] = parts;
+      const [yesLabel, yesData] = yesPart.includes(":")
+        ? yesPart.split(":").map((s) => s.trim())
+        : [yesPart, normalizeLowercaseStringOrEmpty(yesPart)];
+      const [noLabel, noData] = noPart.includes(":")
+        ? noPart.split(":").map((s) => s.trim())
+        : [noPart, normalizeLowercaseStringOrEmpty(noPart)];
+
+      lineData.templateMessage = {
+        type: "confirm",
+        text: question,
+        confirmLabel: yesLabel,
+        confirmData: yesData,
+        cancelLabel: noLabel,
+        cancelData: noData,
+        altText: question,
+      };
+    }
+    text = text.replace(confirmMatch[0], "").trim();
+  }
+
+  const buttonsMatch = text.match(/\[\[buttons:\s*([^\]]+)\]\]/i);
+  if (buttonsMatch && !lineData.templateMessage) {
+    const parts = buttonsMatch[1].split("|").map((s) => s.trim());
+    if (parts.length >= 3) {
+      const [title, bodyText, actionsStr] = parts;
+
+      const actions = actionsStr.split(",").map((actionStr) => {
+        const trimmed = actionStr.trim();
+        const colonIndex = (() => {
+          const index = trimmed.indexOf(":");
+          if (index === -1) {
+            return -1;
+          }
+          const lower = normalizeLowercaseStringOrEmpty(trimmed);
+          if (lower.startsWith("http://") || lower.startsWith("https://")) {
+            return -1;
+          }
+          return index;
+        })();
+
+        let label: string;
+        let data: string;
+
+        if (colonIndex === -1) {
+          label = trimmed;
+          data = trimmed;
+        } else {
+          label = trimmed.slice(0, colonIndex).trim();
+          data = trimmed.slice(colonIndex + 1).trim();
+        }
+
+        if (data.startsWith("http://") || data.startsWith("https://")) {
+          return { type: "uri" as const, label, uri: data };
+        }
+        if (data.includes("=")) {
+          return { type: "postback" as const, label, data };
+        }
+        return { type: "message" as const, label, data: data || label };
+      });
+
+      if (actions.length > 0) {
+        lineData.templateMessage = {
+          type: "buttons",
+          title,
+          text: bodyText,
+          actions: actions.slice(0, 4),
+          altText: `${title}: ${bodyText}`,
+        };
+      }
+    }
+    text = text.replace(buttonsMatch[0], "").trim();
+  }
+
+  const mediaPlayerMatch = text.match(/\[\[media_player:\s*([^\]]+)\]\]/i);
+  if (mediaPlayerMatch && !lineData.flexMessage) {
+    const parts = mediaPlayerMatch[1].split("|").map((s) => s.trim());
+    if (parts.length >= 1) {
+      const [title, artist, source, imageUrl, statusStr] = parts;
+      const isPlaying = normalizeLowercaseStringOrEmpty(statusStr) === "playing";
+      const validImageUrl = imageUrl?.startsWith("https://") ? imageUrl : undefined;
+      const deviceKey = toSlug(source || title || "media");
+      const card = createMediaPlayerCard({
+        title: title || "Unknown Track",
+        subtitle: artist || undefined,
+        source: source || undefined,
+        imageUrl: validImageUrl,
+        isPlaying: statusStr ? isPlaying : undefined,
+        controls: {
+          previous: { data: lineActionData("previous", { "line.device": deviceKey }) },
+          play: { data: lineActionData("play", { "line.device": deviceKey }) },
+          pause: { data: lineActionData("pause", { "line.device": deviceKey }) },
+          next: { data: lineActionData("next", { "line.device": deviceKey }) },
+        },
+      });
+
+      lineData.flexMessage = {
+        altText: `🎵 ${title}${artist ? ` - ${artist}` : ""}`,
+        contents: card,
+      };
+    }
+    text = text.replace(mediaPlayerMatch[0], "").trim();
+  }
+
+  const eventMatch = text.match(/\[\[event:\s*([^\]]+)\]\]/i);
+  if (eventMatch && !lineData.flexMessage) {
+    const parts = eventMatch[1].split("|").map((s) => s.trim());
+    if (parts.length >= 2) {
+      const [title, date, time, location, description] = parts;
+
+      const card = createEventCard({
+        title: title || "Event",
+        date: date || "TBD",
+        time: time || undefined,
+        location: location || undefined,
+        description: description || undefined,
+      });
+
+      lineData.flexMessage = {
+        altText: `📅 ${title} - ${date}${time ? ` ${time}` : ""}`,
+        contents: card,
+      };
+    }
+    text = text.replace(eventMatch[0], "").trim();
+  }
+
+  const appleTvMatch = text.match(/\[\[appletv_remote:\s*([^\]]+)\]\]/i);
+  if (appleTvMatch && !lineData.flexMessage) {
+    const parts = appleTvMatch[1].split("|").map((s) => s.trim());
+    if (parts.length >= 1) {
+      const [deviceName, status] = parts;
+      const deviceKey = toSlug(deviceName || "apple_tv");
+
+      const card = createAppleTvRemoteCard({
+        deviceName: deviceName || "Apple TV",
+        status: status || undefined,
+        actionData: {
+          up: lineActionData("up", { "line.device": deviceKey }),
+          down: lineActionData("down", { "line.device": deviceKey }),
+          left: lineActionData("left", { "line.device": deviceKey }),
+          right: lineActionData("right", { "line.device": deviceKey }),
+          select: lineActionData("select", { "line.device": deviceKey }),
+          menu: lineActionData("menu", { "line.device": deviceKey }),
+          home: lineActionData("home", { "line.device": deviceKey }),
+          play: lineActionData("play", { "line.device": deviceKey }),
+          pause: lineActionData("pause", { "line.device": deviceKey }),
+          volumeUp: lineActionData("volume_up", { "line.device": deviceKey }),
+          volumeDown: lineActionData("volume_down", { "line.device": deviceKey }),
+          mute: lineActionData("mute", { "line.device": deviceKey }),
+        },
+      });
+
+      lineData.flexMessage = {
+        altText: `📺 ${deviceName || "Apple TV"} Remote`,
+        contents: card,
+      };
+    }
+    text = text.replace(appleTvMatch[0], "").trim();
+  }
+
+  const agendaMatch = text.match(/\[\[agenda:\s*([^\]]+)\]\]/i);
+  if (agendaMatch && !lineData.flexMessage) {
+    const parts = agendaMatch[1].split("|").map((s) => s.trim());
+    if (parts.length >= 2) {
+      const [title, eventsStr] = parts;
+      const events = eventsStr.split(",").map((eventStr) => {
+        const trimmed = eventStr.trim();
+        const colonIdx = trimmed.lastIndexOf(":");
+        if (colonIdx > 0) {
+          return {
+            title: trimmed.slice(0, colonIdx).trim(),
+            time: trimmed.slice(colonIdx + 1).trim(),
+          };
+        }
+        return { title: trimmed };
+      });
+
+      const card = createAgendaCard({
+        title: title || "Agenda",
+        events,
+      });
+
+      lineData.flexMessage = {
+        altText: `📋 ${title} (${events.length} events)`,
+        contents: card,
+      };
+    }
+    text = text.replace(agendaMatch[0], "").trim();
+  }
+
+  const deviceMatch = text.match(/\[\[device:\s*([^\]]+)\]\]/i);
+  if (deviceMatch && !lineData.flexMessage) {
+    const parts = deviceMatch[1].split("|").map((s) => s.trim());
+    if (parts.length >= 1) {
+      const [deviceName, deviceType, status, controlsStr] = parts;
+      const deviceKey = toSlug(deviceName || "device");
+      const controls = controlsStr
+        ? controlsStr.split(",").map((ctrlStr) => {
+            const [label, data] = ctrlStr.split(":").map((s) => s.trim());
+            const action = data || normalizeLowercaseStringOrEmpty(label).replace(/\s+/g, "_");
+            return { label, data: lineActionData(action, { "line.device": deviceKey }) };
+          })
+        : [];
+
+      const card = createDeviceControlCard({
+        deviceName: deviceName || "Device",
+        deviceType: deviceType || undefined,
+        status: status || undefined,
+        controls,
+      });
+
+      lineData.flexMessage = {
+        altText: `📱 ${deviceName}${status ? `: ${status}` : ""}`,
+        contents: card,
+      };
+    }
+    text = text.replace(deviceMatch[0], "").trim();
+  }
+
+  text = text.replace(/\n{3,}/g, "\n\n").trim();
+
+  result.text = text || undefined;
+  if (Object.keys(lineData).length > 0) {
+    result.channelData = { ...result.channelData, line: lineData };
+  }
+  return result;
+}
+
+export function hasLineDirectives(text: string): boolean {
+  return /\[\[(quick_replies|location|confirm|buttons|media_player|event|agenda|device|appletv_remote):/i.test(
+    text,
+  );
+}

package/src/rich-menu.ts

@@ -0,0 +1,326 @@
+import { messagingApi } from "@line/bot-sdk";
+import { getAgentScopedMediaLocalRoots } from "autobot/plugin-sdk/agent-media-payload";
+import type { AutoBotConfig } from "autobot/plugin-sdk/config-contracts";
+import { mimeTypeFromFilePath } from "autobot/plugin-sdk/media-mime";
+import { logVerbose } from "autobot/plugin-sdk/runtime-env";
+import { loadWebMediaRaw } from "autobot/plugin-sdk/web-media";
+import { resolveLineAccount } from "./accounts.js";
+import { datetimePickerAction, messageAction, postbackAction, uriAction } from "./actions.js";
+import { resolveLineChannelAccessToken } from "./channel-access-token.js";
+
+type RichMenuRequest = messagingApi.RichMenuRequest;
+type RichMenuResponse = messagingApi.RichMenuResponse;
+type RichMenuArea = messagingApi.RichMenuArea;
+type Action = messagingApi.Action;
+const USER_BATCH_SIZE = 500;
+
+export interface RichMenuSize {
+  width: 2500;
+  height: 1686 | 843;
+}
+
+export interface RichMenuAreaRequest {
+  bounds: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+  };
+  action: Action;
+}
+
+export interface CreateRichMenuParams {
+  size: RichMenuSize;
+  selected?: boolean;
+  name: string;
+  chatBarText: string;
+  areas: RichMenuAreaRequest[];
+}
+
+interface RichMenuOpts {
+  cfg: AutoBotConfig;
+  channelAccessToken?: string;
+  accountId?: string;
+  verbose?: boolean;
+  mediaLocalRoots?: readonly string[];
+}
+
+function getClient(opts: RichMenuOpts): messagingApi.MessagingApiClient {
+  const account = resolveLineAccount({
+    cfg: opts.cfg,
+    accountId: opts.accountId,
+  });
+  const token = resolveLineChannelAccessToken(opts.channelAccessToken, account);
+
+  return new messagingApi.MessagingApiClient({
+    channelAccessToken: token,
+  });
+}
+
+function getBlobClient(opts: RichMenuOpts): messagingApi.MessagingApiBlobClient {
+  const account = resolveLineAccount({
+    cfg: opts.cfg,
+    accountId: opts.accountId,
+  });
+  const token = resolveLineChannelAccessToken(opts.channelAccessToken, account);
+
+  return new messagingApi.MessagingApiBlobClient({
+    channelAccessToken: token,
+  });
+}
+
+function chunkUserIds(userIds: string[]): string[][] {
+  const batches: string[][] = [];
+  for (let i = 0; i < userIds.length; i += USER_BATCH_SIZE) {
+    batches.push(userIds.slice(i, i + USER_BATCH_SIZE));
+  }
+  return batches;
+}
+
+export async function createRichMenu(
+  menu: CreateRichMenuParams,
+  opts: RichMenuOpts,
+): Promise<string> {
+  const client = getClient(opts);
+
+  const richMenuRequest: RichMenuRequest = {
+    size: menu.size,
+    selected: menu.selected ?? false,
+    name: menu.name.slice(0, 300),
+    chatBarText: menu.chatBarText.slice(0, 14),
+    areas: menu.areas as RichMenuArea[],
+  };
+
+  const response = await client.createRichMenu(richMenuRequest);
+
+  if (opts.verbose) {
+    logVerbose(`line: created rich menu ${response.richMenuId}`);
+  }
+
+  return response.richMenuId;
+}
+
+export async function uploadRichMenuImage(
+  richMenuId: string,
+  imagePath: string,
+  opts: RichMenuOpts,
+): Promise<void> {
+  const blobClient = getBlobClient(opts);
+
+  const media = await loadWebMediaRaw(imagePath, {
+    localRoots: opts.mediaLocalRoots ?? getAgentScopedMediaLocalRoots(opts.cfg),
+  });
+  const contentType =
+    media.contentType === "image/png" || media.contentType === "image/jpeg"
+      ? media.contentType
+      : mimeTypeFromFilePath(imagePath) === "image/png"
+        ? "image/png"
+        : "image/jpeg";
+
+  const imageBytes = new ArrayBuffer(media.buffer.byteLength);
+  new Uint8Array(imageBytes).set(media.buffer);
+  await blobClient.setRichMenuImage(richMenuId, new Blob([imageBytes], { type: contentType }));
+
+  if (opts.verbose) {
+    logVerbose(`line: uploaded image to rich menu ${richMenuId}`);
+  }
+}
+
+export async function setDefaultRichMenu(richMenuId: string, opts: RichMenuOpts): Promise<void> {
+  const client = getClient(opts);
+  await client.setDefaultRichMenu(richMenuId);
+
+  if (opts.verbose) {
+    logVerbose(`line: set default rich menu to ${richMenuId}`);
+  }
+}
+
+export async function cancelDefaultRichMenu(opts: RichMenuOpts): Promise<void> {
+  const client = getClient(opts);
+  await client.cancelDefaultRichMenu();
+
+  if (opts.verbose) {
+    logVerbose("line: cancelled default rich menu");
+  }
+}
+
+export async function getDefaultRichMenuId(opts: RichMenuOpts): Promise<string | null> {
+  const client = getClient(opts);
+
+  try {
+    const response = await client.getDefaultRichMenuId();
+    return response.richMenuId ?? null;
+  } catch {
+    return null;
+  }
+}
+
+export async function linkRichMenuToUser(
+  userId: string,
+  richMenuId: string,
+  opts: RichMenuOpts,
+): Promise<void> {
+  const client = getClient(opts);
+  await client.linkRichMenuIdToUser(userId, richMenuId);
+
+  if (opts.verbose) {
+    logVerbose(`line: linked rich menu ${richMenuId} to user ${userId}`);
+  }
+}
+
+export async function linkRichMenuToUsers(
+  userIds: string[],
+  richMenuId: string,
+  opts: RichMenuOpts,
+): Promise<void> {
+  const client = getClient(opts);
+
+  for (const batch of chunkUserIds(userIds)) {
+    await client.linkRichMenuIdToUsers({
+      richMenuId,
+      userIds: batch,
+    });
+  }
+
+  if (opts.verbose) {
+    logVerbose(`line: linked rich menu ${richMenuId} to ${userIds.length} users`);
+  }
+}
+
+export async function unlinkRichMenuFromUser(userId: string, opts: RichMenuOpts): Promise<void> {
+  const client = getClient(opts);
+  await client.unlinkRichMenuIdFromUser(userId);
+
+  if (opts.verbose) {
+    logVerbose(`line: unlinked rich menu from user ${userId}`);
+  }
+}
+
+export async function unlinkRichMenuFromUsers(
+  userIds: string[],
+  opts: RichMenuOpts,
+): Promise<void> {
+  const client = getClient(opts);
+
+  for (const batch of chunkUserIds(userIds)) {
+    await client.unlinkRichMenuIdFromUsers({
+      userIds: batch,
+    });
+  }
+
+  if (opts.verbose) {
+    logVerbose(`line: unlinked rich menu from ${userIds.length} users`);
+  }
+}
+
+export async function getRichMenuIdOfUser(
+  userId: string,
+  opts: RichMenuOpts,
+): Promise<string | null> {
+  const client = getClient(opts);
+
+  try {
+    const response = await client.getRichMenuIdOfUser(userId);
+    return response.richMenuId ?? null;
+  } catch {
+    return null;
+  }
+}
+
+export async function getRichMenuList(opts: RichMenuOpts): Promise<RichMenuResponse[]> {
+  const client = getClient(opts);
+  const response = await client.getRichMenuList();
+  return response.richmenus ?? [];
+}
+
+export async function getRichMenu(
+  richMenuId: string,
+  opts: RichMenuOpts,
+): Promise<RichMenuResponse | null> {
+  const client = getClient(opts);
+
+  try {
+    return await client.getRichMenu(richMenuId);
+  } catch {
+    return null;
+  }
+}
+
+export async function deleteRichMenu(richMenuId: string, opts: RichMenuOpts): Promise<void> {
+  const client = getClient(opts);
+  await client.deleteRichMenu(richMenuId);
+
+  if (opts.verbose) {
+    logVerbose(`line: deleted rich menu ${richMenuId}`);
+  }
+}
+
+export async function createRichMenuAlias(
+  richMenuId: string,
+  aliasId: string,
+  opts: RichMenuOpts,
+): Promise<void> {
+  const client = getClient(opts);
+
+  await client.createRichMenuAlias({
+    richMenuId,
+    richMenuAliasId: aliasId,
+  });
+
+  if (opts.verbose) {
+    logVerbose(`line: created alias ${aliasId} for rich menu ${richMenuId}`);
+  }
+}
+
+export async function deleteRichMenuAlias(aliasId: string, opts: RichMenuOpts): Promise<void> {
+  const client = getClient(opts);
+  await client.deleteRichMenuAlias(aliasId);
+
+  if (opts.verbose) {
+    logVerbose(`line: deleted alias ${aliasId}`);
+  }
+}
+
+export function createGridLayout(
+  height: 1686 | 843,
+  actions: [Action, Action, Action, Action, Action, Action],
+): RichMenuAreaRequest[] {
+  const colWidth = Math.floor(2500 / 3);
+  const rowHeight = Math.floor(height / 2);
+
+  return [
+    { bounds: { x: 0, y: 0, width: colWidth, height: rowHeight }, action: actions[0] },
+    { bounds: { x: colWidth, y: 0, width: colWidth, height: rowHeight }, action: actions[1] },
+    { bounds: { x: colWidth * 2, y: 0, width: colWidth, height: rowHeight }, action: actions[2] },
+    { bounds: { x: 0, y: rowHeight, width: colWidth, height: rowHeight }, action: actions[3] },
+    {
+      bounds: { x: colWidth, y: rowHeight, width: colWidth, height: rowHeight },
+      action: actions[4],
+    },
+    {
+      bounds: { x: colWidth * 2, y: rowHeight, width: colWidth, height: rowHeight },
+      action: actions[5],
+    },
+  ];
+}
+
+export { datetimePickerAction, messageAction, postbackAction, uriAction };
+
+export function createDefaultMenuConfig(): CreateRichMenuParams {
+  return {
+    size: { width: 2500, height: 843 },
+    selected: false,
+    name: "Default Menu",
+    chatBarText: "Menu",
+    areas: createGridLayout(843, [
+      messageAction("Help", "/help"),
+      messageAction("Status", "/status"),
+      messageAction("Settings", "/settings"),
+      messageAction("About", "/about"),
+      messageAction("Feedback", "/feedback"),
+      messageAction("Contact", "/contact"),
+    ]),
+  };
+}
+
+export type { RichMenuRequest, RichMenuResponse, RichMenuArea };

package/src/runtime.ts

@@ -0,0 +1,32 @@
+import type { PluginRuntime } from "autobot/plugin-sdk/core";
+import { createPluginRuntimeStore } from "autobot/plugin-sdk/runtime-store";
+
+type LineChannelRuntime = {
+  buildTemplateMessageFromPayload?: typeof import("./template-messages.js").buildTemplateMessageFromPayload;
+  createQuickReplyItems?: typeof import("./send.js").createQuickReplyItems;
+  monitorLineProvider?: typeof import("./monitor.js").monitorLineProvider;
+  pushFlexMessage?: typeof import("./send.js").pushFlexMessage;
+  pushLocationMessage?: typeof import("./send.js").pushLocationMessage;
+  pushMessageLine?: typeof import("./send.js").pushMessageLine;
+  pushMessagesLine?: typeof import("./send.js").pushMessagesLine;
+  pushTemplateMessage?: typeof import("./send.js").pushTemplateMessage;
+  pushTextMessageWithQuickReplies?: typeof import("./send.js").pushTextMessageWithQuickReplies;
+  resolveLineAccount?: typeof import("./accounts.js").resolveLineAccount;
+  sendMessageLine?: typeof import("./send.js").sendMessageLine;
+};
+
+type LineRuntime = PluginRuntime & {
+  channel: PluginRuntime["channel"] & {
+    line?: LineChannelRuntime;
+  };
+};
+
+const {
+  setRuntime: setLineRuntime,
+  clearRuntime: clearLineRuntime,
+  getRuntime: getLineRuntime,
+} = createPluginRuntimeStore<LineRuntime>({
+  pluginId: "line",
+  errorMessage: "LINE runtime not initialized - plugin not registered",
+});
+export { clearLineRuntime, getLineRuntime, setLineRuntime };

package/src/send-receipt.ts

@@ -0,0 +1,32 @@
+import {
+  createMessageReceiptFromOutboundResults,
+  type MessageReceipt,
+  type MessageReceiptPartKind,
+} from "autobot/plugin-sdk/channel-message";
+
+export function createLineSendReceipt(params: {
+  messageId: string;
+  chatId: string;
+  kind?: MessageReceiptPartKind;
+  messageCount?: number;
+}): MessageReceipt {
+  const messageId = params.messageId.trim();
+  const chatId = params.chatId.trim();
+  return createMessageReceiptFromOutboundResults({
+    results: messageId
+      ? [
+          {
+            channel: "line",
+            messageId,
+            chatId,
+            conversationId: chatId,
+            meta: {
+              messageCount: params.messageCount ?? 1,
+            },
+          },
+        ]
+      : [],
+    ...(chatId ? { threadId: chatId } : {}),
+    kind: params.kind ?? "unknown",
+  });
+}