@zhin.js/adapter-onebot12 1.1.17 → 1.1.19

package/lib/ws-endpoint.d.ts

@@ -1,22 +1,16 @@
-import { ClientEndpoint, type EndpointControl, type EndpointManagement, type EndpointSendRequest } from 'zhin.js/adapter';
+import { endpointSpec, type Endpoint, type EndpointSpecification } from 'zhin.js/adapter';
 import type { CapabilityId } from 'zhin.js';
 import { type OneBot12WsConfig } from './protocol.js';
-import { type Onebot12Client } from './client.js';
+import { Onebot12Client } from './client.js';
 import { type OneBot12WsCreateOptions, type OneBot12WsSocket } from './ws-types.js';
 export interface OneBot12WsEndpointOptions {
+    readonly signal?: AbortSignal;
     readonly id: CapabilityId;
     readonly config: OneBot12WsConfig;
     readonly createWebSocket?: (url: string, options: OneBot12WsCreateOptions) => OneBot12WsSocket;
 }
-export declare class OneBot12WsEndpoint extends ClientEndpoint<Onebot12Client> {
+export declare class OneBot12WsEndpoint extends Onebot12Client implements Endpoint {
     #private;
-    readonly client: Onebot12Client;
-    readonly management: EndpointManagement;
-    readonly control: EndpointControl;
-    readonly content: import("@zhin.js/adapter").EndpointContentPort;
+    readonly [endpointSpec]: EndpointSpecification;
     constructor(options: OneBot12WsEndpointOptions);
-    start(): Promise<void>;
-    stop(): Promise<void>;
-    send({ conversation, payload }: EndpointSendRequest): Promise<string>;
-    recallMessage(messageId: string): Promise<void>;
 }

package/lib/ws-endpoint.js

@@ -2,37 +2,56 @@
  * OneBot12 WS client endpoint — outbound connect to OneBot implementation.
  */
 import WebSocket from 'ws';
-import { ClientEndpoint, createRecallEndpointControl, createEndpointLifecycle, } from 'zhin.js/adapter';
+import { createEndpointSpecification, endpointSpec, createRecallEndpointControl, createEndpointLifecycle, } from 'zhin.js/adapter';
 import { formatCompact, getAdapterLogger } from '@zhin.js/logger';
 import { createOneBot12EndpointManagement } from './endpoint-management.js';
-import { buildSendMessageParams, buildWsConnectOptions, formatInboundContent, formatOutboundSegments, isBotMentioned, isMessageEvent, onebot12InboundConversation, senderNickname, senderUserId, uploadOneBot12MediaSegments, } from './protocol.js';
+import { buildSendMessageParams, matchesOneBot12Self, buildWsConnectOptions, formatInboundContent, formatOutboundSegments, isBotMentioned, isMessageEvent, onebot12InboundConversation, senderNickname, senderUserId, uploadOneBot12MediaSegments, } from './protocol.js';
 import { receiveOneBot12SideEvent } from './side-event-dispatch.js';
 import { createOneBot12ContentPort } from './content-port.js';
-import { callOnebot12Client, createOnebot12EndpointClient, forwardOnebot12ClientEvents } from './client.js';
-import { callOneBot12WsAction, handleOneBot12WsMessage, rejectAllPending, } from './ws-transport.js';
-export class OneBot12WsEndpoint extends ClientEndpoint {
-    client;
+import { callOnebot12Client, readOnebot12Response, onebot12ClientOptions, forwardOnebot12ClientEvents, Onebot12Client } from './client.js';
+import { createOneBot12Rpc } from './ws-transport.js';
+export class OneBot12WsEndpoint extends Onebot12Client {
+    [endpointSpec];
+    #open = false;
     #logger;
     #options;
-    management;
-    control = createRecallEndpointControl((id) => this.recallMessage(id));
-    content;
+    #management;
+    #control = createRecallEndpointControl((id, signal) => this.#recallMessage(id, signal));
+    #content;
+    #releaseClientEvents;
     #lifecycle;
     #ws;
-    #requestId = { value: 0 };
-    #pending = new Map();
+    #rpc;
     constructor(options) {
-        super();
+        const rpc = createOneBot12Rpc({ endpointId: options.config.id, signal: options.signal,
+            self: { platform: options.config.platform, user_id: options.config.userId },
+            socket: () => this.#lifecycle.state === 'open' ? this.#ws : undefined,
+        });
+        super(onebot12ClientOptions(options.config, (action, params) => rpc.call({ action, params })));
+        this.#rpc = rpc;
         this.#logger = getAdapterLogger('onebot12', options.config.id);
         this.#options = options;
-        this.client = createOnebot12EndpointClient(options.config, (action, params) => this.#callAction(action, params ?? {}));
-        const callApi = (action, params) => callOnebot12Client(this.client, action, params);
-        this.management = createOneBot12EndpointManagement({ callApi });
-        this.content = createOneBot12ContentPort(callApi);
-        this.bindClientEvents((receive) => forwardOnebot12ClientEvents(this.client, receive), (name, payload) => {
-            if (name === 'event')
-                this.#admitRaw(payload);
-        }, (_name, error) => this.#warnPlatformEvent(error));
+        const callApi = (request) => this.#rpc.call(request).then(readOnebot12Response);
+        this.#management = createOneBot12EndpointManagement({ callApi });
+        this.#content = createOneBot12ContentPort(callApi);
+        const readTransportState = () => this.#lifecycle.state;
+        this[endpointSpec] = createEndpointSpecification(this, {
+            name: options.config.id,
+            start: () => this.#start(), open: () => { this.#open = true; },
+            close: () => { this.#open = false; }, stop: () => this.#stop(),
+            send: request => this.#send(request),
+            get transportState() { return readTransportState(); },
+            management: this.#management, control: this.#control, content: this.#content,
+        });
+        this.#releaseClientEvents = forwardOnebot12ClientEvents(this, (name, payload) => {
+            void this[endpointSpec].events.run(() => {
+                if (!this.#open && !this.#lifecycle.started)
+                    return;
+                void this[endpointSpec].events.platform(name, payload).catch(error => this.#warnPlatformEvent(error));
+                if (name === 'event')
+                    this.#admitRaw(payload);
+            }).catch(error => this.#warnPlatformEvent(error));
+        });
         const { config } = options;
         this.#lifecycle = createEndpointLifecycle({
             name: config.id,
@@ -46,7 +65,7 @@ export class OneBot12WsEndpoint extends ClientEndpoint {
             heartbeat: { intervalMs: config.heartbeat_interval },
         });
     }
-    async start() {
+    async #start() {
         if (this.#lifecycle.started)
             return;
         try {
@@ -66,24 +85,30 @@ export class OneBot12WsEndpoint extends ClientEndpoint {
             throw err;
         }
     }
-    async stop() {
-        this.close();
+    async #stop() {
+        this.#open = false;
         // 基座负责：清重连/心跳定时器、强关 ws、唤醒 stop-during-connect 竞态
-        await this.#lifecycle.stop();
-        rejectAllPending(this.#pending);
-        this.#ws = undefined;
+        try {
+            await this.#lifecycle.stop();
+        }
+        finally {
+            this.#rpc.dispose();
+            this.#releaseClientEvents();
+            this.#ws = undefined;
+        }
     }
-    async send({ conversation, payload }) {
-        const materialized = await uploadOneBot12MediaSegments(payload, (action, params) => callOnebot12Client(this.client, action, params), (error) => {
-            this.#logger.warn(formatCompact({
-                op: 'onebot12_upload_failed',
-                endpoint: this.#options.config.id,
-                error: error instanceof Error ? error.message : String(error),
-            }));
+    async #send({ conversation, payload, signal }) {
+        const materialized = await uploadOneBot12MediaSegments({
+            payload, signal,
+            callAction: (action, params) => this.#rpc.call({ action, params, signal }).then(readOnebot12Response),
+            onUploadFailed: error => {
+                this.#logger.warn(formatCompact({ op: 'onebot12_upload_failed', endpoint: this.#options.config.id,
+                    error: error instanceof Error ? error.message : String(error) }));
+            },
         });
         const message = formatOutboundSegments(materialized);
         const params = buildSendMessageParams(conversation, message);
-        const data = await callOnebot12Client(this.client, 'send_message', params);
+        const data = readOnebot12Response(await this.#rpc.call({ action: 'send_message', params, signal }));
         const messageId = data?.message_id ?? '';
         this.#logger.debug(formatCompact({
             op: 'onebot12_send',
@@ -94,21 +119,31 @@ export class OneBot12WsEndpoint extends ClientEndpoint {
         }));
         return messageId;
     }
-    async recallMessage(messageId) {
+    async #recallMessage(messageId, signal) {
         if (!messageId)
             return;
-        await callOnebot12Client(this.client, 'delete_message', { message_id: messageId });
+        await this.#rpc.call({ action: 'delete_message', params: { message_id: messageId }, signal }).then(readOnebot12Response);
     }
     #admitRaw(ev) {
+        if (!matchesOneBot12Self(this.#options.config, ev))
+            return;
+        this[endpointSpec].reportSelfUserId(ev.self.user_id);
         if (!isMessageEvent(ev)) {
-            receiveOneBot12SideEvent((name, payload) => this.emit(name, payload), this.#options.config.id, { callApi: (action, params) => callOnebot12Client(this.client, action, params) }, ev, this.#logger);
+            receiveOneBot12SideEvent(ev, {
+                emit: (name, payload) => this[endpointSpec].events.emit(name, payload),
+                endpointKey: this.#options.config.id,
+                caller: { callApi: (action, params) => callOnebot12Client({ client: this, action, params }) },
+                logger: this.#logger,
+            });
             return;
         }
-        const conversation = onebot12InboundConversation(String(this.#options.id), ev);
+        const conversation = { ...onebot12InboundConversation(String(this.#options.id), ev), endpoint: this[endpointSpec].identity };
         const content = formatInboundContent(ev);
         const nickname = senderNickname(ev);
         const mentioned = isBotMentioned(ev);
-        void this.emit('message.receive', {
+        void this[endpointSpec].events.message({
+            event: ev,
+            ...(typeof ev.time === 'number' ? { platformSentAt: ev.time * 1000 } : {}),
             conversation,
             message: { conversation, id: ev.message_id },
             content,
@@ -173,10 +208,9 @@ export class OneBot12WsEndpoint extends ClientEndpoint {
                 if (this.#ws !== ws)
                     return;
                 this.#lifecycle.notifyHeartbeatAck();
-                handleOneBot12WsMessage(data, {
-                    endpointId: this.#options.config.id,
-                    pending: this.#pending,
-                    ingest: (event) => this.client.ingest(event),
+                this.#rpc.receive(data, event => {
+                    if (matchesOneBot12Self(this.#options.config, event))
+                        this.ingest(event);
                 });
             });
             ws.on('close', (code, reason) => {
@@ -192,7 +226,7 @@ export class OneBot12WsEndpoint extends ClientEndpoint {
                 }
                 if (this.#ws === ws) {
                     this.#ws = undefined;
-                    rejectAllPending(this.#pending);
+                    this.#rpc.disconnect();
                 }
                 // 断开日志与重连武装均由基座负责；仅曾 open 的连接才会武装重连，
                 // 初始连接失败由 start() 的拒绝路径复位，不产生僵尸重连。
@@ -214,6 +248,6 @@ export class OneBot12WsEndpoint extends ClientEndpoint {
         });
     }
     #callAction(action, params) {
-        return callOneBot12WsAction(this.#ws, this.#pending, this.#requestId, action, params);
+        return this.#rpc.call({ action, params });
     }
 }

package/lib/ws-transport.d.ts

@@ -1,12 +1,20 @@
-import type { OneBot12ActionResponse, OneBot12Event } from './protocol.js';
-import { type OneBot12PendingAction, type OneBot12WsSocket } from './ws-types.js';
-export interface OneBot12WsMessageOptions {
+import { type PendingRpc, type PendingRpcRequest } from 'zhin.js/adapter';
+import type { OneBot12ActionResponse, OneBot12Event, OneBot12Self } from './protocol.js';
+import { type OneBot12WsSocket } from './ws-types.js';
+export interface OneBot12RpcOptions {
     readonly endpointId: string;
-    readonly pending: Map<string, OneBot12PendingAction>;
-    readonly ingest: (event: OneBot12Event) => void;
+    readonly signal?: AbortSignal;
+    /** Reads the lifecycle's selected socket; RPC never opens or reconnects it. */
+    readonly socket: () => OneBot12WsSocket | undefined;
+    readonly self: OneBot12Self;
 }
-export declare function handleOneBot12WsMessage(data: unknown, options: OneBot12WsMessageOptions): void;
-export declare function callOneBot12WsAction(ws: OneBot12WsSocket | undefined, pending: Map<string, OneBot12PendingAction>, requestId: {
-    value: number;
-}, action: string, params: Record<string, unknown>): Promise<OneBot12ActionResponse>;
-export declare function rejectAllPending(pending: Map<string, OneBot12PendingAction>, message?: string): void;
+export interface OneBot12Rpc {
+    call(request: PendingRpcRequest): Promise<OneBot12ActionResponse>;
+    receive(data: unknown, ingest: (event: OneBot12Event) => void): void;
+    disconnect: PendingRpc<OneBot12ActionResponse>['disconnect'];
+    dispose(): void;
+    readonly pendingCount: number;
+}
+/** A Client's one request owner serves native SDK actions and framework operations. */
+export declare function createOneBot12Rpc(options: OneBot12RpcOptions): OneBot12Rpc;
+export declare function decodeWsPayload(data: unknown): string;

package/lib/ws-transport.js

@@ -1,53 +1,34 @@
-import { clearTimeout, setTimeout } from 'node:timers';
+import { createPendingRpc } from 'zhin.js/adapter';
 import { formatCompact, getLogger } from '@zhin.js/logger';
-import { WS_OPEN, } from './ws-types.js';
+import { WS_OPEN } from './ws-types.js';
 const logger = getLogger('onebot12');
-export function handleOneBot12WsMessage(data, options) {
-    try {
-        const message = JSON.parse(decodeOneBot12WsPayload(data));
-        if ('echo' in message && typeof message.echo === 'string') {
-            const response = message;
-            const pending = options.pending.get(response.echo);
-            if (pending) {
-                options.pending.delete(response.echo);
-                clearTimeout(pending.timeout);
-                pending.resolve(response);
+/** A Client's one request owner serves native SDK actions and framework operations. */
+export function createOneBot12Rpc(options) {
+    const pending = createPendingRpc({
+        signal: options.signal, requestPrefix: 'ob12_', timeoutMs: 30_000,
+        transport: () => { const socket = options.socket(); return socket?.readyState === WS_OPEN ? socket : undefined; },
+        serialize: request => JSON.stringify({ action: request.action, params: request.params ?? {}, echo: request.id, self: options.self }),
+    });
+    return Object.freeze({
+        call: pending.call, disconnect: pending.disconnect, dispose: pending.dispose,
+        get pendingCount() { return pending.pendingCount; },
+        receive(data, ingest) {
+            try {
+                const message = JSON.parse(decodeWsPayload(data));
+                if ('echo' in message && typeof message.echo === 'string') {
+                    pending.accept({ id: message.echo, value: message });
+                    return;
+                }
+                ingest(message);
             }
-            return;
-        }
-        options.ingest(message);
-    }
-    catch (error) {
-        logger.warn(formatCompact({
-            op: 'onebot12_parse_failed',
-            endpoint: options.endpointId,
-            error: error instanceof Error ? error.message : String(error),
-        }));
-    }
-}
-export function callOneBot12WsAction(ws, pending, requestId, action, params) {
-    if (!ws || ws.readyState !== WS_OPEN) {
-        return Promise.reject(new Error('WebSocket 未连接'));
-    }
-    const echo = `ob12_${++requestId.value}`;
-    const request = { action, params, echo };
-    return new Promise((resolve, reject) => {
-        const timeout = setTimeout(() => {
-            pending.delete(echo);
-            reject(new Error(`OneBot12 动作超时: ${action}`));
-        }, 30_000);
-        pending.set(echo, { resolve, reject, timeout });
-        ws.send(JSON.stringify(request));
+            catch (error) {
+                logger.warn(formatCompact({ op: 'onebot12_parse_failed', endpoint: options.endpointId,
+                    error: error instanceof Error ? error.message : String(error) }));
+            }
+        },
     });
 }
-export function rejectAllPending(pending, message = '连接已关闭') {
-    for (const [, entry] of pending) {
-        clearTimeout(entry.timeout);
-        entry.reject(new Error(message));
-    }
-    pending.clear();
-}
-function decodeOneBot12WsPayload(data) {
+export function decodeWsPayload(data) {
     if (typeof data === 'string')
         return data;
     if (Buffer.isBuffer(data))

package/lib/ws-types.d.ts

@@ -1,4 +1,3 @@
-import type { OneBot12ActionResponse } from './protocol.js';
 /** Minimal WS surface used by the endpoint (real `ws` or test mock). */
 export interface OneBot12WsSocket {
     readonly readyState: number;
@@ -10,8 +9,3 @@ export interface OneBot12WsCreateOptions {
     readonly headers?: Record<string, string>;
 }
 export declare const WS_OPEN = 1;
-export interface OneBot12PendingAction {
-    resolve: (value: OneBot12ActionResponse) => void;
-    reject: (err: Error) => void;
-    timeout: NodeJS.Timeout;
-}

package/lib/wss-endpoint.d.ts

@@ -1,25 +1,19 @@
 /**
  * OneBot12 reverse WSS endpoint — accepts inbound WebSocket from OneBot implementation.
  */
-import { ClientEndpoint, type EndpointControl, type EndpointManagement, type EndpointSendRequest } from 'zhin.js/adapter';
+import { endpointSpec, type Endpoint, type EndpointSpecification } from 'zhin.js/adapter';
 import type { HttpHost } from '@zhin.js/host-http';
 import type { CapabilityId } from 'zhin.js';
 import { type OneBot12WssConfig } from './protocol.js';
-import { type Onebot12Client } from './client.js';
+import { Onebot12Client } from './client.js';
 export interface OneBot12WssEndpointOptions {
+    readonly signal?: AbortSignal;
     readonly id: CapabilityId;
     readonly http: HttpHost;
     readonly config: OneBot12WssConfig;
 }
-export declare class OneBot12WssEndpoint extends ClientEndpoint<Onebot12Client> {
+export declare class OneBot12WssEndpoint extends Onebot12Client implements Endpoint {
     #private;
-    readonly client: Onebot12Client;
-    readonly management: EndpointManagement;
-    readonly control: EndpointControl;
-    readonly content: import("@zhin.js/adapter").EndpointContentPort;
+    readonly [endpointSpec]: EndpointSpecification;
     constructor(options: OneBot12WssEndpointOptions);
-    start(): Promise<void>;
-    stop(): Promise<void>;
-    send({ conversation, payload }: EndpointSendRequest): Promise<string>;
-    recallMessage(messageId: string): Promise<void>;
 }

package/lib/wss-endpoint.js

@@ -1,47 +1,66 @@
 /**
  * OneBot12 reverse WSS endpoint — accepts inbound WebSocket from OneBot implementation.
  */
-import { ClientEndpoint, createEndpointLifecycle, createRecallEndpointControl, } from 'zhin.js/adapter';
+import { createEndpointSpecification, endpointSpec, createEndpointLifecycle, createRecallEndpointControl, } from 'zhin.js/adapter';
 import { formatCompact, getAdapterLogger } from '@zhin.js/logger';
 import { createOneBot12EndpointManagement } from './endpoint-management.js';
-import { buildSendMessageParams, formatInboundContent, formatOutboundSegments, isBotMentioned, isMessageEvent, onebot12InboundConversation, senderNickname, senderUserId, uploadOneBot12MediaSegments, } from './protocol.js';
+import { buildSendMessageParams, matchesOneBot12Self, formatInboundContent, formatOutboundSegments, isBotMentioned, isMessageEvent, onebot12InboundConversation, senderNickname, senderUserId, uploadOneBot12MediaSegments, } from './protocol.js';
 import { receiveOneBot12SideEvent } from './side-event-dispatch.js';
 import { createOneBot12ContentPort } from './content-port.js';
-import { callOnebot12Client, createOnebot12EndpointClient, forwardOnebot12ClientEvents } from './client.js';
+import { callOnebot12Client, readOnebot12Response, onebot12ClientOptions, forwardOnebot12ClientEvents, Onebot12Client } from './client.js';
 import { verifyOneBotAccessToken } from './wss-auth.js';
-import { callOneBot12WsAction, handleOneBot12WsMessage, rejectAllPending, } from './ws-transport.js';
-export class OneBot12WssEndpoint extends ClientEndpoint {
-    client;
+import { createOneBot12Rpc } from './ws-transport.js';
+export class OneBot12WssEndpoint extends Onebot12Client {
+    [endpointSpec];
+    #open = false;
     #logger;
     #options;
-    management;
-    control = createRecallEndpointControl((id) => this.recallMessage(id));
-    content;
+    #management;
+    #control = createRecallEndpointControl((id, signal) => this.#recallMessage(id, signal));
+    #content;
+    #releaseClientEvents;
     #ws;
     #wsRelease;
     #connectionLifecycle;
     #connectionTask = Promise.resolve();
-    #requestId = { value: 0 };
-    #pending = new Map();
+    #rpc;
     #started = false;
     constructor(options) {
-        super();
+        const rpc = createOneBot12Rpc({ endpointId: options.config.id, signal: options.signal,
+            self: { platform: options.config.platform, user_id: options.config.userId },
+            socket: () => this.#connectionLifecycle.state === 'closed' ? undefined : this.#ws,
+        });
+        super(onebot12ClientOptions(options.config, (action, params) => rpc.call({ action, params })));
+        this.#rpc = rpc;
         this.#logger = getAdapterLogger('onebot12', options.config.id);
         this.#options = options;
         this.#connectionLifecycle = createEndpointLifecycle({
             name: `${options.config.id}:inbound`,
             reconnect: false,
         });
-        this.client = createOnebot12EndpointClient(options.config, (action, params) => this.#callAction(action, params ?? {}));
-        const callApi = (action, params) => callOnebot12Client(this.client, action, params);
-        this.management = createOneBot12EndpointManagement({ callApi });
-        this.content = createOneBot12ContentPort(callApi);
-        this.bindClientEvents((receive) => forwardOnebot12ClientEvents(this.client, receive), (name, payload) => {
-            if (name === 'event')
-                this.#admitRaw(payload);
-        }, (_name, error) => this.#warnPlatformEvent(error));
+        const callApi = (request) => this.#rpc.call(request).then(readOnebot12Response);
+        this.#management = createOneBot12EndpointManagement({ callApi });
+        this.#content = createOneBot12ContentPort(callApi);
+        const readTransportState = () => this.#connectionLifecycle.state;
+        this[endpointSpec] = createEndpointSpecification(this, {
+            name: options.config.id,
+            start: () => this.#start(), open: () => { this.#open = true; },
+            close: () => { this.#open = false; }, stop: () => this.#stop(),
+            send: request => this.#send(request),
+            get transportState() { return readTransportState(); },
+            management: this.#management, control: this.#control, content: this.#content,
+        });
+        this.#releaseClientEvents = forwardOnebot12ClientEvents(this, (name, payload) => {
+            void this[endpointSpec].events.run(() => {
+                if (!this.#open && !this.#started)
+                    return;
+                void this[endpointSpec].events.platform(name, payload).catch(error => this.#warnPlatformEvent(error));
+                if (name === 'event')
+                    this.#admitRaw(payload);
+            }).catch(error => this.#warnPlatformEvent(error));
+        });
     }
-    async start() {
+    async #start() {
         if (this.#started)
             return;
         if (!this.#options.config.access_token) {
@@ -73,43 +92,59 @@ export class OneBot12WssEndpoint extends ClientEndpoint {
             path: this.#options.config.path,
         }));
     }
-    async stop() {
-        this.close();
+    async #stop() {
+        this.#open = false;
         this.#wsRelease?.();
         this.#wsRelease = undefined;
-        await this.#connectionTask;
-        await this.#connectionLifecycle.stop();
-        rejectAllPending(this.#pending);
-        this.#ws = undefined;
-        this.#started = false;
+        try {
+            await this.#connectionTask;
+            await this.#connectionLifecycle.stop();
+        }
+        finally {
+            this.#rpc.dispose();
+            this.#releaseClientEvents();
+            this.#ws = undefined;
+            this.#started = false;
+        }
     }
-    async send({ conversation, payload }) {
-        const materialized = await uploadOneBot12MediaSegments(payload, (action, params) => callOnebot12Client(this.client, action, params), (error) => {
-            this.#logger.warn(formatCompact({
-                op: 'onebot12_upload_failed',
-                endpoint: this.#options.config.id,
-                error: error instanceof Error ? error.message : String(error),
-            }));
+    async #send({ conversation, payload, signal }) {
+        const materialized = await uploadOneBot12MediaSegments({
+            payload, signal,
+            callAction: (action, params) => this.#rpc.call({ action, params, signal }).then(readOnebot12Response),
+            onUploadFailed: error => {
+                this.#logger.warn(formatCompact({ op: 'onebot12_upload_failed', endpoint: this.#options.config.id,
+                    error: error instanceof Error ? error.message : String(error) }));
+            },
         });
         const message = formatOutboundSegments(materialized);
         const params = buildSendMessageParams(conversation, message);
-        const data = await callOnebot12Client(this.client, 'send_message', params);
+        const data = readOnebot12Response(await this.#rpc.call({ action: 'send_message', params, signal }));
         return data?.message_id ?? '';
     }
-    async recallMessage(messageId) {
+    async #recallMessage(messageId, signal) {
         if (!messageId)
             return;
-        await callOnebot12Client(this.client, 'delete_message', { message_id: messageId });
+        await this.#rpc.call({ action: 'delete_message', params: { message_id: messageId }, signal }).then(readOnebot12Response);
     }
     #admitRaw(ev) {
+        if (!matchesOneBot12Self(this.#options.config, ev))
+            return;
+        this[endpointSpec].reportSelfUserId(ev.self.user_id);
         if (!isMessageEvent(ev)) {
-            receiveOneBot12SideEvent((name, payload) => this.emit(name, payload), this.#options.config.id, { callApi: (action, params) => callOnebot12Client(this.client, action, params) }, ev, this.#logger);
+            receiveOneBot12SideEvent(ev, {
+                emit: (name, payload) => this[endpointSpec].events.emit(name, payload),
+                endpointKey: this.#options.config.id,
+                caller: { callApi: (action, params) => callOnebot12Client({ client: this, action, params }) },
+                logger: this.#logger,
+            });
             return;
         }
-        const conversation = onebot12InboundConversation(String(this.#options.id), ev);
+        const conversation = { ...onebot12InboundConversation(String(this.#options.id), ev), endpoint: this[endpointSpec].identity };
         const nickname = senderNickname(ev);
         const mentioned = isBotMentioned(ev);
-        void this.emit('message.receive', {
+        void this[endpointSpec].events.message({
+            event: ev,
+            ...(typeof ev.time === 'number' ? { platformSentAt: ev.time * 1000 } : {}),
             conversation,
             message: { conversation, id: ev.message_id },
             content: formatInboundContent(ev),
@@ -147,7 +182,7 @@ export class OneBot12WssEndpoint extends ClientEndpoint {
         }
         const socket = connection.socket;
         await this.#connectionLifecycle.stop();
-        rejectAllPending(this.#pending, '连接已替换');
+        this.#rpc.disconnect('连接已替换');
         await this.#connectionLifecycle.start(async (lifecycleHandle) => {
             this.#ws = socket;
             lifecycleHandle.onForceClose(() => {
@@ -167,16 +202,15 @@ export class OneBot12WssEndpoint extends ClientEndpoint {
                 if (this.#ws !== socket)
                     return;
                 this.#connectionLifecycle.notifyHeartbeatAck();
-                handleOneBot12WsMessage(data, {
-                    endpointId: this.#options.config.id,
-                    pending: this.#pending,
-                    ingest: (event) => this.client.ingest(event),
+                this.#rpc.receive(data, event => {
+                    if (matchesOneBot12Self(this.#options.config, event))
+                        this.ingest(event);
                 });
             });
             socket.on('close', () => {
                 if (this.#ws === socket) {
                     this.#ws = undefined;
-                    rejectAllPending(this.#pending);
+                    this.#rpc.disconnect();
                 }
                 lifecycleHandle.notifyClosed(new Error('OneBot12 reverse WebSocket closed'));
             });
@@ -188,6 +222,6 @@ export class OneBot12WssEndpoint extends ClientEndpoint {
         }));
     }
     #callAction(action, params) {
-        return callOneBot12WsAction(this.#ws, this.#pending, this.#requestId, action, params);
+        return this.#rpc.call({ action, params });
     }
 }