@zhin.js/adapter-line 2.0.1 → 2.0.3

package/lib/index.js

@@ -1,83 +1,4 @@
-/**
- * LINE Messaging API 适配器入口：类型扩展、导出、注册
- */
-import { usePlugin } from 'zhin.js';
-import { LineAdapter } from './adapter.js';
-export * from './types.js';
-export { LineEndpoint } from './endpoint.js';
-export { LineAdapter } from './adapter.js';
-const plugin = usePlugin();
-const { provide, useContext } = plugin;
-useContext('router', (router) => {
-    provide({
-        name: 'line',
-        description: 'LINE Messaging API Endpoint Adapter',
-        mounted: async (p) => {
-            const adapter = new LineAdapter(p, router);
-            await adapter.start();
-            return adapter;
-        },
-        dispose: async (adapter) => {
-            await adapter.stop();
-        },
-    });
-});
-// L11: Register LINE-specific tools
-useContext('tool', 'line', (toolService, lineAdapter) => {
-    const accessToken = lineAdapter.endpoints.values().next().value?.$config?.channelAccessToken;
-    const apiBaseUrl = lineAdapter.endpoints.values().next().value?.$config?.apiBaseUrl || 'https://api.line.me';
-    const disposers = [];
-    disposers.push(toolService.addTool({
-        name: 'line_get_profile',
-        description: 'Get LINE user profile by userId',
-        parameters: {
-            type: 'object',
-            properties: {
-                userId: { type: 'string', description: 'LINE user ID (starts with U)' },
-            },
-            required: ['userId'],
-        },
-        execute: async ({ userId }) => {
-            if (!userId.startsWith('U')) {
-                throw new Error(`Invalid userId "${userId}": must start with U`);
-            }
-            const response = await fetch(`${apiBaseUrl}/v2/profile/${userId}`, {
-                headers: { 'Authorization': `Bearer ${accessToken}` },
-            });
-            if (!response.ok) {
-                const errorText = await response.text();
-                throw new Error(`LINE Profile API error ${response.status}: ${errorText}`);
-            }
-            return await response.json();
-        },
-    }));
-    disposers.push(toolService.addTool({
-        name: 'line_get_group_members',
-        description: 'Get LINE group member IDs',
-        parameters: {
-            type: 'object',
-            properties: {
-                groupId: { type: 'string', description: 'LINE group ID (starts with G)' },
-            },
-            required: ['groupId'],
-        },
-        execute: async ({ groupId }) => {
-            if (!groupId.startsWith('G')) {
-                throw new Error(`Invalid groupId "${groupId}": must start with G`);
-            }
-            const response = await fetch(`${apiBaseUrl}/v2/bot/group/${groupId}/members/ids`, {
-                headers: { 'Authorization': `Bearer ${accessToken}` },
-            });
-            if (!response.ok) {
-                const errorText = await response.text();
-                throw new Error(`LINE Group Members API error ${response.status}: ${errorText}`);
-            }
-            return await response.json();
-        },
-    }));
-    return () => {
-        for (const disposer of disposers)
-            disposer();
-    };
-});
-//# sourceMappingURL=index.js.map
+export { formatInboundContent, formatOutboundMessages, generateMessageId, isMessageEvent, isPostbackEvent, isValidLineRecipientId, normalizeWebhookPath, readTextBody, resolveChannel, resolveLineConfig, verifySignature, } from './protocol.js';
+export { LineEndpoint, } from './endpoint.js';
+export { registerLineWebhookRoutes, handleLineWebhookRequest, } from './webhook.js';
+export { getLineAgentDeps, getLineApiConfig, registerLineAgentEndpoint, setLineAgentDeps, } from './line-agent-deps.js';

package/lib/line-agent-deps.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Agent tool deps for line (get_profile / get_group_members).
+ * Endpoints register themselves on start; tools look up the active API config.
+ */
+export interface LineAgentEndpoint {
+    getApiConfig(): {
+        accessToken: string;
+        apiBaseUrl: string;
+    };
+}
+export interface LineAgentDeps {
+    getApiConfig: () => {
+        accessToken: string;
+        apiBaseUrl: string;
+    };
+}
+export declare function registerLineAgentEndpoint(endpointId: string, endpoint: LineAgentEndpoint): () => void;
+/** Optional override used by tests / transitional callers. Pass `null` to clear. */
+export declare function setLineAgentDeps(deps: LineAgentDeps | null): void;
+export declare function getLineAgentDeps(): LineAgentDeps;
+export declare function getLineApiConfig(): {
+    accessToken: string;
+    apiBaseUrl: string;
+};

package/lib/line-agent-deps.js

@@ -0,0 +1,33 @@
+/**
+ * Agent tool deps for line (get_profile / get_group_members).
+ * Endpoints register themselves on start; tools look up the active API config.
+ */
+const endpoints = new Map();
+let override = null;
+export function registerLineAgentEndpoint(endpointId, endpoint) {
+    endpoints.set(endpointId, endpoint);
+    return () => {
+        if (endpoints.get(endpointId) === endpoint) {
+            endpoints.delete(endpointId);
+        }
+    };
+}
+/** Optional override used by tests / transitional callers. Pass `null` to clear. */
+export function setLineAgentDeps(deps) {
+    override = deps;
+}
+export function getLineAgentDeps() {
+    if (override)
+        return override;
+    return {
+        getApiConfig() {
+            const first = endpoints.values().next().value;
+            if (!first)
+                throw new Error('LINE channel access token not configured');
+            return first.getApiConfig();
+        },
+    };
+}
+export function getLineApiConfig() {
+    return getLineAgentDeps().getApiConfig();
+}

package/lib/protocol.d.ts

@@ -0,0 +1,151 @@
+/**
+ * LINE Messaging API protocol helpers — no legacy Adapter/Endpoint / segment-mapper.
+ * Canonicalization is owned by gateway/core before endpoint.send.
+ */
+import type { IncomingMessage } from 'node:http';
+/** Plugin Runtime owner config (`plugins.<instanceKey>` / schema.json). */
+export interface LineAdapterConfig {
+    readonly name?: string;
+    readonly channelSecret?: string;
+    readonly channelAccessToken?: string;
+    readonly webhookPath?: string;
+    readonly apiBaseUrl?: string;
+    /** Transitional: legacy root `endpoints[]` with `context: line`. */
+    readonly endpoints?: ReadonlyArray<Partial<ResolvedLineConfig> & {
+        readonly context?: string;
+    }>;
+}
+export interface ResolvedLineConfig {
+    readonly context: 'line';
+    readonly name: string;
+    readonly channelSecret: string;
+    readonly channelAccessToken: string;
+    readonly webhookPath: string;
+    readonly apiBaseUrl: string;
+}
+export interface LineUser {
+    readonly userId: string;
+    readonly displayName?: string;
+    readonly pictureUrl?: string;
+    readonly statusMessage?: string;
+}
+export interface LineMessageEvent {
+    readonly type: 'message';
+    readonly replyToken: string;
+    readonly source: LineSource;
+    readonly timestamp: number;
+    readonly message: LineMessage;
+}
+export interface LineFollowEvent {
+    readonly type: 'follow';
+    readonly replyToken: string;
+    readonly source: LineSource;
+    readonly timestamp: number;
+}
+export interface LineUnfollowEvent {
+    readonly type: 'unfollow';
+    readonly source: LineSource;
+    readonly timestamp: number;
+}
+export interface LineJoinEvent {
+    readonly type: 'join';
+    readonly replyToken: string;
+    readonly source: LineSource;
+    readonly timestamp: number;
+}
+export interface LineLeaveEvent {
+    readonly type: 'leave';
+    readonly source: LineSource;
+    readonly timestamp: number;
+}
+export interface LinePostbackEvent {
+    readonly type: 'postback';
+    readonly replyToken: string;
+    readonly source: LineSource;
+    readonly timestamp: number;
+    readonly postback: {
+        readonly data: string;
+        readonly params?: Record<string, string>;
+    };
+}
+export type LineEvent = LineMessageEvent | LineFollowEvent | LineUnfollowEvent | LineJoinEvent | LineLeaveEvent | LinePostbackEvent;
+export interface LineSource {
+    readonly type: 'user' | 'group' | 'room';
+    readonly userId?: string;
+    readonly groupId?: string;
+    readonly roomId?: string;
+}
+export interface LineMessage {
+    readonly id: string;
+    readonly type: 'text' | 'image' | 'video' | 'audio' | 'file' | 'location' | 'sticker';
+    readonly text?: string;
+    readonly fileName?: string;
+    readonly fileSize?: number;
+    readonly title?: string;
+    readonly address?: string;
+    readonly latitude?: number;
+    readonly longitude?: number;
+    readonly packageId?: string;
+    readonly stickerId?: string;
+    readonly stickerResourceType?: string;
+    readonly duration?: number;
+}
+export interface LineWebhookBody {
+    readonly destination: string;
+    readonly events: readonly LineEvent[];
+}
+export interface LineReplyMessage {
+    readonly type: 'text' | 'image' | 'video' | 'audio' | 'location' | 'sticker' | 'flex';
+    readonly text?: string;
+    readonly originalContentUrl?: string;
+    readonly previewImageUrl?: string;
+    readonly packageId?: string;
+    readonly stickerId?: string;
+    readonly title?: string;
+    readonly address?: string;
+    readonly latitude?: number;
+    readonly longitude?: number;
+    readonly duration?: number;
+    readonly altText?: string;
+    readonly contents?: Record<string, unknown>;
+}
+export interface LineReplyRequest {
+    readonly replyToken: string;
+    readonly messages: readonly LineReplyMessage[];
+}
+export interface LinePushRequest {
+    readonly to: string;
+    readonly messages: readonly LineReplyMessage[];
+}
+export interface LineApiResponse {
+    readonly sentMessages?: ReadonlyArray<{
+        readonly id: string;
+        readonly quoteToken?: string;
+    }>;
+}
+export interface LineWireSegment {
+    readonly type: string;
+    readonly data?: Record<string, unknown>;
+}
+export interface LineChannel {
+    readonly channelType: 'private' | 'group' | 'channel';
+    readonly channelId: string;
+}
+export declare function resolveLineConfig(config?: LineAdapterConfig): ResolvedLineConfig;
+export declare function normalizeWebhookPath(path: string): string;
+export declare function isMessageEvent(event: LineEvent): event is LineMessageEvent;
+export declare function isPostbackEvent(event: LineEvent): event is LinePostbackEvent;
+export declare function resolveChannel(source: LineSource): LineChannel;
+export declare function generateMessageId(event: LineEvent): string;
+/** Build inbound text for MessageGateway.receive. */
+export declare function formatInboundContent(event: LineEvent): string;
+export declare function verifySignature(channelSecret: string, body: string, signature: string): boolean;
+export declare function isValidLineRecipientId(id: string): boolean;
+/**
+ * Wire-encode an already-rendered outbound payload into LINE Reply/Push messages.
+ * Segment canonicalization is intentionally not done here.
+ */
+export declare function formatOutboundMessages(payload: unknown): LineReplyMessage[];
+export declare function readTextBody(request: IncomingMessage, options?: {
+    readonly limit?: number;
+}): Promise<string>;

package/lib/protocol.js

@@ -0,0 +1,212 @@
+/**
+ * LINE Messaging API protocol helpers — no legacy Adapter/Endpoint / segment-mapper.
+ * Canonicalization is owned by gateway/core before endpoint.send.
+ */
+import { createHmac, timingSafeEqual } from 'node:crypto';
+export function resolveLineConfig(config = {}) {
+    const entry = config.endpoints?.find((item) => item.context === 'line');
+    const channelSecret = config.channelSecret
+        ?? entry?.channelSecret
+        ?? process.env.LINE_CHANNEL_SECRET;
+    const channelAccessToken = config.channelAccessToken
+        ?? entry?.channelAccessToken
+        ?? process.env.LINE_CHANNEL_ACCESS_TOKEN;
+    if (!channelSecret || !channelAccessToken) {
+        throw new TypeError('LINE adapter requires channelSecret + channelAccessToken (plugins.<key> or endpoints with context: line)');
+    }
+    const name = (typeof config.name === 'string' && config.name)
+        || (typeof entry?.name === 'string' && entry.name)
+        || process.env.LINE_BOT_NAME
+        || 'line-bot';
+    const webhookPath = normalizeWebhookPath(config.webhookPath ?? entry?.webhookPath ?? '/line/webhook');
+    const apiBaseUrl = (config.apiBaseUrl ?? entry?.apiBaseUrl ?? 'https://api.line.me').replace(/\/$/, '');
+    return {
+        context: 'line',
+        name,
+        channelSecret,
+        channelAccessToken,
+        webhookPath,
+        apiBaseUrl,
+    };
+}
+export function normalizeWebhookPath(path) {
+    const trimmed = path.trim() || '/line/webhook';
+    return trimmed.startsWith('/') ? trimmed : `/${trimmed}`;
+}
+export function isMessageEvent(event) {
+    return event.type === 'message' && 'message' in event && event.message != null;
+}
+export function isPostbackEvent(event) {
+    return event.type === 'postback' && 'postback' in event;
+}
+export function resolveChannel(source) {
+    switch (source.type) {
+        case 'user':
+            return { channelType: 'private', channelId: source.userId || '' };
+        case 'group':
+            return { channelType: 'group', channelId: source.groupId || '' };
+        case 'room':
+            return { channelType: 'channel', channelId: source.roomId || '' };
+        default:
+            return { channelType: 'private', channelId: '' };
+    }
+}
+export function generateMessageId(event) {
+    if (isMessageEvent(event) && event.message?.id)
+        return event.message.id;
+    return `${event.type}-${event.timestamp}`;
+}
+/** Build inbound text for MessageGateway.receive. */
+export function formatInboundContent(event) {
+    if (isMessageEvent(event)) {
+        const msg = event.message;
+        switch (msg.type) {
+            case 'text':
+                return msg.text || '';
+            case 'location':
+                return msg.address || `[location: ${msg.latitude},${msg.longitude}]`;
+            case 'image':
+                return '[image]';
+            case 'video':
+                return '[video]';
+            case 'audio':
+                return '[audio]';
+            case 'file':
+                return msg.fileName ? `[file: ${msg.fileName}]` : '[file]';
+            case 'sticker':
+                return `[sticker: ${msg.packageId}/${msg.stickerId}]`;
+            default:
+                return `[${msg.type}]`;
+        }
+    }
+    if (event.type === 'follow')
+        return '[follow]';
+    if (event.type === 'join')
+        return '[join]';
+    if (event.type === 'unfollow')
+        return '[unfollow]';
+    if (event.type === 'leave')
+        return '[leave]';
+    if (event.type === 'postback')
+        return `[postback: ${event.postback.data}]`;
+    return '';
+}
+export function verifySignature(channelSecret, body, signature) {
+    const hmac = createHmac('sha256', channelSecret);
+    hmac.update(body, 'utf-8');
+    const computedSignature = hmac.digest('base64');
+    const sigBuf = Buffer.from(signature);
+    const computedBuf = Buffer.from(computedSignature);
+    if (sigBuf.length !== computedBuf.length)
+        return false;
+    return timingSafeEqual(sigBuf, computedBuf);
+}
+export function isValidLineRecipientId(id) {
+    return /^[UGR]/.test(id);
+}
+function buildTextMessage(text) {
+    const truncated = text.length > 5000 ? `${text.slice(0, 4997)}...` : text;
+    return { type: 'text', text: truncated };
+}
+/**
+ * Wire-encode an already-rendered outbound payload into LINE Reply/Push messages.
+ * Segment canonicalization is intentionally not done here.
+ */
+export function formatOutboundMessages(payload) {
+    if (typeof payload === 'string') {
+        return [buildTextMessage(payload)];
+    }
+    const items = Array.isArray(payload)
+        ? payload
+        : payload && typeof payload === 'object' && 'type' in payload
+            ? [payload]
+            : [];
+    if (items.length === 0) {
+        const text = payload == null
+            ? ''
+            : typeof payload === 'object'
+                ? JSON.stringify(payload)
+                : String(payload);
+        return [buildTextMessage(text)];
+    }
+    const messages = [];
+    for (const item of items) {
+        if (typeof item === 'string') {
+            messages.push(buildTextMessage(item));
+            continue;
+        }
+        const data = item.data ?? {};
+        switch (item.type) {
+            case 'text':
+                messages.push(buildTextMessage(String(data.text ?? data.content ?? '')));
+                break;
+            case 'at':
+                if (data.id) {
+                    messages.push(buildTextMessage(`@${String(data.name || data.id)}`));
+                }
+                break;
+            case 'image':
+                if (typeof data.url === 'string' && data.url) {
+                    messages.push({
+                        type: 'image',
+                        originalContentUrl: data.url,
+                        previewImageUrl: data.url,
+                    });
+                }
+                break;
+            case 'video':
+                if (typeof data.url === 'string' && data.url) {
+                    messages.push({
+                        type: 'video',
+                        originalContentUrl: data.url,
+                        previewImageUrl: typeof data.previewUrl === 'string' ? data.previewUrl : data.url,
+                    });
+                }
+                break;
+            case 'audio':
+                if (typeof data.url === 'string' && data.url) {
+                    messages.push({
+                        type: 'audio',
+                        originalContentUrl: data.url,
+                        duration: typeof data.duration === 'number' ? data.duration : 0,
+                    });
+                }
+                break;
+            case 'location':
+                messages.push({
+                    type: 'location',
+                    title: String(data.title || 'Location'),
+                    address: String(data.address || ''),
+                    latitude: typeof data.latitude === 'number' ? data.latitude : 0,
+                    longitude: typeof data.longitude === 'number' ? data.longitude : 0,
+                });
+                break;
+            case 'sticker':
+                messages.push({
+                    type: 'sticker',
+                    packageId: String(data.package_id || '1'),
+                    stickerId: String(data.sticker_id || '1'),
+                });
+                break;
+            default:
+                messages.push(buildTextMessage(`[${item.type}]`));
+        }
+    }
+    // LINE allows at most 5 messages per Reply/Push request.
+    return messages.slice(0, 5);
+}
+export async function readTextBody(request, options = {}) {
+    const limit = options.limit ?? 1_048_576;
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of request) {
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        size += buffer.length;
+        if (size > limit) {
+            request.destroy();
+            throw new Error(`Request body exceeds ${limit} bytes`);
+        }
+        chunks.push(buffer);
+    }
+    return Buffer.concat(chunks).toString('utf8');
+}

package/lib/webhook.d.ts

@@ -0,0 +1,13 @@
+/**
+ * LINE webhook HTTP: signature → parse → admit.
+ */
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { HttpHost, HttpRouteRegistration } from '@zhin.js/host-http';
+import { type LineEvent, type ResolvedLineConfig } from './protocol.js';
+export interface LineWebhookHandler {
+    readonly config: ResolvedLineConfig;
+    readonly isOpen: boolean;
+    admit(event: LineEvent): void;
+}
+export declare function registerLineWebhookRoutes(http: HttpHost, handler: LineWebhookHandler): HttpRouteRegistration[];
+export declare function handleLineWebhookRequest(request: IncomingMessage, response: ServerResponse, handler: LineWebhookHandler): Promise<void>;

package/lib/webhook.js

@@ -0,0 +1,50 @@
+import { formatCompact, getLogger } from '@zhin.js/logger';
+import { readTextBody, verifySignature, } from './protocol.js';
+const logger = getLogger('line');
+export function registerLineWebhookRoutes(http, handler) {
+    const path = handler.config.webhookPath;
+    return [
+        http.route('POST', path, async (request, response) => {
+            await handleLineWebhookRequest(request, response, handler);
+        }, { summary: 'LINE Messaging API webhook', tags: ['line'] }),
+    ];
+}
+export async function handleLineWebhookRequest(request, response, handler) {
+    try {
+        const signature = request.headers['x-line-signature'];
+        const signatureValue = Array.isArray(signature) ? signature[0] : signature;
+        if (!signatureValue) {
+            response.writeHead(403, { 'Content-Type': 'application/json' });
+            response.end(JSON.stringify({ message: 'Missing signature' }));
+            return;
+        }
+        const rawBody = await readTextBody(request);
+        if (!verifySignature(handler.config.channelSecret, rawBody, signatureValue)) {
+            logger.warn(formatCompact({ op: 'webhook', ok: false, error: 'invalid signature' }));
+            response.writeHead(403, { 'Content-Type': 'application/json' });
+            response.end(JSON.stringify({ message: 'Invalid signature' }));
+            return;
+        }
+        let body;
+        try {
+            body = JSON.parse(rawBody);
+        }
+        catch {
+            response.writeHead(200, { 'Content-Type': 'application/json' });
+            response.end(JSON.stringify({ message: 'OK' }));
+            return;
+        }
+        if (handler.isOpen && Array.isArray(body.events)) {
+            for (const event of body.events) {
+                handler.admit(event);
+            }
+        }
+        response.writeHead(200, { 'Content-Type': 'application/json' });
+        response.end(JSON.stringify({ message: 'OK' }));
+    }
+    catch (error) {
+        logger.error('LINE webhook error:', error);
+        response.writeHead(200, { 'Content-Type': 'application/json' });
+        response.end(JSON.stringify({ message: 'OK' }));
+    }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@zhin.js/adapter-line",
-  "version": "2.0.1",
-  "description": "Zhin.js adapter for LINE Messaging API",
+  "version": "2.0.3",
+  "description": "Zhin.js LINE Messaging API adapter for Plugin Runtime (HTTP webhook)",
   "type": "module",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
@@ -31,34 +31,47 @@
     "type": "git",
     "directory": "plugins/adapters/line"
   },
-  "devDependencies": {
-    "@types/node": "^26.1.0",
-    "typescript": "^6.0.3",
-    "@zhin.js/host-api": "2.0.4",
-    "@zhin.js/host-router": "2.0.2",
-    "@zhin.js/logger": "1.0.73",
-    "zhin.js": "4.1.1",
-    "@zhin.js/cli": "1.0.92"
+  "dependencies": {
+    "@zhin.js/adapter": "1.0.1",
+    "@zhin.js/core": "1.3.5",
+    "@zhin.js/host-http": "1.0.1",
+    "@zhin.js/logger": "1.0.75",
+    "@zhin.js/plugin-runtime": "1.0.1"
   },
   "peerDependencies": {
-    "@zhin.js/host-api": "2.0.4",
-    "@zhin.js/host-router": "2.0.2",
-    "@zhin.js/logger": "1.0.73",
-    "zhin.js": "4.1.1"
+    "zod": "^4.0.0",
+    "@zhin.js/adapter": "1.0.1",
+    "@zhin.js/agent": "1.0.4",
+    "@zhin.js/core": "1.3.5",
+    "@zhin.js/host-http": "1.0.1",
+    "@zhin.js/plugin-runtime": "1.0.1",
+    "zhin.js": "4.1.3"
   },
   "peerDependenciesMeta": {
-    "@zhin.js/host-router": {
+    "zhin.js": {
+      "optional": true
+    },
+    "@zhin.js/agent": {
       "optional": true
     },
-    "@zhin.js/host-api": {
+    "zod": {
       "optional": true
     }
   },
+  "devDependencies": {
+    "@types/node": "^26.1.0",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.10",
+    "zod": "^4.4.3",
+    "@zhin.js/agent": "1.0.4"
+  },
   "files": [
+    "adapters",
+    "plugin.ts",
+    "schema.json",
     "src",
     "lib",
-    "skills",
-    "plugin.yml",
+    "agent",
     "README.md",
     "CHANGELOG.md"
   ],
@@ -69,9 +82,23 @@
   "engines": {
     "node": "^20.19.0 || >=22.12.0"
   },
+  "zhin": {
+    "protocol": 1,
+    "type": "plugin",
+    "entry": "./plugin.ts",
+    "engine": "^1.0.0",
+    "runtime": "trusted",
+    "features": [
+      {
+        "package": "@zhin.js/adapter",
+        "api": "^1.0.0"
+      }
+    ],
+    "plugins": []
+  },
   "scripts": {
-    "build": "zhin build",
-    "clean": "rimraf lib dist",
-    "build:node": "tsc"
+    "build": "tsc",
+    "clean": "rimraf lib",
+    "test": "NODE_OPTIONS=--experimental-strip-types vitest run --root ../../.. plugins/adapters/line/tests"
   }
 }

package/plugin.ts

@@ -0,0 +1,8 @@
+import { definePlugin } from '@zhin.js/plugin-runtime';
+
+export default definePlugin({
+  name: 'line',
+  metadata: {
+    displayName: 'LINE Messaging API Adapter',
+  },
+});