@zhin.js/adapter-onebot11 1.1.18 → 1.1.20

package/CHANGELOG.md

@@ -1,5 +1,51 @@
 # @zhin.js/adapter-onebot11
 
+## 1.1.20
+
+### Patch Changes
+
+- Updated dependencies [5e878ba]
+  - @zhin.js/page@1.1.12
+
+## 1.1.19
+
+### Patch Changes
+
+- 2c3610a: Move account lifecycle ownership into the generic Adapter base and let native Endpoints retain their SDK Client inheritance. Infer platform-specific operation Sessions from a single adapter registry while preserving command parameter, option, configuration and factory inference.
+
+  Bind message replies, management ports, login challenges and Agent cancellation to the captured account incarnation. Persist runtime account intent with encrypted, revision-checked Host storage; keep account management independent of Root process restarts. Require explicit operator confirmation before importing existing accounts, and give replacement accounts a new identity without inheriting previous Sessions.
+
+  Expose account save, start, stop, update and replacement through the existing adapter Console, with exact account ownership, truthful pending/unknown outcomes and no startup configuration or environment-file rewrites.
+
+  Complete the target migration across every adapter, the public authoring API, generators, examples and Console. This intentionally removes the old create factory, inheritable Endpoint/ClientEndpoint classes, Client descriptors and file-rewrite account management; plugin authors must use createAdapter, native Client inheritance and the single AdapterRegistry. Satori and OneBot12 require explicit platform/userId selection, and WeCom requires a separate agentId.
+
+  Verify opaque credential changes before the same configuration snapshot is committed. Drain admitted native callbacks across close/rollback, cancel target work on stop, and keep raw transport parsing, platform ACK timing and SDK native methods under their existing owners. Account metadata conceals credentials carried in URLs.
+
+- a9f4e48: PATCH COMPATIBILITY CUTOVER: this batch intentionally changes plugin APIs. The maintainer explicitly chose patch releases with declared version boundaries. Upgrade the complete tested dependency set; patch numbering does not promise compatibility with the removed interfaces.
+
+  The first planned floors are zhin.js 1.1.19, Core 1.1.54, Adapter 1.1.26, FeatureKit 1.1.10, Plugin Runtime 1.1.18, Runtime/Isolate 1.1.16 and Agent 1.1.45. Keep old-interface plugins with the earlier locked stack until they are migrated. Adapter's independent Feature API changes from 1.0.0 to 2.0.0; official consumers declare ^2.0.0. Existing Feature API admission rejects explicitly incompatible ranges; omitted API metadata keeps its existing behavior and does not certify compatibility. Runtime engine and patch-only release gates remain unchanged.
+
+  Use the native-Client Adapter target contract, canonical FeatureKit AdapterRegistry augmentation and named Endpoint control/management requests. Route message controls from canonical message/conversation refs; retain exact source authority and propagate caller/account/explicit-Root-stop cancellation. Replace removed Agent activity feedback exports with source-bound feedback. HMR pause/resume belongs to concrete plugin instances; plugins choose accepted-work policy without changing Controller commit/rollback authority. Cooperative worker/process control cancellation does not kill an isolate or reopen retired business admission.
+
+  Provide authenticated historical-data preview, exact selected binding, transactional application, authoritative inspection and explicit resumption, including active games. Preserve before-images and journals; never replay an unconfirmed effect, infer an account from an alias, or reuse historical permission grants. Owner V2 approvals remain inactive legacy data, while new writes use V3. Rollback requires matching software, lockfile and verified data; installing old code alone cannot read a new V3 approval file. Conflicting after-images are never overwritten.
+
+  See docs/plans/adapter-operation-version-boundaries.md and the Chinese/English upgrade guide for the complete version inventory, custom-plugin changes, acceptance and recovery sequence. These code and metadata changes do not authorize merging, publication, deployment, login, production migration or removal of installed workspace patches.
+
+- Updated dependencies [2c3610a]
+- Updated dependencies [a9f4e48]
+- Updated dependencies [f8505b0]
+- Updated dependencies [2c3610a]
+  - @zhin.js/adapter@1.1.26
+  - @zhin.js/feature-kit@1.1.10
+  - @zhin.js/core@1.1.54
+  - @zhin.js/host-http@1.1.12
+  - @zhin.js/client@1.1.22
+  - @zhin.js/page@1.1.11
+  - @zhin.js/agent-feature@1.1.11
+  - @zhin.js/skill@1.1.11
+  - @zhin.js/tool@1.1.13
+  - @zhin.js/permission@1.1.10
+
 ## 1.1.18
 
 ### Patch Changes

package/README.md

@@ -2,13 +2,15 @@
 
 Zhin.js [OneBot 11](https://github.com/botuniverse/onebot-11) 适配器（Plugin Runtime）。生产路径为正向 WebSocket 客户端（`connection: ws`）；亦支持反向 WS（`connection: wss`，经 `httpHostToken`）。
 
+账号由 `Onebot11Adapter` 管理。Endpoint 直接继承实际 `OneBotV11Client`，保留原生方法与事件；框架生命周期、规范入站与发送经 `endpointSpec` 和 AdapterIndex 接入，不占用 Client 的原生 `start` / `stop` / `send` 方法。
+
 ## 功能特性
 
 - [OneBot 11 标准](https://github.com/botuniverse/onebot-11) 兼容（事件 + 动作）
 - 约定式 `defineAdapter` / `definePlugin`（无需 `usePlugin`）
 - **正向 WebSocket**（`connection: ws`）：应用连 OneBot 实现的 WS 服务器
 - `access_token` 鉴权（Bearer + query）
-- 入站经 `Endpoint.emit(...)`；出站 `send({ conversation, payload })`
+- 入站经 `endpointSpec.events`；出站 `send({ conversation, payload })`
 
 ## 安装
 
@@ -19,19 +21,24 @@ pnpm add @zhin.js/adapter-onebot11
 ## Plugin Runtime
 
 - `@zhin.js/adapter` — 约定式 `adapters/onebot11/index.ts`（`defineAdapter`）
-- `@zhin.js/core` — `Endpoint.emit(...)` 入站、`outboundMessageToken` 出站
+- `@zhin.js/core` — `endpointSpec.events` 入站、`outboundMessageToken` 出站
 - `zhin.js` — `plugin.ts`（`definePlugin`）
 - 配置经插件 `schema.json` 落到顶层 `<instanceKey>`
 
 `AdapterIndex` 会把实例默认值与 `endpoints[]` 的逐项覆盖合并；协议层只接收一个已经展开的 endpoint 配置，不再读取嵌套 endpoint、旧 `type: ws_reverse` 别名或进程环境。
 
-每个 Endpoint 的 `$client` 是 `@imhelper/onebot-v11` 的 `OneBotV11Client`。业务代码直接调用
+Endpoint 直接继承 `@imhelper/onebot-v11` 的 `OneBotV11Client`；当前操作的 `$client` 就是该实际实例。业务代码直接调用
 `$client.call(action, params)` 和 Client 的公开平台能力；双工 WS 的 `echo` 响应由 Endpoint
 先行分流，只有事件帧进入 Client 的 `ingest()` 和公开事件流。
 
-入站：`gateway.receive({ conversation, message, content, sender, metadata })`（`conversation.kind` 为 `private`/`group`，`id` 为 uid/gid）  
+入站：`endpoint[endpointSpec].events.emit('message.receive', { conversation, message, content, sender, metadata })`（`conversation.kind` 为 `private`/`group`，`id` 为 uid/gid）
+
 出站：`send({ conversation, payload })` → WS `send_private_msg` / `send_group_msg`（payload 已由 gateway/core 渲染；无 segment-mapper）
 
+## 操作生命周期
+
+每个实际 Client 的请求关联、定时器与取消由同一个实例级 RPC 模块持有。停止、删除或替换账号时，先取消该实例的等待，再关闭连接；已提交但未收到结果的请求保持“结果未知”，不会重试。框架发送与内容读取还绑定各自的操作信号，取消单个操作不影响其他操作或账号。原生 SDK 方法和事件重载保持不变。
+
 ## 前置条件
 
 1. 启动兼容 OneBot 11 的实现，并选定正向或反向 WebSocket。
@@ -84,7 +91,7 @@ onebot11:
 
 ## 迁移说明（Plugin Runtime）
 
-- **notice / request / meta 侧事件**：经 the unified `Endpoint.emit(...)` ingress 归一后分发到 `handlers`；消息仍走 `outboundMessageToken`。
+- **notice / request / meta 侧事件**：经统一 `endpointSpec.events` 归一后分发到 `handlers`；消息仍走 `outboundMessageToken`。
 - **群管工具暂未迁移**：旧 Adapter 经 `createSceneManagementTools` 注册踢人 / 禁言 / 群名片等成套 agent 工具；迁移后仅保留 `onebot11_set_title`，其余群管能力可通过 `$client.call()`（如 `set_group_kick`、`set_group_ban`）作为逃生舱调用。
 - **平台权限门禁**：`plugin.ts` setup 通过 generation-owned `permissionHostToken` 调用 `host.registerPlatform('onebot11', createSceneRolePlatformChecker())`，`scene_admin` / `scene_owner` 依据入站 metadata 中的 sender `role`（owner / admin）判定。
 
@@ -98,7 +105,7 @@ onebot11:
 启动后打开 Console 的「OneBot 11」页（地址 `/onebot11`），可以：
 
 - 查看运行中的连接、点「测试连接」做连通性诊断；
-- 增删 `plugins.onebot11.endpoints`（凭据写入 `.env`，配置里只保留 `${ENV}` 引用）；
+- 经所属 Adapter 增删持久化账号、启停单个 Endpoint；凭据由 Host 加密仓储保存，不改启动 YAML 或 `.env`，不重启进程；
 - 如果适配器要求登录，页面会显示 LoginAssist 的扫码 / 滑块 / 设备确认待办；
 
 读取需要 `onebot11:read`，写操作需要 `onebot11:write`；管理员 full token 不受限。页面里的「添加 endpoint」等价于原来的 `onebot11 endpoint add`。

package/adapters/onebot11/index.js

@@ -3,11 +3,8 @@
  * Convention entry: discover `adapters/onebot11/index.ts` → defineAdapter.
  */
 import { defineAdapter } from 'zhin.js/adapter';
-import { httpHostToken } from '@zhin.js/host-http';
-import { OneBot11WsEndpoint } from "../../lib/ws-endpoint.js";
-import { OneBot11WssEndpoint } from "../../lib/wss-endpoint.js";
-import { resolveOneBot11Config, } from "../../lib/protocol.js";
-import { onebot11RuntimeStateToken } from "../../lib/onebot11-runtime-state.js";
+import { Onebot11Adapter } from "../../lib/adapter.js";
+import {} from "../../lib/protocol.js";
 export { OneBot11WsEndpoint } from "../../lib/ws-endpoint.js";
 export { OneBot11WssEndpoint } from "../../lib/wss-endpoint.js";
 export default defineAdapter({
@@ -18,25 +15,5 @@ export default defineAdapter({
         outboundMedia: ['url', 'base64'],
         interactive: 'text',
     },
-    create(context) {
-        const config = resolveOneBot11Config(context.config);
-        // 注册到插件运行时状态（onebot11 endpoint list 的"运行中"数据源）
-        context.use(onebot11RuntimeStateToken).endpoints.set(config.id, {
-            id: config.id,
-            mode: config.connection,
-        });
-        if (config.connection === 'wss') {
-            return new OneBot11WssEndpoint({
-                id: context.id,
-                http: context.use(httpHostToken),
-                config,
-                probeLoginInfo: true,
-            });
-        }
-        return new OneBot11WsEndpoint({
-            id: context.id,
-            config,
-            probeLoginInfo: true,
-        });
-    },
+    createAdapter: context => new Onebot11Adapter(context),
 });

package/adapters/onebot11/index.ts

@@ -2,14 +2,10 @@
  * Convention entry: discover `adapters/onebot11/index.ts` → defineAdapter.
  */
 import { defineAdapter } from 'zhin.js/adapter';
-import { httpHostToken } from '@zhin.js/host-http';
-import { OneBot11WsEndpoint } from '../../src/ws-endpoint.js';
-import { OneBot11WssEndpoint } from '../../src/wss-endpoint.js';
+import { Onebot11Adapter } from '../../src/adapter.js';
 import {
-  resolveOneBot11Config,
   type OneBot11EndpointConfig,
 } from '../../src/protocol.js';
-import { onebot11RuntimeStateToken } from '../../src/onebot11-runtime-state.js';
 
 export { OneBot11WsEndpoint } from '../../src/ws-endpoint.js';
 export type { OneBot11WsEndpointOptions } from '../../src/ws-endpoint.js';
@@ -17,12 +13,6 @@ export { OneBot11WssEndpoint } from '../../src/wss-endpoint.js';
 export type { OneBot11WssEndpointOptions } from '../../src/wss-endpoint.js';
 export type { OneBot11WsSocket, OneBot11WsCreateOptions } from '../../src/ws-types.js';
 
-declare module '@zhin.js/core' {
-  interface AdapterEndpoints {
-    onebot11: import('../../src/ws-endpoint.js').OneBot11WsEndpoint;
-  }
-}
-
 export default defineAdapter<OneBot11EndpointConfig>({
   capabilities: ['inbound', 'outbound'],
   operations: ['recall'],
@@ -31,25 +21,5 @@ export default defineAdapter<OneBot11EndpointConfig>({
     outboundMedia: ['url', 'base64'],
     interactive: 'text',
   },
-  create(context) {
-    const config = resolveOneBot11Config(context.config);
-    // 注册到插件运行时状态（onebot11 endpoint list 的"运行中"数据源）
-    context.use(onebot11RuntimeStateToken).endpoints.set(config.id, {
-      id: config.id,
-      mode: config.connection,
-    });
-    if (config.connection === 'wss') {
-      return new OneBot11WssEndpoint({
-        id: context.id,
-        http: context.use(httpHostToken),
-        config,
-        probeLoginInfo: true,
-      });
-    }
-    return new OneBot11WsEndpoint({
-      id: context.id,
-      config,
-      probeLoginInfo: true,
-    });
-  },
+  createAdapter: context => new Onebot11Adapter(context),
 });

package/commands/onebot11/endpoint/definition.js

@@ -5,7 +5,6 @@
  */
 import { createEndpointCommands } from 'zhin.js/adapter';
 import { defineCommand } from 'zhin.js/command';
-import { onebot11RuntimeStateToken } from "../../../lib/onebot11-runtime-state.js";
 export const onebot11EndpointCommands = createEndpointCommands({
     adapterKey: 'onebot11',
     adapterDisplayName: 'OneBot 11',
@@ -14,7 +13,6 @@ export const onebot11EndpointCommands = createEndpointCommands({
         { key: 'path', description: 'reverse-wss 路径（connection: wss）', descriptionI18n: { en: "Reverse WebSocket path (connection: wss)" } },
         { key: 'access_token', env: true, description: 'OneBot access token' },
     ],
-    running: (use) => use(onebot11RuntimeStateToken).endpoints.values(),
     describeEntry: (entry) => {
         if (entry.url)
             return `url: ${String(entry.url)}`;

package/commands/onebot11/endpoint/definition.ts

@@ -4,7 +4,6 @@
  */
 import { createEndpointCommands } from 'zhin.js/adapter';
 import { defineCommand } from 'zhin.js/command';
-import { onebot11RuntimeStateToken } from '../../../src/onebot11-runtime-state.js';
 
 export const onebot11EndpointCommands = createEndpointCommands({
   adapterKey: 'onebot11',
@@ -14,7 +13,6 @@ export const onebot11EndpointCommands = createEndpointCommands({
     { key: 'path', description: 'reverse-wss 路径（connection: wss）', descriptionI18n: { en: "Reverse WebSocket path (connection: wss)" } },
     { key: 'access_token', env: true, description: 'OneBot access token' },
   ],
-  running: (use) => use(onebot11RuntimeStateToken).endpoints.values(),
   describeEntry: (entry) => {
     if (entry.url) return `url: ${String(entry.url)}`;
     if (entry.path) return `path: ${String(entry.path)}`;

package/lib/adapter.d.ts

@@ -0,0 +1,20 @@
+import { Adapter, type AdapterContext, type EndpointCreationContext } from 'zhin.js/adapter';
+import { type OneBot11EndpointConfig } from './protocol.js';
+import { OneBot11WsEndpoint } from './ws-endpoint.js';
+import { OneBot11WssEndpoint } from './wss-endpoint.js';
+import type { Onebot11ClientEventMap } from './client.js';
+export declare class Onebot11Adapter extends Adapter<OneBot11WsEndpoint | OneBot11WssEndpoint, OneBot11EndpointConfig, Onebot11ClientEventMap> {
+    #private;
+    constructor(context: AdapterContext<OneBot11EndpointConfig>);
+    get configurationIdentityFields(): readonly string[];
+    get configurationIdentityProbeFields(): readonly string[];
+    get configurationUpdateFields(): readonly string[];
+    protected validateConfiguration(config: OneBot11EndpointConfig): void;
+    protected identifyConfiguration(input: OneBot11EndpointConfig, signal: AbortSignal): Promise<string | undefined>;
+    protected createEndpoint(input: OneBot11EndpointConfig, execution: EndpointCreationContext): OneBot11WsEndpoint | OneBot11WssEndpoint;
+}
+declare module '@zhin.js/feature-kit' {
+    interface AdapterRegistry {
+        readonly onebot11: Onebot11Adapter;
+    }
+}

package/lib/adapter.js

@@ -0,0 +1,26 @@
+import { Adapter } from 'zhin.js/adapter';
+import { httpHostToken } from '@zhin.js/host-http';
+import { resolveOneBot11Config } from './protocol.js';
+import { OneBot11WsEndpoint } from './ws-endpoint.js';
+import { OneBot11WssEndpoint } from './wss-endpoint.js';
+import { probeOnebot11Identity } from './identity.js';
+export class Onebot11Adapter extends Adapter {
+    #context;
+    constructor(context) { super(); this.#context = context; }
+    get configurationIdentityFields() { return ['id']; }
+    get configurationIdentityProbeFields() { return ['connection', 'access_token', 'url']; }
+    get configurationUpdateFields() {
+        return ['connection', 'url', 'path', 'access_token', 'reconnect_interval', 'heartbeat_interval'];
+    }
+    validateConfiguration(config) { resolveOneBot11Config(config); }
+    async identifyConfiguration(input, signal) {
+        const config = resolveOneBot11Config(input);
+        return config.connection === 'ws' ? probeOnebot11Identity(config, signal) : undefined;
+    }
+    createEndpoint(input, execution) {
+        const config = resolveOneBot11Config(input);
+        return config.connection === 'wss'
+            ? new OneBot11WssEndpoint({ id: execution.canonicalId, signal: execution.signal, http: this.#context.use(httpHostToken), config, probeLoginInfo: true })
+            : new OneBot11WsEndpoint({ id: execution.canonicalId, signal: execution.signal, config, probeLoginInfo: true });
+    }
+}

package/lib/client.d.ts

@@ -6,15 +6,17 @@ export { OneBotV11Client as Onebot11Client } from '@imhelper/onebot-v11';
 export type Onebot11ApiCall = (action: string, params?: Record<string, unknown>) => Promise<OneBotV11Response>;
 type Onebot11ClientEvents = ImHelperEventMap<number, ImHelperOneBot11Event, EventMap<number>>;
 export type Onebot11ClientEventMap = ClientEventPayloads<Onebot11ClientEvents>;
-export declare function createOnebot11EndpointClient(config: ResolvedOneBot11Config, request: Onebot11ApiCall): OneBotV11Client;
-export declare function callOnebot11Client<T = unknown>(client: OneBotV11Client, action: string, params?: Record<string, unknown>): Promise<T | undefined>;
-export declare function forwardOnebot11ClientEvents(client: OneBotV11Client, receive: (name: string, payload: unknown) => void): () => void;
-declare module '@zhin.js/feature-kit' {
-    interface AdapterClientRegistry {
-        readonly onebot11: {
-            readonly client: OneBotV11Client;
-            readonly events: Onebot11ClientEventMap;
-        };
-    }
+export declare function onebot11ClientOptions(config: ResolvedOneBot11Config, request: Onebot11ApiCall): ConstructorParameters<typeof OneBotV11Client>[0];
+export interface Onebot11ClientRequest {
+    readonly client: OneBotV11Client;
+    readonly action: string;
+    readonly params?: Record<string, unknown>;
 }
-export declare const onebot11Client: import("@zhin.js/adapter").EndpointClientToken<OneBotV11Client, ClientEventPayloads<Onebot11ClientEvents>>;
+/** Native methods retain ProtocolError; framework ports preserve the underlying delivery evidence. */
+export declare function callOnebot11Client<T = unknown>(request: Onebot11ClientRequest): Promise<T | undefined>;
+/**
+ * Framework evidence follows the OB11 response envelope, including async/1 submission.
+ * @see https://github.com/botuniverse/onebot-11/blob/master/communication/http.md
+ */
+export declare function readOnebot11Response<T = unknown>(response: unknown): T | undefined;
+export declare function forwardOnebot11ClientEvents(client: OneBotV11Client, receive: (name: string, payload: unknown) => void): () => void;

package/lib/client.js

@@ -1,9 +1,9 @@
-import { OneBotV11Client, } from '@imhelper/onebot-v11';
-import { EventFactory } from 'imhelper';
-import { defineEndpointClient, forwardEndpointClientEvents, } from 'zhin.js/adapter';
+import { EndpointDeliveryError } from '@zhin.js/im-contract';
+import { ProtocolError, EventFactory } from 'imhelper';
+import { forwardEndpointClientEvents, } from 'zhin.js/adapter';
 export { OneBotV11Client as Onebot11Client } from '@imhelper/onebot-v11';
-export function createOnebot11EndpointClient(config, request) {
-    return new OneBotV11Client({
+export function onebot11ClientOptions(config, request) {
+    return {
         baseUrl: config.connection === 'ws'
             ? config.url.replace(/^ws(s?):/, 'http$1:')
             : 'http://localhost',
@@ -11,14 +11,38 @@ export function createOnebot11EndpointClient(config, request) {
         accessToken: config.access_token,
         receiveMode: 'manual',
         call: request,
-    });
+    };
 }
-export async function callOnebot11Client(client, action, params) {
-    const response = await client.call(action, params);
-    if (response.status !== 'ok') {
-        throw new Error(`OneBot 11 API ${action}: retcode=${response.retcode}${response.message ? ` ${response.message}` : ''}`);
+/** Native methods retain ProtocolError; framework ports preserve the underlying delivery evidence. */
+export async function callOnebot11Client(request) {
+    try {
+        return readOnebot11Response(await request.client.call(request.action, request.params));
     }
-    return response.data;
+    catch (error) {
+        if (error instanceof ProtocolError) {
+            if (error.cause instanceof EndpointDeliveryError)
+                throw error.cause;
+            if (error.response !== undefined)
+                readOnebot11Response(error.response);
+        }
+        throw error;
+    }
+}
+/**
+ * Framework evidence follows the OB11 response envelope, including async/1 submission.
+ * @see https://github.com/botuniverse/onebot-11/blob/master/communication/http.md
+ */
+export function readOnebot11Response(response) {
+    if (response && typeof response === 'object') {
+        const result = response;
+        if (result.status === 'ok' && result.retcode === 0)
+            return result.data;
+        if (result.status === 'failed' && Number.isSafeInteger(result.retcode) && result.retcode !== 0 && result.retcode !== 1) {
+            throw new EndpointDeliveryError('platform_rejected', `OneBot 11 API rejected: retcode=${result.retcode}${result.message ? ` ${result.message}` : ''}`, 'rejected');
+        }
+    }
+    // OB11 async/1 acknowledges submission, never the final outcome.
+    throw new EndpointDeliveryError('delivery_unconfirmed', 'OneBot 11 response did not confirm the action result', 'unknown');
 }
 const onebot11ClientEventNames = Object.freeze([
     ...EventFactory.getSupportedEventTypes(),
@@ -27,4 +51,3 @@ const onebot11ClientEventNames = Object.freeze([
 export function forwardOnebot11ClientEvents(client, receive) {
     return forwardEndpointClientEvents(client, onebot11ClientEventNames, receive);
 }
-export const onebot11Client = defineEndpointClient('onebot11');

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 createOnebot11ConsoleRpc(resources: AdapterConsoleResources, getConfig: () => unknown): PluginConsoleRpc;
+export declare function createOnebot11ConsoleRpc(_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 { onebot11RuntimeStateToken } from './onebot11-runtime-state.js';
 import { onebot11ConsoleSpec } from './console-spec.js';
-export function createOnebot11ConsoleRpc(resources, getConfig) {
-    const state = resources.use(onebot11RuntimeStateToken);
+export function createOnebot11ConsoleRpc(_resources, getConfig) {
     return createAdapterConsoleRpc({
         ...onebot11ConsoleSpec,
-        running: () => state.endpoints.values(),
         getConfig,
-    }, resources);
+    });
 }

package/lib/content-port.d.ts

@@ -1,4 +1,4 @@
-import type { EndpointContentPort } from 'zhin.js/adapter';
-type CallApi = (action: string, params?: Record<string, unknown>) => Promise<unknown>;
+import type { EndpointContentPort, PendingRpcRequest } from 'zhin.js/adapter';
+type CallApi = (request: PendingRpcRequest) => Promise<unknown>;
 export declare function createOneBot11ContentPort(callApi: CallApi): EndpointContentPort;
 export {};

package/lib/content-port.js

@@ -10,7 +10,7 @@ export function createOneBot11ContentPort(callApi) {
                         : Object.freeze({ status: 'resolved', reference, value: reference.media });
                 }
                 if (reference.kind === 'message') {
-                    const row = await callApi('get_msg', { message_id: reference.message.id });
+                    const row = await callApi({ action: 'get_msg', params: { message_id: reference.message.id }, signal: context.signal });
                     context.signal.throwIfAborted();
                     const segments = normalizeSegments(row.message ?? row.raw_message);
                     const sender = row.sender;
@@ -25,7 +25,7 @@ export function createOneBot11ContentPort(callApi) {
                     });
                     return Object.freeze({ status: 'resolved', reference, value });
                 }
-                const raw = await callApi('get_forward_msg', { id: reference.forwardId });
+                const raw = await callApi({ action: 'get_forward_msg', params: { id: reference.forwardId }, signal: context.signal });
                 context.signal.throwIfAborted();
                 const nodes = Array.isArray(raw.messages) ? raw.messages.slice(0, context.maxEntries) : [];
                 const value = Object.freeze(nodes.map((node) => {

package/lib/endpoint-management.d.ts

@@ -7,9 +7,9 @@
  * - group → {group_id:number, name: group_name ?? name}
  * - 群成员列表保持 OneBot11 原生形状，仅保证数组
  */
-import type { EndpointManagement } from 'zhin.js/adapter';
+import { type EndpointManagement, type PendingRpcRequest } from 'zhin.js/adapter';
 /** 管理面只依赖 endpoint 的 callApi（ws/wss 两种传输各自实现）。 */
 export interface OneBot11ManagementCaller {
-    callApi(action: string, params?: Record<string, unknown>): Promise<unknown>;
+    callApi(request: PendingRpcRequest): Promise<unknown>;
 }
 export declare function createOneBot11EndpointManagement(endpoint: OneBot11ManagementCaller): EndpointManagement;

package/lib/endpoint-management.js

@@ -1,7 +1,7 @@
 export function createOneBot11EndpointManagement(endpoint) {
     return Object.freeze({
-        async listFriends() {
-            const data = await endpoint.callApi('get_friend_list');
+        async listFriends(request = {}) {
+            const data = await endpoint.callApi({ action: 'get_friend_list', signal: request.signal });
             return toArray(data).map((value) => {
                 const friend = asRecord(value);
                 return {
@@ -11,8 +11,8 @@ export function createOneBot11EndpointManagement(endpoint) {
                 };
             });
         },
-        async listGroups() {
-            const data = await endpoint.callApi('get_group_list');
+        async listGroups(request = {}) {
+            const data = await endpoint.callApi({ action: 'get_group_list', signal: request.signal });
             return toArray(data).map((value) => {
                 const group = asRecord(value);
                 return {
@@ -21,10 +21,10 @@ export function createOneBot11EndpointManagement(endpoint) {
                 };
             });
         },
-        async listGroupMembers(groupId) {
-            const data = await endpoint.callApi('get_group_member_list', {
-                group_id: toNumberId(groupId, 'group_id'),
-            });
+        async listGroupMembers({ groupId, signal }) {
+            const data = await endpoint.callApi({ action: 'get_group_member_list', signal, params: {
+                    group_id: toNumberId(groupId, 'group_id'),
+                } });
             return toArray(data);
         },
     });

package/lib/identity.d.ts

@@ -0,0 +1,3 @@
+import { type OneBot11WsConfig } from './protocol.js';
+/** Separate read-only connection: never changes credentials or state of the running Endpoint. */
+export declare function probeOnebot11Identity(config: OneBot11WsConfig, signal: AbortSignal): Promise<string | undefined>;

package/lib/identity.js

@@ -0,0 +1,32 @@
+import WebSocket from 'ws';
+import { buildWsConnectOptions } from './protocol.js';
+import { createOneBot11Rpc } from './ws-transport.js';
+import { resolveOnebot11SelfId } from './self-id.js';
+/** Separate read-only connection: never changes credentials or state of the running Endpoint. */
+export async function probeOnebot11Identity(config, signal) {
+    signal.throwIfAborted();
+    const { url, headers } = buildWsConnectOptions(config);
+    const socket = new WebSocket(url, { headers });
+    const rpc = createOneBot11Rpc({ endpointId: config.id, signal, socket: () => socket, });
+    let rejectOpen = () => undefined;
+    const abort = () => { rejectOpen(signal.reason); rpc.disconnect(); socket.terminate(); };
+    signal.addEventListener('abort', abort, { once: true });
+    socket.on('message', data => rpc.receive(data, () => undefined));
+    socket.on('close', () => { rejectOpen(new Error('Identity connection closed')); rpc.disconnect(); });
+    try {
+        await new Promise((resolve, reject) => { rejectOpen = reject; socket.once('open', resolve); socket.on('error', reject); });
+        signal.throwIfAborted();
+        const response = await rpc.call({ action: 'get_login_info' });
+        signal.throwIfAborted();
+        if (response.status !== 'ok' || response.retcode !== 0)
+            throw new Error('OneBot11 identity lookup failed');
+        const data = response.data;
+        const id = resolveOnebot11SelfId(data && typeof data === 'object' && 'user_id' in data ? data.user_id : undefined);
+        return id === undefined ? undefined : `qq:${id}`;
+    }
+    finally {
+        signal.removeEventListener('abort', abort);
+        rpc.dispose();
+        socket.terminate();
+    }
+}

package/lib/index.d.ts

@@ -2,9 +2,10 @@ export { buildSendAction, buildWsConnectOptions, extractQuoteId, formatInboundCo
 export { OneBot11WsEndpoint, type OneBot11WsEndpointOptions, } from './ws-endpoint.js';
 export { OneBot11WssEndpoint, type OneBot11WssEndpointOptions, } from './wss-endpoint.js';
 export type { OneBot11WsSocket, OneBot11WsCreateOptions } from './ws-types.js';
-export { callOneBot11WsAction, decodeWsPayload, handleOneBot11WsMessage, rejectAllPending, } from './ws-transport.js';
+export { createOneBot11Rpc, type OneBot11Rpc, type OneBot11RpcOptions, decodeWsPayload, } from './ws-transport.js';
 export { verifyOneBotAccessToken } from './wss-auth.js';
-export { Onebot11Client, onebot11Client, type Onebot11ClientEventMap, } from './client.js';
+export { Onebot11Client, type Onebot11ClientEventMap, } from './client.js';
 export type { OneBotV11ActionUrlResolver, OneBotV11AdapterConfig as ImHelperOneBotV11AdapterConfig, OneBotV11Call, OneBotV11ClientConfig, OneBotV11Event as ImHelperOneBotV11Event, OneBotV11Response, } from '@imhelper/onebot-v11';
 export { ProtocolError } from '@imhelper/onebot-v11';
 export type { ProtocolErrorKind, ProtocolErrorOptions } from 'imhelper';
+export { Onebot11Adapter } from './adapter.js';

package/lib/index.js

@@ -1,7 +1,8 @@
 export { buildSendAction, buildWsConnectOptions, extractQuoteId, formatInboundContent, formatInboundMetadata, formatOutboundSegments, getChannelId, isMessageEvent, isOneBot11BotMentioned, mediaRefToOneBotFile, onebot11InboundConversation, resolveOneBot11Config, senderDisplayName, senderNickname, senderUserId, } from './protocol.js';
 export { OneBot11WsEndpoint, } from './ws-endpoint.js';
 export { OneBot11WssEndpoint, } from './wss-endpoint.js';
-export { callOneBot11WsAction, decodeWsPayload, handleOneBot11WsMessage, rejectAllPending, } from './ws-transport.js';
+export { createOneBot11Rpc, decodeWsPayload, } from './ws-transport.js';
 export { verifyOneBotAccessToken } from './wss-auth.js';
-export { Onebot11Client, onebot11Client, } from './client.js';
+export { Onebot11Client, } from './client.js';
 export { ProtocolError } from '@imhelper/onebot-v11';
+export { Onebot11Adapter } from './adapter.js';

package/lib/self-id.js

@@ -15,7 +15,7 @@ export function resolveOnebot11SelfId(value) {
 /** Best-effort `get_login_info`；失败返回 undefined 并交给调用方 debug，不抛错。 */
 export async function probeOnebot11SelfId(client, onError) {
     try {
-        const data = await callOnebot11Client(client, 'get_login_info');
+        const data = await callOnebot11Client({ client, action: 'get_login_info' });
         return resolveOnebot11SelfId(data?.user_id);
     }
     catch (error) {

package/lib/side-event-dispatch.d.ts

@@ -4,4 +4,11 @@ import type { OneBot11Event } from './protocol.js';
 export interface OneBot11SideEventCaller {
     callApi(action: string, params?: Record<string, unknown>): Promise<unknown>;
 }
-export declare function receiveOneBot11SideEvent(emit: EndpointEventEmitter, endpointKey: string, caller: OneBot11SideEventCaller, raw: OneBot11Event, logger: ReturnType<typeof getAdapterLogger>): void;
+/** Exact instance-owned dependencies for one canonical side-event projection. */
+export interface OneBot11SideEventContext {
+    readonly emit: EndpointEventEmitter;
+    readonly endpointKey: string;
+    readonly caller: OneBot11SideEventCaller;
+    readonly logger: ReturnType<typeof getAdapterLogger>;
+}
+export declare function receiveOneBot11SideEvent(raw: OneBot11Event, context: OneBot11SideEventContext): void;

package/lib/side-event-dispatch.js

@@ -1,6 +1,7 @@
 import { receiveOneBotLikeSideEvent } from '@zhin.js/core';
 import { formatCompact } from '@zhin.js/logger';
-export function receiveOneBot11SideEvent(emit, endpointKey, caller, raw, logger) {
+export function receiveOneBot11SideEvent(raw, context) {
+    const { emit, endpointKey, caller, logger } = context;
     if (!emit)
         return;
     const record = raw;

package/lib/ws-endpoint.d.ts

@@ -1,25 +1,18 @@
-import { ClientEndpoint, type EndpointControl, type EndpointManagement, type EndpointSendRequest, type EndpointTransportState } from 'zhin.js/adapter';
+import { endpointSpec, type Endpoint, type EndpointSpecification } from 'zhin.js/adapter';
 import type { CapabilityId } from 'zhin.js';
 import { type OneBot11WsConfig } from './protocol.js';
 import { type OneBot11WsCreateOptions, type OneBot11WsSocket } from './ws-types.js';
-import { type Onebot11Client } from './client.js';
+import { Onebot11Client } from './client.js';
 export interface OneBot11WsEndpointOptions {
+    readonly signal?: AbortSignal;
     readonly id: CapabilityId;
     /** 连接后 best-effort 调用 get_login_info 上报账号（Adapter 工厂开启；默认关闭以免占用首个 echo）。 */
     readonly probeLoginInfo?: boolean;
     readonly config: OneBot11WsConfig;
     readonly createWebSocket?: (url: string, options: OneBot11WsCreateOptions) => OneBot11WsSocket;
 }
-export declare class OneBot11WsEndpoint extends ClientEndpoint<Onebot11Client> {
+export declare class OneBot11WsEndpoint extends Onebot11Client implements Endpoint {
     #private;
-    readonly client: Onebot11Client;
-    readonly management: EndpointManagement;
-    readonly control: EndpointControl;
-    readonly content: import("@zhin.js/adapter").EndpointContentPort;
+    readonly [endpointSpec]: EndpointSpecification;
     constructor(options: OneBot11WsEndpointOptions);
-    get transportState(): EndpointTransportState;
-    start(): Promise<void>;
-    stop(): Promise<void>;
-    send({ conversation, payload }: EndpointSendRequest): Promise<string>;
-    recallMessage(messageId: string): Promise<void>;
 }