@zhin.js/adapter-napcat 3.0.2 → 5.0.0

package/lib/src/segment-mapper.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"segment-mapper.js","sourceRoot":"","sources":["../../src/segment-mapper.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC"}

package/lib/src/types.js

@@ -1,6 +0,0 @@
-/**
- * NapCat 适配器类型定义
- * 覆盖 OneBot11 标准 + go-cqhttp 扩展 + NapCat 独有 API
- */
-export {};
-//# sourceMappingURL=types.js.map

package/lib/src/types.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAAA;;;GAGG"}

package/plugin.yml

@@ -1,3 +0,0 @@
-name: adapter-napcat
-description: NapCatQQ 适配器：OneBot11 + go-cqhttp 扩展 + NapCat 独有 API（戳一戳、表情回应、AI语音、群文件、精华消息、群公告等）
-version: 0.1.13

package/src/adapter.ts

@@ -1,109 +0,0 @@
-/**
- * NapCat 适配器：支持正向 WS / 反向 WS / HTTP
- */
-import { formatCompact, Adapter, Plugin, OUTBOUND_RICH_SEGMENT_POLICY_IM_FULL, ONEBOT_KEYBOARD_AI_OUTBOUND_EXTENSION } from 'zhin.js';
-import type { Router } from '@zhin.js/host-router';
-import { NapCatWsClient } from './endpoint-ws-client.js';
-import { NapCatWsServer } from './endpoint-ws-server.js';
-import { NapCatHttpEndpoint } from './endpoint-http.js';
-import type { NapCatEndpointConfig, NapCatWsClientConfig, NapCatWsServerConfig, NapCatHttpConfig } from './types.js';
-
-export type NapCatEndpoint = NapCatWsClient | NapCatWsServer | NapCatHttpEndpoint;
-
-export class NapCatAdapter extends Adapter<NapCatEndpoint> {
-  static override readonly capabilities = ['inbound', 'outbound'] as const;
-  static override outboundRichSegmentPolicy = OUTBOUND_RICH_SEGMENT_POLICY_IM_FULL;
-  static override interactivePolicy = 'text' as const;
-  static override aiOutboundCapabilities = {
-    mentions: true,
-    richSegments: ['qrcode', 'html', 'markdown', 'tts'],
-    interactive: 'text' as const,
-  };
-  static override aiOutboundExtensions = [ONEBOT_KEYBOARD_AI_OUTBOUND_EXTENSION];
-
-  #router?: Router;
-
-  constructor(plugin: Plugin) {
-    super(plugin, 'napcat', []);
-  }
-
-  createEndpoint(config: NapCatEndpointConfig): NapCatEndpoint {
-    const connection = config.connection ?? 'ws';
-    switch (connection) {
-      case 'ws':
-        return new NapCatWsClient(this, config as NapCatWsClientConfig);
-      case 'wss':
-        if (!this.#router) throw new Error('NapCat connection: wss requires router. Enable @zhin.js/host-router first.');
-        return new NapCatWsServer(this, this.#router, config as NapCatWsServerConfig);
-      case 'http':
-        if (!this.#router) throw new Error('NapCat connection: http requires router. Enable @zhin.js/host-router first.');
-        return new NapCatHttpEndpoint(this, this.#router, config as NapCatHttpConfig);
-      default:
-        throw new Error(`Unknown NapCat connection: ${connection}`);
-    }
-  }
-
-  // ── 群管理接口（ISceneManagement 适配）──────────────────────────
-
-  async removeMember(endpointId: string, sceneId: string, userId: string) {
-    const endpoint = this.endpoints.get(endpointId);
-    if (!endpoint) throw new Error(`Endpoint ${endpointId} not found`);
-    return endpoint.kickMember(Number(sceneId), Number(userId));
-  }
-
-  async muteMember(endpointId: string, sceneId: string, userId: string, duration = 600) {
-    const endpoint = this.endpoints.get(endpointId);
-    if (!endpoint) throw new Error(`Endpoint ${endpointId} not found`);
-    return endpoint.muteMember(Number(sceneId), Number(userId), duration);
-  }
-
-  async setSceneMuted(endpointId: string, sceneId: string, enable = true) {
-    const endpoint = this.endpoints.get(endpointId);
-    if (!endpoint) throw new Error(`Endpoint ${endpointId} not found`);
-    return endpoint.muteAll(Number(sceneId), enable);
-  }
-
-  async setModerator(endpointId: string, sceneId: string, userId: string, enable = true) {
-    const endpoint = this.endpoints.get(endpointId);
-    if (!endpoint) throw new Error(`Endpoint ${endpointId} not found`);
-    return endpoint.setAdmin(Number(sceneId), Number(userId), enable);
-  }
-
-  async setMemberNickname(endpointId: string, sceneId: string, userId: string, nickname: string) {
-    const endpoint = this.endpoints.get(endpointId);
-    if (!endpoint) throw new Error(`Endpoint ${endpointId} not found`);
-    return endpoint.setCard(Number(sceneId), Number(userId), nickname);
-  }
-
-  async renameScene(endpointId: string, sceneId: string, name: string) {
-    const endpoint = this.endpoints.get(endpointId);
-    if (!endpoint) throw new Error(`Endpoint ${endpointId} not found`);
-    return endpoint.setGroupName(Number(sceneId), name);
-  }
-
-  async listMembers(endpointId: string, sceneId: string) {
-    const endpoint = this.endpoints.get(endpointId);
-    if (!endpoint) throw new Error(`Endpoint ${endpointId} not found`);
-    const members = await endpoint.getMemberList(Number(sceneId));
-    return {
-      members: members.map((m: any) => ({
-        user_id: m.user_id, nickname: m.nickname, card: m.card, role: m.role, title: m.title,
-      })),
-      count: members.length,
-    };
-  }
-
-  async getSceneInfo(endpointId: string, sceneId: string) {
-    const endpoint = this.endpoints.get(endpointId);
-    if (!endpoint) throw new Error(`Endpoint ${endpointId} not found`);
-    return endpoint.getGroupInfo(Number(sceneId));
-  }
-
-  async start(): Promise<void> {
-    this.#router = (this.plugin.inject as (key: string) => Router | undefined)('router');
-    (this.plugin.useContext as (key: string, fn: (router: Router) => void) => void)('router', (router: Router) => {
-      this.#router = router;
-    });
-    await super.start();
-  }
-}

package/src/agent-prompt.ts

@@ -1,115 +0,0 @@
-import type {
-  AgentPromptBuildContext,
-  AgentPromptContributor,
-  AgentPromptSection,
-  DeferredToolCatalogItem,
-} from 'zhin.js';
-import { filterTools, type AgentTool } from 'zhin.js/ai';
-
-function isNapCatDelegatedTask(query: string, goal: string): boolean {
-  const text = `${query} ${goal}`;
-  if (/\bnapcat\b|napcat_|mcp_napcat/i.test(text)) return true;
-  if (/戳一戳|poke|表情回应|emoji.*reaction/i.test(text)) return true;
-  if (/精华消息|essence|群公告|group.*notice/i.test(text)) return true;
-  if (/AI语音|ai.*record|tts|文字转语音/i.test(text)) return true;
-  if (/群文件|upload.*file|群签到|group.*sign/i.test(text)) return true;
-  if (/合并转发|forward.*msg|转发消息/i.test(text)) return true;
-  if (/点赞/.test(text) && /qq|好友|\d{5,}/i.test(text)) return true;
-  return false;
-}
-
-function selectNapCatDeferredTools(
-  query: string,
-  goal: string,
-  deferredCatalog: DeferredToolCatalogItem[],
-  maxTools: number,
-): DeferredToolCatalogItem[] {
-  const pool = deferredCatalog.filter(
-    t => !t.name.startsWith('mcp_filesystem') && !t.name.startsWith('mcp_memory_'),
-  );
-  const napcatTools = pool.filter(t => t.name.startsWith('napcat_'));
-  const pinned: DeferredToolCatalogItem[] = [];
-  const preferOrder = [
-    'napcat_send_poke',
-    'napcat_set_emoji_reaction',
-    'napcat_send_like',
-    'napcat_set_essence_msg',
-    'napcat_send_group_notice',
-    'napcat_ai_tts',
-  ];
-  for (const name of preferOrder) {
-    const t = napcatTools.find(x => x.name === name);
-    if (t) pinned.push(t);
-  }
-  for (const t of napcatTools) {
-    if (pinned.length >= maxTools) break;
-    if (!pinned.some(p => p.name === t.name)) pinned.push(t);
-  }
-
-  const extra = filterTools(query, pool as AgentTool[], { maxTools, minScore: 0.08 })
-    .map((t) => ({ name: t.name, description: t.description }))
-    .filter(t => !pinned.some(p => p.name === t.name));
-
-  const merged: DeferredToolCatalogItem[] = [...pinned];
-  for (const t of extra) {
-    if (merged.length >= maxTools) break;
-    merged.push(t);
-  }
-  return merged.slice(0, maxTools);
-}
-
-const ORCHESTRATOR_NAPCAT = [
-  'On napcat/QQ: use run_deferred_task with tool_query "napcat_send_poke" or "napcat_set_emoji_reaction".',
-  'NapCat supports: poke, emoji reaction, forward msg, essence, group notice, AI TTS, OCR, group files.',
-  'Skip tool_search when the user clearly asks for QQ-specific features like poke, reaction, or group management.',
-].join('\n');
-
-const WORKER_NAPCAT = [
-  '- Use `napcat_send_poke` for poke/戳一戳.',
-  '- Use `napcat_set_emoji_reaction` for emoji reaction/表情回应.',
-  '- Use `napcat_send_like` for friend like/点赞.',
-  '- Use `napcat_ai_tts` for AI voice/AI语音.',
-  '- Use `napcat_set_essence_msg` / `napcat_delete_essence_msg` for essence messages.',
-  '- Use `napcat_send_group_notice` for group announcements.',
-  '- Do NOT use mcp_filesystem_* or explore node_modules for QQ tasks.',
-].join('\n');
-
-export function createNapCatAgentPromptContributor(): AgentPromptContributor {
-  return {
-    platform: 'napcat',
-
-    async buildSections(ctx: AgentPromptBuildContext): Promise<AgentPromptSection[] | null> {
-      if (ctx.slot === 'orchestrator') {
-        return [{
-          id: 'platform.napcat.orchestrator',
-          title: '## napcat / QQ',
-          body: ORCHESTRATOR_NAPCAT,
-          priority: 50,
-        }];
-      }
-      if (ctx.slot === 'deferred_worker') {
-        const query = ctx.deferred?.toolQuery ?? ctx.deferred?.goal ?? '';
-        const goal = ctx.deferred?.goal ?? '';
-        if (!isNapCatDelegatedTask(query, goal)) return null;
-        return [{
-          id: 'platform.napcat.deferred_worker',
-          title: '## napcat / QQ（本任务）',
-          body: WORKER_NAPCAT,
-          priority: 50,
-        }];
-      }
-      return null;
-    },
-
-    matchesDeferredTask(ctx: AgentPromptBuildContext): boolean {
-      const query = ctx.deferred?.toolQuery ?? ctx.deferred?.goal ?? ctx.userMessagePreview ?? '';
-      const goal = ctx.deferred?.goal ?? ctx.userMessagePreview ?? '';
-      return isNapCatDelegatedTask(query, goal);
-    },
-
-    selectDeferredTools(query, goal, catalog, maxTools) {
-      if (!isNapCatDelegatedTask(query, goal)) return null;
-      return selectNapCatDeferredTools(query, goal, catalog, maxTools);
-    },
-  };
-}

package/src/endpoint-base.ts

@@ -1,362 +0,0 @@
-/**
- * NapCat Endpoint 抽象基类
- * 子类只需实现 callApi / $connect / $disconnect，其余 API 方法和事件处理全部复用。
- */
-import { EventEmitter } from 'events';
-import {
-  Endpoint,
-  Message,
-  SendContent,
-  SendOptions,
-  segment,
-  expandInteractiveSegmentsInContent,
-  mapNoticeParts,
-  mapRequestParts,
-  buildNotice,
-  buildRequest,
-  senderFromId,
-  type QuotedMessagePayload,} from 'zhin.js';
-import { parseOneBotGetMsgResponse } from './onebot-get-msg.js';
-import type { NapCatEndpointConfig, NapCatMessageEvent, MessageSegment, ApiResponse } from './types.js';
-import type { NapCatAdapter } from './adapter.js';
-import { InboundMessageDeduper, isSelfMessage, normalizeMessage, resolveSideEventDedupeKey } from './napcat-inbound.js';
-import { fromCanonicalSegments, toCanonicalSegments } from './segment-mapper.js';
-
-export abstract class NapCatEndpointBase extends EventEmitter implements Endpoint<NapCatEndpointConfig, NapCatMessageEvent> {
-  $connected = false;
-  protected readonly inboundDeduper = new InboundMessageDeduper();
-
-  get logger() { return this.adapter.plugin.logger; }
-  get $id() { return this.$config.name; }
-
-  constructor(public adapter: NapCatAdapter, public $config: NapCatEndpointConfig) {
-    super();
-  }
-
-  abstract $connect(): Promise<void>;
-  abstract $disconnect(): Promise<void>;
-  abstract callApi<T = any>(action: string, params?: Record<string, any>): Promise<T>;
-
-  // ══════════════════════════════════════════════════════════════════
-  // 消息格式化
-  // ══════════════════════════════════════════════════════════════════
-
-  private toWireSendContent(content: SendContent): MessageSegment[] {
-    const items = (Array.isArray(content) ? content : [content]).map((item) =>
-      typeof item === 'string' ? { type: 'text', data: { text: item } } : item as MessageSegment,
-    );
-    return fromCanonicalSegments(toCanonicalSegments(items)) as MessageSegment[];
-  }
-
-  $formatMessage(ev: NapCatMessageEvent): Message<NapCatMessageEvent> {
-    const wire = normalizeMessage(ev.message);
-    const quoteId = Message.quoteIdFromContent(wire);
-    Message.alignReplySegments(wire, quoteId);
-    const content = toCanonicalSegments(wire);
-
-    const message = Message.from(ev, {
-      $id: ev.message_id.toString(),
-      $adapter: 'napcat',
-      $endpoint: this.$config.name,
-      $sender: {
-        id: ev.user_id.toString(),
-        name: ev.sender?.nickname || ev.user_id.toString(),
-        role: ev.sender?.role,
-      },
-      $channel: {
-        id: (ev.group_id || ev.user_id).toString(),
-        type: ev.group_id ? 'group' : 'private',
-      },
-      $content: content,
-      $quote_id: quoteId,
-      $raw: ev.raw_message,
-      $timestamp: ev.time,
-      $recall: async () => { await this.deleteMsg(ev.message_id); },
-      $reply: async (content: SendContent, quote?: boolean | string): Promise<string> => {
-        if (!Array.isArray(content)) content = [content];
-        if (quote) content.unshift({ type: 'reply', data: { message_id: ev.message_id.toString() } });
-        return await this.adapter.sendMessage({
-          id: (ev.group_id || ev.user_id).toString(),
-          type: ev.group_id ? 'group' : 'private',
-          context: 'napcat',
-          endpoint: this.$config.name,
-          content,
-        });
-      },
-    });
-    return message;
-  }
-
-  async $sendMessage(options: SendOptions): Promise<string> {
-    const content = this.toWireSendContent(expandInteractiveSegmentsInContent(options.content));
-    const msg: any = { message: content };
-    if (options.type === 'group') {
-      const result = await this.callApi<{ message_id: number }>('send_group_msg', { group_id: parseInt(options.id), ...msg });
-      this.logger.debug(`${this.$id} send group(${options.id}):${segment.raw(options.content)}`);
-      return result.message_id.toString();
-    }
-    if (options.type === 'private') {
-      const result = await this.callApi<{ message_id: number }>('send_private_msg', { user_id: parseInt(options.id), ...msg });
-      this.logger.debug(`${this.$id} send private(${options.id}):${segment.raw(options.content)}`);
-      return result.message_id.toString();
-    }
-    throw new Error('Either group_id or user_id must be provided');
-  }
-
-  async $recallMessage(id: string): Promise<void> {
-    await this.deleteMsg(parseInt(id));
-  }
-
-  async $addReaction(messageId: string, emojiId: string): Promise<string> {
-    await this.setMsgEmojiLike(parseInt(messageId), emojiId);
-    return `reaction:${messageId}:${emojiId}`;
-  }
-
-  async $removeReaction(messageId: string, _reactionId: string): Promise<void> {
-    // NapCat 的 set_msg_emoji_like 是 toggle 行为，再调一次即取消
-    const parts = _reactionId.split(':');
-    const emojiId = parts[2] || parts[0];
-    await this.setMsgEmojiLike(parseInt(messageId), emojiId);
-  }
-
-  // ══════════════════════════════════════════════════════════════════
-  // 事件分发
-  // ══════════════════════════════════════════════════════════════════
-
-  protected dispatchEvent(event: any): void {
-    switch (event.post_type) {
-      case 'message':
-      case 'message_sent':
-        return this.handleMessage(event);
-      case 'notice':
-        return this.handleNotice(event);
-      case 'request':
-        return this.handleRequest(event);
-      case 'meta_event':
-        return this.handleMeta(event);
-    }
-  }
-
-  private handleMessage(ev: NapCatMessageEvent): void {
-    if (isSelfMessage(ev)) return;
-    const msgId = ev.message_id.toString();
-    if (!this.inboundDeduper.shouldProcess(msgId)) return;
-    ev.message = normalizeMessage(ev.message);
-    const message = this.$formatMessage(ev);
-    this.adapter.emit('message.receive', message);
-    this.logger.debug(`${this.$id} recv ${message.$channel.type}(${message.$channel.id}):${segment.raw(message.$content)}`);
-  }
-
-  private handleNotice(event: any): void {
-    const dedupeKey = resolveSideEventDedupeKey(event, 'notice');
-    if (!this.inboundDeduper.shouldProcess(dedupeKey)) return;
-    const isGroup = !!event.group_id;
-    const { scene_type, sub_type } = mapNoticeParts('napcat', event.notice_type ?? '', {
-      sub_type: event.sub_type,
-      is_group: isGroup,
-    });
-    const sceneId = String((event.group_id || event.user_id) ?? '');
-    const notice = buildNotice(event, {
-      $id: `${event.time}_${event.notice_type}_${event.group_id || event.user_id}`,
-      $adapter: 'napcat',
-      $endpoint: this.$config.name,
-      $type: 'notice',
-      $scene_id: sceneId,
-      $scene_type: scene_type,
-      $sub_type: sub_type,
-      $actor: senderFromId(event.operator_id),
-      $target: senderFromId(event.user_id),
-      $timestamp: (event.time || Math.floor(Date.now() / 1000)) * 1000,
-    });
-    this.adapter.emit('notice.receive', notice);
-  }
-
-  private handleRequest(event: any): void {
-    const dedupeKey = resolveSideEventDedupeKey(event, 'request');
-    if (!this.inboundDeduper.shouldProcess(dedupeKey)) return;
-    const { scene_type, sub_type } = mapRequestParts('napcat', event.request_type ?? '', event.sub_type);
-    const sceneId = String((event.group_id || event.user_id) ?? '');
-    const request = buildRequest(event, {
-      $id: event.flag || `${event.time}_${event.request_type}_${event.user_id}`,
-      $adapter: 'napcat',
-      $endpoint: this.$config.name,
-      $type: 'request',
-      $scene_id: sceneId,
-      $scene_type: scene_type,
-      $sub_type: sub_type,
-      $actor: senderFromId(event.user_id) ?? { id: '', name: '' },
-      $comment: event.comment,
-      $timestamp: (event.time || Math.floor(Date.now() / 1000)) * 1000,
-      $approve: async (remark?: string) => {
-        await this.callApi(
-          event.request_type === 'friend' ? 'set_friend_add_request' : 'set_group_add_request',
-          { flag: event.flag, approve: true, remark },
-        );
-      },
-      $reject: async (reason?: string) => {
-        await this.callApi(
-          event.request_type === 'friend' ? 'set_friend_add_request' : 'set_group_add_request',
-          { flag: event.flag, approve: false, reason },
-        );
-      },
-    });
-    this.adapter.emit('request.receive', request);
-  }
-
-  protected handleMeta(event: any): void {
-    // subclass may override for lifecycle handling
-  }
-
-  // ══════════════════════════════════════════════════════════════════
-  // OneBot11 标准 API
-  // ══════════════════════════════════════════════════════════════════
-
-  async sendMsg(messageType: 'private' | 'group', id: number, message: MessageSegment[]) {
-    return this.callApi<{ message_id: number }>('send_msg', { message_type: messageType, [messageType === 'group' ? 'group_id' : 'user_id']: id, message });
-  }
-  async deleteMsg(messageId: number) { return this.callApi('delete_msg', { message_id: messageId }); }
-  async getMsg(messageId: number) { return this.callApi('get_msg', { message_id: messageId }); }
-
-  async $getMsg(messageId: string): Promise<QuotedMessagePayload> {
-    const idParam = /^\d+$/.test(messageId) ? Number(messageId) : messageId;
-    const data = await this.callApi('get_msg', { message_id: idParam });
-    return parseOneBotGetMsgResponse(messageId, data);
-  }
-  async getForwardMsg(id: string) { return this.callApi('get_forward_msg', { id }); }
-  async sendLike(userId: number, times = 1) { return this.callApi('send_like', { user_id: userId, times }); }
-
-  // 群管理
-  async setGroupKick(groupId: number, userId: number, rejectAddRequest = false) { return this.callApi('set_group_kick', { group_id: groupId, user_id: userId, reject_add_request: rejectAddRequest }); }
-  async setGroupBan(groupId: number, userId: number, duration = 600) { return this.callApi('set_group_ban', { group_id: groupId, user_id: userId, duration }); }
-  async setGroupWholeBan(groupId: number, enable = true) { return this.callApi('set_group_whole_ban', { group_id: groupId, enable }); }
-  async setGroupAdmin(groupId: number, userId: number, enable = true) { return this.callApi('set_group_admin', { group_id: groupId, user_id: userId, enable }); }
-  async setGroupCard(groupId: number, userId: number, card: string) { return this.callApi('set_group_card', { group_id: groupId, user_id: userId, card }); }
-  async setGroupName(groupId: number, groupName: string) { return this.callApi('set_group_name', { group_id: groupId, group_name: groupName }); }
-  async setGroupLeave(groupId: number, isDismiss = false) { return this.callApi('set_group_leave', { group_id: groupId, is_dismiss: isDismiss }); }
-  async setGroupSpecialTitle(groupId: number, userId: number, specialTitle: string, duration = -1) { return this.callApi('set_group_special_title', { group_id: groupId, user_id: userId, special_title: specialTitle, duration }); }
-
-  // 好友/群请求
-  async setFriendAddRequest(flag: string, approve = true, remark?: string) { return this.callApi('set_friend_add_request', { flag, approve, remark }); }
-  async setGroupAddRequest(flag: string, subType: string, approve = true, reason?: string) { return this.callApi('set_group_add_request', { flag, sub_type: subType, approve, reason }); }
-
-  // 信息查询
-  async getLoginInfo() { return this.callApi('get_login_info'); }
-  async getStrangerInfo(userId: number, noCache = false) { return this.callApi('get_stranger_info', { user_id: userId, no_cache: noCache }); }
-  async getFriendList() { return this.callApi('get_friend_list'); }
-  async getGroupInfo(groupId: number, noCache = false) { return this.callApi('get_group_info', { group_id: groupId, no_cache: noCache }); }
-  async getGroupList() { return this.callApi('get_group_list'); }
-  async getGroupMemberInfo(groupId: number, userId: number, noCache = false) { return this.callApi('get_group_member_info', { group_id: groupId, user_id: userId, no_cache: noCache }); }
-  async getGroupMemberList(groupId: number) { return this.callApi('get_group_member_list', { group_id: groupId }); }
-  async getGroupHonorInfo(groupId: number, type: string) { return this.callApi('get_group_honor_info', { group_id: groupId, type }); }
-
-  // 凭证
-  async getCookies(domain?: string) { return this.callApi('get_cookies', { domain }); }
-  async getCsrfToken() { return this.callApi('get_csrf_token'); }
-  async getCredentials(domain?: string) { return this.callApi('get_credentials', { domain }); }
-
-  // 媒体
-  async getRecord(file: string, outFormat: string) { return this.callApi('get_record', { file, out_format: outFormat }); }
-  async getImage(file: string) { return this.callApi('get_image', { file }); }
-  async canSendImage() { return this.callApi('can_send_image'); }
-  async canSendRecord() { return this.callApi('can_send_record'); }
-
-  // 系统
-  async getStatus() { return this.callApi('get_status'); }
-  async getVersionInfo() { return this.callApi('get_version_info'); }
-  async cleanCache() { return this.callApi('clean_cache'); }
-
-  // ══════════════════════════════════════════════════════════════════
-  // go-cqhttp 扩展 API
-  // ══════════════════════════════════════════════════════════════════
-
-  async setQQProfile(nickname: string, company?: string, email?: string, college?: string, personalNote?: string) {
-    return this.callApi('set_qq_profile', { nickname, company, email, college, personal_note: personalNote });
-  }
-  async getOnlineClients(noCache = false) { return this.callApi('get_online_clients', { no_cache: noCache }); }
-  async deleteFriend(userId: number) { return this.callApi('delete_friend', { user_id: userId }); }
-  async markMsgAsRead(messageId: number) { return this.callApi('mark_msg_as_read', { message_id: messageId }); }
-  async sendGroupForwardMsg(groupId: number, messages: any[]) { return this.callApi('send_group_forward_msg', { group_id: groupId, messages }); }
-  async sendPrivateForwardMsg(userId: number, messages: any[]) { return this.callApi('send_private_forward_msg', { user_id: userId, messages }); }
-  async getGroupMsgHistory(groupId: number, messageSeq?: number, count?: number) { return this.callApi('get_group_msg_history', { group_id: groupId, message_seq: messageSeq, count }); }
-  async ocrImage(image: string) { return this.callApi('ocr_image', { image }); }
-  async getGroupSystemMsg() { return this.callApi('get_group_system_msg'); }
-  async getEssenceMsgList(groupId: number) { return this.callApi('get_essence_msg_list', { group_id: groupId }); }
-  async getGroupAtAllRemain(groupId: number) { return this.callApi('get_group_at_all_remain', { group_id: groupId }); }
-  async setGroupPortrait(groupId: number, file: string) { return this.callApi('set_group_portrait', { group_id: groupId, file }); }
-  async setEssenceMsg(messageId: number) { return this.callApi('set_essence_msg', { message_id: messageId }); }
-  async deleteEssenceMsg(messageId: number) { return this.callApi('delete_essence_msg', { message_id: messageId }); }
-  async sendGroupSign(groupId: number) { return this.callApi('send_group_sign', { group_id: groupId }); }
-  async sendGroupNotice(groupId: number, content: string, image?: string) { return this.callApi('_send_group_notice', { group_id: groupId, content, image }); }
-  async getGroupNotice(groupId: number) { return this.callApi('_get_group_notice', { group_id: groupId }); }
-  async deleteGroupNotice(groupId: number, noticeId: string) { return this.callApi('_del_group_notice', { group_id: groupId, notice_id: noticeId }); }
-  async uploadGroupFile(groupId: number, file: string, name: string, folder?: string) { return this.callApi('upload_group_file', { group_id: groupId, file, name, folder }); }
-  async deleteGroupFile(groupId: number, fileId: string, busid: number) { return this.callApi('delete_group_file', { group_id: groupId, file_id: fileId, busid }); }
-  async createGroupFileFolder(groupId: number, name: string, parentId = '/') { return this.callApi('create_group_file_folder', { group_id: groupId, name, parent_id: parentId }); }
-  async deleteGroupFolder(groupId: number, folderId: string) { return this.callApi('delete_group_folder', { group_id: groupId, folder_id: folderId }); }
-  async getGroupFileSystemInfo(groupId: number) { return this.callApi('get_group_file_system_info', { group_id: groupId }); }
-  async getGroupRootFiles(groupId: number) { return this.callApi('get_group_root_files', { group_id: groupId }); }
-  async getGroupFilesByFolder(groupId: number, folderId: string) { return this.callApi('get_group_files_by_folder', { group_id: groupId, folder_id: folderId }); }
-  async getGroupFileUrl(groupId: number, fileId: string, busid: number) { return this.callApi('get_group_file_url', { group_id: groupId, file_id: fileId, busid }); }
-  async uploadPrivateFile(userId: number, file: string, name: string) { return this.callApi('upload_private_file', { user_id: userId, file, name }); }
-  async downloadFile(url: string, threadCount = 1, headers?: string[]) { return this.callApi('download_file', { url, thread_count: threadCount, headers }); }
-  async checkUrlSafely(url: string) { return this.callApi('check_url_safely', { url }); }
-
-  // ══════════════════════════════════════════════════════════════════
-  // NapCat 独有 API
-  // ══════════════════════════════════════════════════════════════════
-
-  async setGroupSign(groupId: number) { return this.callApi('set_group_sign', { group_id: groupId }); }
-  async arkSharePeer(userId: number) { return this.callApi('ArkSharePeer', { user_id: userId }); }
-  async arkShareGroup(groupId: number) { return this.callApi('ArkShareGroup', { group_id: groupId }); }
-  async getRobotUinRange() { return this.callApi('get_robot_uin_range'); }
-  async setOnlineStatus(status: number, extStatus: number) { return this.callApi('set_online_status', { status, ext_status: extStatus }); }
-  async getFriendsWithCategory() { return this.callApi('get_friends_with_category'); }
-  async setQQAvatar(file: string) { return this.callApi('set_qq_avatar', { file }); }
-  async getFile(fileId: string) { return this.callApi('get_file', { file_id: fileId }); }
-  async forwardFriendSingleMsg(userId: number, messageId: number) { return this.callApi('forward_friend_single_msg', { user_id: userId, message_id: messageId }); }
-  async forwardGroupSingleMsg(groupId: number, messageId: number) { return this.callApi('forward_group_single_msg', { group_id: groupId, message_id: messageId }); }
-  async translateEn2Zh(sourceText: string) { return this.callApi('translate_en2zh', { source_text: sourceText }); }
-  async setMsgEmojiLike(messageId: number, emojiId: string) { return this.callApi('set_msg_emoji_like', { message_id: messageId, emoji_id: emojiId }); }
-  async sendForwardMsg(messageType: 'private' | 'group', id: number, messages: any[]) {
-    return this.callApi('send_forward_msg', { message_type: messageType, [messageType === 'group' ? 'group_id' : 'user_id']: id, messages });
-  }
-  async markPrivateMsgAsRead(userId: number) { return this.callApi('mark_private_msg_as_read', { user_id: userId }); }
-  async markGroupMsgAsRead(groupId: number) { return this.callApi('mark_group_msg_as_read', { group_id: groupId }); }
-  async getFriendMsgHistory(userId: number, messageSeq?: number, count?: number) { return this.callApi('get_friend_msg_history', { user_id: userId, message_seq: messageSeq, count }); }
-  async createCollection(briefContent: string, rawData: string) { return this.callApi('create_collection', { brief: briefContent, rawData }); }
-  async getCollectionList(page = 0, limit = 20) { return this.callApi('get_collection_list', { page, limit }); }
-  async setSelfLongnick(longnick: string) { return this.callApi('set_self_longnick', { longNick: longnick }); }
-  async getRecentContact(count = 10) { return this.callApi('get_recent_contact', { count }); }
-  async markAllAsRead() { return this.callApi('_mark_all_as_read'); }
-  async getProfileLike() { return this.callApi('get_profile_like'); }
-  async fetchCustomFace() { return this.callApi('fetch_custom_face'); }
-  async fetchEmojiLike(messageId: number, emojiId: string, emojiType: string) { return this.callApi('fetch_emoji_like', { message_id: messageId, emoji_id: emojiId, emoji_type: emojiType }); }
-  async setInputStatus(userId: number, eventType: string) { return this.callApi('set_input_status', { user_id: userId, event_type: eventType }); }
-  async getGroupInfoEx(groupId: number) { return this.callApi('get_group_info_ex', { group_id: groupId }); }
-  async getGroupIgnoreAddRequest(groupId: number) { return this.callApi('get_group_ignore_add_request', { group_id: groupId }); }
-  async friendPoke(userId: number) { return this.callApi('friend_poke', { user_id: userId }); }
-  async groupPoke(groupId: number, userId: number) { return this.callApi('group_poke', { group_id: groupId, user_id: userId }); }
-  async sendPoke(userId: number, groupId?: number) { return this.callApi('send_poke', { user_id: userId, group_id: groupId }); }
-  async ncGetPacketStatus() { return this.callApi('nc_get_packet_status'); }
-  async ncGetUserStatus(userId: number) { return this.callApi('nc_get_user_status', { user_id: userId }); }
-  async ncGetRkey() { return this.callApi('nc_get_rkey'); }
-  async getGroupShutList(groupId: number) { return this.callApi('get_group_shut_list', { group_id: groupId }); }
-  async getMiniAppArk(type: string, title: string, desc: string, picUrl: string, jumpUrl: string) {
-    return this.callApi('get_mini_app_ark', { type, title, desc, picUrl, jumpUrl });
-  }
-  async getAiRecord(groupId: number, characterId: string, text: string) { return this.callApi('get_ai_record', { group_id: groupId, character: characterId, text }); }
-  async getAiCharacters(groupId: number) { return this.callApi('get_ai_characters', { group_id: groupId }); }
-  async sendGroupAiRecord(groupId: number, characterId: string, text: string) { return this.callApi('send_group_ai_record', { group_id: groupId, character: characterId, text }); }
-
-  // ══════════════════════════════════════════════════════════════════
-  // Adapter 群管理接口适配
-  // ══════════════════════════════════════════════════════════════════
-
-  async kickMember(groupId: number, userId: number, reject = false) { await this.setGroupKick(groupId, userId, reject); return true; }
-  async muteMember(groupId: number, userId: number, duration = 600) { await this.setGroupBan(groupId, userId, duration); return true; }
-  async muteAll(groupId: number, enable = true) { await this.setGroupWholeBan(groupId, enable); return true; }
-  async setAdmin(groupId: number, userId: number, enable = true) { await this.setGroupAdmin(groupId, userId, enable); return true; }
-  async setCard(groupId: number, userId: number, card: string) { await this.setGroupCard(groupId, userId, card); return true; }
-  async setTitle(groupId: number, userId: number, title: string, duration = -1) { await this.setGroupSpecialTitle(groupId, userId, title, duration); return true; }
-  async getMemberList(groupId: number) { return this.getGroupMemberList(groupId); }
-}