@zhin.js/core 1.3.1 → 1.3.3

package/lib/built/ai-outbound/extensions/qq-message.d.ts

@@ -0,0 +1,3 @@
+import type { AiOutboundExtensionDefinition } from '../types.js';
+export declare const QQ_MARKDOWN_AI_OUTBOUND_EXTENSION: AiOutboundExtensionDefinition;
+export declare const QQ_AI_OUTBOUND_EXTENSIONS: readonly AiOutboundExtensionDefinition[];

package/lib/built/ai-outbound/extensions/qq-message.js

@@ -0,0 +1,23 @@
+const QQ_MARKDOWN_SCHEMA = {
+    type: 'object',
+    properties: {
+        content: { type: 'string' },
+    },
+    required: ['content'],
+};
+export const QQ_MARKDOWN_AI_OUTBOUND_EXTENSION = {
+    key: 'qq.markdown',
+    schema: QQ_MARKDOWN_SCHEMA,
+    examples: ['{"extensions":{"qq.markdown":{"content":"# Title\\nBody"}}}'],
+    toMessageElements(ext, _ctx) {
+        if (!ext || typeof ext !== 'object')
+            return [];
+        const content = ext.content;
+        if (typeof content !== 'string' || !content.trim())
+            return [];
+        return [{ type: 'markdown', data: { content: content.trim() } }];
+    },
+};
+export const QQ_AI_OUTBOUND_EXTENSIONS = [
+    QQ_MARKDOWN_AI_OUTBOUND_EXTENSION,
+];

package/lib/built/ai-outbound/index.d.ts

@@ -0,0 +1,9 @@
+export * from './types.js';
+export * from './parse.js';
+export * from './plain-mention-rewrite.js';
+export * from './resolve.js';
+export * from './prompt.js';
+export * from './structured-detect.js';
+export * from './adapter-access.js';
+export * from './extensions/onebot-keyboard.js';
+export * from './extensions/qq-message.js';

package/lib/built/ai-outbound/index.js

@@ -0,0 +1,9 @@
+export * from './types.js';
+export * from './parse.js';
+export * from './plain-mention-rewrite.js';
+export * from './resolve.js';
+export * from './prompt.js';
+export * from './structured-detect.js';
+export * from './adapter-access.js';
+export * from './extensions/onebot-keyboard.js';
+export * from './extensions/qq-message.js';

package/lib/built/ai-outbound/parse.d.ts

@@ -0,0 +1,13 @@
+import type { Segment } from '../segment-contract/types.js';
+import type { ZhinAiOutboundPayload } from './types.js';
+/** 解析单条 outbound segment（canonical 或 legacy kind/mode）。 */
+export declare function parseOutboundSegment(raw: unknown): Segment | null;
+/** 去掉嵌入 JSON 候选末尾的 markdown 围栏（模型常见 ```json … ``` 误输出）。 */
+export declare function trimTrailingMarkdownFence(raw: string): string;
+export declare function unwrapAiOutboundJsonCandidate(raw: string): string;
+/** 从「正文 + 嵌入 JSON」混合文本中提取 AI outbound JSON（协作群常见误输出）。 */
+export declare function extractEmbeddedAiOutboundJson(plain: string): {
+    prose: string;
+    jsonRaw: string;
+} | null;
+export declare function parseAiOutboundJson(raw: string): ZhinAiOutboundPayload | null;

package/lib/built/ai-outbound/parse.js

@@ -0,0 +1,94 @@
+import { isCanonicalSegment } from '../segment-contract/assert.js';
+function isPlainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/** 解析单条 outbound segment（canonical 或 legacy kind/mode）。 */
+export function parseOutboundSegment(raw) {
+    if (!isPlainObject(raw))
+        return null;
+    const type = typeof raw.type === 'string' && raw.type.trim()
+        ? raw.type.trim()
+        : typeof raw.kind === 'string' && raw.kind.trim()
+            ? raw.kind.trim()
+            : undefined;
+    if (!type)
+        return null;
+    const data = isPlainObject(raw.data) ? raw.data : {};
+    const platform = isPlainObject(raw.platform) ? raw.platform : undefined;
+    const segment = platform ? { type, data, platform } : { type, data };
+    return isCanonicalSegment(segment) ? segment : null;
+}
+/** 去掉嵌入 JSON 候选末尾的 markdown 围栏（模型常见 ```json … ``` 误输出）。 */
+export function trimTrailingMarkdownFence(raw) {
+    let s = raw.trim();
+    const trailingFence = s.match(/^([\s\S]*?)\s*```\s*$/);
+    if (trailingFence)
+        s = trailingFence[1].trim();
+    return s;
+}
+export function unwrapAiOutboundJsonCandidate(raw) {
+    const trimmed = raw.trim();
+    const fenced = trimmed.match(/^```(?:json)?\s*([\s\S]*?)```\s*$/i);
+    if (fenced)
+        return fenced[1].trim();
+    const embeddedFence = trimmed.match(/```(?:json)?\s*([\s\S]*?)```/i);
+    if (embeddedFence && trimmed.indexOf('{') >= 0) {
+        return trimTrailingMarkdownFence(embeddedFence[1].trim());
+    }
+    return trimTrailingMarkdownFence(trimmed);
+}
+/** 从「正文 + 嵌入 JSON」混合文本中提取 AI outbound JSON（协作群常见误输出）。 */
+export function extractEmbeddedAiOutboundJson(plain) {
+    const trimmed = plain.trim();
+    if (!trimmed.includes('{'))
+        return null;
+    const fenced = trimmed.match(/```(?:json)?\s*([\s\S]*?)```/i);
+    if (fenced) {
+        const jsonRaw = trimTrailingMarkdownFence(fenced[1].trim());
+        const payload = parseAiOutboundJson(jsonRaw);
+        if (payload?.mentions?.length && payload.text?.trim()) {
+            const prose = trimmed.slice(0, fenced.index).trim();
+            return { prose, jsonRaw };
+        }
+    }
+    let idx = trimmed.indexOf('{');
+    while (idx >= 0) {
+        const jsonRaw = trimTrailingMarkdownFence(trimmed.slice(idx).trim());
+        const payload = parseAiOutboundJson(jsonRaw);
+        if (payload?.mentions?.length && payload.text?.trim()) {
+            return { prose: trimmed.slice(0, idx).trim(), jsonRaw };
+        }
+        idx = trimmed.indexOf('{', idx + 1);
+    }
+    return null;
+}
+export function parseAiOutboundJson(raw) {
+    const candidate = unwrapAiOutboundJsonCandidate(raw);
+    if (!candidate.startsWith('{'))
+        return null;
+    try {
+        const parsed = JSON.parse(candidate);
+        const text = typeof parsed.text === 'string' ? parsed.text.trim() : undefined;
+        const mentionsRaw = parsed.mentions;
+        const mentions = Array.isArray(mentionsRaw)
+            ? mentionsRaw.map((m) => String(m).trim()).filter(Boolean)
+            : undefined;
+        const segmentsRaw = parsed.segments;
+        const segments = Array.isArray(segmentsRaw)
+            ? segmentsRaw
+                .map((item) => parseOutboundSegment(item))
+                .filter((s) => s != null)
+            : undefined;
+        const extensions = parsed.extensions != null && typeof parsed.extensions === 'object' && !Array.isArray(parsed.extensions)
+            ? parsed.extensions
+            : undefined;
+        if (!text && !mentions?.length && !segments?.length && !extensions)
+            return null;
+        if (mentions?.length && !text)
+            return null;
+        return { text, mentions, segments, extensions };
+    }
+    catch {
+        return null;
+    }
+}

package/lib/built/ai-outbound/plain-mention-rewrite.d.ts

@@ -0,0 +1,6 @@
+import type { AiOutboundMentionResolver, ZhinAiOutboundPayload } from './types.js';
+/**
+ * 从正文中提取 cell roster 可识别的假 @（@researcher / @210723495 等），
+ * 剥离后返回等效 ZhinAiOutboundPayload。
+ */
+export declare function rewritePlainTextMentions(plainText: string, mentionResolver: AiOutboundMentionResolver): ZhinAiOutboundPayload | null;

package/lib/built/ai-outbound/plain-mention-rewrite.js

@@ -0,0 +1,37 @@
+const PLAIN_MENTION_PATTERN = /@([\w-]+)/g;
+/**
+ * 从正文中提取 cell roster 可识别的假 @（@researcher / @210723495 等），
+ * 剥离后返回等效 ZhinAiOutboundPayload。
+ */
+export function rewritePlainTextMentions(plainText, mentionResolver) {
+    const trimmed = plainText.trim();
+    if (!trimmed)
+        return null;
+    const mentions = [];
+    let rewritten = trimmed;
+    for (const match of trimmed.matchAll(PLAIN_MENTION_PATTERN)) {
+        const token = match[1];
+        if (!token)
+            continue;
+        const endpointId = mentionResolver(token);
+        if (!endpointId)
+            continue;
+        const ref = token;
+        if (!mentions.includes(ref))
+            mentions.push(ref);
+    }
+    if (mentions.length === 0)
+        return null;
+    rewritten = trimmed.replace(PLAIN_MENTION_PATTERN, (full, token) => {
+        const endpointId = mentionResolver(token);
+        return endpointId ? '' : full;
+    });
+    rewritten = rewritten
+        .replace(/[ \t]+\n/g, '\n')
+        .replace(/\n{3,}/g, '\n\n')
+        .replace(/^\s+|\s+$/g, '')
+        .trim();
+    if (!rewritten)
+        return null;
+    return { mentions, text: rewritten };
+}

package/lib/built/ai-outbound/prompt.d.ts

@@ -0,0 +1,11 @@
+import type { AiOutboundCapabilities, AiOutboundExtensionDefinition } from './types.js';
+export declare const AI_OUTBOUND_JSON_EXAMPLE = "{\"mentions\":[\"researcher\",\"210723495\"],\"text\":\"\u6B63\u6587\"}";
+export declare function buildCoreAiOutboundPromptHint(capabilities?: AiOutboundCapabilities): string;
+export declare function buildAiOutboundPromptHint(input: {
+    capabilities?: AiOutboundCapabilities;
+    extensions?: readonly AiOutboundExtensionDefinition[];
+    rosterLines?: string[];
+    forceJsonOnly?: boolean;
+}): string;
+/** 检测入站是否含 handoff / @ 意图（协作群 structured_only 信号）。 */
+export declare function detectInboundHandoffIntent(content: string): boolean;

package/lib/built/ai-outbound/prompt.js

@@ -0,0 +1,44 @@
+export const AI_OUTBOUND_JSON_EXAMPLE = '{"mentions":["researcher","210723495"],"text":"正文"}';
+export function buildCoreAiOutboundPromptHint(capabilities) {
+    const lines = [
+        'When your reply must @ peers, send rich media, buttons, or delegate — output JSON only (no Markdown wrapper):',
+        AI_OUTBOUND_JSON_EXAMPLE,
+        'mentions: peer endpoint ID or pipelineRole; text: message body.',
+        'Do NOT write "@researcher" in plain text — the framework converts JSON mentions to real platform @ segments.',
+    ];
+    if (capabilities?.richSegments?.length) {
+        lines.push(`Rich segments (optional "segments" array): ${capabilities.richSegments.join(', ')}.`);
+    }
+    if (capabilities?.interactive === 'native') {
+        lines.push('Interactive buttons: use extensions field per adapter schema.');
+    }
+    return lines.join('\n');
+}
+export function buildAiOutboundPromptHint(input) {
+    const lines = [];
+    if (input.rosterLines?.length) {
+        lines.push(...input.rosterLines);
+    }
+    lines.push(buildCoreAiOutboundPromptHint(input.capabilities));
+    if (input.extensions?.length) {
+        lines.push('Adapter extensions (optional "extensions" object):');
+        for (const ext of input.extensions) {
+            lines.push(`- ${ext.key}: see platform schema`);
+            if (ext.examples[0])
+                lines.push(`  example: ${ext.examples[0]}`);
+        }
+    }
+    if (input.forceJsonOnly) {
+        lines.push('MUST reply with JSON only when @ peers or handoff — no Markdown body with plain "@role" text.');
+    }
+    return lines.join('\n');
+}
+/** 检测入站是否含 handoff / @ 意图（协作群 structured_only 信号）。 */
+export function detectInboundHandoffIntent(content) {
+    const t = content.trim();
+    if (!t)
+        return false;
+    if (t.includes('@'))
+        return true;
+    return /依次|自我介绍|叫大家|请各位|handoff|delegate/i.test(t);
+}

package/lib/built/ai-outbound/resolve.d.ts

@@ -0,0 +1,4 @@
+import type { MessageElement } from '../../types.js';
+import type { AiOutboundParseContext, ZhinAiOutboundPayload } from './types.js';
+/** 将 ZhinAiOutboundPayload 转为 MessageElement[]（canonical segments + extensions）。 */
+export declare function resolveAiOutboundToMessageElements(payload: ZhinAiOutboundPayload, ctx: AiOutboundParseContext): Promise<MessageElement[] | null>;

package/lib/built/ai-outbound/resolve.js

@@ -0,0 +1,64 @@
+import { segmentsForImDelivery } from '../segment-contract/delivery.js';
+function buildMentionSegments(endpointIds, text, ctx) {
+    const segments = [];
+    for (const endpointId of endpointIds) {
+        const target = ctx.atIdResolver?.(endpointId) ?? endpointId;
+        segments.push({ type: 'mention', data: { target } });
+    }
+    const body = text.trim();
+    segments.push({
+        type: 'text',
+        data: { text: body.startsWith(' ') ? body : ` ${body}` },
+    });
+    return segments;
+}
+function resolveMentionEndpointIds(mentions, ctx) {
+    if (!mentions?.length) {
+        return { ok: false, error: 'mentions 不能为空' };
+    }
+    if (!ctx.mentionResolver) {
+        return { ok: false, error: 'mentionResolver 未配置' };
+    }
+    const endpointIds = [];
+    for (const ref of mentions) {
+        const resolved = ctx.mentionResolver(ref);
+        if (!resolved) {
+            return { ok: false, error: `未知 peer "${ref}"` };
+        }
+        if (!endpointIds.includes(resolved))
+            endpointIds.push(resolved);
+    }
+    return { ok: true, endpointIds };
+}
+/** 将 ZhinAiOutboundPayload 转为 MessageElement[]（canonical segments + extensions）。 */
+export async function resolveAiOutboundToMessageElements(payload, ctx) {
+    const segments = [];
+    if (payload.mentions?.length) {
+        const resolved = resolveMentionEndpointIds(payload.mentions, ctx);
+        if (!resolved.ok)
+            return null;
+        const text = payload.text?.trim() ?? '';
+        if (!text)
+            return null;
+        segments.push(...buildMentionSegments(resolved.endpointIds, text, ctx));
+    }
+    else if (payload.text?.trim()) {
+        segments.push({ type: 'text', data: { text: payload.text.trim() } });
+    }
+    if (payload.segments?.length) {
+        segments.push(...payload.segments);
+    }
+    const parts = segments.length
+        ? segmentsForImDelivery(segments)
+        : [];
+    if (payload.extensions && ctx.extensions?.length) {
+        for (const def of ctx.extensions) {
+            const ext = payload.extensions[def.key];
+            if (ext == null || !def.toMessageElements)
+                continue;
+            const extSegments = await def.toMessageElements(ext, ctx);
+            parts.push(...(Array.isArray(extSegments) ? extSegments : [extSegments]));
+        }
+    }
+    return parts.length ? parts : null;
+}

package/lib/built/ai-outbound/structured-detect.d.ts

@@ -0,0 +1,3 @@
+import type { StructuredOutboundDetectInput } from './types.js';
+/** structured_only：满足任一即进入结构化出站模式。 */
+export declare function isStructuredOutboundRequired(input: StructuredOutboundDetectInput): boolean;

package/lib/built/ai-outbound/structured-detect.js

@@ -0,0 +1,7 @@
+/** structured_only：满足任一即进入结构化出站模式。 */
+export function isStructuredOutboundRequired(input) {
+    return Boolean(input.collaborationCell
+        || input.toolRequiresStructured
+        || input.inboundHandoffIntent
+        || input.adapterHasExtensions);
+}

package/lib/built/ai-outbound/types.d.ts

@@ -0,0 +1,60 @@
+import type { Message } from '../../message.js';
+import type { MessageElement } from '../../types.js';
+import type { InteractivePolicy } from '../interactive-segments/types.js';
+import type { Segment } from '../segment-contract/types.js';
+/** AI 结构化出站 payload — 平台无关 DSL（Adapter extensions 承载平台特有段）。 */
+export interface ZhinAiOutboundPayload {
+    text?: string;
+    mentions?: string[];
+    segments?: Segment[];
+    extensions?: Record<string, unknown>;
+}
+/**
+ * @deprecated 使用 canonical `Segment`（`type` + `data` + 可选 `platform`）。
+ * 历史 `kind` → `type`；`mode` 已删除。
+ */
+export interface AiOutboundSegment {
+    kind: string;
+    mode?: string;
+    data?: Record<string, unknown>;
+}
+export interface AiOutboundCapabilities {
+    mentions?: boolean;
+    richSegments?: readonly string[];
+    interactive?: InteractivePolicy;
+}
+export interface AiOutboundExtensionDefinition {
+    /** 平台扩展字段名，如 qq.ark / onebot.keyboard */
+    key: string;
+    /** JSON Schema 子集，对齐平台 SDK 文档 */
+    schema: Record<string, unknown>;
+    examples: readonly string[];
+    toMessageElements?: (ext: unknown, ctx: AiOutboundParseContext) => MessageElement[] | Promise<MessageElement[]>;
+}
+export interface AiOutboundMentionResolver {
+    (ref: string): string | undefined;
+}
+export interface AiOutboundAtIdResolver {
+    (endpointId: string): string;
+}
+/** 解析 AI 出站 JSON 时的上下文。 */
+export interface AiOutboundParseContext {
+    message: Message;
+    /** 将 peer ref（role/endpoint/primary）解析为 endpointId */
+    mentionResolver?: AiOutboundMentionResolver;
+    /** 将 endpointId 解析为 platform @ id */
+    atIdResolver?: AiOutboundAtIdResolver;
+    /** Adapter 声明的 extensions（运行时从 Adapter 静态属性注入） */
+    extensions?: readonly AiOutboundExtensionDefinition[];
+}
+export interface StructuredOutboundDetectInput {
+    /** 协作 Cell 活跃且可能 @ peer */
+    collaborationCell?: boolean;
+    /** 工具链要求结构化出站（如 group_delegate message JSON） */
+    toolRequiresStructured?: boolean;
+    /** 用户入站含 handoff / @ 意图 */
+    inboundHandoffIntent?: boolean;
+    /** Adapter 声明 extensions 且非空 */
+    adapterHasExtensions?: boolean;
+}
+export declare const DEFAULT_AI_OUTBOUND_CAPABILITIES: AiOutboundCapabilities;

package/lib/built/ai-outbound/types.js

@@ -0,0 +1,5 @@
+export const DEFAULT_AI_OUTBOUND_CAPABILITIES = {
+    mentions: true,
+    richSegments: ['qrcode', 'html', 'markdown', 'tts'],
+    interactive: 'text',
+};

package/lib/built/ai-trigger.d.ts

@@ -39,6 +39,11 @@ export interface AITriggerConfig {
     trusted?: string[];
     /** 是否在 AI 入参前拉取 $quote_id 对应消息正文（默认 true） */
     resolveQuotedMessages?: boolean;
+    /**
+     * 协作单元内 peer Bot 入站策略（ADR 0023）。
+     * mention-only：仅被 @ 时触发；off：与普通人消息相同规则。
+     */
+    peerMode?: 'mention-only' | 'off';
 }
 /**
  * AI 触发检查结果
@@ -97,4 +102,3 @@ export declare function shouldTriggerAI<T extends object>(message: Message<T>, c
  * 合并配置
  */
 export declare function mergeAITriggerConfig(config: AITriggerConfig): Required<AITriggerConfig>;
-//# sourceMappingURL=ai-trigger.d.ts.map

package/lib/built/ai-trigger.js

@@ -9,6 +9,7 @@
  * 4. 关键词触发 - 非群/频道场景下匹配关键词时触发
  */
 import { segment } from "../utils.js";
+import { readMentionSegmentTarget } from './segment-contract/mention.js';
 import { normalizeSenderRoles, } from './roles.js';
 // ============================================================================
 // 默认配置
@@ -26,6 +27,7 @@ export const DEFAULT_AI_TRIGGER_CONFIG = {
     masters: [],
     trusted: [],
     resolveQuotedMessages: true,
+    peerMode: 'mention-only',
 };
 // ============================================================================
 // 工具函数
@@ -35,12 +37,7 @@ function normalizeAtIds(endpointAtIds) {
     return [...new Set(ids.map((id) => String(id)).filter(Boolean))];
 }
 function segmentAtUserId(seg) {
-    const { data } = seg;
-    if (!data || typeof data !== 'object')
-        return '';
-    const record = data;
-    const raw = record.user_id ?? record.qq ?? record.id;
-    return raw == null ? '' : String(raw);
+    return readMentionSegmentTarget(seg);
 }
 function isAtSegmentForEndpoint(seg, endpointIds) {
     if (seg.type !== 'at' && seg.type !== 'mention')
@@ -233,4 +230,3 @@ export function shouldTriggerAI(message, config, options) {
 export function mergeAITriggerConfig(config) {
     return { ...DEFAULT_AI_TRIGGER_CONFIG, ...config };
 }
-//# sourceMappingURL=ai-trigger.js.map

package/lib/built/authorization.d.ts

@@ -8,4 +8,3 @@ import { type SenderRolesResult } from './ai-trigger.js';
  * 从 ConfigFeature + Message 重算发送者角色（含群角色与 master/trusted）
  */
 export declare function resolveSubjectRoles(plugin: Plugin, message: Message<any>): SenderRolesResult;
-//# sourceMappingURL=authorization.d.ts.map

package/lib/built/authorization.js

@@ -50,4 +50,3 @@ export function resolveSubjectRoles(plugin, message) {
     const endpointConfig = readEndpointConfig(plugin, message);
     return resolveSenderRoles(message, triggerConfig, endpointConfig);
 }
-//# sourceMappingURL=authorization.js.map

package/lib/built/command.d.ts

@@ -5,6 +5,8 @@
 import { Feature, FeatureJSON } from "@zhin.js/kernel";
 /** 命令 pattern 的首个词（用于前缀排序） */
 export declare function commandLeadingToken(pattern: string): string;
+/** 命令匹配优先级：首词越长越优先；同首词则完整 pattern 越长越优先 */
+export declare function compareCommandPatterns(a: string, b: string): number;
 import { MessageCommand } from "../command.js";
 import { Message } from "../message.js";
 import { Plugin } from "../plugin.js";
@@ -65,4 +67,3 @@ export declare class CommandFeature extends Feature<MessageCommand<RegisteredAda
         addCommand<T extends RegisteredAdapter>(command: MessageCommand<T>): () => void;
     };
 }
-//# sourceMappingURL=command.d.ts.map

package/lib/built/command.js

@@ -7,7 +7,18 @@ import { Feature } from "@zhin.js/kernel";
 export function commandLeadingToken(pattern) {
     return pattern.split(/\s/)[0] ?? "";
 }
-import { getPlugin } from "../plugin.js";
+/** 命令匹配优先级：首词越长越优先；同首词则完整 pattern 越长越优先 */
+export function compareCommandPatterns(a, b) {
+    const leadDiff = commandLeadingToken(b).length - commandLeadingToken(a).length;
+    if (leadDiff !== 0)
+        return leadDiff;
+    const lenDiff = b.length - a.length;
+    if (lenDiff !== 0)
+        return lenDiff;
+    const tokA = a.trim().split(/\s+/).length;
+    const tokB = b.trim().split(/\s+/).length;
+    return tokB - tokA;
+}
 /**
  * 命令服务 Feature
  */
@@ -41,7 +52,7 @@ export class CommandFeature extends Feature {
      * 处理消息，依次尝试匹配命令（较长前缀优先，避免 `teach` 抢 `teach-list`）
      */
     async handle(message, plugin) {
-        const commands = [...this.items].sort((a, b) => commandLeadingToken(b.pattern).length - commandLeadingToken(a.pattern).length);
+        const commands = [...this.items].sort((a, b) => compareCommandPatterns(a.pattern, b.pattern));
         for (const command of commands) {
             const result = await command.handle(message, plugin);
             if (result)
@@ -80,7 +91,7 @@ export class CommandFeature extends Feature {
         const feature = this;
         return {
             addCommand(command) {
-                const plugin = getPlugin();
+                const plugin = this;
                 const dispose = feature.add(command, plugin.name);
                 plugin.recordFeatureContribution(feature.name, command.pattern);
                 plugin.onDispose(dispose);
@@ -89,4 +100,3 @@ export class CommandFeature extends Feature {
         };
     }
 }
-//# sourceMappingURL=command.js.map

package/lib/built/common-adapter-tools.d.ts

@@ -1,36 +1,36 @@
 /**
- * Group Management — 方法规范与 Tool 工厂
+ * Scene Management — 方法规范与 Tool 工厂
  *
  * 设计理念：
- *   各 IM 平台在适配器内自行实现群管方法（kickMember、muteMember 等），
+ *   各 IM 平台在适配器内自行实现场景治理方法（removeMember、muteMember 等），
  *   并自行注册 Tool；平台说明使用包内 `skills/<adapter>/SKILL.md`。
  *
  * 使用方式（在各适配器 start 或注册方法中）：
  *
- *   import { createGroupManagementTools, GROUP_MANAGEMENT_SKILL_KEYWORDS, GROUP_MANAGEMENT_SKILL_TAGS } from 'zhin.js';
- *   const tools = createGroupManagementTools(this, this.name);
+ *   import { createSceneManagementTools, SCENE_MANAGEMENT_SKILL_KEYWORDS, SCENE_MANAGEMENT_SKILL_TAGS } from 'zhin.js';
+ *   const tools = createSceneManagementTools(this, this.name);
  *   tools.forEach(t => this.addTool(t));
  *   // 另：包内 skills/<name>/SKILL.md 供 Agent 发现
  */
 import type { Tool } from '../types.js';
 /**
- * 群管理能力接口。
+ * 场景治理能力接口。
  * Adapter 基类通过此接口声明方法签名，子类选择性覆写。
  */
-export interface IGroupManagement {
-    kickMember?(endpointId: string, sceneId: string, userId: string): Promise<any>;
+export interface ISceneManagement {
+    removeMember?(endpointId: string, sceneId: string, userId: string): Promise<any>;
     muteMember?(endpointId: string, sceneId: string, userId: string, duration?: number): Promise<any>;
     setMemberNickname?(endpointId: string, sceneId: string, userId: string, nickname: string): Promise<any>;
-    setAdmin?(endpointId: string, sceneId: string, userId: string, enable?: boolean): Promise<any>;
+    setModerator?(endpointId: string, sceneId: string, userId: string, enable?: boolean): Promise<any>;
     listMembers?(endpointId: string, sceneId: string): Promise<any>;
     banMember?(endpointId: string, sceneId: string, userId: string, reason?: string): Promise<any>;
     unbanMember?(endpointId: string, sceneId: string, userId: string): Promise<any>;
-    setGroupName?(endpointId: string, sceneId: string, name: string): Promise<any>;
-    muteAll?(endpointId: string, sceneId: string, enable?: boolean): Promise<any>;
-    getGroupInfo?(endpointId: string, sceneId: string): Promise<any>;
+    renameScene?(endpointId: string, sceneId: string, name: string): Promise<any>;
+    setSceneMuted?(endpointId: string, sceneId: string, enable?: boolean): Promise<any>;
+    getSceneInfo?(endpointId: string, sceneId: string): Promise<any>;
 }
-export interface GroupMethodSpec {
-    method: keyof IGroupManagement;
+export interface SceneManagementMethodSpec {
+    method: keyof ISceneManagement;
     toolSuffix: string;
     description: string;
     keywords: string[];
@@ -43,20 +43,19 @@ export interface GroupMethodSpec {
     extraRequired?: string[];
     preExecutable?: boolean;
 }
-export declare const GROUP_METHOD_SPECS: GroupMethodSpec[];
-export declare const GROUP_MANAGEMENT_SKILL_TAGS: string[];
-export declare const GROUP_MANAGEMENT_SKILL_KEYWORDS: string[];
-export interface GroupManagementToolFactory<T> {
-    (spec: GroupMethodSpec, prefix: string, execute: (args: Record<string, any>) => Promise<any>): T;
+export declare const SCENE_MANAGEMENT_METHOD_SPECS: SceneManagementMethodSpec[];
+export declare const SCENE_MANAGEMENT_SKILL_TAGS: string[];
+export declare const SCENE_MANAGEMENT_SKILL_KEYWORDS: string[];
+export interface SceneManagementToolFactory<T> {
+    (spec: SceneManagementMethodSpec, prefix: string, execute: (args: Record<string, any>) => Promise<any>): T;
 }
-export declare function defaultQqGroupPermitResolver(adapterPrefix: string): (logicalPerm: string) => string;
-export interface CreateGroupManagementToolsOptions {
-    /** 将 GROUP_METHOD_SPECS 逻辑 perm（group_admin/group_owner）映射为 platform(...) 字符串 */
+export declare function defaultScenePermitResolver(adapterPrefix: string): (logicalPerm: string) => string;
+export interface CreateSceneManagementToolsOptions {
+    /** 将 SCENE_MANAGEMENT_METHOD_SPECS 逻辑 perm（scene_admin/scene_owner）映射为 platform(...) 字符串 */
     permitResolver?: (logicalPerm: string) => string | undefined;
-    /** 是否注册默认 QQ 系 group checker（默认 true） */
+    /** 是否注册默认 QQ 系 scene checker（默认 true） */
     registerChecker?: boolean;
 }
-export declare function createGroupManagementTools(adapter: IGroupManagement, prefix: string, options?: CreateGroupManagementToolsOptions): Tool[];
-export declare function createGroupManagementToolsRaw<T>(adapter: IGroupManagement, prefix: string, factory: GroupManagementToolFactory<T>): T[];
-export declare function buildMethodArgs(method: keyof IGroupManagement, endpointId: string, sceneId: string, rest: Record<string, any>): any[];
-//# sourceMappingURL=common-adapter-tools.d.ts.map
+export declare function createSceneManagementTools(adapter: ISceneManagement, prefix: string, options?: CreateSceneManagementToolsOptions): Tool[];
+export declare function createSceneManagementToolsRaw<T>(adapter: ISceneManagement, prefix: string, factory: SceneManagementToolFactory<T>): T[];
+export declare function buildSceneMethodArgs(method: keyof ISceneManagement, endpointId: string, sceneId: string, rest: Record<string, any>): any[];