@zhin.js/adapter-milky 1.1.18 → 1.1.20

package/lib/sse-endpoint.js

@@ -1,34 +1,49 @@
 /**
  * Milky SSE client endpoint — GET text/event-stream on /event.
  */
-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 { createMilkyEndpointManagement } from './endpoint-management.js';
-import { callMilkyClient, createMilkyEndpointClient, forwardMilkyClientEvents } from './client.js';
+import { createMilkyActionCaller, readMilkyResponse, milkyClientOptions, forwardMilkyClientEvents, MilkyClient } from './client.js';
 import { buildSendAction, buildSseConnectOptions, callApi, extractInboundAudioUrl, formatInboundContent, formatInboundMessageId, formatInboundSegments, formatOutboundMessageId, formatOutboundSegments, isMentioned, milkyInboundConversation, parseMessageReceiveData, parseMilkyMessageId, senderNickname, } from './protocol.js';
 import { openSseStream } from './sse-client.js';
-export class MilkySseEndpoint extends ClientEndpoint {
-    client;
+export class MilkySseEndpoint extends MilkyClient {
+    [endpointSpec];
+    #open = false;
     #logger;
     #options;
-    #callApi;
-    management;
-    control = createRecallEndpointControl((id) => this.recallMessage(id));
+    #management;
+    #call;
+    #control = createRecallEndpointControl((id, signal) => this.#recallMessage({ id, signal }));
     #lifecycle;
     #stream;
     constructor(options) {
-        super();
+        const call = createMilkyActionCaller({ config: options.config, request: options.callApi ?? callApi, signal: options.signal });
+        super(milkyClientOptions({ config: options.config, call }));
+        this.#call = call;
         this.#logger = getAdapterLogger('milky', options.config.id);
         this.#options = options;
-        this.#callApi = options.callApi ?? callApi;
-        this.client = createMilkyEndpointClient(options.config, this.#callApi);
-        this.management = createMilkyEndpointManagement({
-            callApi: (action, params) => callMilkyClient(this.client, action, params),
+        this.#management = createMilkyEndpointManagement({
+            callApi: request => call(request).then(response => readMilkyResponse(response, request.action)),
+        });
+        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),
+            management: this.#management, control: this.#control,
+            get transportState() { return readTransportState(); },
+        });
+        forwardMilkyClientEvents(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));
         });
-        this.bindClientEvents((receive) => forwardMilkyClientEvents(this.client, receive), (name, payload) => {
-            if (name === 'event')
-                this.#admitRaw(payload);
-        }, (_name, error) => this.#warnPlatformEvent(error));
         this.#lifecycle = createEndpointLifecycle({
             name: options.config.id,
             // reconnect_interval 旧语义为固定间隔：multiplier 1 + 无 jitter + 不封顶
@@ -40,7 +55,7 @@ export class MilkySseEndpoint extends ClientEndpoint {
             },
         });
     }
-    async start() {
+    async #start() {
         if (this.#lifecycle.started)
             return;
         try {
@@ -51,16 +66,16 @@ export class MilkySseEndpoint extends ClientEndpoint {
             throw err;
         }
     }
-    async stop() {
-        this.close();
+    async #stop() {
+        this.#open = false;
         await this.#lifecycle.stop();
         this.#stream?.close();
         this.#stream = undefined;
     }
-    async send({ conversation, payload }) {
+    async #send({ conversation, payload, signal }) {
         const message = formatOutboundSegments(payload);
         const { action, params } = buildSendAction(conversation, message);
-        const data = await callMilkyClient(this.client, action, params);
+        const data = readMilkyResponse(await this.#call({ action, params, signal }), action);
         const messageId = formatOutboundMessageId(conversation, data?.message_seq);
         this.#logger.debug(formatCompact({
             op: 'milky_send',
@@ -71,24 +86,26 @@ export class MilkySseEndpoint extends ClientEndpoint {
         }));
         return messageId;
     }
-    async recallMessage(id) {
+    async #recallMessage({ id, signal }) {
         const parsed = parseMilkyMessageId(id);
         if (!parsed)
             throw new Error(`Invalid message id: ${id}`);
         if (parsed.message_scene === 'group') {
-            await callMilkyClient(this.client, 'recall_group_message', {
-                group_id: parsed.peer_id,
-                message_seq: parsed.message_seq,
-            });
+            readMilkyResponse(await this.#call({ action: 'recall_group_message', signal, params: {
+                    group_id: parsed.peer_id,
+                    message_seq: parsed.message_seq,
+                } }), 'recall_group_message');
         }
         else {
-            await callMilkyClient(this.client, 'recall_private_message', {
-                user_id: parsed.peer_id,
-                message_seq: parsed.message_seq,
-            });
+            readMilkyResponse(await this.#call({ action: 'recall_private_message', signal, params: {
+                    user_id: parsed.peer_id,
+                    message_seq: parsed.message_seq,
+                } }), 'recall_private_message');
         }
     }
     #admitRaw(event) {
+        if (event.self_id != null)
+            this[endpointSpec].reportSelfUserId(String(event.self_id));
         const data = parseMessageReceiveData(event);
         if (!data)
             return;
@@ -98,14 +115,16 @@ export class MilkySseEndpoint extends ClientEndpoint {
         this.#logger.warn(formatCompact({ op: 'milky_platform_event_failed', error: error instanceof Error ? error.message : String(error) }));
     }
     #admitMessage(data, event) {
-        const conversation = milkyInboundConversation(String(this.#options.id), data);
+        const conversation = { ...milkyInboundConversation(String(this.#options.id), data), endpoint: this[endpointSpec].identity };
         const target = `${conversation.kind}:${conversation.id}`;
         const content = formatInboundContent(data);
         const segments = formatInboundSegments(data);
         const audioUrl = extractInboundAudioUrl(data);
         const nickname = senderNickname(data);
         const mentioned = isMentioned(data, event.self_id);
-        void this.emit('message.receive', {
+        void this[endpointSpec].events.message({
+            event,
+            ...(typeof event.time === 'number' ? { platformSentAt: event.time * 1000 } : {}),
             conversation,
             message: { conversation, id: formatInboundMessageId(data) },
             content,
@@ -193,7 +212,7 @@ export class MilkySseEndpoint extends ClientEndpoint {
     #onMessage(data) {
         try {
             const event = JSON.parse(data);
-            this.client.ingest(event);
+            this.ingest(event);
         }
         catch (error) {
             this.#logger.warn(formatCompact({

package/lib/webhook-endpoint.d.ts

@@ -1,22 +1,17 @@
-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 MilkyClient } from './client.js';
+import { MilkyClient } from './client.js';
 import { callApi, type MilkyWebhookConfig } from './protocol.js';
 export interface MilkyWebhookEndpointOptions {
     readonly id: CapabilityId;
+    readonly signal?: AbortSignal;
     readonly http: HttpHost;
     readonly config: MilkyWebhookConfig;
     readonly callApi?: typeof callApi;
 }
-export declare class MilkyWebhookEndpoint extends ClientEndpoint<MilkyClient> {
+export declare class MilkyWebhookEndpoint extends MilkyClient implements Endpoint {
     #private;
-    readonly client: MilkyClient;
-    readonly management: EndpointManagement;
-    readonly control: EndpointControl;
+    readonly [endpointSpec]: EndpointSpecification;
     constructor(options: MilkyWebhookEndpointOptions);
-    start(): Promise<void>;
-    stop(): Promise<void>;
-    send({ conversation, payload }: EndpointSendRequest): Promise<string>;
-    recallMessage(id: string): Promise<void>;
 }

package/lib/webhook-endpoint.js

@@ -1,33 +1,47 @@
-import { ClientEndpoint, createRecallEndpointControl, } from 'zhin.js/adapter';
+import { acceptHttpIngress } from 'imhelper';
+import { createEndpointSpecification, endpointSpec, createRecallEndpointControl, } from 'zhin.js/adapter';
 import { formatCompact, getAdapterLogger } from '@zhin.js/logger';
 import { verifyMilkyAccessToken } from './milky-auth.js';
 import { createMilkyEndpointManagement } from './endpoint-management.js';
-import { callMilkyClient, createMilkyEndpointClient, forwardMilkyClientEvents } from './client.js';
+import { createMilkyActionCaller, readMilkyResponse, milkyClientOptions, forwardMilkyClientEvents, MilkyClient } from './client.js';
 import { buildSendAction, callApi, extractInboundAudioUrl, formatInboundContent, formatInboundMessageId, formatInboundSegments, formatOutboundMessageId, formatOutboundSegments, isMentioned, milkyInboundConversation, parseMessageReceiveData, parseMilkyMessageId, senderNickname, } from './protocol.js';
-export class MilkyWebhookEndpoint extends ClientEndpoint {
-    client;
+export class MilkyWebhookEndpoint extends MilkyClient {
+    [endpointSpec];
+    #open = false;
     #logger;
     #options;
-    #callApi;
-    management;
-    control = createRecallEndpointControl((id) => this.recallMessage(id));
+    #management;
+    #call;
+    #control = createRecallEndpointControl((id, signal) => this.#recallMessage({ id, signal }));
     #routeReleases = [];
     #started = false;
     constructor(options) {
-        super();
+        const call = createMilkyActionCaller({ config: options.config, request: options.callApi ?? callApi, signal: options.signal });
+        super(milkyClientOptions({ config: options.config, call }));
+        this.#call = call;
         this.#logger = getAdapterLogger('milky', options.config.id);
         this.#options = options;
-        this.#callApi = options.callApi ?? callApi;
-        this.client = createMilkyEndpointClient(options.config, this.#callApi);
-        this.management = createMilkyEndpointManagement({
-            callApi: (action, params) => callMilkyClient(this.client, action, params),
+        this.#management = createMilkyEndpointManagement({
+            callApi: request => call(request).then(response => readMilkyResponse(response, request.action)),
+        });
+        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),
+            management: this.#management, control: this.#control,
+        });
+        forwardMilkyClientEvents(this, (name, payload) => {
+            void this[endpointSpec].events.run(() => {
+                if (!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));
         });
-        this.bindClientEvents((receive) => forwardMilkyClientEvents(this.client, receive), (name, payload) => {
-            if (name === 'event')
-                this.#admitRaw(payload);
-        }, (_name, error) => this.#warnPlatformEvent(error));
     }
-    async start() {
+    async #start() {
         if (this.#started)
             return;
         this.#started = true;
@@ -39,17 +53,17 @@ export class MilkyWebhookEndpoint extends ClientEndpoint {
             path: this.#options.config.path,
         }));
     }
-    async stop() {
-        this.close();
+    async #stop() {
+        this.#open = false;
         for (const release of this.#routeReleases.splice(0))
             release();
         this.#started = false;
         this.#logger.debug(formatCompact({ op: 'disconnect' }));
     }
-    async send({ conversation, payload }) {
+    async #send({ conversation, payload, signal }) {
         const message = formatOutboundSegments(payload);
         const { action, params } = buildSendAction(conversation, message);
-        const data = await callMilkyClient(this.client, action, params);
+        const data = readMilkyResponse(await this.#call({ action, params, signal }), action);
         const messageId = formatOutboundMessageId(conversation, data?.message_seq);
         this.#logger.debug(formatCompact({
             op: 'milky_send',
@@ -59,24 +73,26 @@ export class MilkyWebhookEndpoint extends ClientEndpoint {
         }));
         return messageId;
     }
-    async recallMessage(id) {
+    async #recallMessage({ id, signal }) {
         const parsed = parseMilkyMessageId(id);
         if (!parsed)
             throw new Error(`Invalid message id: ${id}`);
         if (parsed.message_scene === 'group') {
-            await callMilkyClient(this.client, 'recall_group_message', {
-                group_id: parsed.peer_id,
-                message_seq: parsed.message_seq,
-            });
+            readMilkyResponse(await this.#call({ action: 'recall_group_message', signal, params: {
+                    group_id: parsed.peer_id,
+                    message_seq: parsed.message_seq,
+                } }), 'recall_group_message');
         }
         else {
-            await callMilkyClient(this.client, 'recall_private_message', {
-                user_id: parsed.peer_id,
-                message_seq: parsed.message_seq,
-            });
+            readMilkyResponse(await this.#call({ action: 'recall_private_message', signal, params: {
+                    user_id: parsed.peer_id,
+                    message_seq: parsed.message_seq,
+                } }), 'recall_private_message');
         }
     }
     #admitRaw(event) {
+        if (event.self_id != null)
+            this[endpointSpec].reportSelfUserId(String(event.self_id));
         const data = parseMessageReceiveData(event);
         if (!data)
             return;
@@ -86,14 +102,16 @@ export class MilkyWebhookEndpoint extends ClientEndpoint {
         this.#logger.warn(formatCompact({ op: 'milky_platform_event_failed', error: error instanceof Error ? error.message : String(error) }));
     }
     #admitMessage(data, event) {
-        const conversation = milkyInboundConversation(String(this.#options.id), data);
+        const conversation = { ...milkyInboundConversation(String(this.#options.id), data), endpoint: this[endpointSpec].identity };
         const target = `${conversation.kind}:${conversation.id}`;
         const content = formatInboundContent(data);
         const segments = formatInboundSegments(data);
         const audioUrl = extractInboundAudioUrl(data);
         const nickname = senderNickname(data);
         const mentioned = isMentioned(data, event.self_id);
-        void this.emit('message.receive', {
+        void this[endpointSpec].events.message({
+            event,
+            ...(typeof event.time === 'number' ? { platformSentAt: event.time * 1000 } : {}),
             conversation,
             message: { conversation, id: formatInboundMessageId(data) },
             content,
@@ -131,12 +149,15 @@ export class MilkyWebhookEndpoint extends ClientEndpoint {
                 response.end(JSON.stringify({ message: 'Unauthorized' }));
                 return;
             }
-            if (!this.clientEventsOpen) {
+            if (!this.#open) {
                 response.writeHead(200, { 'Content-Type': 'application/json' });
                 response.end(JSON.stringify({ status: 'ok' }));
                 return;
             }
-            await this.client.acceptHttp(request, response);
+            await acceptHttpIngress(request, response, event => {
+                void this[endpointSpec].events.run(() => this.ingest(event))
+                    .catch(error => this.#warnPlatformEvent(error));
+            });
         }
         catch (error) {
             this.#logger.error('Milky webhook error:', error);

package/lib/ws-endpoint.d.ts

@@ -1,23 +1,17 @@
-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 MilkyClient } from './client.js';
+import { MilkyClient } from './client.js';
 import { callApi, type MilkyWsConfig } from './protocol.js';
 import type { MilkyWsCreateOptions, MilkyWsSocket } from './ws-types.js';
 export interface MilkyWsEndpointOptions {
     readonly id: CapabilityId;
+    readonly signal?: AbortSignal;
     readonly config: MilkyWsConfig;
     readonly createWebSocket?: (url: string, options: MilkyWsCreateOptions) => MilkyWsSocket;
     readonly callApi?: typeof callApi;
 }
-export declare class MilkyWsEndpoint extends ClientEndpoint<MilkyClient> {
+export declare class MilkyWsEndpoint extends MilkyClient implements Endpoint {
     #private;
-    readonly client: MilkyClient;
-    readonly management: EndpointManagement;
-    readonly control: EndpointControl;
+    readonly [endpointSpec]: EndpointSpecification;
     constructor(options: MilkyWsEndpointOptions);
-    start(): Promise<void>;
-    close(): void;
-    stop(): Promise<void>;
-    send({ conversation, payload }: EndpointSendRequest): Promise<string>;
-    recallMessage(id: string): Promise<void>;
 }

package/lib/ws-endpoint.js

@@ -2,35 +2,50 @@
  * Milky WS client endpoint — outbound connect to Milky protocol server.
  */
 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 { createMilkyEndpointManagement } from './endpoint-management.js';
-import { callMilkyClient, createMilkyEndpointClient, forwardMilkyClientEvents, } from './client.js';
+import { createMilkyActionCaller, readMilkyResponse, milkyClientOptions, forwardMilkyClientEvents, MilkyClient, } from './client.js';
 import { buildSendAction, buildWsConnectOptions, callApi, extractInboundAudioUrl, formatInboundContent, formatInboundMessageId, formatInboundSegments, formatOutboundMessageId, formatOutboundSegments, isMentioned, milkyInboundConversation, parseMessageReceiveData, parseMilkyMessageId, senderNickname, } from './protocol.js';
 const WS_OPEN = 1;
-export class MilkyWsEndpoint extends ClientEndpoint {
-    client;
+export class MilkyWsEndpoint extends MilkyClient {
+    [endpointSpec];
+    #open = false;
     #logger;
     #options;
-    #callApi;
-    management;
-    control = createRecallEndpointControl((id) => this.recallMessage(id));
+    #management;
+    #call;
+    #control = createRecallEndpointControl((id, signal) => this.#recallMessage({ id, signal }));
     #lifecycle;
     #ws;
     #clientSocketRelease;
     constructor(options) {
-        super();
+        const call = createMilkyActionCaller({ config: options.config, request: options.callApi ?? callApi, signal: options.signal });
+        super(milkyClientOptions({ config: options.config, call }));
+        this.#call = call;
         this.#logger = getAdapterLogger('milky', options.config.id);
         this.#options = options;
-        this.#callApi = options.callApi ?? callApi;
-        this.client = createMilkyEndpointClient(options.config, this.#callApi);
-        this.management = createMilkyEndpointManagement({
-            callApi: (action, params) => callMilkyClient(this.client, action, params),
+        this.#management = createMilkyEndpointManagement({
+            callApi: request => call(request).then(response => readMilkyResponse(response, request.action)),
+        });
+        const readTransportState = () => this.#lifecycle.state;
+        this[endpointSpec] = createEndpointSpecification(this, {
+            name: options.config.id,
+            start: () => this.#start(), open: () => { this.#open = true; },
+            close: () => { this.#close(); }, stop: () => this.#stop(),
+            send: request => this.#send(request),
+            management: this.#management, control: this.#control,
+            get transportState() { return readTransportState(); },
+        });
+        forwardMilkyClientEvents(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));
         });
-        this.bindClientEvents((receive) => forwardMilkyClientEvents(this.client, receive), (name, payload) => {
-            if (name === 'event')
-                this.#admitRaw(payload);
-        }, (_name, error) => this.#warnPlatformEvent(error));
         this.#lifecycle = createEndpointLifecycle({
             name: options.config.id,
             // reconnect_interval 旧语义为固定间隔：multiplier 1 + 无 jitter + 不封顶
@@ -42,18 +57,18 @@ export class MilkyWsEndpoint extends ClientEndpoint {
             },
         });
     }
-    async start() {
+    async #start() {
         if (this.#lifecycle.started)
             return;
         await this.#lifecycle.start((handle) => this.#connect(handle));
     }
-    close() {
-        super.close();
+    #close() {
+        this.#open = false;
         this.#clientSocketRelease?.();
         this.#clientSocketRelease = undefined;
     }
-    async stop() {
-        this.close();
+    async #stop() {
+        this.#close();
         await this.#lifecycle.stop();
         if (this.#ws) {
             try {
@@ -65,10 +80,10 @@ export class MilkyWsEndpoint extends ClientEndpoint {
             this.#ws = undefined;
         }
     }
-    async send({ conversation, payload }) {
+    async #send({ conversation, payload, signal }) {
         const message = formatOutboundSegments(payload);
         const { action, params } = buildSendAction(conversation, message);
-        const data = await callMilkyClient(this.client, action, params);
+        const data = readMilkyResponse(await this.#call({ action, params, signal }), action);
         const messageId = formatOutboundMessageId(conversation, data?.message_seq);
         this.#logger.debug(formatCompact({
             op: 'milky_send',
@@ -78,24 +93,26 @@ export class MilkyWsEndpoint extends ClientEndpoint {
         }));
         return messageId;
     }
-    async recallMessage(id) {
+    async #recallMessage({ id, signal }) {
         const parsed = parseMilkyMessageId(id);
         if (!parsed)
             throw new Error(`Invalid message id: ${id}`);
         if (parsed.message_scene === 'group') {
-            await callMilkyClient(this.client, 'recall_group_message', {
-                group_id: parsed.peer_id,
-                message_seq: parsed.message_seq,
-            });
+            readMilkyResponse(await this.#call({ action: 'recall_group_message', signal, params: {
+                    group_id: parsed.peer_id,
+                    message_seq: parsed.message_seq,
+                } }), 'recall_group_message');
         }
         else {
-            await callMilkyClient(this.client, 'recall_private_message', {
-                user_id: parsed.peer_id,
-                message_seq: parsed.message_seq,
-            });
+            readMilkyResponse(await this.#call({ action: 'recall_private_message', signal, params: {
+                    user_id: parsed.peer_id,
+                    message_seq: parsed.message_seq,
+                } }), 'recall_private_message');
         }
     }
     #admitRaw(event) {
+        if (event.self_id != null)
+            this[endpointSpec].reportSelfUserId(String(event.self_id));
         const data = parseMessageReceiveData(event);
         if (!data)
             return;
@@ -108,14 +125,16 @@ export class MilkyWsEndpoint extends ClientEndpoint {
         }));
     }
     #admitMessage(data, event) {
-        const conversation = milkyInboundConversation(String(this.#options.id), data);
+        const conversation = { ...milkyInboundConversation(String(this.#options.id), data), endpoint: this[endpointSpec].identity };
         const target = `${conversation.kind}:${conversation.id}`;
         const content = formatInboundContent(data);
         const segments = formatInboundSegments(data);
         const audioUrl = extractInboundAudioUrl(data);
         const nickname = senderNickname(data);
         const mentioned = isMentioned(data, event.self_id);
-        void this.emit('message.receive', {
+        void this[endpointSpec].events.message({
+            event,
+            ...(typeof event.time === 'number' ? { platformSentAt: event.time * 1000 } : {}),
             conversation,
             message: { conversation, id: formatInboundMessageId(data) },
             content,
@@ -187,7 +206,7 @@ export class MilkyWsEndpoint extends ClientEndpoint {
                 resolve();
             });
             this.#clientSocketRelease?.();
-            this.#clientSocketRelease = this.client.acceptWebSocket(ws);
+            this.#clientSocketRelease = this.acceptWebSocket(ws);
             ws.on('close', (code, reason) => {
                 this.#clientSocketRelease?.();
                 this.#clientSocketRelease = undefined;

package/lib/wss-endpoint.d.ts

@@ -1,25 +1,20 @@
 /**
  * Milky reverse WSS endpoint — httpHostToken WS upgrade inbound + baseUrl HTTP API outbound.
  */
-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 MilkyClient } from './client.js';
+import { MilkyClient } from './client.js';
 import { callApi, type MilkyWssConfig } from './protocol.js';
 export interface MilkyWssEndpointOptions {
     readonly id: CapabilityId;
+    readonly signal?: AbortSignal;
     readonly http: HttpHost;
     readonly config: MilkyWssConfig;
     readonly callApi?: typeof callApi;
 }
-export declare class MilkyWssEndpoint extends ClientEndpoint<MilkyClient> {
+export declare class MilkyWssEndpoint extends MilkyClient implements Endpoint {
     #private;
-    readonly client: MilkyClient;
-    readonly management: EndpointManagement;
-    readonly control: EndpointControl;
+    readonly [endpointSpec]: EndpointSpecification;
     constructor(options: MilkyWssEndpointOptions);
-    start(): Promise<void>;
-    stop(): Promise<void>;
-    send({ conversation, payload }: EndpointSendRequest): Promise<string>;
-    recallMessage(id: string): Promise<void>;
 }