@elizaos/plugin-line 2.0.3-beta.6 → 2.0.3-beta.7

package/dist/service.js

@@ -0,0 +1,861 @@
+/**
+ * LINE service implementation for ElizaOS.
+ */
+import { logger, Service } from "@elizaos/core";
+import { messagingApi, middleware } from "@line/bot-sdk";
+import { getChatTypeFromId, LINE_SERVICE_NAME, LineApiError, LineConfigurationError, LineEventTypes, MAX_LINE_BATCH_SIZE, normalizeLineTarget, splitMessageForLine, } from "./types.js";
+function objectToMetadataValue(obj) {
+    return JSON.parse(JSON.stringify(obj));
+}
+function normalizeLineQuery(query) {
+    return query.trim().toLowerCase();
+}
+function scoreLineCandidate(values, query) {
+    const normalized = normalizeLineQuery(query);
+    if (!normalized) {
+        return 0.45;
+    }
+    const candidates = values
+        .filter((value) => typeof value === "string" && value.trim().length > 0)
+        .map((value) => value.trim().toLowerCase());
+    if (candidates.some((candidate) => candidate === normalized)) {
+        return 1;
+    }
+    return candidates.some((candidate) => candidate.includes(normalized)) ? 0.8 : 0;
+}
+function lineRoomToConnectorTarget(room, score = 0.55) {
+    const channelId = String(room.channelId ?? "");
+    const chatType = channelId ? getChatTypeFromId(channelId) : undefined;
+    return {
+        target: {
+            source: LINE_SERVICE_NAME,
+            roomId: room.id,
+            channelId,
+        },
+        label: room.name || channelId || String(room.id),
+        kind: chatType === "user" ? "contact" : chatType || "room",
+        description: "LINE chat from stored room context",
+        score,
+        contexts: ["social", "connectors"],
+        metadata: {
+            chatType,
+            channelId,
+            roomType: room.type,
+        },
+    };
+}
+function normalizeConnectorLimit(limit, fallback = 50) {
+    if (!Number.isFinite(limit) || !limit || limit <= 0) {
+        return fallback;
+    }
+    return Math.min(Math.floor(limit), 200);
+}
+async function readStoredMessageMemories(runtime, roomId, limit) {
+    return runtime.getMemories({
+        tableName: "messages",
+        roomId,
+        limit,
+        orderBy: "createdAt",
+        orderDirection: "desc",
+    });
+}
+async function readStoredMessagesForTargets(runtime, targets, limit) {
+    const roomIds = Array.from(new Set(targets.map((target) => target.target.roomId).filter((id) => Boolean(id))));
+    const chunks = await Promise.all(roomIds.map((roomId) => readStoredMessageMemories(runtime, roomId, limit)));
+    return chunks
+        .flat()
+        .sort((left, right) => (right.createdAt ?? 0) - (left.createdAt ?? 0))
+        .slice(0, limit);
+}
+function filterMemoriesByQuery(memories, query, limit) {
+    const normalized = query.trim().toLowerCase();
+    if (!normalized) {
+        return memories.slice(0, limit);
+    }
+    return memories
+        .filter((memory) => {
+        const text = typeof memory.content.text === "string" ? memory.content.text : "";
+        return text.toLowerCase().includes(normalized);
+    })
+        .slice(0, limit);
+}
+function quickReplyItemsFromStrings(values) {
+    if (!Array.isArray(values)) {
+        return undefined;
+    }
+    const items = values
+        .filter((value) => typeof value === "string" && value.trim().length > 0)
+        .slice(0, 13)
+        .map((text) => ({
+        type: "action",
+        action: {
+            type: "message",
+            label: text.slice(0, 20),
+            text,
+        },
+    }));
+    return items.length > 0 ? items : undefined;
+}
+function lineDataFromContent(content) {
+    const data = content.data;
+    if (data?.line && typeof data.line === "object") {
+        return data.line;
+    }
+    return data ?? {};
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+function isValidHttpsUrl(value) {
+    try {
+        const url = new URL(value);
+        return url.protocol === "https:";
+    }
+    catch {
+        return false;
+    }
+}
+function validateTemplateUrls(template) {
+    const content = template.template;
+    if ("thumbnailImageUrl" in content && content.thumbnailImageUrl) {
+        if (!isValidHttpsUrl(content.thumbnailImageUrl)) {
+            return "LINE template thumbnailImageUrl must be an HTTPS URL";
+        }
+    }
+    for (const action of content.actions) {
+        if (action.type === "uri" && (!action.uri || !isValidHttpsUrl(action.uri))) {
+            return "LINE template URI actions must use HTTPS URLs";
+        }
+    }
+    return null;
+}
+function validateLocation(location) {
+    if (!Number.isFinite(location.latitude) || location.latitude < -90 || location.latitude > 90) {
+        return "LINE location latitude must be between -90 and 90";
+    }
+    if (!Number.isFinite(location.longitude) ||
+        location.longitude < -180 ||
+        location.longitude > 180) {
+        return "LINE location longitude must be between -180 and 180";
+    }
+    return null;
+}
+/**
+ * LINE messaging service for ElizaOS agents.
+ */
+export class LineService extends Service {
+    static serviceType = LINE_SERVICE_NAME;
+    capabilityDescription = "The agent is able to send and receive messages via LINE";
+    settings = null;
+    client = null;
+    connected = false;
+    constructor(runtime) {
+        super(runtime);
+        if (!runtime)
+            return;
+        this.settings = this.loadSettings();
+    }
+    /**
+     * Start the LINE service.
+     */
+    static async start(runtime) {
+        const service = new LineService(runtime);
+        await service.initialize();
+        return service;
+    }
+    static registerSendHandlers(runtime, service) {
+        const sendHandler = async (handlerRuntime, target, content) => {
+            await service.handleSendMessage(handlerRuntime, target, content);
+            return undefined;
+        };
+        if (typeof runtime.registerMessageConnector === "function") {
+            const registration = {
+                source: LINE_SERVICE_NAME,
+                label: "LINE",
+                capabilities: [
+                    "send_message",
+                    "send_flex_message",
+                    "send_location",
+                    "send_template_message",
+                    "quick_reply",
+                ],
+                supportedTargetKinds: ["contact", "group", "room", "channel"],
+                contexts: ["social", "connectors"],
+                description: "Send LINE text, flex/card, template, quick reply, and location messages to known LINE chats.",
+                sendHandler,
+                resolveTargets: async (query, context) => {
+                    const normalizedTarget = normalizeLineTarget(query);
+                    const exactTarget = normalizedTarget
+                        ? [
+                            {
+                                target: {
+                                    source: LINE_SERVICE_NAME,
+                                    channelId: normalizedTarget,
+                                },
+                                label: normalizedTarget,
+                                kind: getChatTypeFromId(normalizedTarget) === "user"
+                                    ? "contact"
+                                    : getChatTypeFromId(normalizedTarget),
+                                score: 1,
+                                contexts: ["social", "connectors"],
+                                metadata: {
+                                    chatType: getChatTypeFromId(normalizedTarget),
+                                },
+                            },
+                        ]
+                        : [];
+                    const roomTargets = (await service.listConnectorRooms(context.runtime))
+                        .map((room) => ({
+                        room,
+                        score: scoreLineCandidate([room.name, room.channelId, String(room.id)], query),
+                    }))
+                        .filter(({ score }) => score > 0)
+                        .map(({ room, score }) => lineRoomToConnectorTarget(room, score));
+                    return [...exactTarget, ...roomTargets]
+                        .sort((left, right) => (right.score ?? 0) - (left.score ?? 0))
+                        .slice(0, 10);
+                },
+                listRecentTargets: async (context) => (await service.listConnectorRooms(context.runtime))
+                    .slice(0, 10)
+                    .map((room) => lineRoomToConnectorTarget(room)),
+                listRooms: async (context) => (await service.listConnectorRooms(context.runtime)).map((room) => lineRoomToConnectorTarget(room)),
+                fetchMessages: async (context, params) => {
+                    const limit = normalizeConnectorLimit(params?.limit);
+                    const target = params?.target ?? context.target;
+                    if (target?.roomId) {
+                        return readStoredMessageMemories(context.runtime, target.roomId, limit);
+                    }
+                    const targets = (await service.listConnectorRooms(context.runtime))
+                        .slice(0, 10)
+                        .map((room) => lineRoomToConnectorTarget(room));
+                    return readStoredMessagesForTargets(context.runtime, targets, limit);
+                },
+                searchMessages: async (context, params) => {
+                    const limit = normalizeConnectorLimit(params?.limit);
+                    const target = params?.target ?? context.target;
+                    const messages = target?.roomId
+                        ? await readStoredMessageMemories(context.runtime, target.roomId, Math.max(limit, 100))
+                        : await readStoredMessagesForTargets(context.runtime, (await service.listConnectorRooms(context.runtime))
+                            .slice(0, 10)
+                            .map((room) => lineRoomToConnectorTarget(room)), Math.max(limit, 100));
+                    return filterMemoriesByQuery(messages, params.query, limit);
+                },
+                leaveHandler: async (handlerRuntime, params) => {
+                    const target = params.target ?? { source: LINE_SERVICE_NAME };
+                    const room = target.roomId ? await handlerRuntime.getRoom(target.roomId) : null;
+                    const channelId = String(params.channelId ?? target.channelId ?? room?.channelId ?? "");
+                    const chatType = getChatTypeFromId(channelId);
+                    if (chatType !== "group" && chatType !== "room") {
+                        throw new Error("LINE leaveHandler requires a group or room target");
+                    }
+                    await service.leaveChat(channelId, chatType);
+                },
+                getUser: async (_handlerRuntime, params) => {
+                    const userId = String(params.userId ??
+                        params.username ??
+                        params.handle ??
+                        params.target?.entityId ??
+                        params.target?.channelId ??
+                        "").trim();
+                    if (!userId || getChatTypeFromId(userId) !== "user") {
+                        return null;
+                    }
+                    const user = await service.getUserProfile(userId).catch(() => null);
+                    if (!user) {
+                        return null;
+                    }
+                    return {
+                        id: user.userId,
+                        names: [user.displayName, user.userId].filter((value) => value.length > 0),
+                        agentId: _handlerRuntime.agentId,
+                        metadata: { line: objectToMetadataValue(user) },
+                    };
+                },
+                getChatContext: async (target, context) => {
+                    const room = target.roomId ? await context.runtime.getRoom(target.roomId) : null;
+                    const channelId = String(target.channelId ?? room?.channelId ?? "").trim();
+                    if (!channelId) {
+                        return null;
+                    }
+                    const chatType = getChatTypeFromId(channelId);
+                    let label = room?.name || channelId;
+                    let metadata = { chatType, channelId };
+                    if (chatType === "group" || chatType === "room") {
+                        const group = await service.getGroupInfo(channelId).catch(() => null);
+                        if (group?.groupName) {
+                            label = group.groupName;
+                        }
+                        metadata = {
+                            ...metadata,
+                            ...(group ? { group: objectToMetadataValue(group) } : {}),
+                        };
+                    }
+                    else {
+                        const user = await service.getUserProfile(channelId).catch(() => null);
+                        if (user?.displayName) {
+                            label = user.displayName;
+                        }
+                        metadata = {
+                            ...metadata,
+                            ...(user ? { user: objectToMetadataValue(user) } : {}),
+                        };
+                    }
+                    return {
+                        target: {
+                            source: LINE_SERVICE_NAME,
+                            roomId: target.roomId,
+                            channelId,
+                        },
+                        label,
+                        summary: `LINE ${chatType} chat`,
+                        metadata,
+                    };
+                },
+                getUserContext: async (entityId, context) => {
+                    const entity = typeof context.runtime.getEntityById === "function"
+                        ? await context.runtime.getEntityById(String(entityId))
+                        : null;
+                    if (!entity) {
+                        return null;
+                    }
+                    return {
+                        entityId,
+                        label: entity.names[0],
+                        aliases: entity.names,
+                        handles: {},
+                        metadata: entity.metadata,
+                    };
+                },
+            };
+            runtime.registerMessageConnector(registration);
+            return;
+        }
+        runtime.registerSendHandler(LINE_SERVICE_NAME, sendHandler);
+    }
+    /**
+     * Initialize the service.
+     */
+    async initialize() {
+        if (!this.runtime)
+            return;
+        logger.info("Starting LINE service...");
+        // Load settings
+        if (!this.settings) {
+            this.settings = this.loadSettings();
+        }
+        if (!this.settings.enabled) {
+            this.connected = false;
+            logger.info("LINE service disabled by LINE_ENABLED=false");
+            return;
+        }
+        this.validateSettings();
+        // Initialize LINE client
+        this.client = new messagingApi.MessagingApiClient({
+            channelAccessToken: this.settings.channelAccessToken,
+        });
+        this.connected = true;
+        logger.info("LINE service started");
+        // Emit connection ready event
+        if (this.runtime) {
+            this.runtime.emitEvent([LineEventTypes.CONNECTION_READY], {
+                runtime: this.runtime,
+                source: "line",
+                service: this,
+            });
+        }
+    }
+    /**
+     * Stop the LINE service.
+     */
+    async stop() {
+        logger.info("Stopping LINE service...");
+        this.connected = false;
+        this.client = null;
+        this.settings = null;
+        logger.info("LINE service stopped");
+    }
+    /**
+     * Check if the service is connected.
+     */
+    isConnected() {
+        return this.connected && this.client !== null;
+    }
+    /**
+     * Get bot info.
+     */
+    async getBotInfo() {
+        if (!this.client) {
+            return null;
+        }
+        const info = await this.client.getBotInfo();
+        return {
+            userId: info.userId,
+            displayName: info.displayName,
+            pictureUrl: info.pictureUrl,
+        };
+    }
+    /**
+     * Send a text message.
+     */
+    async sendMessage(to, text, options) {
+        if (!this.client) {
+            return { success: false, error: "Service not connected" };
+        }
+        const chunks = splitMessageForLine(text);
+        const messages = chunks.map((chunk) => ({
+            type: "text",
+            text: chunk,
+        }));
+        // Add quick replies to last message if provided
+        if (options?.quickReplyItems && messages.length > 0) {
+            const lastIdx = messages.length - 1;
+            messages[lastIdx].quickReply = {
+                items: options.quickReplyItems,
+            };
+        }
+        return this.pushMessages(to, messages);
+    }
+    /**
+     * Send multiple messages.
+     */
+    async sendMessages(to, messages) {
+        return this.pushMessages(to, messages);
+    }
+    /**
+     * Send a flex message.
+     */
+    async sendFlexMessage(to, flex) {
+        if (!this.client) {
+            return { success: false, error: "Service not connected" };
+        }
+        const message = {
+            type: "flex",
+            altText: flex.altText.slice(0, 400),
+            contents: flex.contents,
+        };
+        return this.pushMessages(to, [message]);
+    }
+    /**
+     * Send a template message.
+     */
+    async sendTemplateMessage(to, template) {
+        if (!this.client) {
+            return { success: false, error: "Service not connected" };
+        }
+        const validationError = validateTemplateUrls(template);
+        if (validationError) {
+            return { success: false, error: validationError };
+        }
+        const message = {
+            type: "template",
+            altText: template.altText.slice(0, 400),
+            template: template.template,
+        };
+        return this.pushMessages(to, [message]);
+    }
+    /**
+     * Send a location message.
+     */
+    async sendLocationMessage(to, location) {
+        if (!this.client) {
+            return { success: false, error: "Service not connected" };
+        }
+        const validationError = validateLocation(location);
+        if (validationError) {
+            return { success: false, error: validationError };
+        }
+        const message = {
+            type: "location",
+            title: location.title.slice(0, 100),
+            address: location.address.slice(0, 100),
+            latitude: location.latitude,
+            longitude: location.longitude,
+        };
+        return this.pushMessages(to, [message]);
+    }
+    /**
+     * Reply to a message using reply token.
+     */
+    async replyMessage(replyToken, messages) {
+        if (!this.client) {
+            return { success: false, error: "Service not connected" };
+        }
+        await this.client.replyMessage({
+            replyToken,
+            messages: messages.slice(0, MAX_LINE_BATCH_SIZE),
+        });
+        return {
+            success: true,
+            messageId: "reply",
+            chatId: "reply",
+        };
+    }
+    /**
+     * Get user profile.
+     */
+    async getUserProfile(userId) {
+        if (!this.client) {
+            return null;
+        }
+        const profile = await this.client.getProfile(userId);
+        return {
+            userId: profile.userId,
+            displayName: profile.displayName,
+            pictureUrl: profile.pictureUrl,
+            statusMessage: profile.statusMessage,
+            language: profile.language,
+        };
+    }
+    /**
+     * Get group info.
+     */
+    async getGroupInfo(groupId) {
+        if (!this.client) {
+            return null;
+        }
+        const chatType = getChatTypeFromId(groupId);
+        if (chatType === "group") {
+            const summary = await this.client.getGroupSummary(groupId);
+            return {
+                groupId: summary.groupId,
+                groupName: summary.groupName,
+                pictureUrl: summary.pictureUrl,
+                type: "group",
+            };
+        }
+        else if (chatType === "room") {
+            // Rooms don't have summary, just return ID
+            return {
+                groupId,
+                type: "room",
+            };
+        }
+        return null;
+    }
+    /**
+     * Leave a group or room.
+     */
+    async leaveChat(chatId, chatType) {
+        if (!this.client) {
+            throw new LineApiError("Service not connected");
+        }
+        if (chatType === "group") {
+            await this.client.leaveGroup(chatId);
+        }
+        else {
+            await this.client.leaveRoom(chatId);
+        }
+    }
+    /**
+     * Get the middleware config for webhook verification.
+     */
+    getMiddlewareConfig() {
+        if (!this.settings) {
+            throw new LineConfigurationError("Service not configured");
+        }
+        return {
+            channelSecret: this.settings.channelSecret,
+        };
+    }
+    /**
+     * Create Express middleware for webhook handling.
+     */
+    createMiddleware() {
+        return middleware(this.getMiddlewareConfig());
+    }
+    /**
+     * Handle webhook events.
+     */
+    async handleWebhookEvents(events) {
+        if (!this.runtime) {
+            return;
+        }
+        if (!Array.isArray(events)) {
+            return;
+        }
+        for (const event of events) {
+            if (!isRecord(event) || typeof event.type !== "string") {
+                continue;
+            }
+            await this.handleWebhookEvent(event);
+        }
+    }
+    /**
+     * Get current settings.
+     */
+    getSettings() {
+        return this.settings;
+    }
+    async sendDirectMessage(target, content) {
+        await this.sendConnectorContent(target, content);
+    }
+    async sendRoomMessage(target, content) {
+        await this.sendConnectorContent(target, content);
+    }
+    // Private methods
+    async handleSendMessage(runtime, target, content) {
+        const room = target.roomId ? await runtime.getRoom(target.roomId) : null;
+        const chatId = String(target.channelId ?? room?.channelId ?? "").trim();
+        if (!chatId) {
+            throw new Error("LINE target is missing a user, group, or room ID");
+        }
+        await this.sendConnectorContent(chatId, content);
+    }
+    async sendConnectorContent(to, content) {
+        const data = lineDataFromContent(content);
+        const flexMessage = data.flexMessage;
+        if (flexMessage) {
+            const result = await this.sendFlexMessage(to, flexMessage);
+            if (!result.success) {
+                throw new Error(result.error || "LINE flex message send failed");
+            }
+            return;
+        }
+        const location = data.location;
+        if (location) {
+            const result = await this.sendLocationMessage(to, location);
+            if (!result.success) {
+                throw new Error(result.error || "LINE location send failed");
+            }
+            return;
+        }
+        const templateMessage = data.templateMessage;
+        if (templateMessage) {
+            const result = await this.sendTemplateMessage(to, templateMessage);
+            if (!result.success) {
+                throw new Error(result.error || "LINE template message send failed");
+            }
+            return;
+        }
+        // Agent-generated attachments (#8876). LINE has a dedicated image message
+        // (url-based); it has no generic file message, so non-image media (video
+        // without a thumbnail, audio, documents) is appended to the text as a link
+        // rather than dropped. LINE requires https media URLs.
+        const attachments = Array.isArray(content.attachments) ? content.attachments : [];
+        const imageMessages = [];
+        const linkedUrls = [];
+        for (const media of attachments) {
+            const url = typeof media?.url === "string" ? media.url.trim() : "";
+            if (!/^https:\/\//i.test(url))
+                continue;
+            if (media.contentType === "image") {
+                imageMessages.push({
+                    type: "image",
+                    originalContentUrl: url,
+                    previewImageUrl: url,
+                });
+            }
+            else {
+                linkedUrls.push(url);
+            }
+        }
+        const baseText = typeof content.text === "string" ? content.text.trim() : "";
+        const text = linkedUrls.length > 0 ? [baseText, ...linkedUrls].filter(Boolean).join("\n") : baseText;
+        if (!text && imageMessages.length === 0) {
+            return;
+        }
+        if (text) {
+            const result = await this.sendMessage(to, text, {
+                quickReplyItems: quickReplyItemsFromStrings(data.quickReplies),
+            });
+            if (!result.success) {
+                throw new Error(result.error || "LINE message send failed");
+            }
+        }
+        if (imageMessages.length > 0) {
+            const result = await this.pushMessages(to, imageMessages);
+            if (!result.success) {
+                throw new Error(result.error || "LINE image send failed");
+            }
+        }
+    }
+    async listConnectorRooms(runtime) {
+        if (typeof runtime.getRoomsForParticipant !== "function") {
+            return [];
+        }
+        const roomIds = await runtime.getRoomsForParticipant(runtime.agentId).catch(() => []);
+        const rooms = [];
+        for (const roomId of roomIds) {
+            const room = await runtime.getRoom(roomId).catch(() => null);
+            if (room?.source === LINE_SERVICE_NAME && room.channelId) {
+                rooms.push(room);
+            }
+        }
+        return rooms;
+    }
+    loadSettings() {
+        if (!this.runtime) {
+            throw new LineConfigurationError("Runtime not initialized");
+        }
+        const getStringSetting = (key) => {
+            const value = this.runtime.getSetting(key);
+            return typeof value === "string" ? value : "";
+        };
+        const channelAccessToken = getStringSetting("LINE_CHANNEL_ACCESS_TOKEN") || process.env.LINE_CHANNEL_ACCESS_TOKEN || "";
+        const channelSecret = getStringSetting("LINE_CHANNEL_SECRET") || process.env.LINE_CHANNEL_SECRET || "";
+        const webhookPath = getStringSetting("LINE_WEBHOOK_PATH") || process.env.LINE_WEBHOOK_PATH || "/webhooks/line";
+        const dmPolicyRaw = getStringSetting("LINE_DM_POLICY") || process.env.LINE_DM_POLICY || "pairing";
+        const dmPolicy = dmPolicyRaw;
+        const groupPolicyRaw = getStringSetting("LINE_GROUP_POLICY") || process.env.LINE_GROUP_POLICY || "allowlist";
+        const groupPolicy = groupPolicyRaw;
+        const allowFromRaw = getStringSetting("LINE_ALLOW_FROM") || process.env.LINE_ALLOW_FROM || "";
+        const allowFrom = allowFromRaw
+            .split(",")
+            .map((s) => s.trim())
+            .filter(Boolean);
+        const enabledRaw = getStringSetting("LINE_ENABLED") || process.env.LINE_ENABLED || "true";
+        const enabled = enabledRaw !== "false";
+        return {
+            channelAccessToken,
+            channelSecret,
+            webhookPath,
+            dmPolicy,
+            groupPolicy,
+            allowFrom,
+            enabled,
+        };
+    }
+    validateSettings() {
+        if (!this.settings) {
+            throw new LineConfigurationError("Settings not loaded");
+        }
+        if (!this.settings.channelAccessToken) {
+            throw new LineConfigurationError("LINE_CHANNEL_ACCESS_TOKEN is required", "LINE_CHANNEL_ACCESS_TOKEN");
+        }
+        if (!this.settings.channelSecret) {
+            throw new LineConfigurationError("LINE_CHANNEL_SECRET is required", "LINE_CHANNEL_SECRET");
+        }
+    }
+    async pushMessages(to, messages) {
+        if (!this.client) {
+            return { success: false, error: "Service not connected" };
+        }
+        // Send in batches of 5
+        for (let i = 0; i < messages.length; i += MAX_LINE_BATCH_SIZE) {
+            const batch = messages.slice(i, i + MAX_LINE_BATCH_SIZE);
+            await this.client.pushMessage({
+                to,
+                messages: batch,
+            });
+        }
+        // Emit sent event
+        if (this.runtime) {
+            this.runtime.emitEvent(LineEventTypes.MESSAGE_SENT, {
+                runtime: this.runtime,
+                source: "line",
+                to,
+                messageCount: messages.length,
+            });
+        }
+        return {
+            success: true,
+            messageId: Date.now().toString(),
+            chatId: to,
+        };
+    }
+    async handleWebhookEvent(event) {
+        if (!this.runtime) {
+            return;
+        }
+        switch (event.type) {
+            case "message":
+                await this.handleMessageEvent(event);
+                break;
+            case "follow":
+                this.runtime.emitEvent([LineEventTypes.FOLLOW], {
+                    runtime: this.runtime,
+                    source: "line",
+                    userId: event.source?.userId,
+                    timestamp: event.timestamp,
+                });
+                break;
+            case "unfollow":
+                this.runtime.emitEvent([LineEventTypes.UNFOLLOW], {
+                    runtime: this.runtime,
+                    source: "line",
+                    userId: event.source?.userId,
+                    timestamp: event.timestamp,
+                });
+                break;
+            case "join":
+                this.runtime.emitEvent([LineEventTypes.JOIN_GROUP], {
+                    runtime: this.runtime,
+                    source: "line",
+                    groupId: event.source?.type === "group"
+                        ? event.source.groupId
+                        : event.source?.type === "room"
+                            ? event.source.roomId
+                            : undefined,
+                    type: event.source?.type,
+                    timestamp: event.timestamp,
+                });
+                break;
+            case "leave":
+                this.runtime.emitEvent([LineEventTypes.LEAVE_GROUP], {
+                    runtime: this.runtime,
+                    source: "line",
+                    groupId: event.source?.type === "group"
+                        ? event.source.groupId
+                        : event.source?.type === "room"
+                            ? event.source.roomId
+                            : undefined,
+                    type: event.source?.type,
+                    timestamp: event.timestamp,
+                });
+                break;
+            case "postback":
+                if (!isRecord(event.postback) || typeof event.postback.data !== "string") {
+                    return;
+                }
+                this.runtime.emitEvent([LineEventTypes.POSTBACK], {
+                    runtime: this.runtime,
+                    source: "line",
+                    userId: event.source?.userId,
+                    data: event.postback.data,
+                    params: event.postback.params,
+                    timestamp: event.timestamp,
+                });
+                break;
+        }
+    }
+    async handleMessageEvent(event) {
+        if (!this.runtime) {
+            return;
+        }
+        if (!isRecord(event.message) || typeof event.message.id !== "string") {
+            return;
+        }
+        if (typeof event.message.type !== "string") {
+            return;
+        }
+        const timestamp = Number.isFinite(event.timestamp) ? event.timestamp : Date.now();
+        const message = {
+            id: event.message.id,
+            type: event.message.type,
+            userId: event.source?.userId || "",
+            timestamp,
+            replyToken: event.replyToken,
+        };
+        // Add text for text messages
+        if (event.message.type === "text") {
+            message.text = event.message.text;
+            message.mention = event.message.mention;
+        }
+        // Add group/room ID if applicable
+        if (event.source?.type === "group") {
+            message.groupId = event.source.groupId;
+        }
+        else if (event.source?.type === "room") {
+            message.roomId = event.source.roomId;
+        }
+        // Emit message received event
+        this.runtime.emitEvent([LineEventTypes.MESSAGE_RECEIVED], {
+            runtime: this.runtime,
+            source: "line",
+            message,
+            lineSource: event.source,
+            replyToken: event.replyToken,
+        });
+    }
+}
+//# sourceMappingURL=service.js.map