@zhin.js/adapter-line 1.1.18 → 1.1.19

package/lib/client.js

@@ -1,54 +1,252 @@
-import { defineEndpointClient } from 'zhin.js/adapter';
-/** Direct LINE Messaging API client; it has no Endpoint lifecycle methods. */
-export class LineClient {
-    config;
-    fetch;
-    constructor(config, fetch) {
-        this.config = config;
-        this.fetch = fetch;
-    }
-    async request(path, init = {}) {
-        const response = await this.fetch(`${this.config.apiBaseUrl}${path}`, {
-            method: init.method ?? 'GET',
+import { LineApiClient } from './api-client.js';
+import { EndpointDeliveryError } from '@zhin.js/im-contract';
+import { formatCompact, getAdapterLogger } from '@zhin.js/logger';
+import { formatInboundContent, formatOutboundMessages, generateMessageId, isLineLifecycleEvent, isMessageEvent, isValidLineRecipientId, lineInboundConversation, } from './protocol.js';
+import { registerLineWebhookRoutes } from './webhook.js';
+import { receiveLineSideEvent } from './side-event-dispatch.js';
+/** LINE replyToken 有效期短，过期后 reply 必 400；缓存带时间戳，超时弃用改走 push。 */
+const REPLY_TOKEN_TTL_MS = 60_000;
+/** 出站 HTTP 调用统一 30s 超时。 */
+const OUTBOUND_TIMEOUT_MS = 30_000;
+export class LineClient extends LineApiClient {
+    #logger;
+    #options;
+    #fetch;
+    #routeReleases = [];
+    #replyTokenCache = new Map();
+    #admissions = new Map();
+    #open = false;
+    #started = false;
+    endpointManagement = createLineEndpointManagement(this);
+    configName() { return this.#options.config.id; }
+    get transportState() { return undefined; }
+    executionSignal;
+    setExecutionSignal(signal) { this.executionSignal = signal; this.transportSignal = signal; }
+    /** Native protocol work runs here; Endpoint attaches the framework receipt without replacing SDK APIs. */
+    receiveInboundCallback(receive) {
+        try {
+            return Promise.resolve(receive());
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+    }
+    publishEvent(name, payload) { this.emit(name, payload); return Promise.resolve(); }
+    publishAccepted(name, payload) { return this.publishEvent(name, payload).then(() => undefined); }
+    publishPlatform(name, event) { this.emit(name, event); return Promise.resolve(); }
+    constructor(options) {
+        super({ config: options.config, fetch: options.fetch ?? globalThis.fetch });
+        this.#logger = getAdapterLogger('line', options.config.id);
+        this.#options = options;
+        const transportFetch = options.fetch ?? globalThis.fetch;
+        this.#fetch = (url, init) => {
+            this.executionSignal?.throwIfAborted();
+            return transportFetch(url, { ...init, ...(this.executionSignal ? { signal: init?.signal ? AbortSignal.any([this.executionSignal, init.signal]) : this.executionSignal } : {}) });
+        };
+    }
+    /** Used by webhook handler. */
+    get isOpen() {
+        return this.#open;
+    }
+    get config() {
+        return this.#options.config;
+    }
+    async connectTransport(signal) {
+        if (signal) {
+            this.setExecutionSignal(signal);
+            signal.throwIfAborted();
+        }
+        if (this.#started)
+            return;
+        this.#started = true;
+        try {
+            this.#routeReleases.push(...registerLineWebhookRoutes(this.#options.http, this));
+            this.#logger.debug(formatCompact({
+                endpoint: this.#options.config.id,
+                op: 'webhook',
+                path: this.#options.config.webhookPath,
+            }));
+        }
+        catch (error) {
+            await this.disconnectTransport();
+            this.#logger.error('Failed to connect LINE endpoint:', error);
+            throw error;
+        }
+    }
+    openInput() {
+        this.#open = true;
+    }
+    closeInput() {
+        this.#open = false;
+    }
+    async disconnectTransport() {
+        this.#open = false;
+        this.#replyTokenCache.clear();
+        this.#admissions.clear();
+        for (const release of this.#routeReleases.splice(0))
+            release();
+        this.#started = false;
+        this.#logger.debug(formatCompact({ op: 'disconnect' }));
+    }
+    async sendPayload({ conversation, payload, signal }) {
+        try {
+            const messages = formatOutboundMessages(payload);
+            if (messages.length === 0) {
+                throw new EndpointDeliveryError('invalid_payload', 'No valid LINE messages to send', 'not_sent');
+            }
+            // LINE recipient id 前缀（U/G/R）自带场景信息，原生 id 即投递地址。
+            const target = conversation.id;
+            const cached = this.#replyTokenCache.get(target);
+            if (cached) {
+                this.#replyTokenCache.delete(target);
+                if (Date.now() - cached.timestamp <= REPLY_TOKEN_TTL_MS) {
+                    return await this.#replyMessage({ replyToken: cached.token, messages, signal });
+                }
+            }
+            if (!isValidLineRecipientId(target)) {
+                throw new EndpointDeliveryError('invalid_recipient', `Invalid LINE recipient ID "${target}": must start with U (user), G (group), or R (room)`, 'not_sent');
+            }
+            return await this.#pushMessage({ to: target, messages, signal });
+        }
+        catch (error) {
+            if (error instanceof EndpointDeliveryError)
+                throw error;
+            throw new EndpointDeliveryError('delivery_unconfirmed', 'Outbound request outcome is unknown', 'unknown', { cause: error });
+        }
+    }
+    /** Test / internal: admit a parsed event when open (non-webhook path). */
+    admit(event) {
+        if (!this.#open)
+            return;
+        void this.admitAccepted(event).catch((err) => {
+            this.#logger.warn(formatCompact({ op: 'line_gateway_receive_failed', error: err instanceof Error ? err.message : String(err) }));
+        });
+    }
+    /** Webhook acknowledgement follows actual runtime generation admission. */
+    async admitAccepted(event) {
+        if (!this.#open)
+            throw new Error('LINE endpoint is closed');
+        return this.receiveInboundCallback(() => this.#acceptMessage(event));
+    }
+    async #acceptMessage(event) {
+        if (!this.#open)
+            throw new Error('LINE endpoint is closed');
+        const id = event.webhookEventId;
+        if (typeof id !== 'string' || !id.trim())
+            return this.#dispatchAccepted(event);
+        const now = Date.now();
+        for (const [key, entry] of this.#admissions)
+            if (entry.expires <= now)
+                this.#admissions.delete(key);
+        const existing = this.#admissions.get(id);
+        if (existing)
+            return existing.promise;
+        // Never evict in-flight admissions: overload returns 503 and permits platform retry.
+        if (this.#admissions.size >= 10_000)
+            throw new Error('LINE admission dedup capacity exhausted');
+        const entry = { promise: Promise.resolve().then(() => this.#dispatchAccepted(event)), expires: Infinity };
+        this.#admissions.set(id, entry);
+        try {
+            await entry.promise;
+            if (this.#admissions.get(id) === entry)
+                entry.expires = Date.now() + 24 * 60 * 60 * 1000;
+        }
+        catch (error) {
+            if (this.#admissions.get(id) === entry)
+                this.#admissions.delete(id);
+            throw error;
+        }
+    }
+    inboundReceiptCurrent() { return this.#open && !this.executionSignal?.aborted; }
+    async #dispatchAccepted(event) {
+        if (!this.inboundReceiptCurrent())
+            throw new Error('LINE endpoint is closed');
+        void this.publishPlatform(event.type || 'event', event).catch((error) => {
+            this.#logger.warn(formatCompact({
+                op: 'line_platform_event_failed',
+                event: event.type,
+                error: error instanceof Error ? error.message : String(error),
+            }));
+        });
+        if (isLineLifecycleEvent(event)) {
+            await receiveLineSideEvent((name, payload) => this.publishAccepted(name, payload), String(this.#options.id), this.#options.config.id, event, this.#logger);
+            return;
+        }
+        const conversation = lineInboundConversation(String(this.#options.id), event.source);
+        if ('replyToken' in event && typeof event.replyToken === 'string') {
+            this.#replyTokenCache.set(conversation.id, { token: event.replyToken, timestamp: Date.now() });
+        }
+        await this.publishAccepted('message.receive', {
+            event,
+            conversation,
+            message: { conversation, id: generateMessageId(event) },
+            content: formatInboundContent(event),
+            ...(event.source.userId ? { sender: { id: event.source.userId } } : {}),
+            endpointId: this.#options.config.id,
+            metadata: Object.freeze({
+                eventType: event.type,
+                sourceType: event.source.type,
+                timestamp: event.timestamp,
+                ...(isMessageEvent(event) ? { messageType: event.message.type } : {}),
+            }),
+        });
+    }
+    async #replyMessage({ replyToken, messages, signal }) {
+        const url = `${this.#options.config.apiBaseUrl}/v2/bot/message/reply`;
+        const response = await this.#fetch(url, {
+            method: 'POST',
             headers: {
-                Authorization: `Bearer ${this.config.channelAccessToken}`,
-                ...(init.body === undefined ? {} : { 'Content-Type': 'application/json' }),
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${this.#options.config.channelAccessToken}`,
             },
-            ...(init.body === undefined ? {} : { body: init.body }),
-            signal: init.signal ?? AbortSignal.timeout(30_000),
+            body: JSON.stringify({ replyToken, messages }),
+            signal: signal ? AbortSignal.any([signal, AbortSignal.timeout(OUTBOUND_TIMEOUT_MS)]) : AbortSignal.timeout(OUTBOUND_TIMEOUT_MS),
         });
         if (!response.ok) {
-            const text = await response.text();
-            throw new Error(`LINE API error ${response.status}: ${text}`);
-        }
-        return await response.json();
-    }
-    getProfile(userId) {
-        return this.request(`/v2/profile/${encodeURIComponent(userId)}`);
-    }
-    getGroupMemberIds(groupId, start) {
-        const kind = groupId.startsWith('R') ? 'room' : 'group';
-        const query = start ? `?start=${encodeURIComponent(start)}` : '';
-        return this.request(`/v2/bot/${kind}/${encodeURIComponent(groupId)}/members/ids${query}`);
-    }
-    async getGroupMembers(groupId) {
-        const kind = groupId.startsWith('R') ? 'room' : 'group';
-        const ids = [];
-        let next;
-        do {
-            const page = await this.getGroupMemberIds(groupId, next);
-            ids.push(...(page.memberIds ?? []).filter((id) => typeof id === 'string' && id.length > 0));
-            next = page.next || undefined;
-        } while (next);
-        return Promise.all(ids.map(async (userId) => {
-            try {
-                const profile = await this.request(`/v2/bot/${kind}/${encodeURIComponent(groupId)}/member/${encodeURIComponent(userId)}`);
-                return { user_id: userId, nickname: String(profile.displayName ?? userId) };
-            }
-            catch {
-                return { user_id: userId, nickname: userId };
-            }
-        }));
+            throw await lineResponseError(response);
+        }
+        const result = await response.json();
+        return requireMessageId(result.sentMessages?.[0]?.id);
     }
+    async #pushMessage({ to, messages, signal }) {
+        const url = `${this.#options.config.apiBaseUrl}/v2/bot/message/push`;
+        const response = await this.#fetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${this.#options.config.channelAccessToken}`,
+            },
+            body: JSON.stringify({ to, messages }),
+            signal: signal ? AbortSignal.any([signal, AbortSignal.timeout(OUTBOUND_TIMEOUT_MS)]) : AbortSignal.timeout(OUTBOUND_TIMEOUT_MS),
+        });
+        if (!response.ok) {
+            throw await lineResponseError(response);
+        }
+        const result = await response.json();
+        return requireMessageId(result.sentMessages?.[0]?.id);
+    }
+}
+function createLineEndpointManagement(endpoint) {
+    return Object.freeze({
+        // listGroups 不接：LINE Bot API 没有"我加入了哪些群"的接口，群 id 只能来自入站事件。
+        listGroupMembers: ({ groupId, signal }) => endpoint.getGroupMembers(groupId, { signal }),
+    });
+}
+async function lineResponseError(response) {
+    // Error responses may carry sentMessages: a failed request can have partial side effects.
+    let body;
+    try {
+        body = await response.json();
+    }
+    catch {
+        return new EndpointDeliveryError('delivery_unconfirmed', `LINE HTTP ${response.status}`, 'unknown');
+    }
+    const disposition = Array.isArray(body?.sentMessages) && body.sentMessages.length > 0
+        ? 'unknown' : response.status >= 400 && response.status < 500 && response.status !== 408 && response.status !== 409 ? 'rejected' : 'unknown';
+    return new EndpointDeliveryError(disposition === 'unknown' ? 'delivery_unconfirmed' : 'platform_rejected', `LINE HTTP ${response.status}`, disposition);
+}
+function requireMessageId(value) {
+    if (typeof value === 'string' && value.trim().length > 0)
+        return value;
+    throw new EndpointDeliveryError('delivery_unconfirmed', 'Platform did not return a real message ID', 'unknown');
 }
-export const lineClient = defineEndpointClient('line');

package/lib/console.d.ts

@@ -5,4 +5,4 @@
  */
 import { type AdapterConsoleResources } from 'zhin.js/adapter';
 import type { PluginConsoleRpc } from 'zhin.js';
-export declare function createLineConsoleRpc(resources: AdapterConsoleResources, getConfig: () => unknown): PluginConsoleRpc;
+export declare function createLineConsoleRpc(_resources: AdapterConsoleResources, getConfig: () => unknown): PluginConsoleRpc;

package/lib/console.js

@@ -4,13 +4,10 @@
  * 页面绑定 `pages/index`，读取 / 写入分别要求 `<adapter>:read` / `<adapter>:write`。
  */
 import { createAdapterConsoleRpc } from 'zhin.js/adapter';
-import { lineRuntimeStateToken } from './line-runtime-state.js';
 import { lineConsoleSpec } from './console-spec.js';
-export function createLineConsoleRpc(resources, getConfig) {
-    const state = resources.use(lineRuntimeStateToken);
+export function createLineConsoleRpc(_resources, getConfig) {
     return createAdapterConsoleRpc({
         ...lineConsoleSpec,
-        running: () => state.endpoints.values(),
         getConfig,
-    }, resources);
+    });
 }

package/lib/endpoint.d.ts

@@ -1,43 +1,15 @@
-/**
- * LineEndpoint — lifecycle, outbound, admit, OpenAPI helpers for agent tools.
- */
-import { Endpoint, type EndpointManagement, type EndpointSendRequest } from 'zhin.js/adapter';
-import type { HttpHost } from '@zhin.js/host-http';
-import type { CapabilityId } from 'zhin.js';
-import { type LineEvent, type ResolvedLineConfig } from './protocol.js';
-import { LineClient } from './client.js';
-export type LineFetch = (url: string, init?: {
-    readonly method?: string;
-    readonly headers?: Record<string, string>;
-    readonly body?: string;
-    readonly signal?: AbortSignal;
-}) => Promise<{
-    readonly ok: boolean;
-    readonly status: number;
-    text(): Promise<string>;
-    json(): Promise<unknown>;
-}>;
-export interface LineEndpointOptions {
-    readonly id: CapabilityId;
-    readonly http: HttpHost;
-    readonly config: ResolvedLineConfig;
-    readonly fetch?: LineFetch;
-}
-export declare class LineEndpoint extends Endpoint<LineClient> {
+import { endpointSpec, type Endpoint } from 'zhin.js/adapter';
+import { LineClient, type LineEndpointOptions } from './client.js';
+export type { LineEndpointOptions } from './client.js';
+export type { LineFetch } from './client.js';
+/** Actual protocol Client; framework lifecycle and admission stay in their symbol namespace. */
+export declare class LineEndpoint extends LineClient implements Endpoint {
     #private;
-    readonly client: LineClient;
-    readonly management: EndpointManagement;
+    readonly [endpointSpec]: import("@zhin.js/adapter").EndpointSpecification;
     constructor(options: LineEndpointOptions);
-    /** Used by webhook handler. */
-    get isOpen(): boolean;
-    get config(): ResolvedLineConfig;
-    start(): Promise<void>;
-    open(): void;
-    close(): void;
-    stop(): Promise<void>;
-    send({ conversation, payload }: EndpointSendRequest): Promise<string>;
-    /** Test / internal: admit a parsed event when open (non-webhook path). */
-    admit(event: LineEvent): void;
-    /** Webhook acknowledgement follows actual runtime generation admission. */
-    admitAccepted(event: LineEvent): Promise<void>;
+    protected inboundReceiptCurrent(): boolean;
+    protected receiveInboundCallback<T>(receive: () => T | Promise<T>): Promise<T>;
+    protected publishEvent(name: string, payload: unknown): Promise<unknown>;
+    protected publishAccepted(name: string, payload: unknown): Promise<void>;
+    protected publishPlatform(name: string, event: unknown): Promise<unknown>;
 }

package/lib/endpoint.js

@@ -1,227 +1,33 @@
-import { EndpointDeliveryError } from '@zhin.js/im-contract';
-/**
- * LineEndpoint — lifecycle, outbound, admit, OpenAPI helpers for agent tools.
- */
-import { Endpoint } from 'zhin.js/adapter';
-import { formatCompact, getAdapterLogger } from '@zhin.js/logger';
-import { formatInboundContent, formatOutboundMessages, generateMessageId, isLineLifecycleEvent, isMessageEvent, isValidLineRecipientId, lineInboundConversation, } from './protocol.js';
-import { registerLineWebhookRoutes } from './webhook.js';
-import { receiveLineSideEvent } from './side-event-dispatch.js';
+import { createEndpointSpecification, endpointSpec } from 'zhin.js/adapter';
 import { LineClient } from './client.js';
-/** LINE replyToken 有效期短，过期后 reply 必 400；缓存带时间戳，超时弃用改走 push。 */
-const REPLY_TOKEN_TTL_MS = 60_000;
-/** 出站 HTTP 调用统一 30s 超时。 */
-const OUTBOUND_TIMEOUT_MS = 30_000;
-export class LineEndpoint extends Endpoint {
-    client;
-    #logger;
-    #options;
-    #fetch;
-    #routeReleases = [];
-    #replyTokenCache = new Map();
-    #admissions = new Map();
-    #open = false;
-    #started = false;
-    management = createLineEndpointManagement(this);
-    constructor(options) {
-        super();
-        this.#logger = getAdapterLogger('line', options.config.id);
-        this.#options = options;
-        this.#fetch = options.fetch ?? globalThis.fetch;
-        this.client = new LineClient(options.config, this.#fetch);
+/** Actual protocol Client; framework lifecycle and admission stay in their symbol namespace. */
+export class LineEndpoint extends LineClient {
+    [endpointSpec] = this.#createSpecification();
+    constructor(options) { super(options); }
+    #createSpecification() {
+        const hooks = {
+            start: (signal) => this.#startFramework(signal),
+            open: () => this.openInput(), close: () => this.closeInput(), stop: () => this.disconnectTransport(),
+            send: (request) => this.sendPayload(request),
+            name: this.configName(),
+            management: this.endpointManagement,
+        };
+        Object.defineProperty(hooks, 'transportState', { get: () => this.transportState });
+        return createEndpointSpecification(this, hooks);
+    }
+    #startFramework(signal) { return this.connectTransport(signal); }
+    inboundReceiptCurrent() { return !this.executionSignal?.aborted; }
+    receiveInboundCallback(receive) {
+        return this[endpointSpec].events.run(receive);
+    }
+    publishEvent(name, payload) {
+        return this[endpointSpec].events.emit(name, payload);
+    }
+    publishAccepted(name, payload) {
+        return this[endpointSpec].events.emitAccepted(name, payload).then(() => undefined);
+    }
+    async publishPlatform(name, event) {
+        await super.publishPlatform(name, event);
+        return this[endpointSpec].events.platform(name, event);
     }
-    /** Used by webhook handler. */
-    get isOpen() {
-        return this.#open;
-    }
-    get config() {
-        return this.#options.config;
-    }
-    async start() {
-        if (this.#started)
-            return;
-        this.#started = true;
-        try {
-            this.#routeReleases.push(...registerLineWebhookRoutes(this.#options.http, this));
-            this.#logger.debug(formatCompact({
-                endpoint: this.#options.config.id,
-                op: 'webhook',
-                path: this.#options.config.webhookPath,
-            }));
-        }
-        catch (error) {
-            await this.stop();
-            this.#logger.error('Failed to connect LINE endpoint:', error);
-            throw error;
-        }
-    }
-    open() {
-        this.#open = true;
-    }
-    close() {
-        this.#open = false;
-    }
-    async stop() {
-        this.#open = false;
-        this.#replyTokenCache.clear();
-        this.#admissions.clear();
-        for (const release of this.#routeReleases.splice(0))
-            release();
-        this.#started = false;
-        this.#logger.debug(formatCompact({ op: 'disconnect' }));
-    }
-    async send({ conversation, payload }) {
-        try {
-            const messages = formatOutboundMessages(payload);
-            if (messages.length === 0) {
-                throw new EndpointDeliveryError('invalid_payload', 'No valid LINE messages to send', 'not_sent');
-            }
-            // LINE recipient id 前缀（U/G/R）自带场景信息，原生 id 即投递地址。
-            const target = conversation.id;
-            const cached = this.#replyTokenCache.get(target);
-            if (cached) {
-                this.#replyTokenCache.delete(target);
-                if (Date.now() - cached.timestamp <= REPLY_TOKEN_TTL_MS) {
-                    return await this.#replyMessage(cached.token, messages);
-                }
-            }
-            if (!isValidLineRecipientId(target)) {
-                throw new EndpointDeliveryError('invalid_recipient', `Invalid LINE recipient ID "${target}": must start with U (user), G (group), or R (room)`, 'not_sent');
-            }
-            return await this.#pushMessage(target, messages);
-        }
-        catch (error) {
-            if (error instanceof EndpointDeliveryError)
-                throw error;
-            throw new EndpointDeliveryError('delivery_unconfirmed', 'Outbound request outcome is unknown', 'unknown', { cause: error });
-        }
-    }
-    /** Test / internal: admit a parsed event when open (non-webhook path). */
-    admit(event) {
-        if (!this.#open)
-            return;
-        void this.admitAccepted(event).catch((err) => {
-            this.#logger.warn(formatCompact({ op: 'line_gateway_receive_failed', error: err instanceof Error ? err.message : String(err) }));
-        });
-    }
-    /** Webhook acknowledgement follows actual runtime generation admission. */
-    async admitAccepted(event) {
-        if (!this.#open)
-            throw new Error('LINE endpoint is closed');
-        const id = event.webhookEventId;
-        if (typeof id !== 'string' || !id.trim())
-            return this.#dispatchAccepted(event);
-        const now = Date.now();
-        for (const [key, entry] of this.#admissions)
-            if (entry.expires <= now)
-                this.#admissions.delete(key);
-        const existing = this.#admissions.get(id);
-        if (existing)
-            return existing.promise;
-        // Never evict in-flight admissions: overload returns 503 and permits platform retry.
-        if (this.#admissions.size >= 10_000)
-            throw new Error('LINE admission dedup capacity exhausted');
-        const entry = { promise: Promise.resolve().then(() => this.#dispatchAccepted(event)), expires: Infinity };
-        this.#admissions.set(id, entry);
-        try {
-            await entry.promise;
-            if (this.#admissions.get(id) === entry)
-                entry.expires = Date.now() + 24 * 60 * 60 * 1000;
-        }
-        catch (error) {
-            if (this.#admissions.get(id) === entry)
-                this.#admissions.delete(id);
-            throw error;
-        }
-    }
-    async #dispatchAccepted(event) {
-        if (!this.#open)
-            throw new Error('LINE endpoint is closed');
-        void this.emitPlatform(event.type || 'event', event).catch((error) => {
-            this.#logger.warn(formatCompact({
-                op: 'line_platform_event_failed',
-                event: event.type,
-                error: error instanceof Error ? error.message : String(error),
-            }));
-        });
-        if (isLineLifecycleEvent(event)) {
-            await receiveLineSideEvent((name, payload) => this.emitAccepted(name, payload), String(this.#options.id), this.#options.config.id, event, this.#logger);
-            return;
-        }
-        const conversation = lineInboundConversation(String(this.#options.id), event.source);
-        if ('replyToken' in event && typeof event.replyToken === 'string') {
-            this.#replyTokenCache.set(conversation.id, { token: event.replyToken, timestamp: Date.now() });
-        }
-        await this.emitAccepted('message.receive', {
-            conversation,
-            message: { conversation, id: generateMessageId(event) },
-            content: formatInboundContent(event),
-            sender: { id: event.source.userId || conversation.id },
-            endpointId: this.#options.config.id,
-            metadata: Object.freeze({
-                eventType: event.type,
-                sourceType: event.source.type,
-                timestamp: event.timestamp,
-                ...(isMessageEvent(event) ? { messageType: event.message.type } : {}),
-            }),
-        });
-    }
-    async #replyMessage(replyToken, messages) {
-        const url = `${this.#options.config.apiBaseUrl}/v2/bot/message/reply`;
-        const response = await this.#fetch(url, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                Authorization: `Bearer ${this.#options.config.channelAccessToken}`,
-            },
-            body: JSON.stringify({ replyToken, messages }),
-            signal: AbortSignal.timeout(OUTBOUND_TIMEOUT_MS),
-        });
-        if (!response.ok) {
-            throw await lineResponseError(response);
-        }
-        const result = await response.json();
-        return requireMessageId(result.sentMessages?.[0]?.id);
-    }
-    async #pushMessage(to, messages) {
-        const url = `${this.#options.config.apiBaseUrl}/v2/bot/message/push`;
-        const response = await this.#fetch(url, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                Authorization: `Bearer ${this.#options.config.channelAccessToken}`,
-            },
-            body: JSON.stringify({ to, messages }),
-            signal: AbortSignal.timeout(OUTBOUND_TIMEOUT_MS),
-        });
-        if (!response.ok) {
-            throw await lineResponseError(response);
-        }
-        const result = await response.json();
-        return requireMessageId(result.sentMessages?.[0]?.id);
-    }
-}
-function createLineEndpointManagement(endpoint) {
-    return Object.freeze({
-        // listGroups 不接：LINE Bot API 没有"我加入了哪些群"的接口，群 id 只能来自入站事件。
-        listGroupMembers: (groupId) => endpoint.client.getGroupMembers(groupId),
-    });
-}
-async function lineResponseError(response) {
-    // Error responses may carry sentMessages: a failed request can have partial side effects.
-    let body;
-    try {
-        body = await response.json();
-    }
-    catch {
-        return new EndpointDeliveryError('delivery_unconfirmed', `LINE HTTP ${response.status}`, 'unknown');
-    }
-    const disposition = Array.isArray(body?.sentMessages) && body.sentMessages.length > 0
-        ? 'unknown' : response.status >= 400 && response.status < 500 && response.status !== 408 && response.status !== 409 ? 'rejected' : 'unknown';
-    return new EndpointDeliveryError(disposition === 'unknown' ? 'delivery_unconfirmed' : 'platform_rejected', `LINE HTTP ${response.status}`, disposition);
-}
-function requireMessageId(value) {
-    if (typeof value === 'string' && value.trim().length > 0)
-        return value;
-    throw new EndpointDeliveryError('delivery_unconfirmed', 'Platform did not return a real message ID', 'unknown');
 }

package/lib/index.d.ts

@@ -1,4 +1,5 @@
 export { formatInboundContent, formatOutboundMessages, generateMessageId, isMessageEvent, isPostbackEvent, isValidLineRecipientId, normalizeWebhookPath, readTextBody, resolveChannel, resolveLineConfig, verifySignature, type LineEndpointConfig, type LineApiResponse, type LineChannel, type LineEvent, type LineFollowEvent, type LineJoinEvent, type LineLeaveEvent, type LineMessage, type LineMessageEvent, type LinePostbackEvent, type LinePushRequest, type LineReplyMessage, type LineReplyRequest, type LineSource, type LineUnfollowEvent, type LineUser, type LineWebhookBody, type LineWireSegment, type ResolvedLineConfig, } from './protocol.js';
 export { LineEndpoint, type LineEndpointOptions, type LineFetch, } from './endpoint.js';
 export { registerLineWebhookRoutes, handleLineWebhookRequest, type LineWebhookHandler, } from './webhook.js';
-export { LineClient, lineClient, type LineClientEventMap, type LineGroupMember, } from './client.js';
+export { LineClient, type LineClientEventMap, type LineGroupMember, } from './client.js';
+export { LineAdapter } from './adapter.js';

package/lib/index.js

@@ -1,4 +1,5 @@
 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 { LineClient, lineClient, } from './client.js';
+export { LineClient, } from './client.js';
+export { LineAdapter } from './adapter.js';