@zhin.js/adapter-onebot12 1.1.17 → 1.1.19

package/src/protocol.ts

@@ -1,15 +1,18 @@
+import { readOnebot12Response } from './response.js';
 /**
  * OneBot 12 protocol helpers (no legacy Adapter/Endpoint / segment-mapper).
  * Canonicalization is owned by gateway/core before endpoint.send.
  * Spec: https://12.onebot.dev/
  */
-import { isMediaRef, type MediaRef, type ConversationRef } from '@zhin.js/im-contract';
+import { EndpointDeliveryError, isMediaRef, type MediaRef, type ConversationRef } from '@zhin.js/im-contract';
 import { formatCompact, getLogger } from '@zhin.js/logger';
 
 const logger = getLogger('onebot12');
 
 /** One endpoint config after AdapterIndex expands `plugins.<instanceKey>.endpoints`. */
 export interface OneBot12EndpointConfig {
+  readonly platform: string;
+  readonly userId: string;
   readonly connection?: 'ws' | 'webhook' | 'wss';
   readonly id: string;
   readonly access_token?: string;
@@ -21,6 +24,8 @@ export interface OneBot12EndpointConfig {
 }
 
 export interface OneBot12ConfigBase {
+  readonly platform: string;
+  readonly userId: string;
   readonly context: 'onebot12';
   readonly id: string;
   readonly access_token?: string;
@@ -78,10 +83,10 @@ export interface OneBot12Segment {
 }
 
 export interface OneBot12ActionRequest {
+  readonly self: OneBot12Self;
   action: string;
   params: Record<string, unknown>;
   echo?: string;
-  self?: OneBot12Self;
 }
 
 export interface OneBot12ActionResponse {
@@ -93,6 +98,8 @@ export interface OneBot12ActionResponse {
 }
 
 export interface OneBot12HttpOptions {
+  readonly self: OneBot12Self;
+  readonly signal?: AbortSignal;
   readonly url: string;
   readonly access_token?: string;
 }
@@ -105,12 +112,14 @@ export interface OneBot12WireSegment {
 export function resolveOneBot12Config(config: OneBot12EndpointConfig): ResolvedOneBot12Config {
   const connection = config.connection ?? 'ws';
   const id = requiredEndpointField(config.id, 'id');
+  const platform = requiredEndpointField(config.platform, 'platform');
+  const userId = requiredEndpointField(config.userId, 'userId');
   const access_token = optionalEndpointField(config.access_token);
 
   if (connection === 'ws') {
     const url = requiredEndpointField(config.url, 'url');
     return {
-      context: 'onebot12',
+      context: 'onebot12', platform, userId,
       connection: 'ws',
       id,
       access_token,
@@ -124,7 +133,7 @@ export function resolveOneBot12Config(config: OneBot12EndpointConfig): ResolvedO
     const path = requiredEndpointField(config.path, 'path');
     const api_url = requiredEndpointField(config.api_url, 'api_url');
     return {
-      context: 'onebot12',
+      context: 'onebot12', platform, userId,
       connection: 'webhook',
       id,
       access_token,
@@ -136,7 +145,7 @@ export function resolveOneBot12Config(config: OneBot12EndpointConfig): ResolvedO
   if (connection === 'wss') {
     const path = requiredEndpointField(config.path, 'path');
     return {
-      context: 'onebot12',
+      context: 'onebot12', platform, userId,
       connection: 'wss',
       id,
       access_token,
@@ -150,7 +159,7 @@ export function resolveOneBot12Config(config: OneBot12EndpointConfig): ResolvedO
 
 function requiredEndpointField(
   value: unknown,
-  field: 'id' | 'url' | 'path' | 'api_url',
+  field: 'id' | 'url' | 'path' | 'api_url' | 'platform' | 'userId',
 ): string {
   const resolved = optionalEndpointField(value);
   if (!resolved) {
@@ -398,11 +407,12 @@ export type OneBot12CallAction = (
 ) => Promise<unknown>;
 
 /** upload_file 文件名：优先段 data.name/filename，URL/路径取 basename，再按 mime 给默认名。 */
-function oneBot12UploadName(
-  segmentType: string,
-  data: Record<string, unknown>,
-  media: MediaRef,
-): string {
+export interface OneBot12MediaSource {
+  readonly type: string;
+  readonly data: Readonly<Record<string, unknown>>;
+  readonly media: MediaRef;
+}
+function oneBot12UploadName({ type, data, media }: OneBot12MediaSource): string {
   const named = data.name ?? data.filename;
   if (typeof named === 'string' && named) return named;
   if (media.kind === 'url') {
@@ -418,16 +428,13 @@ function oneBot12UploadName(
     if (base) return base;
   }
   const ext = media.mime_type?.split('/')[1]?.split(';')[0];
-  return `${segmentType}.${ext || 'bin'}`;
+  return `${type}.${ext || 'bin'}`;
 }
 
 /** canonical MediaRef → OB12 `upload_file` 动作参数（spec: type url/path/data）。 */
-export function mediaRefToOneBot12UploadParams(
-  segmentType: string,
-  data: Record<string, unknown>,
-  media: MediaRef,
-): Record<string, unknown> | undefined {
-  const name = oneBot12UploadName(segmentType, data, media);
+export function mediaRefToOneBot12UploadParams(source: OneBot12MediaSource): Record<string, unknown> | undefined {
+  const { media } = source;
+  const name = oneBot12UploadName(source);
   if (media.kind === 'url') return { type: 'url', name, url: media.value };
   if (media.kind === 'path') {
     const path = media.value.startsWith('file://') ? media.value.slice('file://'.length) : media.value;
@@ -444,8 +451,7 @@ export function mediaRefToOneBot12UploadParams(
 
 async function uploadOneMediaSegment(
   item: unknown,
-  callAction: OneBot12CallAction,
-  onUploadFailed?: (error: unknown) => void,
+  request: OneBot12MediaUpload,
 ): Promise<unknown> {
   if (!item || typeof item !== 'object' || Array.isArray(item)) return item;
   const segment = item as OneBot12WireSegment;
@@ -460,17 +466,18 @@ async function uploadOneMediaSegment(
   if (media.kind === 'file') {
     return { type: segment.type, data: { ...oneBot12MediaExtra(data), file_id: media.value } };
   }
-  const params = mediaRefToOneBot12UploadParams(segment.type, data, media);
+  const params = mediaRefToOneBot12UploadParams({ type: segment.type, data, media });
   if (!params) return item;
   try {
-    const result = await callAction('upload_file', params) as { file_id?: unknown } | undefined;
+    const result = await request.callAction('upload_file', params) as { file_id?: unknown } | undefined;
     if (result && typeof result.file_id === 'string' && result.file_id) {
       return { type: segment.type, data: { ...oneBot12MediaExtra(data), file_id: result.file_id } };
     }
     throw new Error('upload_file 响应缺少 file_id');
   } catch (error) {
+    if (request.signal?.aborted) throw error;
     // 上传失败降级：保留原段，由 formatOutboundSegments 走扩展字段（url/data/path）
-    onUploadFailed?.(error);
+    request.onUploadFailed?.(error);
     return item;
   }
 }
@@ -481,15 +488,17 @@ async function uploadOneMediaSegment(
  * {@link formatOutboundSegments} 编码；kind=file 的 MediaRef 直接按 file_id 复投。
  * 上传失败保留原段（降级扩展字段透传）并回调 onUploadFailed。
  */
-export async function uploadOneBot12MediaSegments(
-  payload: unknown,
-  callAction: OneBot12CallAction,
-  onUploadFailed?: (error: unknown) => void,
-): Promise<unknown> {
-  if (Array.isArray(payload)) {
-    return Promise.all(payload.map((item) => uploadOneMediaSegment(item, callAction, onUploadFailed)));
+export interface OneBot12MediaUpload {
+  readonly payload: unknown;
+  readonly callAction: OneBot12CallAction;
+  readonly signal?: AbortSignal;
+  readonly onUploadFailed?: (error: unknown) => void;
+}
+export async function uploadOneBot12MediaSegments(request: OneBot12MediaUpload): Promise<unknown> {
+  if (Array.isArray(request.payload)) {
+    return Promise.all(request.payload.map(item => uploadOneMediaSegment(item, request)));
   }
-  return uploadOneMediaSegment(payload, callAction, onUploadFailed);
+  return uploadOneMediaSegment(request.payload, request);
 }
 
 /**
@@ -519,40 +528,34 @@ export function buildSendMessageParams(
  * 向 OneBot 实现发送动作请求（HTTP POST），返回动作响应。
  * 供 webhook 出站与纯协议测试使用；WS 路径走 WebSocket echo 请求。
  */
-export async function callOneBot12Action(
-  options: OneBot12HttpOptions,
-  action: string,
-  params: Record<string, unknown> = {},
-  echo?: string,
-): Promise<OneBot12ActionResponse> {
+export interface OneBot12HttpRequest extends OneBot12HttpOptions {
+  readonly action: string;
+  readonly params?: Record<string, unknown>;
+  readonly echo?: string;
+}
+/** HTTP owns submission evidence and cancellation for both SDK and framework callers. */
+export async function callOneBot12Action(request: OneBot12HttpRequest): Promise<OneBot12ActionResponse> {
+  if (request.signal?.aborted) throw new EndpointDeliveryError('endpoint_inactive', 'Endpoint operation cancelled', 'not_sent');
   const headers: Record<string, string> = { 'Content-Type': 'application/json' };
-  if (options.access_token) {
-    headers.Authorization = `Bearer ${options.access_token}`;
-  }
-  const body: OneBot12ActionRequest = { action, params };
-  if (echo) body.echo = echo;
-
-  const res = await fetch(options.url, {
-    method: 'POST',
-    headers,
-    body: JSON.stringify(body),
-    signal: AbortSignal.timeout(30_000),
-  });
-
-  const text = await res.text();
-  if (res.status === 401) throw new Error(`OneBot12 鉴权失败: ${text}`);
-  if (res.status !== 200) throw new Error(`OneBot12 HTTP ${res.status}: ${text}`);
-
-  let data: OneBot12ActionResponse;
+  if (request.access_token) headers.Authorization = `Bearer ${request.access_token}`;
+  const body: OneBot12ActionRequest = { action: request.action, params: request.params ?? {}, self: request.self,
+    ...(request.echo !== undefined ? { echo: request.echo } : {}) };
   try {
-    data = JSON.parse(text) as OneBot12ActionResponse;
-  } catch {
-    throw new Error(`OneBot12 无效响应: ${text.slice(0, 200)}`);
-  }
-  if (data.status === 'failed' && data.retcode !== 0) {
-    throw new Error(`OneBot12 动作失败 retcode=${data.retcode}: ${data.message}`);
+    const response = await fetch(request.url, { method: 'POST', headers, body: JSON.stringify(body),
+      signal: request.signal ? AbortSignal.any([request.signal, AbortSignal.timeout(30_000)]) : AbortSignal.timeout(30_000) });
+    const text = await response.text();
+    if (response.status === 401) throw new EndpointDeliveryError('platform_rejected', `OneBot12 鉴权失败: ${text}`, 'rejected');
+    if (response.status !== 200) throw new EndpointDeliveryError('endpoint_http_failed', `OneBot12 HTTP ${response.status}: ${text}`, 'unknown');
+    let data: OneBot12ActionResponse;
+    try { data = JSON.parse(text) as OneBot12ActionResponse; }
+    catch { throw new EndpointDeliveryError('delivery_unconfirmed', `OneBot12 无效响应: ${text.slice(0, 200)}`, 'unknown'); }
+    readOnebot12Response(data);
+    return data;
+  } catch (cause) {
+    if (cause instanceof EndpointDeliveryError) throw cause;
+    throw new EndpointDeliveryError(request.signal?.aborted ? 'endpoint_inactive' : 'endpoint_transport_failed',
+      cause instanceof Error ? cause.message : String(cause), 'unknown', { cause });
   }
-  return data;
 }
 
 /** Build WS connect URL + headers (access_token via Bearer + query). */
@@ -573,3 +576,9 @@ export function buildWsConnectOptions(config: OneBot12WsConfig): {
   safeUrl.searchParams.delete('access_token');
   return { url: connectUrl, headers, safeUrl: safeUrl.toString() };
 }
+
+/** Route only the explicitly selected bot; service-wide frames carry no account authority. */
+export function matchesOneBot12Self(config: Pick<OneBot12ConfigBase, 'platform' | 'userId'>,
+  event: OneBot12Event): event is OneBot12Event & { readonly self: OneBot12Self } {
+  return event.self?.platform === config.platform && event.self?.user_id === config.userId;
+}

package/src/response.ts

@@ -0,0 +1,19 @@
+import { EndpointDeliveryError } from '@zhin.js/im-contract';
+import type { OneBotV12Response } from '@imhelper/onebot-v12';
+
+/**
+ * One classifier for native SDK, HTTP and WS results.
+ * @see https://12.onebot.dev/connect/data-protocol/action-response/
+ */
+export function readOnebot12Response<T = unknown>(response: unknown): T | undefined {
+  if (response && typeof response === 'object') {
+    const result = response as Partial<OneBotV12Response>;
+    if (result.status === 'ok' && result.retcode === 0) return result.data as T | undefined;
+    if (result.status === 'failed' && typeof result.retcode === 'number' && Number.isSafeInteger(result.retcode) && result.retcode >= 10000 && result.retcode <= 99999) {
+      throw new EndpointDeliveryError('platform_rejected',
+        `OneBot 12 API rejected: retcode=${result.retcode}${result.message ? ` ${result.message}` : ''}`, 'rejected');
+    }
+  }
+  // OB12 defines only ok/0 or failed with an error code; inconsistent envelopes prove neither result.
+  throw new EndpointDeliveryError('delivery_unconfirmed', 'OneBot 12 response did not confirm the action result', 'unknown');
+}

package/src/side-event-dispatch.ts

@@ -7,13 +7,15 @@ export interface OneBot12SideEventCaller {
   callApi(action: string, params?: Record<string, unknown>): Promise<unknown>;
 }
 
-export function receiveOneBot12SideEvent(
-  emit: EndpointEventEmitter,
-  endpointKey: string,
-  caller: OneBot12SideEventCaller,
-  raw: OneBot12Event,
-  logger: ReturnType<typeof getAdapterLogger>,
-): void {
+/** Exact instance-owned dependencies for one canonical side-event projection. */
+export interface OneBot12SideEventContext {
+  readonly emit: EndpointEventEmitter;
+  readonly endpointKey: string;
+  readonly caller: OneBot12SideEventCaller;
+  readonly logger: ReturnType<typeof getAdapterLogger>;
+}
+export function receiveOneBot12SideEvent(raw: OneBot12Event, context: OneBot12SideEventContext): void {
+  const { emit, endpointKey, caller, logger } = context;
   if (!emit) return;
   const record = raw as Record<string, unknown>;
   const eventType = String(record.type ?? record.post_type ?? '');

package/src/webhook.ts

@@ -1,13 +1,16 @@
+import { acceptHttpIngress } from 'imhelper';
 /**
  * OneBot12 HTTP webhook endpoint — POST inbound + api_url outbound.
  */
 import type { IncomingMessage, ServerResponse } from 'node:http';
 import {
-  ClientEndpoint,
+  createEndpointSpecification, endpointSpec,
+  type Endpoint, type EndpointSpecification,
   createRecallEndpointControl,
   type EndpointControl,
   type EndpointManagement,
   type EndpointSendRequest,
+  type PendingRpcRequest,
 } from 'zhin.js/adapter';
 import type { HttpHost, HttpRouteRegistration } from '@zhin.js/host-http';
 import { formatCompact, getLogger } from '@zhin.js/logger';
@@ -15,6 +18,7 @@ import type { CapabilityId } from 'zhin.js';
 import { createOneBot12EndpointManagement } from './endpoint-management.js';
 import {
   buildSendMessageParams,
+  matchesOneBot12Self,
   callOneBot12Action,
   formatInboundContent,
   formatOutboundSegments,
@@ -29,46 +33,55 @@ import {
 } from './protocol.js';
 import { receiveOneBot12SideEvent } from './side-event-dispatch.js';
 import { createOneBot12ContentPort } from './content-port.js';
-import { callOnebot12Client, createOnebot12EndpointClient, forwardOnebot12ClientEvents, type Onebot12Client } from './client.js';
+import { callOnebot12Client, readOnebot12Response, onebot12ClientOptions, forwardOnebot12ClientEvents, Onebot12Client } from './client.js';
 import { verifyOneBotAccessToken } from './wss-auth.js';
 
 const logger = getLogger('onebot12');
 
 export interface OneBot12WebhookEndpointOptions {
+  readonly signal?: AbortSignal;
   readonly id: CapabilityId;
   readonly http: HttpHost;
   readonly config: OneBot12WebhookConfig;
   readonly callAction?: typeof callOneBot12Action;
 }
 
-export class OneBot12WebhookEndpoint extends ClientEndpoint<Onebot12Client> {
-  readonly client: Onebot12Client;
+export class OneBot12WebhookEndpoint extends Onebot12Client implements Endpoint {
+  readonly [endpointSpec]: EndpointSpecification;
+  #open = false;
   readonly #options: OneBot12WebhookEndpointOptions;
-  readonly management: EndpointManagement;
-  readonly control: EndpointControl = createRecallEndpointControl((id) => this.recallMessage(id));
-  readonly content;
+  readonly #management: EndpointManagement;
+  readonly #control: EndpointControl = createRecallEndpointControl((id, signal?: AbortSignal) => this.#recallMessage(id, signal));
+  readonly #content;
+  readonly #releaseClientEvents: () => void;
   readonly #callAction: typeof callOneBot12Action;
   #routeReleases: HttpRouteRegistration[] = [];
   #started = false;
 
   constructor(options: OneBot12WebhookEndpointOptions) {
-    super();
+    super(onebot12ClientOptions(options.config, (action, params) => this.#callApi({ action, params })));
     this.#options = options;
     this.#callAction = options.callAction ?? callOneBot12Action;
-    this.client = createOnebot12EndpointClient(options.config, (action, params) => this.#callApi(action, params));
-    const callApi = (action: string, params?: Record<string, unknown>) => callOnebot12Client(this.client, action, params);
-    this.management = createOneBot12EndpointManagement({ callApi });
-    this.content = createOneBot12ContentPort(callApi);
-    this.bindClientEvents(
-      (receive) => forwardOnebot12ClientEvents(this.client, receive),
-      (name, payload) => {
+    const callApi = (request: PendingRpcRequest) => this.#callApi(request).then(readOnebot12Response);
+    this.#management = createOneBot12EndpointManagement({ callApi });
+    this.#content = createOneBot12ContentPort(callApi);
+    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, content: this.#content,
+    });
+    this.#releaseClientEvents = forwardOnebot12ClientEvents(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 as OneBot12Event);
-      },
-      (_name, error) => this.#warnPlatformEvent(error),
-    );
+      }).catch(error => this.#warnPlatformEvent(error));
+    });
   }
 
-  async start(): Promise<void> {
+  async #start(): Promise<void> {
     if (this.#started) return;
     this.#started = true;
     if (!this.#options.config.access_token) {
@@ -89,28 +102,26 @@ export class OneBot12WebhookEndpoint extends ClientEndpoint<Onebot12Client> {
     }));
   }
 
-  async stop(): Promise<void> {
-    this.close();
+  async #stop(): Promise<void> {
+    this.#open = false;
     for (const release of this.#routeReleases.splice(0)) release();
     this.#started = false;
+    this.#releaseClientEvents();
     logger.debug(formatCompact({ op: 'disconnect', endpoint: this.#options.config.id }));
   }
 
-  async send({ conversation, payload }: EndpointSendRequest): Promise<string> {
-    const materialized = await uploadOneBot12MediaSegments(
-      payload,
-      (action, params) => callOnebot12Client(this.client, action, params),
-      (error) => {
-        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 }: EndpointSendRequest): Promise<string> {
+    const materialized = await uploadOneBot12MediaSegments({
+      payload, signal,
+      callAction: (action, params) => this.#callApi({ action, params, signal }).then(readOnebot12Response),
+      onUploadFailed: error => {
+        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<{ message_id?: string }>(this.client, 'send_message', params);
+    const data = readOnebot12Response<{ message_id?: string }>(await this.#callApi({ action: 'send_message', params, signal }));
     const messageId = data?.message_id ?? '';
     logger.debug(formatCompact({
       op: 'onebot12_send',
@@ -122,38 +133,38 @@ export class OneBot12WebhookEndpoint extends ClientEndpoint<Onebot12Client> {
     return messageId;
   }
 
-  async recallMessage(messageId: string): Promise<void> {
+  async #recallMessage(messageId: string, signal?: AbortSignal): Promise<void> {
     if (!messageId) return;
-    await callOnebot12Client(this.client, 'delete_message', { message_id: messageId });
+    await this.#callApi({ action: 'delete_message', params: { message_id: messageId }, signal }).then(readOnebot12Response);
   }
 
-  async #callApi(
-    action: string,
-    params: Record<string, unknown> = {},
-  ): Promise<import('@imhelper/onebot-v12').OneBotV12Response> {
-    return this.#callAction(
-      { url: this.#options.config.api_url, access_token: this.#options.config.access_token },
-      action,
-      params,
-    );
+  async #callApi(request: PendingRpcRequest): Promise<import('@imhelper/onebot-v12').OneBotV12Response> {
+    const epoch = this.#options.signal;
+    const signal = epoch && request.signal ? AbortSignal.any([epoch, request.signal]) : epoch ?? request.signal;
+    return this.#callAction({ url: this.#options.config.api_url, access_token: this.#options.config.access_token,
+      self: { platform: this.#options.config.platform, user_id: this.#options.config.userId },
+      action: request.action, params: request.params, signal });
   }
 
   #admitRaw(ev: OneBot12Event): void {
+    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,
-        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: 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,
@@ -202,12 +213,16 @@ export class OneBot12WebhookEndpoint extends ClientEndpoint<Onebot12Client> {
         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<OneBot12Event>(request, response, event => {
+        if (!matchesOneBot12Self(this.#options.config, event)) return;
+        void this[endpointSpec].events.run(() => this.ingest(event as Parameters<Onebot12Client['ingest']>[0]))
+          .catch(error => this.#warnPlatformEvent(error));
+      });
     } catch (error) {
       logger.error('OneBot12 webhook error:', error);
       if (!response.headersSent) {