@amical/aiagent-sdk 0.1.7 → 0.1.9

package/dist/runtime/nodeRuntime.js

@@ -6,7 +6,7 @@ var ai = require('ai');
 var openai = require('@ai-sdk/openai');
 var difyAiProvider = require('dify-ai-provider');
 var fs2 = require('fs/promises');
-var path2 = require('path');
+var path = require('path');
 var os = require('os');
 var child_process = require('child_process');
 var util = require('util');
@@ -35,7 +35,7 @@ function _interopNamespace(e) {
 
 var matter__default = /*#__PURE__*/_interopDefault(matter);
 var fs2__namespace = /*#__PURE__*/_interopNamespace(fs2);
-var path2__namespace = /*#__PURE__*/_interopNamespace(path2);
+var path__namespace = /*#__PURE__*/_interopNamespace(path);
 var os__namespace = /*#__PURE__*/_interopNamespace(os);
 
 // src/shared/tools.ts
@@ -582,7 +582,7 @@ var ClineAgent = class {
     }
   }
   /**
-   * 获取当前 Agent 的系统提示词 
+   * 获取当前 Agent 的系统提示词
    * 如果 force 为 true，则强制重新获取系统提示词
    */
   async getPrompt(force = false) {
@@ -720,9 +720,12 @@ ${content.trim()}\`\`\``);
       const history = await this.memory.getHistory();
       const stream = this.api.createMessage(sysPrompt, history);
       let fullResponseText = "";
+      let fullReasoningText = "";
       for await (const chunk of stream) {
         if (chunk.type === "text" && chunk.text) {
           fullResponseText += chunk.text;
+        } else if (chunk.type === "reasoning" && chunk.reasoning) {
+          fullReasoningText += chunk.reasoning;
         }
         if (this.onStreamChunk) {
           this.onStreamChunk(chunk);
@@ -730,7 +733,8 @@ ${content.trim()}\`\`\``);
       }
       await this.memory.appendMessage({
         role: "assistant",
-        content: fullResponseText
+        content: fullResponseText,
+        ...fullReasoningText ? { reasoning: fullReasoningText } : {}
       });
       const parsedBlocks = parseAssistantMessageV2(fullResponseText, this.allToolParamNames);
       const toolUses = parsedBlocks.filter((b) => b.type === "tool_use");
@@ -853,15 +857,20 @@ STDERR: ${result.stderr}` });
             const path3 = tool.params.path || this.runtime.env.cwd();
             const regexStr = tool.params.regex;
             const filePattern = tool.params.file_pattern;
-            if (regexStr && this.runtime.fs.searchFiles) {
+            if (regexStr && path3) {
               try {
-                const result = await this.runtime.fs.searchFiles(path3, regexStr, filePattern);
+                let result;
+                if (typeof this.runtime.fs.searchFiles === "function") {
+                  result = await this.runtime.fs.searchFiles(path3, regexStr, filePattern);
+                } else {
+                  result = await this.searchFiles(path3, regexStr, filePattern);
+                }
                 toolResults.push({ tool, result: `${result}` });
               } catch (e) {
                 toolResults.push({ tool, result: `Error: ${e.message}` });
               }
             } else {
-              toolResults.push({ tool, result: `Error: searchFiles not supported by runtime or missing regex.` });
+              toolResults.push({ tool, result: `Error: miss path or regex params` });
             }
           } else if (tool.name === "agent_use_mcp_tool" /* MCP_USE */) {
             const serverName = tool.params.server_name;
@@ -966,9 +975,14 @@ IMPORTANT: The skill is now loaded. Do NOT call agent_load_skill again for this
           }
         }
         if (this.state === "thinking" /* THINKING */ && toolResults.length > 0) {
-          const toolResultsContext = toolResults.map((tr) => `<${TOOL_RESULT_BLOCK} tool_name="${tr.tool.name}">
+          let toolResultsContext = toolResults.map((tr) => `<${TOOL_RESULT_BLOCK} tool_name="${tr.tool.name}">
 ${typeof tr.result === "string" ? tr.result.trim() : JSON.stringify(tr.result)}
 </${TOOL_RESULT_BLOCK}>`).join("\n\n");
+          const lastResult = toolResults[toolResults.length - 1];
+          if (lastResult && lastResult.tool.name !== "agent_attempt_completion" /* ATTEMPT */) {
+            toolResultsContext += `
+${this.promptManager.getUsedToolResultInstructions()}`;
+          }
           if (this.onStreamChunk) {
             this.onStreamChunk({ type: "text", text: toolResultsContext });
           }
@@ -1026,6 +1040,47 @@ ${searchBlock.substring(0, 100)}...`);
   async getHistory() {
     return this.memory.getHistory();
   }
+  async searchFiles(dirpath, regex, filePattern) {
+    const matches = [];
+    const contentRe = new RegExp(regex);
+    const nameRe = filePattern ? new RegExp(filePattern.replace(/\./g, "\\.").replace(/\*/g, ".*")) : null;
+    const SKIP_DIRS = /* @__PURE__ */ new Set([".git", "dist", ".agent", ".turbopack"]);
+    const walk = async (dir, depth) => {
+      if (depth > 8 || matches.length >= 100) {
+        return;
+      }
+      let entries;
+      try {
+        entries = await this.runtime.fs.readDir(dir, { recursive: false });
+      } catch {
+        return;
+      }
+      for (const entry of entries) {
+        if (matches.length >= 100) {
+          break;
+        }
+        const child = dir === "." ? entry.name : `${dir}/${entry.name}`;
+        if (entry.isDirectory()) {
+          if (!SKIP_DIRS.has(entry.name)) {
+            await walk(child, depth + 1);
+          }
+        } else if (entry.isFile()) {
+          if (nameRe && !nameRe.test(entry.name)) {
+            continue;
+          }
+          try {
+            const content = (await this.runtime.fs.readFile(child, "utf8")).toString();
+            if (contentRe.test(content)) {
+              matches.push(child);
+            }
+          } catch {
+          }
+        }
+      }
+    };
+    await walk(dirpath, 0);
+    return matches.join("\n");
+  }
 };
 var NodeApiHandler = class {
   config;
@@ -1088,6 +1143,11 @@ var NodeApiHandler = class {
             type: "text",
             text: part.textDelta || part.text || ""
           };
+        } else if (part.type === "reasoning-delta") {
+          yield {
+            type: "reasoning",
+            reasoning: part.delta || part.text || ""
+          };
         } else if (part.type === "finish") {
           yield {
             type: "usage",
@@ -1395,6 +1455,21 @@ Otherwise, if you have not completed the task and do not need additional informa
 (This is an automated message, so do not respond to it conversationally.)
 ${this?.getEnvironmentInfoPrompt?.(context)}`;
   }
+  getUsedToolResultInstructions() {
+    return `The above are the results of the tool call. Please continue to complete the remaining tasks.
+
+# TODO LIST UPDATE REQUIRED - You MUST include the task_progress parameter in your NEXT tool call.
+
+1. To create or update a todo list, include the task_progress parameter in the next tool call
+2. Review each item and update its status:
+   - Mark completed items with: - [x]
+   - Keep incomplete items as: - [ ]
+   - Add new items if you discover additional steps
+3. Modify the list as needed:
+		- Add any new steps you've discovered
+		- Reorder if the sequence has changed
+4. Ensure the list accurately reflects the current state`;
+  }
 };
 var NodeMemoryManager = class {
   filePath;
@@ -1404,14 +1479,14 @@ var NodeMemoryManager = class {
    * @param maxMessages 保留的最大消息数量，用于简单的历史截断（默认 150）
    */
   constructor(dbPath, maxMessages = 150) {
-    this.filePath = path2__namespace.resolve(dbPath);
+    this.filePath = path__namespace.resolve(dbPath);
     this.maxMessages = maxMessages;
   }
   async ensureFile() {
     try {
       await fs2__namespace.access(this.filePath);
     } catch {
-      const dir = path2__namespace.dirname(this.filePath);
+      const dir = path__namespace.dirname(this.filePath);
       await fs2__namespace.mkdir(dir, { recursive: true });
       await fs2__namespace.writeFile(this.filePath, "[]", "utf-8");
     }
@@ -1587,10 +1662,13 @@ var NodeMcpManager = class {
 var execAsync = util.promisify(child_process.exec);
 var DefaultNodeRuntime = class {
   fs = {
-    readFile: async (filepath) => fs2__namespace.readFile(filepath, "utf-8"),
+    readFile: async (filepath, options = "utf8") => fs2__namespace.readFile(filepath, options),
     writeFile: async (filepath, content) => {
-      await fs2__namespace.mkdir(path2__namespace.dirname(filepath), { recursive: true });
-      await fs2__namespace.writeFile(filepath, content, "utf-8");
+      const dir = filepath.substring(0, filepath.lastIndexOf("/"));
+      if (dir && dir !== filepath) {
+        await fs2__namespace.mkdir(dir, { recursive: true });
+      }
+      await fs2__namespace.writeFile(filepath, content, "utf8");
     },
     deleteFile: (filepath) => fs2__namespace.unlink(filepath),
     deleteDirectory: (dirpath) => fs2__namespace.rm(dirpath, { recursive: true, force: true }),
@@ -1602,13 +1680,13 @@ var DefaultNodeRuntime = class {
         return false;
       }
     },
-    readDir: (dirpath) => fs2__namespace.readdir(dirpath, { withFileTypes: true }),
+    readDir: (dirpath, options) => fs2__namespace.readdir(dirpath, { withFileTypes: true, ...options || {} }),
     mkdir: async (dirpath) => {
       await fs2__namespace.mkdir(dirpath, { recursive: true });
     }
   };
   path = {
-    join: (...paths) => path2__namespace.join(...paths)
+    join: (...paths) => path__namespace.join(...paths)
   };
   env = {
     get: (key) => process.env[key],
@@ -1630,7 +1708,7 @@ var DefaultNodeRuntime = class {
 function createNodeAgent(options) {
   const runtime = new DefaultNodeRuntime();
   const api = new NodeApiHandler(options.apiConfig);
-  const memory = options.memory || new NodeMemoryManager(options.dbPath || path2__namespace.join(runtime.env.cwd(), ".cline_memory.json"));
+  const memory = options.memory || new NodeMemoryManager(options.dbPath || path__namespace.join(runtime.env.cwd(), ".cline_memory.json"));
   const customTools = options.customTools || [];
   const customToolNames = new Set(customTools.map((t) => t.name));
   const promptManager = new NodePromptManager();