@zhin.js/agent 0.0.16 → 0.0.18

package/src/discovery-utils.ts

@@ -0,0 +1,96 @@
+/**
+ * 发现模块共用的工具函数
+ *
+ * 被 builtin-tools / discover-skills / discover-agents / discover-tools 共同依赖，
+ * 独立出来以避免循环导入。
+ */
+
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import type { Plugin } from '@zhin.js/core';
+
+/** 将 unknown 错误转为字符串 */
+export function errMsg(e: unknown): string {
+  return e instanceof Error ? e.message : String(e);
+}
+
+/** 获取 data/ 目录路径，自动创建 */
+export function getDataDir(): string {
+  const dir = path.join(process.cwd(), 'data');
+  fs.mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+/** 展开路径中的 ~ 为实际 home 目录 */
+export function expandHome(p: string): string {
+  if (p === '~') return os.homedir();
+  if (p.startsWith('~/') || p.startsWith('~\\')) return path.join(os.homedir(), p.slice(2));
+  return p;
+}
+
+/** Workspace / ~/.zhin / data 下 skills 根目录（与 activate_skill 扫描顺序一致的前缀） */
+export function buildStandardSkillDirs(): string[] {
+  return [
+    path.join(process.cwd(), 'skills'),
+    path.join(os.homedir(), '.zhin', 'skills'),
+    path.join(getDataDir(), 'skills'),
+  ];
+}
+
+/**
+ * 从根插件树收集：根插件与**直接子插件**包目录下的 `skills/`（其下为 `<name>/SKILL.md`）
+ */
+export function collectPluginSkillSearchRoots(root: Plugin | null | undefined): string[] {
+  if (!root) return [];
+  const dirs: string[] = [];
+  const push = (d: string) => {
+    if (d && !dirs.includes(d)) dirs.push(d);
+  };
+  const fromPlugin = (p: Plugin) => {
+    if (!p?.filePath) return;
+    const dir = path.dirname(p.filePath);
+    push(path.join(dir, 'skills'));
+    // Also check package root when filePath is under src/ or lib/
+    const dirName = path.basename(dir);
+    if (dirName === 'src' || dirName === 'lib') {
+      push(path.join(path.dirname(dir), 'skills'));
+    }
+  };
+  fromPlugin(root);
+  for (const child of root.children || []) {
+    fromPlugin(child);
+  }
+  return dirs;
+}
+
+/**
+ * 技能发现与 activate_skill 查找共用：标准目录 + 已加载插件包 skills/
+ */
+export function getSkillSearchDirectories(root?: Plugin | null): string[] {
+  const list = [...buildStandardSkillDirs()];
+  for (const d of collectPluginSkillSearchRoots(root ?? undefined)) {
+    if (!list.includes(d)) list.push(d);
+  }
+  return list;
+}
+
+export function mergeSkillDirsWithResolver(resolver?: () => string[]): string[] {
+  const list = [...buildStandardSkillDirs()];
+  for (const d of resolver?.() ?? []) {
+    if (d && !list.includes(d)) list.push(d);
+  }
+  return list;
+}
+
+/** 将 Node 文件错误转为 miniclawd 风格的结构化短句，便于模型区分并重试 */
+export function nodeErrToFileMessage(err: unknown, filePath: string, kind: 'read' | 'write' | 'edit' | 'list'): string {
+  const e = err as NodeJS.ErrnoException;
+  if (e?.code === 'ENOENT') {
+    if (kind === 'list') return `Error: Directory not found: ${filePath}`;
+    return `Error: File not found: ${filePath}`;
+  }
+  if (e?.code === 'EACCES') return `Error: Permission denied: ${filePath}`;
+  const action = kind === 'read' ? 'reading file' : kind === 'write' ? 'writing file' : kind === 'edit' ? 'editing file' : 'listing directory';
+  return `Error ${action}: ${e?.message ?? String(err)}`;
+}

package/src/init/create-zhin-agent.ts

@@ -5,7 +5,8 @@
 import * as path from 'path';
 import { getPlugin, Scheduler, getScheduler, setScheduler, type MessageType, type SendOptions } from '@zhin.js/core';
 import { ZhinAgent } from '../zhin-agent/index.js';
-import { collectPluginSkillSearchRoots, createBuiltinTools } from '../builtin-tools.js';
+import { createBuiltinTools } from '../builtin-tools.js';
+import { collectPluginSkillSearchRoots } from '../discovery-utils.js';
 import { resolveSkillInstructionMaxChars, DEFAULT_CONFIG } from '../zhin-agent/config.js';
 import { PersistentCronEngine, setCronManager } from '../cron-engine.js';
 import type { AIServiceRefs } from './shared-refs.js';

package/src/init/register-ai-trigger.ts

@@ -5,7 +5,7 @@ import './types.js';
 import { getPlugin, Message, shouldTriggerAI, inferSenderPermissions, parseRichMediaContent, mergeAITriggerConfig } from '@zhin.js/core';
 import type { Tool, ToolContext } from '@zhin.js/core';
 import type { ContentPart } from '@zhin.js/core';
-import type { OutputElement } from '../output.js';
+import type { OutputElement } from '@zhin.js/ai';
 import type { AIServiceRefs } from './shared-refs.js';
 
 /**

package/src/init/register-builtin-tools.ts

@@ -5,14 +5,12 @@
 import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
-import { getPlugin, type Tool, type SkillFeature } from '@zhin.js/core';
-import {
-  collectPluginSkillSearchRoots,
-  createBuiltinTools,
-  discoverWorkspaceSkills,
-  loadAlwaysSkillsContent,
-  buildSkillsSummaryXML,
-} from '../builtin-tools.js';
+import { getPlugin, type Tool, type SkillFeature, type AgentPresetFeature } from '@zhin.js/core';
+import { createBuiltinTools } from '../builtin-tools.js';
+import { collectPluginSkillSearchRoots } from '../discovery-utils.js';
+import { discoverWorkspaceSkills, loadAlwaysSkillsContent, buildSkillsSummaryXML } from '../discover-skills.js';
+import { discoverWorkspaceAgents } from '../discover-agents.js';
+import { discoverWorkspaceTools, buildToolFromMeta } from '../discover-tools.js';
 import { resolveSkillInstructionMaxChars, DEFAULT_CONFIG } from '../zhin-agent/config.js';
 import { loadBootstrapFiles, buildContextFiles, buildBootstrapContextSection } from '../bootstrap.js';
 import { triggerAIHook, createAIHookEvent } from '../hooks.js';
@@ -33,6 +31,10 @@ export function registerBuiltinTools(refs: AIServiceRefs): void {
     const builtinTools = createBuiltinTools({
       skillInstructionMaxChars: resolveSkillInstructionMaxChars(fullCfg, modelName),
       pluginSkillRootsResolver: () => collectPluginSkillSearchRoots(root),
+      skillFileLookup: (name: string) => {
+        const skillFeature = root.inject?.('skill') as SkillFeature | undefined;
+        return skillFeature?.get(name)?.filePath;
+      },
     });
     const disposers: (() => void)[] = [];
     for (const tool of builtinTools) disposers.push(toolService.addTool(tool, root.name));
@@ -42,6 +44,7 @@ export function registerBuiltinTools(refs: AIServiceRefs): void {
 
     let skillWatchers: fs.FSWatcher[] = [];
     let skillReloadDebounce: ReturnType<typeof setTimeout> | null = null;
+    let toolReloadDebounce: ReturnType<typeof setTimeout> | null = null;
 
     async function syncWorkspaceSkills(): Promise<number> {
       const skillFeature = root.inject?.('skill') as SkillFeature | undefined;
@@ -49,31 +52,122 @@ export function registerBuiltinTools(refs: AIServiceRefs): void {
       const existing = skillFeature.getByPlugin(root.name);
       for (const s of existing) skillFeature.remove(s);
       const skills = await discoverWorkspaceSkills(root);
-      if (skills.length === 0) return 0;
+      if (skills.length > 0) {
+        const allRegisteredTools = toolService.getAll();
+        const toolNameIndex = new Map<string, Tool>();
+        for (const t of allRegisteredTools) {
+          toolNameIndex.set(t.name, t);
+          const parts = t.name.split('_');
+          if (parts.length === 2) toolNameIndex.set(`${parts[1]}_${parts[0]}`, t);
+        }
+        for (const s of skills) {
+          const associatedTools: Tool[] = [];
+          const toolNames = s.toolNames || [];
+          for (const toolName of toolNames) {
+            let tool = toolService.get(toolName) || toolNameIndex.get(toolName);
+            if (tool) associatedTools.push(tool);
+          }
+          skillFeature.add({
+            name: s.name,
+            description: s.description,
+            tools: associatedTools,
+            keywords: s.keywords || [],
+            tags: s.tags || [],
+            pluginName: root.name,
+            filePath: s.filePath,
+            always: s.always,
+          }, root.name);
+        }
+      }
+      // Inject always-on skills content + XML summary into agent
+      if (refs.zhinAgent) {
+        const alwaysContent = await loadAlwaysSkillsContent(skills);
+        const skillsXml = buildSkillsSummaryXML(skills);
+        refs.zhinAgent.setActiveSkillsContext(alwaysContent);
+        refs.zhinAgent.setSkillsSummaryXML(skillsXml);
+      }
+      return skills.length;
+    }
+
+    // 文件化 Tool 的 disposer（用于热重载时移除旧 tool）
+    let toolFileDisposers: (() => void)[] = [];
+
+    /**
+     * Discover *.tool.md files and register them as tools.
+     */
+    async function syncWorkspaceTools(): Promise<number> {
+      // 移除之前文件化注册的 tool
+      for (const d of toolFileDisposers) d();
+      toolFileDisposers = [];
+
+      const toolMetas = await discoverWorkspaceTools(root);
+      if (toolMetas.length === 0) return 0;
+
+      let added = 0;
+      for (const meta of toolMetas) {
+        // 跳过已通过程序化方式注册的同名 tool
+        if (toolService.get(meta.name)) {
+          logger.debug(`Tool '${meta.name}' 已存在（程序化注册），跳过文件化版本`);
+          continue;
+        }
+        const tool = await buildToolFromMeta(meta);
+        if (!tool) continue;
+        const dispose = toolService.addTool(tool, root.name);
+        toolFileDisposers.push(dispose);
+        added++;
+      }
+      return added;
+    }
+
+    /**
+     * Discover *.agent.md files and register agent presets into AgentPresetFeature.
+     */
+    async function syncWorkspaceAgents(): Promise<number> {
+      const agentPresetFeature = root.inject?.('agentPreset') as AgentPresetFeature | undefined;
+      if (!agentPresetFeature) return 0;
+
+      // Remove previously discovered presets for this plugin
+      const existing = agentPresetFeature.getByPlugin(root.name);
+      for (const p of existing) agentPresetFeature.remove(p);
+
+      const agentMetas = await discoverWorkspaceAgents(root);
+      if (agentMetas.length === 0) return 0;
+
       const allRegisteredTools = toolService.getAll();
-      const toolNameIndex = new Map<string, Tool>();
+      const toolNameIndex = new Map<string, import('@zhin.js/core').Tool>();
       for (const t of allRegisteredTools) {
         toolNameIndex.set(t.name, t);
-        const parts = t.name.split('_');
-        if (parts.length === 2) toolNameIndex.set(`${parts[1]}_${parts[0]}`, t);
       }
-      for (const s of skills) {
-        const associatedTools: Tool[] = [];
-        const toolNames = s.toolNames || [];
-        for (const toolName of toolNames) {
-          let tool = toolService.get(toolName) || toolNameIndex.get(toolName);
+      let added = 0;
+      for (const meta of agentMetas) {
+        if (agentPresetFeature.get(meta.name)) continue;
+        const associatedTools: import('@zhin.js/core').Tool[] = [];
+        for (const toolName of meta.toolNames || []) {
+          const tool = toolService.get(toolName) || toolNameIndex.get(toolName);
           if (tool) associatedTools.push(tool);
         }
-        skillFeature.add({
-          name: s.name,
-          description: s.description,
-          tools: associatedTools,
-          keywords: s.keywords || [],
-          tags: s.tags || [],
-          pluginName: root.name,
+        // Read body as systemPrompt
+        let systemPrompt: string | undefined;
+        try {
+          const content = await fs.promises.readFile(meta.filePath, 'utf-8');
+          const body = content.replace(/^---\s*\n[\s\S]*?\n---\s*(?:\n|$)/, '').trim();
+          if (body) systemPrompt = body;
+        } catch { /* ignore */ }
+        agentPresetFeature.add({
+          name: meta.name,
+          description: meta.description,
+          keywords: meta.keywords,
+          tags: meta.tags,
+          tools: associatedTools.length > 0 ? associatedTools : undefined,
+          systemPrompt,
+          model: meta.model,
+          provider: meta.provider,
+          maxIterations: meta.maxIterations,
+          filePath: meta.filePath,
         }, root.name);
+        added++;
       }
-      return skills.length;
+      return added;
     }
 
     (async () => {
@@ -88,6 +182,26 @@ export function registerBuiltinTools(refs: AIServiceRefs): void {
         logger.warn(`Failed to discover workspace skills: ${e.message}`);
       }
 
+      // Step 1b: discover *.tool.md file-based tools
+      try {
+        const toolCount = await syncWorkspaceTools();
+        if (toolCount > 0) {
+          logger.info(`Registered ${toolCount} workspace file-based tools`);
+        }
+      } catch (e: any) {
+        logger.warn(`Failed to discover workspace tools: ${e.message}`);
+      }
+
+      // Step 1c: discover *.agent.md agent presets
+      try {
+        const agentCount = await syncWorkspaceAgents();
+        if (agentCount > 0) {
+          logger.info(`Registered ${agentCount} workspace agent presets`);
+        }
+      } catch (e: any) {
+        logger.debug(`Failed to discover workspace agents: ${e.message}`);
+      }
+
       // Step 2: load bootstrap files
       const loadedFiles: string[] = [];
       try {
@@ -118,19 +232,6 @@ export function registerBuiltinTools(refs: AIServiceRefs): void {
         logger.debug(`Bootstrap files not loaded: ${e.message}`);
       }
 
-      // Step 3: inject always-on skills content + XML summary
-      try {
-        const skillsForContext = await discoverWorkspaceSkills(root);
-        const alwaysContent = await loadAlwaysSkillsContent(skillsForContext);
-        const skillsXml = buildSkillsSummaryXML(skillsForContext);
-        if (refs.zhinAgent) {
-          refs.zhinAgent.setActiveSkillsContext(alwaysContent);
-          refs.zhinAgent.setSkillsSummaryXML(skillsXml);
-        }
-      } catch (e: unknown) {
-        logger.debug(`Skills context not set: ${e instanceof Error ? e.message : String(e)}`);
-      }
-
       // Trigger agent:bootstrap hook
       const skillFeature2 = root.inject('skill') as SkillFeature | undefined;
       await triggerAIHook(createAIHookEvent('agent', 'bootstrap', undefined, {
@@ -140,6 +241,30 @@ export function registerBuiltinTools(refs: AIServiceRefs): void {
         bootstrapFiles: loadedFiles,
       }));
 
+      // Hot-reload tool directories
+      const workspaceToolDir = path.join(process.cwd(), 'tools');
+      const onToolDirChange = () => {
+        if (toolReloadDebounce) clearTimeout(toolReloadDebounce);
+        toolReloadDebounce = setTimeout(async () => {
+          toolReloadDebounce = null;
+          try {
+            const count = await syncWorkspaceTools();
+            if (count >= 0) logger.info(`[Tool热重载] 已更新，工作区文件化Tool: ${count}`);
+          } catch (e: any) {
+            logger.warn(`[Tool热重载] 失败: ${e.message}`);
+          }
+        }, 400);
+      };
+      if (fs.existsSync(workspaceToolDir)) {
+        try {
+          const w = fs.watch(workspaceToolDir, { recursive: true }, onToolDirChange);
+          skillWatchers.push(w);
+          logger.debug(`[Tool热重载] 监听目录: ${workspaceToolDir}`);
+        } catch (e: any) {
+          logger.debug(`[Tool热重载] 无法监听 ${workspaceToolDir}: ${e.message}`);
+        }
+      }
+
       // Hot-reload skill directories
       const workspaceSkillDir = path.join(process.cwd(), 'skills');
       const localSkillDir = path.join(os.homedir(), '.zhin', 'skills');
@@ -149,15 +274,8 @@ export function registerBuiltinTools(refs: AIServiceRefs): void {
           skillReloadDebounce = null;
           try {
             const count = await syncWorkspaceSkills();
-            const skillsForContext = await discoverWorkspaceSkills(root);
-            const alwaysContent = await loadAlwaysSkillsContent(skillsForContext);
-            const skillsXml = buildSkillsSummaryXML(skillsForContext);
-            if (refs.zhinAgent) {
-              refs.zhinAgent.setActiveSkillsContext(alwaysContent);
-              refs.zhinAgent.setSkillsSummaryXML(skillsXml);
-            }
             await triggerAIHook(createAIHookEvent('agent', 'skills-reloaded', undefined, { skillCount: count }));
-            if (count >= 0) logger.info(`[技能热重载] 已更新，当前工作区技能数: ${count}`);
+            if (count >= 0) logger.info(`[技能热重载] 已更新，工作区技能: ${count}`);
           } catch (e: any) {
             logger.warn(`[技能热重载] 失败: ${e.message}`);
           }
@@ -178,9 +296,12 @@ export function registerBuiltinTools(refs: AIServiceRefs): void {
 
     return () => {
       disposers.forEach(d => d());
+      toolFileDisposers.forEach(d => d());
+      toolFileDisposers = [];
       skillWatchers.forEach(w => w.close());
       skillWatchers = [];
       if (skillReloadDebounce) clearTimeout(skillReloadDebounce);
+      if (toolReloadDebounce) clearTimeout(toolReloadDebounce);
     };
   });
 }

package/src/init/register-db-models.ts

@@ -2,9 +2,9 @@
  * Define AI-related database models (7 tables).
  */
 import { getPlugin } from '@zhin.js/core';
-import { AI_SESSION_MODEL } from '../session.js';
-import { CHAT_MESSAGE_MODEL, CONTEXT_SUMMARY_MODEL } from '../context-manager.js';
-import { AI_MESSAGE_MODEL, AI_SUMMARY_MODEL } from '../conversation-memory.js';
+import { AI_SESSION_MODEL } from '@zhin.js/ai';
+import { CHAT_MESSAGE_MODEL, CONTEXT_SUMMARY_MODEL } from '@zhin.js/ai';
+import { AI_MESSAGE_MODEL, AI_SUMMARY_MODEL } from '@zhin.js/ai';
 import { AI_USER_PROFILE_MODEL } from '../user-profile.js';
 import { AI_FOLLOWUP_MODEL } from '../follow-up.js';
 

package/src/init/register-db-upgrade.ts

@@ -7,8 +7,8 @@
 import './types.js';
 import { getPlugin } from '@zhin.js/core';
 import type { AIConfig } from '@zhin.js/core';
-import { createDatabaseSessionManager } from '../session.js';
-import { createContextManager } from '../context-manager.js';
+import { createDatabaseSessionManager } from '@zhin.js/ai';
+import { createContextManager } from '@zhin.js/ai';
 import type { AIServiceRefs } from './shared-refs.js';
 
 export function registerDbUpgrade(refs: AIServiceRefs): void {

package/src/init/register-management-tools.ts

@@ -3,7 +3,7 @@
  */
 import './types.js';
 import { getPlugin, Message, ZhinTool } from '@zhin.js/core';
-import { SessionManager } from '../session.js';
+import { SessionManager } from '@zhin.js/ai';
 
 export function registerManagementTools(): void {
   const plugin = getPlugin();

package/src/init/register-message-recorder.ts

@@ -2,7 +2,7 @@
  * Register middleware that records messages to the context manager.
  */
 import { getPlugin, Message } from '@zhin.js/core';
-import type { MessageRecord } from '../context-manager.js';
+import type { MessageRecord } from '@zhin.js/ai';
 import type { AIServiceRefs } from './shared-refs.js';
 
 export function registerMessageRecorder(refs: AIServiceRefs): void {

package/src/service.ts

@@ -25,14 +25,28 @@ import {
 import {
   SessionManager,
   createMemorySessionManager,
-  createDatabaseSessionManager,
-} from './session.js';
-import { Agent, createAgent } from './agent.js';
+} from '@zhin.js/ai';
+import { Agent, createAgent } from '@zhin.js/ai';
 import { getBuiltinTools } from './tools.js';
-import type { ContextManager, ContextConfig } from './context-manager.js';
+import type { ContextManager, ContextConfig } from '@zhin.js/ai';
+import { PERM_MAP } from './zhin-agent/config.js';
 
 const aiLogger = new Logger(null, 'AI');
 
+/** Provider 注册表：key → 构造函数 + 是否需要 apiKey */
+const PROVIDER_REGISTRY: Array<{
+  key: keyof NonNullable<AIConfig['providers']>;
+  factory: new (config: any) => AIProvider;
+  requireApiKey: boolean;
+}> = [
+  { key: 'openai', factory: OpenAIProvider, requireApiKey: true },
+  { key: 'anthropic', factory: AnthropicProvider, requireApiKey: true },
+  { key: 'deepseek', factory: DeepSeekProvider, requireApiKey: true },
+  { key: 'moonshot', factory: MoonshotProvider, requireApiKey: true },
+  { key: 'zhipu', factory: ZhipuProvider, requireApiKey: true },
+  { key: 'ollama', factory: OllamaProvider, requireApiKey: false },
+];
+
 export class AIService {
   private providers: Map<string, AIProvider> = new Map();
   private defaultProvider: string;
@@ -55,23 +69,11 @@ export class AIService {
     this.sessions = createMemorySessionManager(this.sessionConfig);
     this.builtinTools = getBuiltinTools().map(tool => this.convertToolToAgentTool(tool.toTool()));
 
-    if (config.providers?.openai?.apiKey) {
-      this.registerProvider(new OpenAIProvider(config.providers.openai));
-    }
-    if (config.providers?.anthropic?.apiKey) {
-      this.registerProvider(new AnthropicProvider(config.providers.anthropic));
-    }
-    if (config.providers?.deepseek?.apiKey) {
-      this.registerProvider(new DeepSeekProvider(config.providers.deepseek));
-    }
-    if (config.providers?.moonshot?.apiKey) {
-      this.registerProvider(new MoonshotProvider(config.providers.moonshot));
-    }
-    if (config.providers?.zhipu?.apiKey) {
-      this.registerProvider(new ZhipuProvider(config.providers.zhipu));
-    }
-    if (config.providers?.ollama) {
-      this.registerProvider(new OllamaProvider(config.providers.ollama));
+    for (const { key, factory, requireApiKey } of PROVIDER_REGISTRY) {
+      const providerConfig = config.providers?.[key];
+      if (!providerConfig) continue;
+      if (requireApiKey && !(providerConfig as any).apiKey) continue;
+      this.registerProvider(new factory(providerConfig as any));
     }
   }
 
@@ -79,98 +81,15 @@ export class AIService {
     return this.providers.size > 0;
   }
 
-  private static readonly PRE_EXEC_TIMEOUT = 10_000;
-
   async process(
     content: string,
     context: ToolContext,
-    tools: Tool[],
-  ): Promise<string | AsyncIterable<string>> {
+    _tools: Tool[],
+  ): Promise<string> {
     const { platform, senderId, sceneId } = context;
     const sessionId = SessionManager.generateId(platform || '', senderId || '', sceneId);
-    const allTools = this.collectAllToolsWithExternal(tools);
-    const baseSystemPrompt = 'You are a helpful AI assistant. Reply in the language specified in [User profile] (key: language / preferred_language), or in the user\'s message language if not set.';
-
-    if (allTools.length === 0) {
-      return this.finishAndSave(sessionId, content, baseSystemPrompt, sceneId);
-    }
-
-    const callerPermissionLevel = context.senderPermissionLevel
-      ? (AIService.PERM_MAP[context.senderPermissionLevel] ?? 0)
-      : (context.isOwner ? 4 : context.isBotAdmin ? 3 : context.isGroupOwner ? 2 : context.isGroupAdmin ? 1 : 0);
-
-    const relevantTools = Agent.filterTools(content, allTools, {
-      callerPermissionLevel,
-      maxTools: 8,
-      minScore: 0.1,
-    });
-
-    if (relevantTools.length === 0) {
-      return this.finishAndSave(sessionId, content, baseSystemPrompt, sceneId);
-    }
-
-    const noParamTools: AgentTool[] = [];
-    const paramTools: AgentTool[] = [];
-    for (const tool of relevantTools) {
-      const required = tool.parameters?.required;
-      (!required || required.length === 0) ? noParamTools.push(tool) : paramTools.push(tool);
-    }
-
-    let preExecutedData = '';
-    const preExecutedCalls: { tool: string; args: Record<string, any>; result: any }[] = [];
-
-    if (noParamTools.length > 0) {
-      const results = await Promise.allSettled(
-        noParamTools.map(async (tool) => {
-          const result = await Promise.race([
-            tool.execute({}),
-            new Promise<never>((_, reject) =>
-              setTimeout(() => reject(new Error('预执行超时')), AIService.PRE_EXEC_TIMEOUT)),
-          ]);
-          return { name: tool.name, result };
-        }),
-      );
-      for (const r of results) {
-        if (r.status === 'fulfilled') {
-          const s = typeof r.value.result === 'string' ? r.value.result : JSON.stringify(r.value.result);
-          preExecutedData += `\n${s}`;
-          preExecutedCalls.push({ tool: r.value.name, args: {}, result: r.value.result });
-        }
-      }
-    }
-
-    let finalResponse: string;
-
-    if (paramTools.length === 0 && preExecutedData) {
-      const singleShotPrompt = `You are a helpful AI assistant. Reply in the language specified in [User profile] (key: language / preferred_language), or in the user's message language if not set.\n\nPre-fetched data:\n${preExecutedData}\n\nAnswer the user's question based on the data above. Do not mention data sources or tool names. Summarize clearly and highlight key information.`;
-      finalResponse = await this.simpleChat(content, singleShotPrompt);
-    } else {
-      const agentSystemPrompt = `You are a helpful AI assistant. Reply in the language specified in [User profile] (key: language / preferred_language), or in the user's message language if not set.
-${preExecutedData ? `\nPre-fetched data:\n${preExecutedData}\n` : ''}
-## Requirements
-- After calling tools, give a complete answer based on the results; do not mention tool names or data sources
-- Summarize in natural language and highlight key information`;
-
-      const agent = this.createAgent({
-        systemPrompt: agentSystemPrompt,
-        tools: paramTools.length > 0 ? paramTools : relevantTools,
-        useBuiltinTools: false,
-        collectExternalTools: false,
-        maxIterations: 3,
-      });
-
-      const agentResult = await agent.run(content);
-      finalResponse = agentResult.content || this.formatToolCallsFallback(
-        [...preExecutedCalls, ...agentResult.toolCalls],
-      );
-    }
-
-    await this.sessions.addMessage(sessionId, { role: 'user', content });
-    await this.sessions.addMessage(sessionId, { role: 'assistant', content: finalResponse });
-    if (this.contextManager && sceneId) {
-      this.contextManager.autoSummarizeIfNeeded(sceneId).catch(() => {});
-    }
-    return finalResponse;
+    const systemPrompt = 'You are a helpful AI assistant. Reply in the language specified in [User profile] (key: language / preferred_language), or in the user\'s message language if not set.';
+    return this.finishAndSave(sessionId, content, systemPrompt, sceneId);
   }
 
   private async finishAndSave(sessionId: string, content: string, systemPrompt: string, sceneId?: string): Promise<string> {
@@ -183,13 +102,6 @@ ${preExecutedData ? `\nPre-fetched data:\n${preExecutedData}\n` : ''}
     return response;
   }
 
-  private formatToolCallsFallback(toolCalls: { tool: string; args: any; result: any }[]): string {
-    if (toolCalls.length === 0) return 'Done.';
-    return toolCalls.map(tc => {
-      return typeof tc.result === 'string' ? tc.result : JSON.stringify(tc.result, null, 2);
-    }).join('\n\n');
-  }
-
   private async simpleChat(content: string, systemPrompt: string): Promise<string> {
     const provider = this.getProvider();
     const response = await this.chat({
@@ -203,22 +115,6 @@ ${preExecutedData ? `\nPre-fetched data:\n${preExecutedData}\n` : ''}
     return typeof msgContent === 'string' ? msgContent : '';
   }
 
-  private collectAllToolsWithExternal(externalTools: Tool[]): AgentTool[] {
-    const tools: AgentTool[] = [];
-    tools.push(...this.builtinTools);
-    tools.push(...this.customTools.values());
-    for (const tool of externalTools) {
-      if (tool.name.startsWith('cmd_') || tool.name.startsWith('process_')) continue;
-      tools.push(this.convertToolToAgentTool(tool));
-    }
-    if (tools.length > 30) return tools.slice(0, 30);
-    return tools;
-  }
-
-  private static readonly PERM_MAP: Record<string, number> = {
-    'user': 0, 'group_admin': 1, 'group_owner': 2, 'bot_admin': 3, 'owner': 4,
-  };
-
   private convertToolToAgentTool(tool: Tool): AgentTool {
     const agentTool: AgentTool = {
       name: tool.name,
@@ -227,7 +123,7 @@ ${preExecutedData ? `\nPre-fetched data:\n${preExecutedData}\n` : ''}
       execute: async (args) => tool.execute(args),
     };
     if (tool.tags?.length) agentTool.tags = tool.tags;
-    if (tool.permissionLevel) agentTool.permissionLevel = AIService.PERM_MAP[tool.permissionLevel] ?? 0;
+    if (tool.permissionLevel) agentTool.permissionLevel = PERM_MAP[tool.permissionLevel] ?? 0;
     if (tool.keywords?.length) agentTool.keywords = tool.keywords;
     return agentTool;
   }

package/src/subagent.ts

@@ -11,7 +11,7 @@
 import { randomUUID } from 'crypto';
 import { Logger } from '@zhin.js/core';
 import type { AIProvider, AgentTool } from '@zhin.js/core';
-import { createAgent } from './agent.js';
+import { createAgent } from '@zhin.js/ai';
 import type { ZhinAgentConfig } from './zhin-agent/config.js';
 import { applyExecPolicyToTools } from './zhin-agent/exec-policy.js';