@zhin.js/agent 0.0.18 → 0.0.19

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # @zhin.js/agent
 
+## 0.0.19
+
+### Patch Changes
+
+- 20ab379: fix: ai 优化
+- Updated dependencies [20ab379]
+  - @zhin.js/ai@1.0.17
+  - @zhin.js/core@1.0.56
+
 ## 0.0.18
 
 ### Patch Changes

package/README.md

@@ -7,10 +7,13 @@ Zhin AI Agent 组合层：在 `@zhin.js/core` 的类型与 Provider 之上，提
 - 🤖 **Agent 循环**：`Agent` / `createAgent`，支持工具调用、迭代与事件
 - 📝 **会话管理**：`SessionManager`、内存/数据库会话、`SessionManager.generateId`
 - 🧠 **ZhinAgent**：与 Zhin 消息流集成的智能体（SOUL/TOOLS/AGENTS、工具收集、执行策略）
+- �️ **6 层 Bash 安全**：`ExecPolicy` 纵深防御（危险黑名单、环境变量剥离、wrapper 剥离、复合命令拆分、只读放行、交互式审批）
+- 📂 **文件访问安全**：`FilePolicy` 路径检查、设备路径拦截、命令读写分类
+- 📋 **10 段系统提示词**：`PromptBuilder` 结构化 prompt（Identity、System、Tasks、Actions、Tools、Communication、Skills、Active Skills、Memory、Bootstrap）
 - 🔌 **框架挂载**：`initAgentModule()` 注册 `ctx.ai`、定时任务、DB 模型等
 - 📦 **上下文与记忆**：`ContextManager`、`ConversationMemory`、`UserProfileStore`
 - ⏰ **跟进与定时**：`FollowUpManager`、`PersistentCronEngine`、cron 工具
-- 🔧 **内置工具**：calculator、time、search、codeRunner、http、memory 等
+- 🔧 **内置工具**：bash、read_file、write_file、ask_user、web_search、chat_history 等
 - 📐 **会话压缩**：`compactSession`、token 估算、总结与裁剪
 - 🪝 **Hook 系统**：`registerAIHook`、`triggerAIHook` 等
 
@@ -76,7 +79,9 @@ const result = await agent.run('你好')
 | 初始化 | `initAgentModule` |
 | Agent | `Agent`, `createAgent`, `formatToolTitle` |
 | 服务与会话 | `AIService`, `SessionManager`, `MemorySessionManager`, `DatabaseSessionManager`, `createMemorySessionManager`, `createDatabaseSessionManager` |
-| ZhinAgent | `ZhinAgent`，以及 config / exec-policy / tool-collector / prompt / builtin-tools 等子模块 |
+| ZhinAgent | `ZhinAgent`，以及 config / exec-policy / file-policy / tool-collector / prompt / builtin-tools 等子模块 |
+| 安全策略 | `checkExecPolicy`, `applyExecPolicyToTools`, `isDangerousCommand`, `stripEnvVarPrefix`, `stripSafeWrappers`, `splitCompoundCommand`, `extractCommandName`, `ExecPolicyResult`, `checkFileAccess`, `classifyBashCommand`, `isBlockedDevicePath` |
+| 提示词构建 | `buildRichSystemPrompt`, `buildEnhancedPersona`, `buildUserMessageWithHistory`, `buildContextHint` |
 | 上下文与记忆 | `ContextManager`, `createContextManager`, `ConversationMemory`, `UserProfileStore` |
 | 跟进与定时 | `FollowUpManager`, `PersistentCronEngine`, `createCronTools`, `setCronManager`, `getCronManager` |
 | 压缩与 Bootstrap | `compactSession`, `estimateTokens`, `loadBootstrapFiles`, `loadSoulPersona`, `loadToolsGuide`, `loadAgentsMemory` |
@@ -190,8 +195,9 @@ src/
 ├── hooks.ts
 ├── output.ts
 ├── tools.ts
-├── builtin-tools.ts
+├── builtin-tools.ts      # 内置工具（bash、read_file、ask_user 等）
 ├── tone-detector.ts
+├── file-policy.ts        # 文件访问安全（路径检查、设备拦截、命令分类）
 ├── init.ts               # initAgentModule 精简入口（委托子模块）
 ├── init/                 # init 子模块（从 init.ts 拆分）
 │   ├── shared-refs.ts
@@ -207,11 +213,11 @@ src/
 │   └── register-builtin-tools.ts
 └── zhin-agent/           # ZhinAgent 及子模块
     ├── index.ts          # ZhinAgent 主类
-    ├── config.ts
-    ├── exec-policy.ts
-    ├── tool-collector.ts
-    ├── prompt.ts
-    └── builtin-tools.ts
+    ├── config.ts         # 配置与常量（ModelSizeHint、KEYWORD_TRIGGERS 等）
+    ├── exec-policy.ts    # Bash 执行安全（6 层纵深防御）
+    ├── tool-collector.ts # 工具收集与过滤
+    ├── prompt.ts         # 系统提示词构建器（10 段结构化架构）
+    └── builtin-tools.ts  # ZhinAgent 专用内置工具
 ```
 
 ### 构建

package/lib/builtin-tools.d.ts

@@ -7,11 +7,15 @@
  * 计划:      todo_read, todo_write
  * 记忆:      read_memory, write_memory (AGENTS.md)
  * 技能:      activate_skill, install_skill
+ * 交互:      ask_user（基于 Prompt 类的用户确认/提问工具）
  *
  * 发现逻辑已拆分到 discover-skills.ts / discover-agents.ts / discover-tools.ts
  */
+import { type Plugin } from '@zhin.js/core';
 import { ZhinTool } from '@zhin.js/core';
 export interface BuiltinToolsOptions {
+    /** 插件实例，用于 ask_user 工具创建 Prompt 交互 */
+    plugin?: Plugin;
     /** Max chars for skill instruction extraction (model-size-aware) */
     skillInstructionMaxChars?: number;
     /**

package/lib/builtin-tools.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"builtin-tools.d.ts","sourceRoot":"","sources":["../src/builtin-tools.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAOH,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAczC,MAAM,WAAW,mBAAmB;IAClC,oEAAoE;IACpE,wBAAwB,CAAC,EAAE,MAAM,CAAC;IAClC;;OAEG;IACH,wBAAwB,CAAC,EAAE,MAAM,MAAM,EAAE,CAAC;IAC1C;;;OAGG;IACH,eAAe,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAC;CACxD;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,CAAC,EAAE,mBAAmB,GAAG,QAAQ,EAAE,CAie5E"}
+{"version":3,"file":"builtin-tools.d.ts","sourceRoot":"","sources":["../src/builtin-tools.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAMH,OAAO,EAAkB,KAAK,MAAM,EAAuB,MAAM,eAAe,CAAC;AACjF,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AA4HzC,MAAM,WAAW,mBAAmB;IAClC,sCAAsC;IACtC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,oEAAoE;IACpE,wBAAwB,CAAC,EAAE,MAAM,CAAC;IAClC;;OAEG;IACH,wBAAwB,CAAC,EAAE,MAAM,MAAM,EAAE,CAAC;IAC1C;;;OAGG;IACH,eAAe,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAC;CACxD;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,CAAC,EAAE,mBAAmB,GAAG,QAAQ,EAAE,CAirB5E"}

package/lib/builtin-tools.js

@@ -7,6 +7,7 @@
  * 计划:      todo_read, todo_write
  * 记忆:      read_memory, write_memory (AGENTS.md)
  * 技能:      activate_skill, install_skill
+ * 交互:      ask_user（基于 Prompt 类的用户确认/提问工具）
  *
  * 发现逻辑已拆分到 discover-skills.ts / discover-agents.ts / discover-tools.ts
  */
@@ -14,13 +15,104 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { exec } from 'child_process';
 import { promisify } from 'util';
-import { Logger } from '@zhin.js/core';
+import { Logger, Prompt } from '@zhin.js/core';
 import { ZhinTool } from '@zhin.js/core';
-import { assertFileAccess, checkBashCommandSafety, shellEscape } from './file-policy.js';
+import { assertFileAccess, checkBashCommandSafety, shellEscape, isBlockedDevicePath, MAX_READ_FILE_SIZE, MAX_EDIT_FILE_SIZE, classifyBashCommand, isFileStale, } from './file-policy.js';
 import { errMsg, expandHome, getDataDir, mergeSkillDirsWithResolver, nodeErrToFileMessage, } from './discovery-utils.js';
 import { checkSkillDeps, extractSkillInstructions } from './discover-skills.js';
 const execAsync = promisify(exec);
 const logger = new Logger(null, 'builtin-tools');
+// ── 引号归一化 + 模糊匹配（参考 Claude Code FileEditTool/utils.ts） ──
+/** 将弯引号归一化为直引号 */
+function normalizeQuotes(str) {
+    return str
+        .replace(/\u2018/g, "'") // '
+        .replace(/\u2019/g, "'") // '
+        .replace(/\u201C/g, '"') // "
+        .replace(/\u201D/g, '"'); // "
+}
+/**
+ * 在文件内容中查找字符串，支持精确匹配和引号归一化模糊匹配。
+ * 参考 Claude Code `findActualString`。
+ */
+function findActualStringInFile(fileContent, searchString) {
+    // 精确匹配
+    const exactCount = fileContent.split(searchString).length - 1;
+    if (exactCount > 0) {
+        return { actual: searchString, count: exactCount, wasNormalized: false };
+    }
+    // 引号归一化匹配
+    const normalizedSearch = normalizeQuotes(searchString);
+    const normalizedFile = normalizeQuotes(fileContent);
+    const idx = normalizedFile.indexOf(normalizedSearch);
+    if (idx !== -1) {
+        // 提取文件中实际的字符串（保留原始弯引号）
+        const actual = fileContent.substring(idx, idx + searchString.length);
+        const normalizedCount = normalizedFile.split(normalizedSearch).length - 1;
+        return { actual, count: normalizedCount, wasNormalized: true };
+    }
+    return null;
+}
+/**
+ * 将 new_string 中的直引号替换为文件中原始的弯引号风格。
+ * 参考 Claude Code `preserveQuoteStyle`。
+ */
+function preserveQuoteStyleInEdit(oldString, actualOldString, newString) {
+    if (oldString === actualOldString)
+        return newString;
+    const hasDouble = actualOldString.includes('\u201C') || actualOldString.includes('\u201D');
+    const hasSingle = actualOldString.includes('\u2018') || actualOldString.includes('\u2019');
+    if (!hasDouble && !hasSingle)
+        return newString;
+    let result = newString;
+    if (hasDouble) {
+        // 简单启发式：前面是空白/行首时用左引号，否则右引号
+        const chars = [...result];
+        const out = [];
+        for (let i = 0; i < chars.length; i++) {
+            if (chars[i] === '"') {
+                const prev = i > 0 ? chars[i - 1] : ' ';
+                const isOpening = /[\s(\[{]/.test(prev) || i === 0;
+                out.push(isOpening ? '\u201C' : '\u201D');
+            }
+            else {
+                out.push(chars[i]);
+            }
+        }
+        result = out.join('');
+    }
+    if (hasSingle) {
+        const chars = [...result];
+        const out = [];
+        for (let i = 0; i < chars.length; i++) {
+            if (chars[i] === "'") {
+                const prev = i > 0 ? chars[i - 1] : ' ';
+                const next = i < chars.length - 1 ? chars[i + 1] : ' ';
+                // 两个字母之间是缩写，用右引号
+                if (/\p{L}/u.test(prev) && /\p{L}/u.test(next)) {
+                    out.push('\u2019');
+                }
+                else {
+                    const isOpening = /[\s(\[{]/.test(prev) || i === 0;
+                    out.push(isOpening ? '\u2018' : '\u2019');
+                }
+            }
+            else {
+                out.push(chars[i]);
+            }
+        }
+        result = out.join('');
+    }
+    return result;
+}
+// ── 图片格式检测（参考 Claude Code FileReadTool imageResizer） ──
+/** 支持的图片扩展名 */
+const IMAGE_EXTENSIONS = new Set([
+    '.png', '.jpg', '.jpeg', '.gif', '.webp', '.bmp', '.svg', '.ico',
+]);
+function isImageFile(filePath) {
+    return IMAGE_EXTENSIONS.has(path.extname(filePath).toLowerCase());
+}
 /**
  * 创建所有内置系统工具
  */
@@ -29,10 +121,11 @@ export function createBuiltinTools(options) {
     const skillMaxChars = options?.skillInstructionMaxChars ?? 4000;
     const skillDirList = () => mergeSkillDirsWithResolver(options?.pluginSkillRootsResolver);
     const skillFileLookup = options?.skillFileLookup;
+    const pluginRef = options?.plugin;
     const tools = [];
-    // ── read_file（清晰描述 + 强关键词） ──
+    // ── read_file（清晰描述 + 强关键词 + 图片检测 + 安全防护） ──
     tools.push(new ZhinTool('read_file')
-        .desc('读取指定路径的文件内容。用于查看、打开或读取任意文本文件。')
+        .desc('读取指定路径的文件内容。用于查看、打开或读取任意文本文件。图片文件返回 Base64 数据。')
         .keyword('读文件', '读取文件', '查看文件', '打开文件', '文件内容', 'read file', 'read', 'cat', '查看', '打开')
         .tag('file', 'read')
         .kind('file')
@@ -42,8 +135,25 @@ export function createBuiltinTools(options) {
         .execute(async (args) => {
         try {
             const fp = expandHome(args.file_path);
+            // 设备路径拦截（参考 Claude Code BLOCKED_DEVICE_PATHS）
+            if (isBlockedDevicePath(fp)) {
+                return `Error: 禁止读取设备文件 ${fp}（会导致进程挂起或注入攻击）`;
+            }
             assertFileAccess(fp);
             const stat = await fs.promises.stat(fp);
+            // 文件大小限制（参考 Claude Code MAX_EDIT_FILE_SIZE）
+            if (stat.size > MAX_READ_FILE_SIZE) {
+                return `Error: 文件过大 (${(stat.size / 1024 / 1024).toFixed(1)} MiB)，超过 ${MAX_READ_FILE_SIZE / 1024 / 1024} MiB 限制。请使用 offset/limit 分段读取。`;
+            }
+            // 图片文件检测（参考 Claude Code FileReadTool 的图片处理）
+            if (isImageFile(fp)) {
+                const buffer = await fs.promises.readFile(fp);
+                const ext = path.extname(fp).toLowerCase().replace('.', '');
+                const mimeType = ext === 'jpg' ? 'jpeg' : ext === 'svg' ? 'svg+xml' : ext;
+                const b64 = buffer.toString('base64');
+                const sizeKb = (buffer.length / 1024).toFixed(1);
+                return `[Image: ${path.basename(fp)}, ${sizeKb} KB, type: image/${mimeType}]\ndata:image/${mimeType};base64,${b64.slice(0, 200)}...(total ${b64.length} chars)`;
+            }
             const content = await fs.promises.readFile(fp, 'utf-8');
             const lines = content.split('\n');
             const offset = args.offset ?? 0;
@@ -76,9 +186,9 @@ export function createBuiltinTools(options) {
             return nodeErrToFileMessage(e, args.file_path, 'write');
         }
     }));
-    // ── edit_file（old_text 必须精确匹配） ──
+    // ── edit_file（支持精确匹配 + 引号归一化模糊匹配）──
     tools.push(new ZhinTool('edit_file')
-        .desc('在文件中查找并替换一段文本。old_string 必须在文件中精确存在且唯一；建议包含完整行或足够上下文以避免重复匹配。')
+        .desc('在文件中查找并替换一段文本。old_string 必须在文件中精确存在且唯一；建议包含完整行或足够上下文以避免重复匹配。支持弯引号/直引号自动归一化。')
         .keyword('编辑文件', '修改文件', '替换内容', '查找替换', 'edit file', 'edit', '修改', '替换')
         .tag('file', 'edit')
         .kind('file')
@@ -89,13 +199,30 @@ export function createBuiltinTools(options) {
         try {
             const fp = expandHome(args.file_path);
             assertFileAccess(fp);
+            // 文件大小限制
+            const stat = await fs.promises.stat(fp);
+            if (stat.size > MAX_EDIT_FILE_SIZE) {
+                return `Error: 文件过大 (${(stat.size / 1024 / 1024).toFixed(1)} MiB)，超过 ${MAX_EDIT_FILE_SIZE / 1024 / 1024} MiB 限制。`;
+            }
+            // 记录 mtime 用于防并发覆写
+            const mtimeBefore = stat.mtimeMs;
             const content = await fs.promises.readFile(fp, 'utf-8');
-            const count = content.split(args.old_string).length - 1;
-            if (count === 0)
-                return `Error: old_string not found in file. Make sure it matches exactly.`;
-            if (count > 1)
-                return `Warning: old_string appears ${count} times. Please provide more context to make it unique.`;
-            const newContent = content.replace(args.old_string, args.new_string);
+            // 精确匹配 → 引号归一化模糊匹配
+            const matchResult = findActualStringInFile(content, args.old_string);
+            if (!matchResult)
+                return `Error: old_string not found in file. Make sure it matches exactly (also tried quote normalization).`;
+            if (matchResult.count > 1)
+                return `Warning: old_string appears ${matchResult.count} times. Please provide more context to make it unique.`;
+            // 如果通过引号归一化匹配，保持文件的引号风格
+            const effectiveNew = matchResult.wasNormalized
+                ? preserveQuoteStyleInEdit(args.old_string, matchResult.actual, args.new_string)
+                : args.new_string;
+            const newContent = content.replace(matchResult.actual, effectiveNew);
+            // 写入前再检查 mtime 防止并发修改
+            const currentStat = await fs.promises.stat(fp);
+            if (isFileStale(mtimeBefore, currentStat.mtimeMs)) {
+                return `Error: 文件 ${fp} 在读取后被外部修改。请重新读取文件后再编辑，避免覆盖他人的修改。`;
+            }
             await fs.promises.writeFile(fp, newContent, 'utf-8');
             const oldLines = args.old_string.split('\n');
             const newLines = args.new_string.split('\n');
@@ -158,25 +285,76 @@ export function createBuiltinTools(options) {
             return `Error: ${errMsg(e)}`;
         }
     }));
-    // ── grep ──
+    // ── grep（支持上下文行、大小写、多行、ripgrep 自动检测） ──
     tools.push(new ZhinTool('grep')
-        .desc('按正则搜索文件内容，返回匹配行和行号')
-        .keyword('搜索', '查找内容', 'grep', '正则')
+        .desc('按正则搜索文件内容，返回匹配行和行号。优先使用 ripgrep (rg)，回退到 grep。')
+        .keyword('搜索', '查找内容', 'grep', '正则', 'rg', 'ripgrep')
         .tag('search', 'regex')
         .kind('file')
         .param('pattern', { type: 'string', description: '正则表达式' }, true)
         .param('path', { type: 'string', description: '搜索路径（默认 .）' })
         .param('include', { type: 'string', description: '文件类型过滤（如 *.ts）' })
+        .param('context', { type: 'number', description: '匹配行上下文行数（-C 参数）' })
+        .param('before', { type: 'number', description: '匹配行之前显示行数（-B 参数）' })
+        .param('after', { type: 'number', description: '匹配行之后显示行数（-A 参数）' })
+        .param('ignore_case', { type: 'boolean', description: '大小写不敏感搜索（-i 参数）' })
+        .param('multiline', { type: 'boolean', description: '多行模式，. 匹配换行（仅 ripgrep 支持）' })
+        .param('limit', { type: 'number', description: '最多返回结果行数（默认 50）' })
         .execute(async (args) => {
         try {
             const searchPath = args.path || '.';
             assertFileAccess(path.resolve(process.cwd(), searchPath));
-            // 安全转义 pattern 和 include 参数防止命令注入
             const safePattern = shellEscape(args.pattern);
             const safePath = shellEscape(searchPath);
-            const includeFlag = args.include ? `--include=${shellEscape(args.include)}` : '';
-            const { stdout } = await execAsync(`grep -rn ${includeFlag} ${safePattern} ${safePath} 2>/dev/null | head -50`, { cwd: process.cwd() });
-            return stdout.trim() || `No matches for '${args.pattern}'`;
+            const limit = args.limit ?? 50;
+            // 检测 ripgrep 是否可用
+            let useRipgrep = false;
+            try {
+                await execAsync('rg --version', { timeout: 3000 });
+                useRipgrep = true;
+            }
+            catch { /* ripgrep 不可用，回退到 grep */ }
+            let cmd;
+            if (useRipgrep) {
+                // ripgrep 命令构建
+                const rgFlags = ['-n']; // 行号
+                if (args.ignore_case)
+                    rgFlags.push('-i');
+                if (args.multiline)
+                    rgFlags.push('-U', '--multiline-dotall');
+                if (args.context)
+                    rgFlags.push(`-C${args.context}`);
+                else {
+                    if (args.before)
+                        rgFlags.push(`-B${args.before}`);
+                    if (args.after)
+                        rgFlags.push(`-A${args.after}`);
+                }
+                if (args.include)
+                    rgFlags.push(`--glob=${shellEscape(args.include)}`);
+                cmd = `rg ${rgFlags.join(' ')} ${safePattern} ${safePath} 2>/dev/null | head -${limit}`;
+            }
+            else {
+                // 传统 grep 回退
+                const grepFlags = ['-rn'];
+                if (args.ignore_case)
+                    grepFlags.push('-i');
+                if (args.context)
+                    grepFlags.push(`-C${args.context}`);
+                else {
+                    if (args.before)
+                        grepFlags.push(`-B${args.before}`);
+                    if (args.after)
+                        grepFlags.push(`-A${args.after}`);
+                }
+                const includeFlag = args.include ? `--include=${shellEscape(args.include)}` : '';
+                cmd = `grep ${grepFlags.join(' ')} ${includeFlag} ${safePattern} ${safePath} 2>/dev/null | head -${limit}`;
+            }
+            const { stdout } = await execAsync(cmd, { cwd: process.cwd() });
+            const engine = useRipgrep ? '(ripgrep)' : '(grep)';
+            return stdout.trim()
+                ? `${engine}\n${stdout.trim()}`
+                : `No matches for '${args.pattern}' ${engine}`;
         }
         catch (e) {
             const err = e;
@@ -185,9 +363,9 @@ export function createBuiltinTools(options) {
             return `Error: ${errMsg(e)}`;
         }
     }));
-    // ── bash ──
+    // ── bash（安全检查 + 命令读写分类） ──
     tools.push(new ZhinTool('bash')
-        .desc('执行 Shell 命令（带超时保护）')
+        .desc('执行 Shell 命令（带超时保护和命令分类）。返回结果中会标注命令类型（只读/搜索/写入）。')
         .keyword('执行', '运行', '命令', '终端', 'shell', 'bash')
         .tag('shell', 'exec')
         .kind('shell')
@@ -202,33 +380,47 @@ export function createBuiltinTools(options) {
             const safety = checkBashCommandSafety(cmd);
             if (!safety.safe)
                 return `Error: ${safety.reason}`;
+            // 命令读写分类
+            const classification = classifyBashCommand(cmd);
             const { stdout, stderr } = await execAsync(cmd, {
                 cwd: args.cwd || process.cwd(),
                 timeout,
                 maxBuffer: 1024 * 1024,
             });
             let result = '';
+            const tag = classification.isReadOnly
+                ? (classification.isSearch ? '[搜索]' : classification.isList ? '[列出]' : '[只读]')
+                : '[执行]';
             if (stdout.trim())
                 result += `STDOUT:\n${stdout.trim()}`;
             if (stderr.trim())
                 result += `${result ? '\n' : ''}STDERR:\n${stderr.trim()}`;
-            return result || '(no output)';
+            return `${tag} ${result || '(no output)'}`;
         }
         catch (e) {
             const err = e;
             return `Error (exit ${err.code || '?'}): ${errMsg(e)}\nSTDOUT:\n${err.stdout || ''}\nSTDERR:\n${err.stderr || ''}`;
         }
     }));
-    // ── web_search（搜索网页，返回标题、URL、摘要） ──
+    // ── web_search（搜索网页，返回标题、URL、摘要 + 域名过滤 + 次数限制） ──
+    let searchCount = 0;
+    const MAX_SEARCH_COUNT = 20; // 单次会话搜索次数上限
     tools.push(new ZhinTool('web_search')
-        .desc('在互联网上搜索，返回匹配的标题、URL 和摘要片段。用于查资料、找网页。')
+        .desc('在互联网上搜索，返回匹配的标题、URL 和摘要片段。用于查资料、找网页。支持域名过滤。')
         .keyword('搜索', '网上搜', '网页搜索', '搜索引擎', 'search', 'google', '百度', '查询', '搜一下')
         .tag('web', 'search')
         .kind('web')
         .param('query', { type: 'string', description: '搜索关键词或完整查询语句' }, true)
         .param('limit', { type: 'number', description: '返回结果数量（默认 5，建议 1–10）' })
+        .param('allowed_domains', { type: 'array', description: '仅保留这些域名的结果（可选，如 ["github.com", "stackoverflow.com"]）' })
+        .param('blocked_domains', { type: 'array', description: '排除这些域名的结果（可选）' })
         .execute(async (args) => {
         try {
+            // 搜索次数限制
+            searchCount++;
+            if (searchCount > MAX_SEARCH_COUNT) {
+                return `Error: 搜索次数已达上限 (${MAX_SEARCH_COUNT})。请使用已获取的信息回答。`;
+            }
             const limit = args.limit ?? 5;
             const url = `https://html.duckduckgo.com/html/?q=${encodeURIComponent(args.query)}`;
             const res = await fetch(url, {
@@ -266,37 +458,97 @@ export function createBuiltinTools(options) {
                     results.push({ title, url: href, snippet });
                 }
             }
-            if (results.length === 0)
+            // 域名过滤
+            let filtered = results;
+            if (args.allowed_domains?.length) {
+                const allowed = new Set(args.allowed_domains.map(d => d.toLowerCase()));
+                filtered = filtered.filter(r => {
+                    try {
+                        return allowed.has(new URL(r.url).hostname.toLowerCase());
+                    }
+                    catch {
+                        return false;
+                    }
+                });
+            }
+            if (args.blocked_domains?.length) {
+                const blocked = new Set(args.blocked_domains.map(d => d.toLowerCase()));
+                filtered = filtered.filter(r => {
+                    try {
+                        return !blocked.has(new URL(r.url).hostname.toLowerCase());
+                    }
+                    catch {
+                        return true;
+                    }
+                });
+            }
+            if (filtered.length === 0)
                 return 'No results found.';
-            return results.map((r, i) => `${i + 1}. ${r.title}\n   URL: ${r.url}\n   ${r.snippet}`).join('\n\n');
+            return `(${searchCount}/${MAX_SEARCH_COUNT} searches)\n` + filtered.map((r, i) => `${i + 1}. ${r.title}\n   URL: ${r.url}\n   ${r.snippet}`).join('\n\n');
         }
         catch (e) {
             return `Error: ${errMsg(e)}`;
         }
     }));
-    // ── web_fetch（抓取 URL 并提取正文） ──
+    // ── web_fetch（抓取 URL 并提取正文 + SSRF 防护 + 改进的内容提取） ──
     tools.push(new ZhinTool('web_fetch')
-        .desc('抓取指定 URL 的网页内容并提取正文（去除广告等），返回可读文本。用于读文章、获取网页内容。')
+        .desc('抓取指定 URL 的网页内容并提取正文（去除广告、脚本等），返回可读文本。仅支持 http/https 协议。')
         .keyword('抓取网页', '打开链接', '获取网页', '读网页', 'fetch', 'url', '链接内容', '网页内容')
         .tag('web', 'fetch')
         .kind('web')
         .param('url', { type: 'string', description: '要抓取的完整 URL（需 http 或 https）' }, true)
+        .param('max_length', { type: 'number', description: '最大返回字符数（默认 20480）' })
         .execute(async (args) => {
         try {
+            // SSRF 防护：仅允许 http/https 协议
+            let parsedUrl;
+            try {
+                parsedUrl = new URL(args.url);
+            }
+            catch {
+                return `Error: 无效的 URL 格式`;
+            }
+            if (parsedUrl.protocol !== 'http:' && parsedUrl.protocol !== 'https:') {
+                return `Error: 仅支持 http/https 协议，拒绝 ${parsedUrl.protocol}`;
+            }
+            // 阻止内网地址（SSRF 关键防护）
+            const hostname = parsedUrl.hostname.toLowerCase();
+            if (hostname === 'localhost' ||
+                hostname === '127.0.0.1' ||
+                hostname === '::1' ||
+                hostname === '0.0.0.0' ||
+                hostname.endsWith('.local') ||
+                hostname.startsWith('10.') ||
+                hostname.startsWith('192.168.') ||
+                /^172\.(1[6-9]|2\d|3[01])\./.test(hostname)) {
+                return `Error: 禁止访问内网地址 ${hostname}（SSRF 防护）`;
+            }
             const response = await fetch(args.url, {
                 headers: { 'User-Agent': 'Mozilla/5.0 (compatible; ZhinBot/1.0)' },
                 signal: AbortSignal.timeout(15000),
+                redirect: 'follow',
             });
             if (!response.ok)
                 return `HTTP ${response.status}: ${response.statusText}`;
             const html = await response.text();
+            // 改进的内容提取：去除脚本、样式、导航、页脚、表单等
             const text = html
                 .replace(/<script[^>]*>[\s\S]*?<\/script>/gi, '')
                 .replace(/<style[^>]*>[\s\S]*?<\/style>/gi, '')
+                .replace(/<nav[^>]*>[\s\S]*?<\/nav>/gi, '')
+                .replace(/<footer[^>]*>[\s\S]*?<\/footer>/gi, '')
+                .replace(/<header[^>]*>[\s\S]*?<\/header>/gi, ' ')
+                .replace(/<form[^>]*>[\s\S]*?<\/form>/gi, '')
+                .replace(/<!--[\s\S]*?-->/g, '')
                 .replace(/<[^>]+>/g, ' ')
+                .replace(/&nbsp;/gi, ' ')
+                .replace(/&amp;/g, '&')
+                .replace(/&lt;/g, '<')
+                .replace(/&gt;/g, '>')
+                .replace(/&quot;/g, '"')
                 .replace(/\s+/g, ' ')
                 .trim();
-            const maxLen = 20 * 1024;
+            const maxLen = args.max_length ?? 20 * 1024;
             return text.length > maxLen ? text.slice(0, maxLen) + '\n...(truncated)' : text;
         }
         catch (e) {
@@ -469,6 +721,62 @@ export function createBuiltinTools(options) {
             return `Error: ${errMsg(e)}`;
         }
     }));
+    // ── ask_user（基于 Prompt 类的用户确认/提问工具） ──
+    tools.push(new ZhinTool('ask_user')
+        .desc('向用户发送问题，等待用户在聊天中回复。用于需要用户确认、补充信息或做出选择时。支持文本输入、数字输入、是/否确认、选项选择。')
+        .keyword('询问', '确认', '提问', '用户输入', 'ask', 'confirm', 'prompt', '选择', '请问')
+        .tag('interaction', 'prompt')
+        .kind('interaction')
+        .param('question', { type: 'string', description: '要向用户提出的问题文本' }, true)
+        .param('type', { type: 'string', description: '问题类型: text(文本输入)、number(数字输入)、confirm(是/否确认)、pick(选项选择)。默认 text' })
+        .param('options', { type: 'array', description: '选项列表（type=pick 时必填），每项为字符串，如 ["选项A","选项B","选项C"]' })
+        .param('default_value', { type: 'string', description: '用户超时未回复时使用的默认值' })
+        .param('timeout', { type: 'number', description: '等待用户回复的超时时间（秒），默认 120' })
+        .execute(async (args, context) => {
+        // 无消息上下文时无法使用（如子任务场景）
+        if (!context?.message) {
+            return 'Error: 当前上下文没有消息来源，无法向用户提问。请改为在回复中直接询问。';
+        }
+        if (!pluginRef) {
+            return 'Error: 插件实例不可用，无法创建交互式提问。请改为在回复中直接询问。';
+        }
+        const prompt = new Prompt(pluginRef, context.message);
+        const timeoutMs = (args.timeout ?? 120) * 1000;
+        const questionType = args.type || 'text';
+        try {
+            switch (questionType) {
+                case 'number': {
+                    const defaultNum = args.default_value != null ? Number(args.default_value) : undefined;
+                    const result = await prompt.number(args.question, timeoutMs, defaultNum, '输入超时，已取消');
+                    return String(result);
+                }
+                case 'confirm': {
+                    const result = await prompt.confirm(args.question, 'yes', timeoutMs, false, '确认超时，已取消');
+                    return result ? 'yes' : 'no';
+                }
+                case 'pick': {
+                    if (!args.options?.length) {
+                        return 'Error: type=pick 时必须提供 options 选项列表';
+                    }
+                    const pickOptions = args.options.map((o) => ({ label: o, value: o }));
+                    const result = await prompt.pick(args.question, {
+                        type: 'text',
+                        options: pickOptions,
+                        timeout: timeoutMs,
+                    }, '选择超时，已取消');
+                    return String(result);
+                }
+                case 'text':
+                default: {
+                    const result = await prompt.text(args.question, timeoutMs, args.default_value || '', '输入超时，已取消');
+                    return result;
+                }
+            }
+        }
+        catch (e) {
+            return `用户未响应或输入错误: ${errMsg(e)}`;
+        }
+    }));
     return tools;
 }
 //# sourceMappingURL=builtin-tools.js.map