@saber2pr/ai-agent 0.0.64 → 0.0.66

package/lib/core/agent-graph.d.ts

@@ -1,6 +1,6 @@
-import { AIMessage, BaseMessage } from '@langchain/core/messages';
-import { GraphAgentOptions } from '../types/type';
-import { AgentGraphModel } from '../model/AgentGraphModel';
+import { AIMessage, BaseMessage } from "@langchain/core/messages";
+import { GraphAgentOptions } from "../types/type";
+import { AgentGraphModel } from "../model/AgentGraphModel";
 interface TokenUsage {
     total: number;
 }
@@ -30,7 +30,7 @@ export default class McpGraphAgent<T extends AgentGraphModel = any> {
      * 设置外部流式输出回调（如 VS Code Webview）。
      * 设置后，callModel 的流式输出将通过回调发送而非写入 stdout。
      */
-    setStreamOutput(callback: (chunk: string, type: 'think' | 'text') => void): void;
+    setStreamOutput(callback: (chunk: string, type: "think" | "text") => void): void;
     /**
      * 清除外部流式输出回调，恢复默认的 stdout 输出。
      */

package/lib/core/agent-graph.js

@@ -76,11 +76,11 @@ class McpGraphAgent {
         const cleanup = async () => {
             this.stopLoading();
             await this.closeMcpClients(); // 清理 MCP 连接
-            process.stdout.write('\u001B[?25h');
+            process.stdout.write("\u001B[?25h");
             process.exit(0);
         };
-        process.on('SIGINT', cleanup);
-        process.on('SIGTERM', cleanup);
+        process.on("SIGINT", cleanup);
+        process.on("SIGTERM", cleanup);
     }
     /**
      * 设置外部流式输出回调（如 VS Code Webview）。
@@ -96,7 +96,7 @@ class McpGraphAgent {
         this.streamOutputCallback = null;
     }
     printLoadedTools() {
-        console.log('\n🛠️  [Graph] 正在加载工具节点...');
+        console.log("\n🛠️  [Graph] 正在加载工具节点...");
         this.langchainTools.forEach((tool) => {
             // 工具名称
             console.log(`\n🧰 工具名: ${tool.name}`);
@@ -120,12 +120,12 @@ class McpGraphAgent {
     loadMcpConfigs() {
         const combined = { mcpServers: {} };
         const paths = [
-            path_1.default.join(os_1.default.homedir(), '.cursor', 'mcp.json'),
-            path_1.default.join(os_1.default.homedir(), '.vscode', 'mcp.json'),
+            path_1.default.join(os_1.default.homedir(), ".cursor", "mcp.json"),
+            path_1.default.join(os_1.default.homedir(), ".vscode", "mcp.json"),
         ];
-        paths.forEach(p => {
+        paths.forEach((p) => {
             if (fs_1.default.existsSync(p)) {
-                const content = JSON.parse(fs_1.default.readFileSync(p, 'utf-8'));
+                const content = JSON.parse(fs_1.default.readFileSync(p, "utf-8"));
                 Object.assign(combined.mcpServers, content.mcpServers);
             }
         });
@@ -142,13 +142,13 @@ class McpGraphAgent {
                     args: config.args,
                     env: { ...process.env, ...(config.env || {}) },
                 });
-                const client = new index_js_1.Client({ name: 'mcp-graph-client', version: '1.0.0' }, { capabilities: {} });
+                const client = new index_js_1.Client({ name: "mcp-graph-client", version: "1.0.0" }, { capabilities: {} });
                 await client.connect(transport);
                 this.mcpClients.push(client);
                 const { tools } = await client.listTools();
-                tools.forEach(tool => {
+                tools.forEach((tool) => {
                     mcpToolInfos.push({
-                        type: 'function',
+                        type: "function",
                         function: {
                             name: tool.name,
                             description: tool.description,
@@ -172,11 +172,23 @@ class McpGraphAgent {
         return mcpToolInfos;
     }
     async prepareTools() {
-        const builtinToolInfos = (0, builtin_1.createDefaultBuiltinTools)({ options: this.options });
+        const builtinToolInfos = (0, builtin_1.createDefaultBuiltinTools)({
+            options: this.options,
+        });
         const mcpToolInfos = await this.initMcpTools();
         // 合并内置、手动传入和 MCP 工具
-        const allToolInfos = [...builtinToolInfos, ...(this.options.tools || []), ...mcpToolInfos];
-        this.langchainTools = allToolInfos.map(t => (0, convertToLangChainTool_1.convertToLangChainTool)(t, { allTools: allToolInfos }));
+        let allToolInfos = [
+            ...builtinToolInfos,
+            ...(this.options.tools || []),
+            ...mcpToolInfos,
+        ];
+        if (this.options.filterTools) {
+            allToolInfos = allToolInfos.filter(this.options.filterTools);
+        }
+        this.langchainTools = allToolInfos.map((t) => (0, convertToLangChainTool_1.convertToLangChainTool)(t, {
+            allTools: allToolInfos,
+            agentOptions: this.options,
+        }));
         this.toolNode = new prebuilt_1.ToolNode(this.langchainTools);
         return {
             builtinToolInfos,
@@ -190,7 +202,6 @@ class McpGraphAgent {
         if (this.model && this.langchainTools.length > 0) {
             return this.getModel();
         }
-        ;
         // 1. 加载所有工具（含 MCP）
         const toolsInfo = await this.prepareTools();
         // 2. 初始化模型
@@ -213,17 +224,17 @@ class McpGraphAgent {
         this.mcpClients = [];
     }
     showLoading(text) {
-        const chars = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+        const chars = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
         let i = 0;
-        process.stdout.write('\u001B[?25l');
+        process.stdout.write("\u001B[?25l");
         const timer = setInterval(() => {
             process.stdout.write(`\r\x1b[36m${chars[i]}\x1b[0m ${text}`);
             i = (i + 1) % chars.length;
         }, 80);
         return () => {
             clearInterval(timer);
-            process.stdout.write('\r\x1b[K');
-            process.stdout.write('\u001B[?25h');
+            process.stdout.write("\r\x1b[K");
+            process.stdout.write("\u001B[?25h");
         };
     }
     startLoading(text) {
@@ -260,29 +271,33 @@ class McpGraphAgent {
         let config = {};
         if (fs_1.default.existsSync(config_1.CONFIG_FILE)) {
             try {
-                config = JSON.parse(fs_1.default.readFileSync(config_1.CONFIG_FILE, 'utf-8'));
+                config = JSON.parse(fs_1.default.readFileSync(config_1.CONFIG_FILE, "utf-8"));
             }
             catch (e) { }
         }
         if (!config.baseURL || !config.apiKey) {
-            const rl = readline_1.default.createInterface({ input: process.stdin, output: process.stdout });
-            const question = (q) => new Promise(res => rl.question(q, res));
+            const rl = readline_1.default.createInterface({
+                input: process.stdin,
+                output: process.stdout,
+            });
+            const question = (q) => new Promise((res) => rl.question(q, res));
             config.baseURL = config.baseURL || (await question(`? API Base URL: `));
             config.apiKey = config.apiKey || (await question(`? API Key: `));
-            config.model = config.model || (await question(`? Model Name: `)) || 'gpt-4o';
+            config.model =
+                config.model || (await question(`? Model Name: `)) || "gpt-4o";
             fs_1.default.writeFileSync(config_1.CONFIG_FILE, JSON.stringify(config, null, 2));
             rl.close();
         }
         return config;
     }
-    async chat(query = '开始代码审计') {
+    async chat(query = "开始代码审计") {
         try {
             await this.ensureInitialized();
             const app = await this.createGraph();
             const graphStream = await app.stream({
                 messages: [new messages_1.HumanMessage(query)],
             }, {
-                configurable: { thread_id: 'auto_worker' },
+                configurable: { thread_id: "auto_worker" },
                 recursionLimit: this.recursionLimit,
                 debug: this.verbose,
             });
@@ -290,7 +305,7 @@ class McpGraphAgent {
                 this.renderOutput(output, this.streamEnabled);
         }
         catch (error) {
-            console.error('\n❌ Chat 过程中发生错误:', error);
+            console.error("\n❌ Chat 过程中发生错误:", error);
         }
         finally {
             await this.closeMcpClients();
@@ -300,7 +315,7 @@ class McpGraphAgent {
      * 流式执行单次查询（编程式 API）。
      * 无论 options.stream 是否开启，此方法始终以流式方式输出。
      */
-    async stream(query = '开始代码审计') {
+    async stream(query = "开始代码审计") {
         const prevStream = this.streamEnabled;
         this.streamEnabled = true;
         try {
@@ -309,7 +324,7 @@ class McpGraphAgent {
             const graphStream = await app.stream({
                 messages: [new messages_1.HumanMessage(query)],
             }, {
-                configurable: { thread_id: 'stream_worker' },
+                configurable: { thread_id: "stream_worker" },
                 recursionLimit: this.recursionLimit,
                 debug: this.verbose,
             });
@@ -317,7 +332,7 @@ class McpGraphAgent {
                 this.renderOutput(output, true);
         }
         catch (error) {
-            console.error('\n❌ Stream 过程中发生错误:', error);
+            console.error("\n❌ Stream 过程中发生错误:", error);
         }
         finally {
             this.streamEnabled = prevStream;
@@ -327,21 +342,24 @@ class McpGraphAgent {
     async start() {
         await this.ensureInitialized();
         const app = await this.createGraph();
-        const rl = readline_1.default.createInterface({ input: process.stdin, output: process.stdout });
-        rl.on('SIGINT', () => {
+        const rl = readline_1.default.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        rl.on("SIGINT", () => {
             this.stopLoading();
             rl.close();
-            process.stdout.write('\u001B[?25h');
+            process.stdout.write("\u001B[?25h");
             process.exit(0);
         });
         const ask = () => {
-            rl.question('> ', async (input) => {
-                if (input.toLowerCase() === 'exit') {
+            rl.question("> ", async (input) => {
+                if (input.toLowerCase() === "exit") {
                     rl.close();
                     return;
                 }
                 const graphStream = await app.stream({ messages: [new messages_1.HumanMessage(input)] }, {
-                    configurable: { thread_id: 'session' },
+                    configurable: { thread_id: "session" },
                     recursionLimit: this.recursionLimit,
                     debug: this.verbose,
                 });
@@ -358,7 +376,9 @@ class McpGraphAgent {
         // ✅ 打印工具执行结果（tools 节点的输出）
         const toolsNode = output.tools;
         if (toolsNode && toolsNode.messages) {
-            const toolMessages = Array.isArray(toolsNode.messages) ? toolsNode.messages : [];
+            const toolMessages = Array.isArray(toolsNode.messages)
+                ? toolsNode.messages
+                : [];
             // 获取最近的 AI 消息以匹配 tool_call_id
             const lastAiMsg = agentNode?.messages?.[agentNode.messages.length - 1];
             const toolCallMap = new Map();
@@ -372,10 +392,12 @@ class McpGraphAgent {
                 // ToolMessage 有 tool_call_id 字段
                 const toolCallId = msg.tool_call_id || msg.id;
                 if (toolCallId) {
-                    const toolName = toolCallMap.get(toolCallId) || msg.name || 'unknown';
-                    const content = typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content);
+                    const toolName = toolCallMap.get(toolCallId) || msg.name || "unknown";
+                    const content = typeof msg.content === "string"
+                        ? msg.content
+                        : JSON.stringify(msg.content);
                     // 如果内容太长，截断显示
-                    const displayContent = content.length > 500 ? content.substring(0, 500) + '...' : content;
+                    const displayContent = content.length > 500 ? content.substring(0, 500) + "..." : content;
                     console.log(`✅ [工具结果] ${toolName}: ${displayContent}`);
                 }
             });
@@ -402,7 +424,7 @@ class McpGraphAgent {
             }
             // 4. 打印工具调用情况
             if (msg.tool_calls?.length) {
-                msg.tool_calls.forEach(call => {
+                msg.tool_calls.forEach((call) => {
                     console.log(`🛠️ [调用工具]: ${call.name} 📦 参数: ${JSON.stringify(call.args)}`);
                 });
             }
@@ -412,9 +434,9 @@ class McpGraphAgent {
         const recentToolCalls = this.getRecentToolCalls(state.messages);
         const recentToolCallsStr = recentToolCalls.length > 0
             ? `\n\n⚠️ 最近调用的工具（避免重复调用相同工具和参数）：\n${recentToolCalls
-                .map(tc => `  - ${tc.name}(${JSON.stringify(tc.args)})`)
-                .join('\n')}`
-            : '';
+                .map((tc) => `  - ${tc.name}(${JSON.stringify(tc.args)})`)
+                .join("\n")}`
+            : "";
         // 1. 构建当前的系统提示词模板
         const systemPromptTemplate = `
 ${(0, getSystemPromptTemplate_1.getSystemPromptTemplate)(this.targetDir)}
@@ -425,32 +447,32 @@ ${(0, getSystemPromptTemplate_1.getSystemPromptTemplate)(this.targetDir)}
         // ✅ 检查 options 中的 alwaysSystem 参数 (默认为 true 或根据你的需求设置)
         // 如果不希望每次都携带（即只在首轮携带），则过滤掉历史消息里的 SystemMessage
         if (this.options.alwaysSystem === false) {
-            inputMessages = state.messages.filter(msg => msg._getType() !== 'system');
+            inputMessages = state.messages.filter((msg) => msg._getType() !== "system");
         }
         else {
             // 默认模式：保持干净，由 PromptTemplate 重新生成最新的 System 状态
-            inputMessages = state.messages.filter(msg => msg._getType() !== 'system');
+            inputMessages = state.messages.filter((msg) => msg._getType() !== "system");
         }
         const prompt = prompts_1.ChatPromptTemplate.fromMessages([
-            ['system', systemPromptTemplate],
-            new prompts_1.MessagesPlaceholder('messages'),
+            ["system", systemPromptTemplate],
+            new prompts_1.MessagesPlaceholder("messages"),
         ]);
-        this.startLoading('AI 正在分析并思考中');
+        this.startLoading("AI 正在分析并思考中");
         try {
             const promptParams = {
                 messages: inputMessages,
                 recentToolCalls: recentToolCallsStr,
-                extraPrompt: this.options.extraSystemPrompt || '',
+                extraPrompt: this.options.extraSystemPrompt || "",
             };
             if (this.streamEnabled) {
                 // ✅ 流式模式：通过 AgentGraphModel.streamGenerate 进行流式输出
                 const formattedMessages = await prompt.formatMessages(promptParams);
                 this.stopLoading();
                 // --- 流式 <think> 标签实时过滤 + 流式打印思考内容 ---
-                const THINK_OPEN = '<think>';
-                const THINK_CLOSE = '</think>';
+                const THINK_OPEN = "<think>";
+                const THINK_CLOSE = "</think>";
                 let inThink = false;
-                let textBuffer = '';
+                let textBuffer = "";
                 let aiHeaderPrinted = false;
                 let thinkHeaderPrinted = false;
                 const hasExternalHandler = !!this.streamOutputCallback;
@@ -458,11 +480,11 @@ ${(0, getSystemPromptTemplate_1.getSystemPromptTemplate)(this.targetDir)}
                     if (!text)
                         return;
                     if (hasExternalHandler) {
-                        this.streamOutputCallback(text, 'text');
+                        this.streamOutputCallback(text, "text");
                     }
                     else {
                         if (!aiHeaderPrinted) {
-                            process.stdout.write('🤖 [AI]: ');
+                            process.stdout.write("🤖 [AI]: ");
                             aiHeaderPrinted = true;
                         }
                         process.stdout.write(text);
@@ -472,11 +494,11 @@ ${(0, getSystemPromptTemplate_1.getSystemPromptTemplate)(this.targetDir)}
                     if (!text)
                         return;
                     if (hasExternalHandler) {
-                        this.streamOutputCallback(text, 'think');
+                        this.streamOutputCallback(text, "think");
                     }
                     else {
                         if (!thinkHeaderPrinted) {
-                            process.stdout.write('\x1b[2m🧠 [思考]: ');
+                            process.stdout.write("\x1b[2m🧠 [思考]: ");
                             thinkHeaderPrinted = true;
                         }
                         process.stdout.write(text);
@@ -496,7 +518,7 @@ ${(0, getSystemPromptTemplate_1.getSystemPromptTemplate)(this.targetDir)}
                                 inThink = false;
                                 // 思考块结束：stdout 模式下换行 + 重置样式
                                 if (!hasExternalHandler && thinkHeaderPrinted) {
-                                    process.stdout.write('\x1b[0m\n');
+                                    process.stdout.write("\x1b[0m\n");
                                     thinkHeaderPrinted = false;
                                 }
                             }
@@ -539,10 +561,10 @@ ${(0, getSystemPromptTemplate_1.getSystemPromptTemplate)(this.targetDir)}
                 // 收尾：stdout 模式下关闭样式和换行
                 if (!hasExternalHandler) {
                     if (thinkHeaderPrinted) {
-                        process.stdout.write('\x1b[0m\n');
+                        process.stdout.write("\x1b[0m\n");
                     }
                     if (aiHeaderPrinted)
-                        process.stdout.write('\n');
+                        process.stdout.write("\n");
                 }
                 const aiMsg = result.generations[0].message;
                 const meta = aiMsg.response_metadata || {};
@@ -591,57 +613,49 @@ ${(0, getSystemPromptTemplate_1.getSystemPromptTemplate)(this.targetDir)}
         const totalTokens = state.tokenUsage?.total || 0;
         const totalMs = state.totalDuration || 0;
         if (totalTokens > 0 || totalMs > 0) {
-            console.log('\n' + '═'.repeat(50));
+            console.log("\n" + "═".repeat(50));
             console.log(`🏁 \x1b[32;1m[审计任务全量结算]\x1b[0m`);
             console.log(`   - 累计消耗总额: \x1b[33m${totalTokens}\x1b[0m Tokens`);
             console.log(`   - 累计执行耗时: \x1b[36m${(totalMs / 1000).toFixed(2)}\x1b[0m s`);
-            console.log('═'.repeat(50) + '\n');
+            console.log("═".repeat(50) + "\n");
         }
     }
     async createGraph() {
         const workflow = new langgraph_1.StateGraph(AgentState)
-            .addNode('agent', state => this.callModel(state))
-            .addNode('tools', this.toolNode)
-            .addNode('interrupt', state => {
+            .addNode("agent", (state) => this.callModel(state))
+            .addNode("tools", this.toolNode)
+            .addNode("interrupt", (state) => {
             return {
-                messages: [new messages_1.AIMessage({
-                        content: `Final Answer:\n💡 **嘿，我们已经聊了很多了！**
-
-为了保证服务质量，我通常会在 50 步操作后停下来和您确认一下。这样可以避免我产生“幻觉”或者做一些无用功。
-
-**任务还没完成吗？** 没关系，只要您回复“继续”，我马上就回来接着干！或者您有什么新的想法要告诉我？`
-                    })]
+                messages: [
+                    new messages_1.AIMessage({
+                        content: `Final Answer:\n💡 ⚠️ 抱歉，当前任务消耗的 Token 已达上限 ${this.options.maxTokens}。为了防止无限循环，我已停止执行。你可以尝试分步骤指令，继续发送指令，直到任务完成。`,
+                    }),
+                ],
             };
         })
-            .addEdge(langgraph_1.START, 'agent')
-            .addConditionalEdges('agent', state => {
+            .addEdge(langgraph_1.START, "agent")
+            .addConditionalEdges("agent", (state) => {
             const { messages } = state;
             const lastMsg = messages[messages.length - 1];
-            const content = lastMsg.content || '';
+            const content = lastMsg.content || "";
             // 🛑 新增：全局 Token 熔断保护
             // 如果已消耗 Token 超过了 options 中设置的 maxTokens (假设是总限额)
-            if (this.options.maxTokens && state.tokenUsage.total >= this.options.maxTokens) {
-                console.warn('⚠️ [警告] 已达到最大 Token 限制，强制结束任务。');
-                state.messages.push(new messages_1.AIMessage({
-                    content: `⚠️ 抱歉，当前任务消耗的 Token 已达上限 ${this.options.maxTokens}。为了防止无限循环，我已停止执行。你可以尝试分步骤指令，继续发送指令，直到任务完成。`
-                }));
-                this.printFinalSummary(state);
-                return langgraph_1.END;
+            if (this.options.maxTokens &&
+                state.tokenUsage.total >= this.options.maxTokens) {
+                return "interrupt";
             }
             // 1. 如果 AI 想要调用工具，去 tools 节点
             if (lastMsg.tool_calls && lastMsg.tool_calls.length > 0) {
-                return 'tools';
+                return "tools";
             }
-            const isFinalAnswer = content.includes('Final Answer');
+            const isFinalAnswer = content.includes("Final Answer");
             if (isFinalAnswer) {
                 this.printFinalSummary(state);
                 return langgraph_1.END;
             }
-            if (messages.length > 50) {
-                return 'interrupt';
-            }
             return langgraph_1.END;
-        }).addEdge('tools', 'agent');
+        })
+            .addEdge("tools", "agent");
         return workflow.compile({ checkpointer: this.checkpointer });
     }
 }

package/lib/tools/builtin.d.ts

@@ -1,4 +1,4 @@
-import { AgentOptions, ToolInfo } from '../types/type';
+import { AgentOptions, ToolInfo } from "../types/type";
 export interface BuiltinToolsContext {
     options?: AgentOptions;
 }

package/lib/tools/builtin.js

@@ -2,13 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createDefaultBuiltinTools = createDefaultBuiltinTools;
 const filesystem_1 = require("./filesystem");
-const get_all_tools_schema_1 = require("./loader/get_all_tools_schema");
 const ts_lsp_1 = require("./ts-lsp");
+const get_all_tools_schema_1 = require("./loader/get_all_tools_schema");
+const batch_run_tools_1 = require("./loader/batch_run_tools");
 function createDefaultBuiltinTools(context) {
     const { options } = context;
     return [
         ...(0, ts_lsp_1.getTsLspTools)(options?.targetDir || process.cwd()),
         ...(0, filesystem_1.getFilesystemTools)(options?.targetDir || process.cwd()),
         get_all_tools_schema_1.getAllToolsSchema,
+        batch_run_tools_1.batchRunTools,
     ];
 }

package/lib/tools/loader/batch_run_tools.d.ts

@@ -0,0 +1,2 @@
+import { ToolInfo } from '../../types/type';
+export declare const batchRunTools: ToolInfo;

package/lib/tools/loader/batch_run_tools.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.batchRunTools = void 0;
+const zod_1 = require("zod");
+const createTool_1 = require("../../utils/createTool");
+const kit_1 = require("../../utils/kit");
+exports.batchRunTools = (0, createTool_1.createTool)({
+    name: 'batch_run_tools',
+    // 使用更具指令性的英文描述
+    description: `Execute multiple tools in parallel. Use this for independent tasks such as reading multiple files, applying unrelated edits to different files, or fetching diagnostics simultaneously. CRITICAL: DO NOT apply multiple edits to the same file within a single batch to avoid write conflicts.`,
+    parameters: zod_1.z.object({
+        actions: zod_1.z.array(zod_1.z.object({
+            // 字段名和描述对齐 AI 习惯
+            tool_name: zod_1.z.string().describe('The name of the tool to execute.'),
+            args: zod_1.z.any().describe('The JSON object containing arguments for the specific tool.')
+        })).describe('A list of tool-calling actions to be executed concurrently.')
+    }),
+    handler: async ({ actions }, context) => {
+        // 1. 获取所有可用工具的映射
+        const toolMap = (0, kit_1.getArray)(context?.allTools).reduce((acc, tool) => ({ ...acc, [tool.function.name]: tool }), {});
+        if (Object.keys(toolMap).length === 0) {
+            return 'Error: Failed to retrieve tool execution context.';
+        }
+        // 2. 并行执行所有 Action
+        const results = await Promise.all(actions.map(async (action) => {
+            const { tool_name, args } = action;
+            const tool = toolMap[tool_name];
+            if (!tool) {
+                return {
+                    tool_name,
+                    status: 'error',
+                    output: `Tool not found: ${tool_name}`
+                };
+            }
+            try {
+                // 特别注意：这里调用的是 _handler，请确保参数 args 的结构与子工具 Zod 定义一致
+                const output = await tool._handler(args, context);
+                return {
+                    tool_name,
+                    status: 'success',
+                    output
+                };
+            }
+            catch (error) {
+                return {
+                    tool_name,
+                    status: 'error',
+                    output: error?.message || String(error)
+                };
+            }
+        }));
+        // 3. 格式化输出结果
+        // 虽然参数改成了英文，但返回给 AI 的结果标题可以保留清晰的结构
+        return results.map(res => `### Tool: ${res.tool_name} (${res.status})\n${res.output}\n---`).join('\n');
+    }
+});

package/lib/tools/loader/get_all_tools_schema.js

@@ -9,25 +9,36 @@ const zod_to_json_schema_1 = __importDefault(require("zod-to-json-schema"));
 const createTool_1 = require("../../utils/createTool");
 const generateToolMarkdown_1 = require("../../utils/generateToolMarkdown");
 const kit_1 = require("../../utils/kit");
+const getSystemPromptTemplate_1 = require("../../utils/getSystemPromptTemplate");
 exports.getAllToolsSchema = (0, createTool_1.createTool)({
-    name: 'get_all_tools_schema',
+    name: "get_all_tools_schema",
     description: 'Use this tool when you encounter a "tool not found" error or are unsure about the parameter schema. It retrieves the full definitions and JSON schemas for all available tools in the current environment.',
     parameters: zod_1.z.object({
-        toolName: zod_1.z.string().optional().describe('Optional: Specify a tool name to get its detailed schema. If omitted, returns all available tools.')
+        toolName: zod_1.z
+            .string()
+            .optional()
+            .describe("Optional: Specify a tool name to get its detailed schema. If omitted, returns all available tools."),
     }),
     // 增加第二个参数 context
     handler: async ({ toolName }, context) => {
         // 这里的 context.allTools 是在运行时从 Agent 实例传入的
         const availableTools = (0, kit_1.getArray)(context?.allTools);
         const targetTools = toolName
-            ? availableTools.filter(t => t.function.name === toolName)
+            ? availableTools.filter((t) => t.function.name === toolName)
             : availableTools;
-        return (0, generateToolMarkdown_1.generateToolMarkdown)(targetTools.map(item => ({
+        let remainPrompt = "";
+        if (context?.agentOptions) {
+            // 如果AI忘记了工具用法，说明出现了记忆模糊，这里把系统提示词再补充上，加强记忆
+            const systemPrompt = (0, getSystemPromptTemplate_1.getSystemPromptTemplate)(context.agentOptions.targetDir);
+            remainPrompt = `${systemPrompt || ""}\n${context?.agentOptions?.extraSystemPrompt || ""}`;
+        }
+        const toolsMarkdown = (0, generateToolMarkdown_1.generateToolMarkdown)(targetTools.map((item) => ({
             ...item,
             function: {
                 ...item.function,
-                parameters: (0, zod_to_json_schema_1.default)(item.function.parameters)
-            }
+                parameters: (0, zod_to_json_schema_1.default)(item.function.parameters),
+            },
         })));
-    }
+        return `${remainPrompt}\n${toolsMarkdown}`;
+    },
 });

package/lib/types/type.d.ts

@@ -1,13 +1,13 @@
-import { z } from 'zod';
-import { Client } from '@modelcontextprotocol/sdk/client/index';
-import { AgentGraphModel } from '../model/AgentGraphModel';
+import { z } from "zod";
+import { Client } from "@modelcontextprotocol/sdk/client/index";
+import { AgentGraphModel } from "../model/AgentGraphModel";
 export interface ApiConfig {
     baseURL: string;
     apiKey: string;
     model: string;
 }
 export interface ToolInfo {
-    type: 'function';
+    type: "function";
     function: {
         name: string;
         description?: string;
@@ -15,6 +15,7 @@ export interface ToolInfo {
     };
     _handler?: (args: any, context: {
         allTools: ToolInfo[];
+        agentOptions?: GraphAgentOptions;
     }) => Promise<any>;
     _client?: Client;
     _originalName?: string;
@@ -42,6 +43,7 @@ export interface GraphAgentOptions<T extends AgentGraphModel = any> extends Agen
     recursionLimit?: number;
     /** 是否启用流式输出，默认 false */
     stream?: boolean;
+    filterTools?: (tool: ToolInfo) => boolean;
 }
 export interface CreateAgentOptions {
     apiKey: string;

package/lib/utils/convertToLangChainTool.d.ts

@@ -1,7 +1,8 @@
 import { DynamicStructuredTool } from '@langchain/core/tools';
-import { ToolInfo } from '../types/type';
+import { GraphAgentOptions, ToolInfo } from '../types/type';
 export declare function convertToLangChainTool(info: ToolInfo, context: {
     allTools: ToolInfo[];
+    agentOptions: GraphAgentOptions;
 }): DynamicStructuredTool<import("zod").ZodObject<any, import("zod").UnknownKeysParam, import("zod").ZodTypeAny, {
     [x: string]: any;
 }, {

package/lib/utils/createTool.d.ts

@@ -1,5 +1,5 @@
-import { z } from 'zod';
-import { ToolInfo } from '../types/type';
+import { z } from "zod";
+import { GraphAgentOptions, ToolInfo } from "../types/type";
 export interface CreateToolOptions {
     name: string;
     description: string;
@@ -9,6 +9,7 @@ export interface CreateToolOptions {
     parameters: z.ZodObject<any>;
     handler: (args: any, context: {
         allTools: ToolInfo[];
+        agentOptions?: GraphAgentOptions;
     }) => Promise<string>;
 }
 export declare function createTool(options: CreateToolOptions): ToolInfo;

package/lib/utils/createTool.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createTool = createTool;
 function createTool(options) {
     return {
-        type: 'function',
+        type: "function",
         function: {
             name: options.name,
             description: options.description,
@@ -12,7 +12,7 @@ function createTool(options) {
         _handler: async (input, context) => {
             // 兼容处理：如果 input 是字符串，尝试解析为 JSON 对象
             let args = input;
-            if (typeof input === 'string') {
+            if (typeof input === "string") {
                 try {
                     args = JSON.parse(input);
                 }

package/lib/utils/formatSchema.js

@@ -6,18 +6,42 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.formatSchema = formatSchema;
 const zod_to_json_schema_1 = __importDefault(require("zod-to-json-schema"));
 function formatSchema(schema) {
-    const res = (0, zod_to_json_schema_1.default)(schema);
-    if (typeof res.properties === 'object') {
-        const requiredKeys = res.required || [];
+    const jsonSchema = (0, zod_to_json_schema_1.default)(schema);
+    // 递归处理函数
+    const processProperties = (properties, required = [], level = 0) => {
+        if (!properties || typeof properties !== 'object')
+            return '';
+        const indent = '  '.repeat(level);
         const lines = [];
-        for (const key in res.properties) {
-            lines.push(`     - ${key}: ${res.properties[key].type}${requiredKeys.includes(key) ? ' (required)' : ''}`);
+        for (const key in properties) {
+            const prop = properties[key];
+            const isRequired = required.includes(key);
+            // 1. 基础描述
+            let line = `${indent}- ${key}: ${prop.type || 'any'}${isRequired ? ' (required)' : ''}`;
+            if (prop.description)
+                line += ` - ${prop.description}`;
+            lines.push(line);
+            // 2. 递归处理数组 (Items)
+            if (prop.type === 'array' && prop.items) {
+                lines.push(`${indent}  Items:`);
+                if (prop.items.type === 'object' && prop.items.properties) {
+                    lines.push(processProperties(prop.items.properties, prop.items.required, level + 2));
+                }
+                else {
+                    lines.push(`${indent}    - Type: ${prop.items.type || 'any'}`);
+                }
+            }
+            // 3. 递归处理嵌套对象 (Object)
+            if (prop.type === 'object' && prop.properties) {
+                lines.push(processProperties(prop.properties, prop.required, level + 1));
+            }
         }
-        if (lines.length > 0) {
-            return lines.join('\n');
-        }
-        return 'No parameters';
+        return lines.join('\n');
+    };
+    if (jsonSchema.properties) {
+        const result = processProperties(jsonSchema.properties, jsonSchema.required, 2); // 保持你原来的缩进感
+        return result || 'No parameters';
     }
     const keys = Object.keys(schema.shape);
-    return keys.join(', ');
+    return keys.length > 0 ? keys.join(', ') : 'No parameters';
 }

package/lib/utils/generateToolMarkdown.d.ts

@@ -1,5 +1 @@
-/**
- * 将工具定义从 Zod Schema 转换为极简 Markdown 格式
- * 目的：显著节省 System Prompt 的 Token，同时保持 LLM 理解力
- */
 export declare function generateToolMarkdown(tools: any[]): string;

package/lib/utils/generateToolMarkdown.js

@@ -7,20 +7,41 @@ const kit_1 = require("./kit");
  * 将工具定义从 Zod Schema 转换为极简 Markdown 格式
  * 目的：显著节省 System Prompt 的 Token，同时保持 LLM 理解力
  */
+/**
+ * 递归解析 JSON Schema 并生成简化的 Markdown
+ */
+function parseSchemaRecursive(schema, indent = '') {
+    if (!schema)
+        return '';
+    let res = '';
+    // 1. 处理对象类型 (Object)
+    if (schema.type === 'object' && schema.properties) {
+        Object.entries(schema.properties).forEach(([key, val]) => {
+            const isReq = schema.required?.includes(key);
+            const type = val.type || (val.anyOf ? 'any' : 'unknown');
+            const desc = val.description ? `: ${val.description}` : '';
+            res += `${indent}- \`${key}\` (${type}${isReq ? ', required' : ''})${desc}\n`;
+            // 递归处理嵌套对象或数组
+            res += parseSchemaRecursive(val, indent + '  ');
+        });
+    }
+    // 2. 处理数组类型 (Array)
+    else if (schema.type === 'array' && schema.items) {
+        // 标注数组项的结构
+        res += `${indent}  *Items:* \n${parseSchemaRecursive(schema.items, indent + '    ')}`;
+    }
+    return res;
+}
 function generateToolMarkdown(tools) {
     let markdown = "## Tool Definitions\n\n";
     (0, kit_1.getArray)(tools).forEach((tool) => {
+        // 假设 cleanToolDefinition 返回的是符合 JSON Schema 规范的对象
         const { name, description, parameters } = (0, cleanToolDefinition_1.cleanToolDefinition)(tool);
         markdown += `- **${name}**: ${description}\n`;
-        // 提取 Zod 参数
-        const shape = parameters.properties || {};
-        const requiredFields = parameters.required || [];
-        Object.entries(shape).forEach(([paramName, schema]) => {
-            const isRequired = requiredFields.includes(paramName);
-            const type = schema.type.replace('Zod', '').toLowerCase();
-            const desc = schema.description || schema.title || '';
-            markdown += `  - \`${paramName}\` (${type}${isRequired ? ', required' : ''})${desc ? `: ${desc}` : ''}\n`;
-        });
+        // 从根部开始递归解析参数
+        if (parameters && parameters.type === 'object') {
+            markdown += parseSchemaRecursive(parameters, '  ');
+        }
         markdown += "\n";
     });
     return markdown;

package/lib/utils/getSystemPromptTemplate.js

@@ -11,6 +11,7 @@ Before providing any output or calling a tool, you **MUST** conduct a deep logic
 1. **Pure JSON Arguments**: Arguments must be a valid JSON object. NEVER wrap the entire JSON object in a string or quotes.
 2. **No Double Escaping**: Do not double-escape characters within the JSON.
 3. **No Idle Operations**: If the task is complete or no tool is needed, DO NOT output any "Action" structure. Never use "None", "null", or empty strings as a tool name.
+4. **Important Note**: For optimal efficiency, when performing multiple operations, use batch_run_tools to invoke all relevant tools in parallel, rather than sequentially. Prioritize parallel tool invocation whenever possible. For example, when reading three files, run three tool invocations in parallel to read all three files into the context simultaneously. When running multiple read-only commands (such as read_file_range, grep_search, or read_text_file), always run all commands in parallel. Use parallel tool invocations whenever possible, rather than running too many tools sequentially.
 
 # 🎯 Core Instructions
 1. **Termination Criterion**: Once you have read the requested files, answered the questions, or completed the code implementation, you must provide the final response immediately.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saber2pr/ai-agent",
-  "version": "0.0.64",
+  "version": "0.0.66",
   "description": "AI Assistant CLI.",
   "author": "saber2pr",
   "license": "ISC",