evoltagent 1.1.2 → 1.1.4

package/dist/index.js

@@ -279,9 +279,96 @@ function escapeRegExp(string) {
   return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
+// src/utils/deprecated.ts
+function deprecated(options = {}) {
+  return function(target, propertyKey, descriptor) {
+    const original = descriptor.value;
+    descriptor.value = function(...args) {
+      const parts = [`${propertyKey} is deprecated`];
+      if (options.version) {
+        parts.push(`will be removed in ${options.version}`);
+      }
+      if (options.replacement) {
+        parts.push(`use ${options.replacement} instead`);
+      }
+      console.warn(parts.join(", "));
+      return original.apply(this, args);
+    };
+    return descriptor;
+  };
+}
+
+// src/utils/readImage.ts
+import * as fs from "fs";
+import * as path from "path";
+var MIME_TYPES = {
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".png": "image/png",
+  ".gif": "image/gif",
+  ".webp": "image/webp"
+};
+var SUPPORTED_FORMATS = /* @__PURE__ */ new Set([".jpg", ".jpeg", ".png", ".gif", ".webp"]);
+function getMimeType(pathOrUrl) {
+  const cleanPath = pathOrUrl.split("?")[0];
+  const ext = path.extname(cleanPath).toLowerCase();
+  return MIME_TYPES[ext] || "image/jpeg";
+}
+function isSupportedImageFile(imagePath) {
+  const cleanPath = imagePath.split("?")[0];
+  const ext = path.extname(cleanPath).toLowerCase();
+  return SUPPORTED_FORMATS.has(ext);
+}
+async function fetchUrl(url) {
+  const response = await fetch(url, {
+    signal: AbortSignal.timeout(3e4)
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to fetch image from ${url}: ${response.statusText}`);
+  }
+  const arrayBuffer = await response.arrayBuffer();
+  return Buffer.from(arrayBuffer);
+}
+function readImage(imagePath) {
+  const mimeType = getMimeType(imagePath);
+  let content;
+  if (imagePath.startsWith("http://") || imagePath.startsWith("https://")) {
+    throw new Error("Synchronous URL fetching is not supported. Use areadImage instead.");
+  } else {
+    if (!fs.existsSync(imagePath)) {
+      throw new Error(`Image file not found: ${imagePath}`);
+    }
+    content = fs.readFileSync(imagePath);
+  }
+  const b64Content = content.toString("base64");
+  const dataUrl = `data:${mimeType};base64,${b64Content}`;
+  return {
+    type: "image_url",
+    image_url: { url: dataUrl }
+  };
+}
+async function areadImage(imagePath) {
+  const mimeType = getMimeType(imagePath);
+  let content;
+  if (imagePath.startsWith("http://") || imagePath.startsWith("https://")) {
+    content = await fetchUrl(imagePath);
+  } else {
+    if (!fs.existsSync(imagePath)) {
+      throw new Error(`Image file not found: ${imagePath}`);
+    }
+    content = await fs.promises.readFile(imagePath);
+  }
+  const b64Content = content.toString("base64");
+  const dataUrl = `data:${mimeType};base64,${b64Content}`;
+  return {
+    type: "image_url",
+    image_url: { url: dataUrl }
+  };
+}
+
 // src/utils/logger.ts
 import * as winston from "winston";
-import * as fs from "fs";
+import * as fs2 from "fs";
 import * as dotenv from "dotenv";
 dotenv.config();
 var getDisableLog = () => {
@@ -474,7 +561,7 @@ var streamLogger = {
     if (!getDisableLog()) {
       process.stdout.write(message);
       if (process.env.LOG_OUTPUT) {
-        fs.appendFileSync(process.env.LOG_OUTPUT, message);
+        fs2.appendFileSync(process.env.LOG_OUTPUT, message);
       }
     }
   },
@@ -485,7 +572,7 @@ var streamLogger = {
     if (!getDisableLog()) {
       process.stderr.write(message);
       if (process.env.LOG_OUTPUT) {
-        fs.appendFileSync(process.env.LOG_OUTPUT, message);
+        fs2.appendFileSync(process.env.LOG_OUTPUT, message);
       }
     }
   },
@@ -496,7 +583,7 @@ var streamLogger = {
     if (!getDisableLog()) {
       process.stdout.write(message + "\n");
       if (process.env.LOG_OUTPUT) {
-        fs.appendFileSync(process.env.LOG_OUTPUT, message + "\n");
+        fs2.appendFileSync(process.env.LOG_OUTPUT, message + "\n");
       }
     }
   },
@@ -504,7 +591,7 @@ var streamLogger = {
     if (!getDisableLog()) {
       process.stdout.write(message);
       if (process.env.LOG_OUTPUT) {
-        fs.appendFileSync(process.env.LOG_OUTPUT, message);
+        fs2.appendFileSync(process.env.LOG_OUTPUT, message);
       }
     }
   }
@@ -671,18 +758,18 @@ function createMcpConnection(config2) {
 }
 
 // src/configs/configLoader.ts
-import * as fs2 from "fs";
-import * as path from "path";
+import * as fs3 from "fs";
+import * as path2 from "path";
 import * as yaml from "yaml";
 function getConfigPath() {
-  return path.join(process.env.HOME || "~", ".evolt", "config.yaml");
+  return path2.join(process.env.HOME || "~", ".evolt", "config.yaml");
 }
 function loadModelConfig(modelName) {
   const configPath = process.env.EVOLT_CONFIG_PATH || getConfigPath();
   let configData = {};
   try {
-    if (fs2.existsSync(configPath)) {
-      const fileContent = fs2.readFileSync(configPath, "utf8");
+    if (fs3.existsSync(configPath)) {
+      const fileContent = fs3.readFileSync(configPath, "utf8");
       configData = yaml.parse(fileContent);
     } else {
       logger.warn(`Config file not found at ${configPath}, using defaults`);
@@ -808,62 +895,62 @@ var LOG_LEVELS = {
 };
 
 // src/configs/paths.ts
-import * as path2 from "path";
-import * as fs3 from "fs";
+import * as path3 from "path";
+import * as fs4 from "fs";
 function getWorkspaceDir() {
-  return process.env.EVOLT_WORKSPACE || path2.join(process.cwd(), "workspace");
+  return process.env.EVOLT_WORKSPACE || path3.join(process.cwd(), "workspace");
 }
 function getConfigDir() {
-  return process.env.EVOLT_CONFIG_DIR || path2.join(process.cwd(), "config");
+  return process.env.EVOLT_CONFIG_DIR || path3.join(process.cwd(), "config");
 }
 function getLogsDir() {
-  return process.env.EVOLT_LOGS_DIR || path2.join(getWorkspaceDir(), "logs");
+  return process.env.EVOLT_LOGS_DIR || path3.join(getWorkspaceDir(), "logs");
 }
 function getCacheDir() {
-  return process.env.EVOLT_CACHE_DIR || path2.join(getWorkspaceDir(), "cache");
+  return process.env.EVOLT_CACHE_DIR || path3.join(getWorkspaceDir(), "cache");
 }
 function getSkillsDir() {
-  return process.env.EVOLT_SKILLS_DIR || path2.join(getWorkspaceDir(), "skills");
+  return process.env.EVOLT_SKILLS_DIR || path3.join(getWorkspaceDir(), "skills");
 }
 function ensureDir(dirPath) {
-  if (!fs3.existsSync(dirPath)) {
-    fs3.mkdirSync(dirPath, { recursive: true });
+  if (!fs4.existsSync(dirPath)) {
+    fs4.mkdirSync(dirPath, { recursive: true });
   }
 }
 function getWorkspacePath(relativePath) {
   const workspaceDir = getWorkspaceDir();
   ensureDir(workspaceDir);
-  return path2.join(workspaceDir, relativePath);
+  return path3.join(workspaceDir, relativePath);
 }
 function getConfigPath2(relativePath) {
   const configDir = getConfigDir();
   ensureDir(configDir);
-  return path2.join(configDir, relativePath);
+  return path3.join(configDir, relativePath);
 }
 function isInWorkspace(filePath) {
   const workspaceDir = getWorkspaceDir();
-  const absolutePath = path2.resolve(filePath);
-  return absolutePath.startsWith(path2.resolve(workspaceDir));
+  const absolutePath = path3.resolve(filePath);
+  return absolutePath.startsWith(path3.resolve(workspaceDir));
 }
 function normalizePath(filePath) {
-  return path2.normalize(filePath).replace(/\\/g, "/");
+  return path3.normalize(filePath).replace(/\\/g, "/");
 }
 function getFileExtension(filePath) {
-  return path2.extname(filePath).toLowerCase();
+  return path3.extname(filePath).toLowerCase();
 }
 function fileExists(filePath) {
   try {
-    return fs3.existsSync(filePath);
+    return fs4.existsSync(filePath);
   } catch {
     return false;
   }
 }
 function getTempFilePath(prefix = "evolt") {
-  const tempDir = path2.join(getCacheDir(), "temp");
+  const tempDir = path3.join(getCacheDir(), "temp");
   ensureDir(tempDir);
   const timestamp = Date.now();
   const random = Math.random().toString(36).substring(2, 8);
-  return path2.join(tempDir, `${prefix}_${timestamp}_${random}.tmp`);
+  return path3.join(tempDir, `${prefix}_${timestamp}_${random}.tmp`);
 }
 var WORKSPACE_DIR = getWorkspaceDir();
 var SKILLS_DIR = getSkillsDir();
@@ -1388,8 +1475,8 @@ var CommandLineTool = class {
     try {
       const workDir = cwd || process.cwd();
       try {
-        const fs9 = await import("fs");
-        if (!fs9.existsSync(workDir)) {
+        const fs14 = await import("fs");
+        if (!fs14.existsSync(workDir)) {
           return `Working directory does not exist: ${workDir}`;
         }
       } catch (error) {
@@ -1409,9 +1496,9 @@ var CommandLineTool = class {
       const processId = manager.registerBackgroundProcess(childProcess, command, workDir);
       logger.debug(`Register background process: Command: ${command}
  Process ID: ${processId}`);
-      return new Promise((resolve2) => {
+      return new Promise((resolve5) => {
         const timeout = setTimeout(async () => {
-          resolve2(
+          resolve5(
             `COMMAND: ${command}
 PROCESS ID: ${processId}
 STATUS: The process may still be executing (waited 5 seconds, not completed)
@@ -1440,11 +1527,11 @@ ${stdoutText}`);
 ${stderrText}`);
           }
           resultParts.push(`EXIT CODE: ${code}`);
-          resolve2(resultParts.join("\n\n"));
+          resolve5(resultParts.join("\n\n"));
         });
         childProcess.on("error", (error) => {
           clearTimeout(timeout);
-          resolve2(`COMMAND: ${command}
+          resolve5(`COMMAND: ${command}
 ERROR: ${error.message}`);
         });
       });
@@ -1543,22 +1630,22 @@ CommandLineTool = __decorateClass([
 ], CommandLineTool);
 
 // src/tools/fileTool.ts
-import * as fs4 from "fs/promises";
+import * as fs5 from "fs/promises";
 import * as pathModule from "path";
 var FileEditor = class {
-  async read(path5, lineRange = "all") {
+  async read(path10, lineRange = "all") {
     try {
-      await fs4.access(path5);
+      await fs5.access(path10);
     } catch {
-      throw new ToolExecutionError(`File does not exist: ${path5}`);
+      throw new ToolExecutionError(`File does not exist: ${path10}`);
     }
     try {
       let content;
       try {
-        content = await fs4.readFile(path5, "utf-8");
+        content = await fs5.readFile(path10, "utf-8");
       } catch (error) {
         if (error.code === "ENCODING_NOT_SUPPORTED" || error.message.includes("encoding")) {
-          const buffer = await fs4.readFile(path5);
+          const buffer = await fs5.readFile(path10);
           content = buffer.toString("latin1");
         } else {
           throw error;
@@ -1577,11 +1664,11 @@ var FileEditor = class {
             throw new ToolExecutionError(`Line range is invalid: ${lineRange}`);
           }
           const selectedLines = lines.slice(start, end);
-          return `Lines ${start + 1} to ${end} of file ${path5}:
+          return `Lines ${start + 1} to ${end} of file ${path10}:
 ` + selectedLines.join("\n");
         } catch (error) {
           throw new ToolExecutionError(
-            `Invalid line range format when reading file ${path5}: ${lineRange}, error: ${error.message}`
+            `Invalid line range format when reading file ${path10}: ${lineRange}, error: ${error.message}`
           );
         }
       } else {
@@ -1593,11 +1680,11 @@ var FileEditor = class {
           if (lineNum >= lines.length) {
             throw new ToolExecutionError(`Line number ${lineNum + 1} exceeds file length ${lines.length}`);
           }
-          return `Line ${lineNum + 1} of file ${path5}:
+          return `Line ${lineNum + 1} of file ${path10}:
 ` + lines[lineNum];
         } catch (error) {
           throw new ToolExecutionError(
-            `Invalid line number format when reading file ${path5}: ${lineRange}, error: ${error.message}`
+            `Invalid line number format when reading file ${path10}: ${lineRange}, error: ${error.message}`
           );
         }
       }
@@ -1605,30 +1692,30 @@ var FileEditor = class {
       if (error instanceof ToolExecutionError) {
         throw error;
       }
-      throw new ToolExecutionError(`Error reading file ${path5}: ${error.message}`);
+      throw new ToolExecutionError(`Error reading file ${path10}: ${error.message}`);
     }
   }
-  async write(path5, content) {
+  async write(path10, content) {
     try {
-      const dirPath = pathModule.dirname(path5);
+      const dirPath = pathModule.dirname(path10);
       if (dirPath) {
-        await fs4.mkdir(dirPath, { recursive: true });
+        await fs5.mkdir(dirPath, { recursive: true });
       }
-      await fs4.writeFile(path5, content, "utf-8");
+      await fs5.writeFile(path10, content, "utf-8");
       const bytesWritten = Buffer.from(content, "utf-8").length;
-      return `Successfully wrote content to file ${path5}, wrote ${bytesWritten} bytes`;
+      return `Successfully wrote content to file ${path10}, wrote ${bytesWritten} bytes`;
     } catch (error) {
       if (error.code === "EACCES") {
-        throw new ToolExecutionError(`No write permission: ${path5}`);
+        throw new ToolExecutionError(`No write permission: ${path10}`);
       }
-      throw new ToolExecutionError(`Error writing to file ${path5}: ${error.message}`);
+      throw new ToolExecutionError(`Error writing to file ${path10}: ${error.message}`);
     }
   }
-  async find(path5, pattern) {
+  async find(path10, pattern) {
     try {
-      await fs4.access(path5);
+      await fs5.access(path10);
     } catch {
-      throw new ToolExecutionError(`File does not exist: ${path5}`);
+      throw new ToolExecutionError(`File does not exist: ${path10}`);
     }
     let compiledPattern;
     try {
@@ -1640,10 +1727,10 @@ var FileEditor = class {
     try {
       let content;
       try {
-        content = await fs4.readFile(path5, "utf-8");
+        content = await fs5.readFile(path10, "utf-8");
       } catch (error) {
         if (error.code === "ENCODING_NOT_SUPPORTED" || error.message.includes("encoding")) {
-          const buffer = await fs4.readFile(path5);
+          const buffer = await fs5.readFile(path10);
           content = buffer.toString("latin1");
         } else {
           throw error;
@@ -1665,23 +1752,23 @@ var FileEditor = class {
         }
       }
     } catch (error) {
-      throw new ToolExecutionError(`Error reading file ${path5}: ${error.message}`);
+      throw new ToolExecutionError(`Error reading file ${path10}: ${error.message}`);
     }
     if (matches.length === 0) {
-      return `No content matching pattern '${pattern}' found in file ${path5}`;
+      return `No content matching pattern '${pattern}' found in file ${path10}`;
     }
-    const resultLines = [`Found ${matches.length} matches in file ${path5}:`];
+    const resultLines = [`Found ${matches.length} matches in file ${path10}:`];
     for (const match of matches) {
       resultLines.push(`Line ${match.lineNumber}: ${match.match} (position ${match.startPos}-${match.endPos})`);
       resultLines.push(`  Full line content: ${match.lineContent}`);
     }
     return resultLines.join("\n");
   }
-  async findAndReplace(path5, pattern, replacement) {
+  async findAndReplace(path10, pattern, replacement) {
     try {
-      await fs4.access(path5);
+      await fs5.access(path10);
     } catch {
-      throw new ToolExecutionError(`File does not exist: ${path5}`);
+      throw new ToolExecutionError(`File does not exist: ${path10}`);
     }
     let compiledPattern;
     try {
@@ -1692,17 +1779,17 @@ var FileEditor = class {
     let content;
     try {
       try {
-        content = await fs4.readFile(path5, "utf-8");
+        content = await fs5.readFile(path10, "utf-8");
       } catch (error) {
         if (error.code === "ENCODING_NOT_SUPPORTED" || error.message.includes("encoding")) {
-          const buffer = await fs4.readFile(path5);
+          const buffer = await fs5.readFile(path10);
           content = buffer.toString("latin1");
         } else {
           throw error;
         }
       }
     } catch (error) {
-      throw new ToolExecutionError(`Error reading file ${path5}: ${error.message}`);
+      throw new ToolExecutionError(`Error reading file ${path10}: ${error.message}`);
     }
     const newContent = content.replace(compiledPattern, replacement);
     const replacementCount = (content.match(compiledPattern) || []).length;
@@ -1712,30 +1799,30 @@ var FileEditor = class {
       const newLines = newContent.split("\n");
       modifiedLines = originalLines.filter((line, index) => line !== newLines[index]).length;
       try {
-        await fs4.writeFile(path5, newContent, "utf-8");
+        await fs5.writeFile(path10, newContent, "utf-8");
       } catch (error) {
         if (error.code === "EACCES") {
-          throw new ToolExecutionError(`No write permission: ${path5}`);
+          throw new ToolExecutionError(`No write permission: ${path10}`);
         }
-        throw new ToolExecutionError(`Error writing to file ${path5}: ${error.message}`);
+        throw new ToolExecutionError(`Error writing to file ${path10}: ${error.message}`);
       }
     }
-    return `In file ${path5}, found and replaced pattern '${pattern}' with '${replacement}', successfully replaced ${replacementCount} occurrences, modified ${modifiedLines} lines`;
+    return `In file ${path10}, found and replaced pattern '${pattern}' with '${replacement}', successfully replaced ${replacementCount} occurrences, modified ${modifiedLines} lines`;
   }
-  async insert(path5, content, line) {
+  async insert(path10, content, line) {
     try {
-      await fs4.access(path5);
+      await fs5.access(path10);
     } catch {
-      throw new ToolExecutionError(`File does not exist: ${path5}`);
+      throw new ToolExecutionError(`File does not exist: ${path10}`);
     }
     let lines;
     try {
       let fileContent;
       try {
-        fileContent = await fs4.readFile(path5, "utf-8");
+        fileContent = await fs5.readFile(path10, "utf-8");
       } catch (error) {
         if (error.code === "ENCODING_NOT_SUPPORTED" || error.message.includes("encoding")) {
-          const buffer = await fs4.readFile(path5);
+          const buffer = await fs5.readFile(path10);
           fileContent = buffer.toString("latin1");
         } else {
           throw error;
@@ -1743,27 +1830,27 @@ var FileEditor = class {
       }
       lines = fileContent.split("\n");
     } catch (error) {
-      throw new ToolExecutionError(`Error reading file ${path5}: ${error.message}`);
+      throw new ToolExecutionError(`Error reading file ${path10}: ${error.message}`);
     }
     let actionDesc;
     if (line === void 0) {
       lines.push(content);
-      actionDesc = `Appended content to end of file ${path5}`;
+      actionDesc = `Appended content to end of file ${path10}`;
     } else {
       if (!(0 < line && line <= lines.length + 1)) {
-        throw new ToolExecutionError(`Line number ${line} exceeds file ${path5} bounds (1 to ${lines.length + 1})`);
+        throw new ToolExecutionError(`Line number ${line} exceeds file ${path10} bounds (1 to ${lines.length + 1})`);
       }
       lines.splice(line - 1, 0, content);
-      actionDesc = `Inserted content at line ${line} of file ${path5}`;
+      actionDesc = `Inserted content at line ${line} of file ${path10}`;
     }
     try {
-      await fs4.writeFile(path5, lines.join("\n"), "utf-8");
+      await fs5.writeFile(path10, lines.join("\n"), "utf-8");
       return actionDesc;
     } catch (error) {
       if (error.code === "EACCES") {
-        throw new ToolExecutionError(`No write permission: ${path5}`);
+        throw new ToolExecutionError(`No write permission: ${path10}`);
       }
-      throw new ToolExecutionError(`Error writing to file ${path5}: ${error.message}`);
+      throw new ToolExecutionError(`Error writing to file ${path10}: ${error.message}`);
     }
   }
 };
@@ -2031,8 +2118,8 @@ ReflectTool = __decorateClass([
 ], ReflectTool);
 
 // src/tools/skills.ts
-import * as fs5 from "fs";
-import * as path3 from "path";
+import * as fs6 from "fs";
+import * as path4 from "path";
 var SkillsTool = class {
   /**
    * Skills directory
@@ -2051,8 +2138,8 @@ var SkillsTool = class {
    *     str: The content of the skill description file
    */
   async readSkillDescription(name) {
-    const skillsPath = path3.join(this.skillsDir, name, "SKILL.md");
-    if (!fs5.existsSync(skillsPath)) {
+    const skillsPath = path4.join(this.skillsDir, name, "SKILL.md");
+    if (!fs6.existsSync(skillsPath)) {
       throw new ToolExecutionError(`Skill description file not found: ${skillsPath}`);
     }
     const fileEditor = new FileEditor();
@@ -2065,14 +2152,14 @@ var SkillsTool = class {
    * List the skills in the skills root directory
    */
   async listSkills() {
-    if (!fs5.existsSync(this.skillsDir)) {
+    if (!fs6.existsSync(this.skillsDir)) {
       throw new ToolExecutionError(`Skills path not found: ${this.skillsDir}`);
     }
     const skillsDict = {};
-    const items = fs5.readdirSync(this.skillsDir);
+    const items = fs6.readdirSync(this.skillsDir);
     for (const skillName of items) {
-      const skillPath = path3.join(this.skillsDir, skillName, "SKILL.md");
-      if (!fs5.existsSync(skillPath)) {
+      const skillPath = path4.join(this.skillsDir, skillName, "SKILL.md");
+      if (!fs6.existsSync(skillPath)) {
         continue;
       }
       const fileEditor = new FileEditor();
@@ -2104,8 +2191,8 @@ SkillsTool = __decorateClass([
 
 // src/tools/gitTool.ts
 import { exec } from "child_process";
-import * as fs6 from "fs";
-import * as path4 from "path";
+import * as fs7 from "fs";
+import * as path5 from "path";
 function quote(str) {
   if (/^[a-zA-Z0-9_\-.\/]+$/.test(str)) {
     return str;
@@ -2657,12 +2744,12 @@ var GitTool = class {
    */
   async _executeGitCommand(command, cwd, timeout = 3e4, config2) {
     const workDir = cwd || process.cwd();
-    if (!fs6.existsSync(workDir)) {
+    if (!fs7.existsSync(workDir)) {
       throw new ToolExecutionError(`\u5DE5\u4F5C\u76EE\u5F55\u4E0D\u5B58\u5728: ${workDir}`);
     }
-    const gitDir = path4.join(workDir, ".git");
+    const gitDir = path5.join(workDir, ".git");
     const isInitOrClone = command.includes("clone") || command.includes("init");
-    if (!fs6.existsSync(gitDir) && !isInitOrClone) {
+    if (!fs7.existsSync(gitDir) && !isInitOrClone) {
       throw new ToolExecutionError(`\u5F53\u524D\u76EE\u5F55\u4E0D\u662F git \u4ED3\u5E93: ${workDir}`);
     }
     let gitCmd = "git";
@@ -2672,7 +2759,7 @@ var GitTool = class {
       }
     }
     gitCmd += ` ${command}`;
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve5, reject) => {
       exec(gitCmd, { cwd: workDir, timeout, encoding: "utf-8" }, (error, stdout, stderr) => {
         const stdoutText = stdout ? stdout.trim() : "";
         const stderrText = stderr ? stderr.trim() : "";
@@ -2685,7 +2772,7 @@ var GitTool = class {
           reject(new ToolExecutionError(`Git \u547D\u4EE4\u6267\u884C\u5931\u8D25: ${errorMsg}`));
           return;
         }
-        resolve2(stdoutText || "\u547D\u4EE4\u6267\u884C\u6210\u529F\uFF0C\u65E0\u8F93\u51FA");
+        resolve5(stdoutText || "\u547D\u4EE4\u6267\u884C\u6210\u529F\uFF0C\u65E0\u8F93\u51FA");
       });
     });
   }
@@ -2863,96 +2950,779 @@ GitTool = __decorateClass([
   tools(gitToolConfig)
 ], GitTool);
 
-// src/model.ts
-import OpenAI from "openai";
-import Anthropic from "@anthropic-ai/sdk";
-import { GoogleGenerativeAI } from "@google/generative-ai";
-var Model = class {
-  modelName;
-  config;
-  openaiClient;
-  anthropicClient;
-  geminiClient;
-  constructor(model) {
-    if (typeof model === "string" || model === void 0) {
-      this.modelName = model || "deepseek";
-      this.config = loadModelConfig(this.modelName);
-    } else {
-      this.config = model;
-      this.modelName = model.model || "deepseek";
+// src/schemas/message.ts
+import * as fs8 from "fs";
+var _Message = class _Message {
+  role;
+  content;
+  images;
+  // OpenAI vision API format image content
+  imagesContent;
+  // Message tag for wrapping content
+  tag;
+  // Function calling / OpenAI tool call message information
+  isFunctionCall;
+  toolCallId;
+  toolName;
+  // Legacy type field (kept for compatibility)
+  type;
+  constructor(role, content, images, type) {
+    this.role = role;
+    this.content = content;
+    this.images = images;
+    this.type = type;
+    this.imagesContent = [];
+    this.tag = "";
+    this.isFunctionCall = false;
+    this.toolCallId = "";
+    this.toolName = "";
+  }
+  /**
+   * Create message from user input
+   */
+  static fromUserMsg(content, images) {
+    return new _Message("user", content, images);
+  }
+  /**
+   * Create message from assistant response
+   */
+  static fromAssistantMsg(content) {
+    return new _Message("assistant", content);
+  }
+  /**
+   * Create system message
+   */
+  static fromSystemMsg(content) {
+    return new _Message("system", content);
+  }
+  /**
+   * Check if message is truthy based on content
+   */
+  isTruthy() {
+    if (typeof this.content === "string") {
+      return Boolean(this.content.trim());
     }
-    this._initializeClient();
+    return false;
   }
   /**
-   * Initialize the appropriate SDK client based on provider
+   * Format the content with pre/post content and optional tag wrapping
    */
-  _initializeClient() {
-    const provider = this.config.provider.toLowerCase();
-    switch (provider) {
-      case "openai":
-        this.openaiClient = new OpenAI({
-          apiKey: this.config.apiKey || process.env.OPENAI_API_KEY,
-          baseURL: this.config.baseUrl,
-          timeout: 6e4
-        });
-        break;
-      case "deepseek":
-        this.openaiClient = new OpenAI({
-          apiKey: this.config.apiKey || process.env.DEEPSEEK_API_KEY,
-          baseURL: this.config.baseUrl || "https://api.deepseek.com",
-          timeout: 6e4
-        });
-        break;
-      case "anthropic":
-        if (this.config.baseUrl.endsWith("/v1") || this.config.baseUrl.endsWith("v1/")) {
-          this.config.baseUrl = this.config.baseUrl.slice(0, -3);
+  _formatForContent(preContent = "", postContent = "") {
+    if (this.tag) {
+      return `${preContent}<${this.tag}>
+${this.content}
+</${this.tag}>${postContent}`.trim();
+    }
+    return `${preContent}${this.content}${postContent}`.trim();
+  }
+  /**
+   * Ensure text content is not empty to avoid API errors
+   */
+  static _ensureNonEmptyText(text) {
+    return text.trim() ? text : " ";
+  }
+  /**
+   * Format message for OpenAI API
+   *
+   * This is the recommended method replacing toChatMessage.
+   *
+   * @param preContent - Content to prepend
+   * @param postContent - Content to append
+   * @returns Formatted message object for API
+   */
+  formatForApi(preContent = "", postContent = "") {
+    const role = ["user", "assistant", "system", "tool"].includes(this.role) ? this.role : "user";
+    const functionCallingMeta = { tool_call_id: this.toolCallId, name: this.toolName };
+    if (!this.imagesContent || this.imagesContent.length === 0) {
+      const msg2 = {
+        role,
+        content: this._formatForContent(preContent, postContent)
+      };
+      return this.isFunctionCall ? { ...msg2, ...functionCallingMeta } : msg2;
+    }
+    let formattedText = this._formatForContent(preContent, postContent);
+    formattedText = _Message._ensureNonEmptyText(formattedText);
+    const content = [{ type: "text", text: formattedText }];
+    content.push(...this.imagesContent);
+    const msg = { role, content };
+    return this.isFunctionCall ? { ...msg, ...functionCallingMeta } : msg;
+  }
+  /**
+   * Convert to plain object for API calls
+   */
+  toObject() {
+    const obj = {
+      role: this.role,
+      content: this.content
+    };
+    if (this.images) {
+      obj.images = this.images;
+    }
+    if (this.type) {
+      obj.type = this.type;
+    }
+    if (this.tag) {
+      obj.tag = this.tag;
+    }
+    if (this.imagesContent && this.imagesContent.length > 0) {
+      obj.images_content = this.imagesContent;
+    }
+    if (this.isFunctionCall) {
+      obj.is_function_call = this.isFunctionCall;
+      obj.tool_call_id = this.toolCallId;
+      obj.tool_name = this.toolName;
+    }
+    return obj;
+  }
+  /**
+   * Convert to dictionary representation
+   */
+  toDict() {
+    return {
+      role: this.role,
+      content: this.content,
+      tag: this.tag || "",
+      images_content: this.imagesContent || [],
+      is_function_call: this.isFunctionCall || false,
+      tool_call_id: this.toolCallId || "",
+      tool_name: this.toolName || ""
+    };
+  }
+  /**
+   * Check if message contains images
+   */
+  hasImages() {
+    return !!this.images && (Array.isArray(this.images) ? this.images.length > 0 : true) || !!this.imagesContent && this.imagesContent.length > 0;
+  }
+  /**
+   * Get message content length
+   */
+  getContentLength() {
+    return this.content.length;
+  }
+  /**
+   * Convert to string representation
+   */
+  toString() {
+    const parts = [];
+    parts.push(`role=${this.role}`);
+    if (this.content) {
+      const truncatedContent = this.content.length > 100 ? this.content.slice(0, 100) + "..." : this.content;
+      parts.push(`content=${truncatedContent}`);
+    }
+    if (this.tag) {
+      parts.push(`tag=${this.tag}`);
+    }
+    if (this.imagesContent && this.imagesContent.length > 0) {
+      const imagePaths = [];
+      for (const img of this.imagesContent) {
+        if (img && img.image_url && img.image_url.url) {
+          const url = img.image_url.url;
+          if (!url.startsWith("data:")) {
+            imagePaths.push(url);
+          }
         }
-        this.anthropicClient = new Anthropic({
-          apiKey: this.config.apiKey || process.env.ANTHROPIC_API_KEY,
-          baseURL: this.config.baseUrl,
-          timeout: 6e4
+      }
+      if (imagePaths.length > 0) {
+        parts.push(`images_paths=[${imagePaths.join(", ")}]`);
+      }
+    }
+    return `Message(${parts.join(", ")})`;
+  }
+  /**
+   * Merge two messages into one
+   *
+   * @param other - Message to merge with
+   * @returns New merged Message
+   */
+  merge(other) {
+    if (this.role !== other.role) {
+      throw new Error("Messages must have the same role to merge");
+    }
+    if (this.isFunctionCall !== other.isFunctionCall) {
+      throw new Error("Messages must have the same isFunctionCall to merge");
+    }
+    if (this.toolCallId !== other.toolCallId) {
+      throw new Error("Messages must have the same toolCallId to merge");
+    }
+    if (this.toolName !== other.toolName) {
+      throw new Error("Messages must have the same toolName to merge");
+    }
+    let selfContent = this.content;
+    let otherContent = other.content;
+    let resultTag = this.tag;
+    if (this.tag !== other.tag) {
+      selfContent = this.tag ? `<${this.tag}>
+${this.content}
+</${this.tag}>` : this.content;
+      otherContent = other.tag ? `<${other.tag}>
+${other.content}
+</${other.tag}>` : other.content;
+      resultTag = "";
+    }
+    const merged = new _Message(this.role, `${selfContent}
+${otherContent}`);
+    merged.tag = resultTag;
+    merged.imagesContent = [...this.imagesContent || [], ...other.imagesContent || []];
+    merged.isFunctionCall = this.isFunctionCall;
+    merged.toolCallId = this.toolCallId;
+    merged.toolName = this.toolName;
+    return merged;
+  }
+  async toChatMessage() {
+    const role = this.role;
+    if (!this.hasImages()) {
+      return { role, content: this.content };
+    }
+    const content = [{ type: "text", text: this.content }];
+    if (this.images) {
+      const imageArray = Array.isArray(this.images) ? this.images : [this.images];
+      for (const img of imageArray) {
+        let base64Data;
+        if (img.startsWith("http://") || img.startsWith("https://")) {
+          base64Data = await this.encodeHttpImage(img);
+        } else if (fs8.existsSync(img)) {
+          base64Data = await this.encodeLocalFile(img);
+        } else {
+          base64Data = img;
+        }
+        const mimeType = this.getMimeType(img);
+        content.push({
+          type: "image_url",
+          image_url: { url: `data:${mimeType};base64,${base64Data}` }
         });
-        break;
-      case "gemini":
-        const apiKey = this.config.apiKey || process.env.GEMINI_API_KEY || "";
-        this.geminiClient = new GoogleGenerativeAI(apiKey);
-        break;
-      default:
-        throw new ModelError(`Unsupported provider: ${provider}`);
+      }
+    }
+    if (this.imagesContent && this.imagesContent.length > 0) {
+      content.push(...this.imagesContent);
     }
+    return { role, content };
   }
   /**
-   * Asynchronous chat completion
+   * Get MIME type from file path or URL
    */
-  async achat(messages, tools2, stream = true) {
-    const provider = this.config.provider.toLowerCase();
-    const useStream = stream !== void 0 ? stream : !!this.config.stream;
+  getMimeType(path10) {
+    const ext = path10.toLowerCase().split(".").pop();
+    const mimeTypes = {
+      png: "image/png",
+      jpg: "image/jpeg",
+      jpeg: "image/jpeg",
+      gif: "image/gif",
+      webp: "image/webp",
+      bmp: "image/bmp"
+    };
+    return mimeTypes[ext || ""] || "image/jpeg";
+  }
+  /**
+   * Encode local file to base64
+   */
+  async encodeLocalFile(filePath) {
+    const fileBuffer = await fs8.promises.readFile(filePath);
+    return fileBuffer.toString("base64");
+  }
+  /**
+   * Fetch and encode HTTP image to base64
+   */
+  async encodeHttpImage(url) {
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`Failed to fetch image from ${url}: ${response.statusText}`);
+    }
+    const buffer = await response.arrayBuffer();
+    return Buffer.from(buffer).toString("base64");
+  }
+};
+__decorateClass([
+  deprecated({ version: "0.2.2", replacement: "formatForApi" })
+], _Message.prototype, "toChatMessage", 1);
+var Message = _Message;
+
+// src/tools/imageTool.ts
+var ImageTool = class {
+  /**
+   * Read and analyze an image (JPEG, JPG, PNG, GIF, WebP) from image path or URL.
+   *
+   * Note: SVG format is not supported by the AI model.
+   *
+   * @param imagePath - Image path or URL
+   * @param instruction - Instruction for analyzing the image
+   * @returns Message containing image content in base64 format
+   */
+  async readImage(imagePath, instruction = "") {
     try {
-      switch (provider) {
-        case "openai":
-        case "deepseek":
-          return await this._callOpenAICompatible(messages, tools2, useStream);
-        case "anthropic":
-          return await this._callAnthropic(messages, tools2, useStream);
-        case "gemini":
-          return await this._callGemini(messages, tools2, useStream);
-        default:
-          throw new ModelError(`Unsupported provider: ${provider}`);
+      if (!isSupportedImageFile(imagePath)) {
+        logger.warn(`Unsupported image format: ${imagePath}. Only JPEG, PNG, GIF, and WebP are supported.`);
+        const errorMsg = new Message(
+          "user",
+          `Error: Unsupported image format '${imagePath}'. Only JPEG, PNG, GIF, and WebP are supported by the AI model.`
+        );
+        return errorMsg;
+      }
+      const imageContent = await areadImage(imagePath);
+      let content;
+      if (instruction) {
+        content = `Please analyze the image from ${imagePath} according to the following instruction:
+
+${instruction}
+
+Please provide a detailed analysis of the image content based on this instruction.`;
+      } else {
+        content = `Please analyze and describe the image from ${imagePath} in detail. Include information about:
+- What is shown in the image
+- Key elements, objects, or features
+- Colors, composition, and visual characteristics
+- Any text or symbols present
+- Overall context and meaning`;
       }
+      const msg = new Message("user", content);
+      msg.imagesContent = [imageContent];
+      msg.tag = "image_content";
+      return msg;
     } catch (error) {
-      logger.error(`Model call failed: ${error}`);
-      throw error;
+      return new Message("user", `Error reading image ${imagePath}: ${error}`);
     }
   }
   /**
-   * Call OpenAI-compatible API (OpenAI, DeepSeek, etc.)
+   * Read images (JPEG, JPG, PNG, GIF, WebP) from image paths or URLs.
+   *
+   * Note: SVG format is not supported by the AI model and will be automatically filtered out.
+   *
+   * @param imagePaths - List of image paths or URLs
+   * @param instruction - Instruction for reading the images
+   * @returns Message containing multiple image contents in base64 format
    */
-  async _callOpenAICompatible(messages, tools2, stream = false) {
-    if (!this.openaiClient) {
-      throw new ModelError("OpenAI client not initialized");
-    }
+  async readImages(imagePaths, instruction = "") {
     try {
-      const params = {
+      const supportedPaths = imagePaths.filter((path10) => isSupportedImageFile(path10));
+      const unsupportedPaths = imagePaths.filter((path10) => !isSupportedImageFile(path10));
+      if (unsupportedPaths.length > 0) {
+        logger.warn(
+          `Skipping unsupported image formats (only JPEG/PNG/GIF/WebP are supported): ${unsupportedPaths.join(", ")}`
+        );
+      }
+      if (supportedPaths.length === 0) {
+        return new Message(
+          "user",
+          `No supported image formats found in the provided list. Only JPEG, PNG, GIF, and WebP are supported. Unsupported files: ${unsupportedPaths.join(", ")}`
+        );
+      }
+      const imageContents = await Promise.all(
+        supportedPaths.map((imagePath) => areadImage(imagePath))
+      );
+      const contentParts = [`Successfully loaded ${supportedPaths.length} image(s): ${supportedPaths.join(", ")}`];
+      if (unsupportedPaths.length > 0) {
+        contentParts.push(`Skipped ${unsupportedPaths.length} unsupported file(s): ${unsupportedPaths.join(", ")}`);
+      }
+      const msg = new Message("user", contentParts.join("\n"));
+      msg.imagesContent = imageContents;
+      return msg;
+    } catch (error) {
+      return new Message("user", `Error reading images ${imagePaths.join(", ")}: ${error}`);
+    }
+  }
+};
+ImageTool = __decorateClass([
+  tools({
+    readImage: {
+      description: "Read and analyze an image (JPEG, JPG, PNG, GIF, WebP) from image path or URL. Note: SVG format is not supported by the AI model.",
+      params: [
+        { name: "imagePath", type: "string", description: "Image path or URL" },
+        { name: "instruction", type: "string", description: "Instruction for analyzing the image", optional: true }
+      ],
+      returns: { type: "Message", description: "Message containing image content in base64 format" }
+    },
+    readImages: {
+      description: "Read images (JPEG, JPG, PNG, GIF, WebP) from image paths or URLs. Note: SVG format is not supported by the AI model and will be automatically filtered out.",
+      params: [
+        { name: "imagePaths", type: "array", description: "List of image paths or URLs" },
+        { name: "instruction", type: "string", description: "Instruction for reading the images", optional: true }
+      ],
+      returns: { type: "Message", description: "Message containing multiple image contents in base64 format" }
+    }
+  })
+], ImageTool);
+
+// src/tools/patchTool.ts
+import * as fs9 from "fs";
+import * as path6 from "path";
+import { spawn as spawn2 } from "child_process";
+var PatchTool = class {
+  /**
+   * Write patch content to file
+   *
+   * @param patchPath - Path to the patch file
+   * @param patchContent - Content of the patch in unified diff format
+   * @returns Success message
+   */
+  async writePatchFile(patchPath, patchContent) {
+    let warningMsg = "";
+    if (!patchPath.endsWith(".patch")) {
+      patchPath = `${patchPath}.patch`;
+      warningMsg = `Warning: Patch path does not end with '.patch', automatically appended '.patch' to ${patchPath}`;
+    }
+    const dirPath = path6.dirname(patchPath);
+    if (dirPath) {
+      await fs9.promises.mkdir(dirPath, { recursive: true });
+    }
+    patchContent = patchContent.trim();
+    if (patchContent.startsWith("```")) {
+      const newlineIndex = patchContent.indexOf("\n");
+      patchContent = newlineIndex !== -1 ? patchContent.slice(newlineIndex + 1) : patchContent.slice(3);
+    }
+    if (patchContent.endsWith("```")) {
+      patchContent = patchContent.slice(0, -3).trimEnd();
+    }
+    patchContent = patchContent.trim();
+    if (patchContent && patchContent.split("\n")[0].startsWith("diff --git")) {
+      patchContent = this._convertGitDiffToUnifiedDiff(patchContent);
+    }
+    this._validatePatchFormat(patchContent);
+    if (fs9.existsSync(patchPath)) {
+      const baseName = path6.basename(patchPath, ".patch");
+      const oldPatchPath = path6.join(path6.dirname(patchPath), `${baseName}1.patch`);
+      await fs9.promises.rename(patchPath, oldPatchPath);
+    }
+    await fs9.promises.writeFile(patchPath, patchContent, "utf-8");
+    const bytesWritten = Buffer.from(patchContent, "utf-8").length;
+    const resultMsg = `Successfully wrote patch to ${patchPath}, wrote ${bytesWritten} bytes`;
+    return warningMsg ? `${resultMsg}
+${warningMsg}` : resultMsg;
+  }
+  /**
+   * Apply a patch to a file
+   *
+   * @param patchPath - Path to the patch file
+   * @param patchContent - Optional patch content to write before applying
+   * @returns Success message
+   */
+  async applyPatch(patchPath, patchContent) {
+    let warningMsg = "";
+    if (!patchPath.endsWith(".patch")) {
+      patchPath = `${patchPath}.patch`;
+      warningMsg = `Warning: Patch path does not end with '.patch', automatically appended '.patch' to ${patchPath}`;
+    }
+    const patchFileAbs = path6.resolve(patchPath);
+    if (patchContent === void 0) {
+      if (!fs9.existsSync(patchFileAbs)) {
+        throw new Error(`Patch file does not exist: ${patchPath}`);
+      }
+      patchContent = await fs9.promises.readFile(patchFileAbs, "utf-8");
+    }
+    const workDir = this._determineWorkDir(patchFileAbs, patchContent);
+    let writeMsg;
+    if (patchContent !== void 0) {
+      writeMsg = await this.writePatchFile(patchPath, patchContent);
+    }
+    const applyMsg = await this._applyPatch(patchFileAbs, workDir);
+    if (writeMsg) {
+      return `${writeMsg}. ${applyMsg}.`;
+    }
+    return `Successfully applied existing patch file ${patchPath}. ${applyMsg}.
+${warningMsg}`;
+  }
+  /**
+   * Validate patch format
+   */
+  _validatePatchFormat(patchContent) {
+    if (!patchContent.trim()) {
+      throw new Error("Patch content is empty.");
+    }
+    const lines = patchContent.split("\n");
+    const hasMinusLine = lines.slice(0, 50).some((line) => line.startsWith("--- "));
+    const hasPlusLine = lines.slice(0, 50).some((line) => line.startsWith("+++ "));
+    const hasHunkHeader = lines.slice(0, 100).some((line) => /^@@ -\d+,\d+ \+\d+,\d+ @@/.test(line));
+    if (!(hasMinusLine && hasPlusLine)) {
+      throw new Error(
+        "Patch does not appear to be in standard unified diff format. Expected lines starting with '--- ' and '+++ '."
+      );
+    }
+    if (!hasHunkHeader) {
+      throw new Error(
+        "Patch does not contain valid hunk headers (lines starting with '@@'). Example: '@@ -1,2 +1,2 @@'"
+      );
+    }
+  }
+  /**
+   * Convert git diff format to unified diff format
+   */
+  _convertGitDiffToUnifiedDiff(patchContent) {
+    const lines = patchContent.split("\n");
+    const convertedLines = [];
+    const skipPrefixes = [
+      "diff --git",
+      "index ",
+      "new file mode",
+      "old file mode",
+      "deleted file mode",
+      "rename from",
+      "rename to",
+      "similarity index",
+      "copy from",
+      "copy to"
+    ];
+    for (const line of lines) {
+      if (skipPrefixes.some((prefix) => line.startsWith(prefix))) {
+        continue;
+      }
+      if (line.startsWith("--- a/")) {
+        const filePath = line.slice(6).split("	")[0];
+        convertedLines.push(`--- ${filePath}`);
+      } else if (line.startsWith("+++ b/")) {
+        const filePath = line.slice(6).split("	")[0];
+        convertedLines.push(`+++ ${filePath}`);
+      } else {
+        convertedLines.push(line);
+      }
+    }
+    return convertedLines.join("\n");
+  }
+  /**
+   * Extract target file path from patch content
+   */
+  _extractTargetFile(patchContent) {
+    for (const line of patchContent.split("\n")) {
+      if (line.startsWith("+++ b/")) {
+        return line.slice(6).split("	")[0];
+      } else if (line.startsWith("+++ ") && !line.startsWith("+++ /dev/null")) {
+        return line.slice(4).split("	")[0];
+      }
+    }
+    return null;
+  }
+  /**
+   * Determine working directory for applying patch
+   */
+  _determineWorkDir(patchFileAbs, patchContent) {
+    const patchDir = path6.dirname(patchFileAbs) || process.cwd();
+    const defaultWorkDir = path6.resolve(patchDir);
+    const targetFile = this._extractTargetFile(patchContent);
+    if (!targetFile || targetFile === "/dev/null") {
+      return defaultWorkDir;
+    }
+    const searchDirs = [process.cwd(), patchDir];
+    for (const searchDir of searchDirs) {
+      const candidate = path6.join(searchDir, targetFile);
+      if (fs9.existsSync(candidate)) {
+        return path6.dirname(candidate);
+      }
+    }
+    return defaultWorkDir;
+  }
+  /**
+   * Apply patch using patch command or manual fallback
+   */
+  async _applyPatch(patchFileAbs, workDir) {
+    try {
+      const result = await this._executePatchCommand(patchFileAbs, workDir);
+      if (result.exitCode === 0) {
+        return `Successfully applied patch using patch command${result.stdout ? ": " + result.stdout : ""}`;
+      }
+    } catch (error) {
+      logger.debug(`Patch command failed: ${error}`);
+    }
+    const manualResult = await this._applyPatchManually(patchFileAbs, workDir);
+    if (manualResult) {
+      return manualResult;
+    }
+    throw new Error(
+      `Failed to apply patch ${patchFileAbs}. Working directory: ${workDir}. Both patch command and manual application failed. Please check: 1) patch format is correct, 2) target file exists, 3) line numbers match the file content.`
+    );
+  }
+  /**
+   * Execute patch command
+   */
+  _executePatchCommand(patchFileAbs, workDir) {
+    return new Promise((resolve5, reject) => {
+      const patchProcess = spawn2("patch", ["--batch", "-p1", "-i", patchFileAbs], {
+        cwd: workDir
+      });
+      let stdout = "";
+      let stderr = "";
+      patchProcess.stdout.on("data", (data) => {
+        stdout += data.toString();
+      });
+      patchProcess.stderr.on("data", (data) => {
+        stderr += data.toString();
+      });
+      patchProcess.on("close", (code) => {
+        resolve5({
+          exitCode: code || 0,
+          stdout: stdout.trim(),
+          stderr: stderr.trim()
+        });
+      });
+      patchProcess.on("error", (error) => {
+        reject(error);
+      });
+    });
+  }
+  /**
+   * Manually apply patch by parsing unified diff format
+   */
+  async _applyPatchManually(patchFileAbs, workDir) {
+    try {
+      const patchContent = await fs9.promises.readFile(patchFileAbs, "utf-8");
+      const targetFile = this._extractTargetFile(patchContent);
+      if (!targetFile || targetFile === "/dev/null") {
+        return null;
+      }
+      const targetPath = path6.join(workDir, targetFile);
+      const targetDir = path6.dirname(targetPath);
+      if (!fs9.existsSync(targetDir)) {
+        await fs9.promises.mkdir(targetDir, { recursive: true });
+      }
+      let fileLines = [];
+      if (fs9.existsSync(targetPath)) {
+        const content = await fs9.promises.readFile(targetPath, "utf-8");
+        fileLines = content.split("\n");
+      }
+      const resultLines = [...fileLines];
+      const lines = patchContent.split("\n");
+      let inHunk = false;
+      let oldLineNum = 0;
+      let newLineNum = 0;
+      const skipPrefixes = ["diff --git", "new file mode", "index ", "---", "+++"];
+      for (const line of lines) {
+        const hunkMatch = line.match(/^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/);
+        if (hunkMatch) {
+          inHunk = true;
+          oldLineNum = parseInt(hunkMatch[1], 10) - 1;
+          newLineNum = parseInt(hunkMatch[3], 10) - 1;
+          continue;
+        }
+        if (skipPrefixes.some((prefix) => line.startsWith(prefix))) {
+          continue;
+        }
+        if (!inHunk) {
+          continue;
+        }
+        if (line.startsWith(" ")) {
+          if (oldLineNum < resultLines.length) {
+            oldLineNum++;
+          }
+          newLineNum++;
+        } else if (line.startsWith("-")) {
+          if (oldLineNum < resultLines.length) {
+            resultLines.splice(oldLineNum, 1);
+          }
+        } else if (line.startsWith("+")) {
+          resultLines.splice(newLineNum, 0, line.slice(1));
+          newLineNum++;
+        }
+      }
+      await fs9.promises.writeFile(targetPath, resultLines.join("\n"), "utf-8");
+      return "Successfully applied patch manually by parsing and applying changes";
+    } catch (error) {
+      logger.debug(`Manual patch application failed: ${error}`);
+      return null;
+    }
+  }
+};
+PatchTool = __decorateClass([
+  tools({
+    writePatchFile: {
+      description: "Write patch content to file. IMPORTANT: Always read the target file first before generating a patch. Use correct line numbers based on actual file content. Never use @@ -0,0 format unless file is truly empty.",
+      params: [
+        { name: "patchPath", type: "string", description: "Path to the patch file. Will automatically append .patch suffix if not present." },
+        { name: "patchContent", type: "string", description: "Content of the patch in unified diff format. Must start with --- a/file_path and include +++ b/file_path lines." }
+      ],
+      returns: { type: "string", description: "Success message with bytes written" }
+    },
+    applyPatch: {
+      description: "Apply a patch to a file. The patch should be generated using writePatchFile first. IMPORTANT: Ensure patch line numbers match the actual file content to avoid duplicate content.",
+      params: [
+        { name: "patchPath", type: "string", description: "Path to the patch file. Will automatically append .patch suffix if not present." },
+        { name: "patchContent", type: "string", description: "Optional patch content to write before applying", optional: true }
+      ],
+      returns: { type: "string", description: "Success message describing the applied patch" }
+    }
+  })
+], PatchTool);
+
+// src/core/agent.ts
+import { v4 as uuidv4 } from "uuid";
+import * as path7 from "path";
+import * as fs10 from "fs";
+
+// src/core/model.ts
+import OpenAI from "openai";
+import { GoogleGenerativeAI } from "@google/generative-ai";
+var Model = class {
+  modelName;
+  config;
+  openaiClient;
+  anthropicClient;
+  geminiClient;
+  constructor(model) {
+    if (typeof model === "string" || model === void 0) {
+      this.modelName = model || "deepseek";
+      this.config = loadModelConfig(this.modelName);
+    } else {
+      this.config = model;
+      this.modelName = model.model || "deepseek";
+    }
+    this._initializeClient();
+  }
+  /**
+   * Initialize the appropriate SDK client based on provider
+   */
+  _initializeClient() {
+    const provider = this.config.provider.toLowerCase();
+    switch (provider) {
+      case "openai":
+      case "anthropic":
+        this.openaiClient = new OpenAI({
+          apiKey: this.config.apiKey || process.env.OPENAI_API_KEY,
+          baseURL: this.config.baseUrl,
+          timeout: 6e4
+        });
+        break;
+      case "deepseek":
+        this.openaiClient = new OpenAI({
+          apiKey: this.config.apiKey || process.env.DEEPSEEK_API_KEY,
+          baseURL: this.config.baseUrl || "https://api.deepseek.com",
+          timeout: 6e4
+        });
+        break;
+      case "gemini":
+        const apiKey = this.config.apiKey || process.env.GEMINI_API_KEY || "";
+        this.geminiClient = new GoogleGenerativeAI(apiKey);
+        break;
+      default:
+        throw new ModelError(`Unsupported provider: ${provider}`);
+    }
+  }
+  /**
+   * Asynchronous chat completion
+   */
+  async achat(messages, tools2, stream = true) {
+    const provider = this.config.provider.toLowerCase();
+    const useStream = stream !== void 0 ? stream : !!this.config.stream;
+    try {
+      switch (provider) {
+        case "openai":
+        case "deepseek":
+        case "anthropic":
+          return await this._callOpenAICompatible(messages, tools2, useStream);
+        case "gemini":
+          return await this._callGemini(messages, tools2, useStream);
+        default:
+          throw new ModelError(`Unsupported provider: ${provider}`);
+      }
+    } catch (error) {
+      logger.error(`Model call failed: ${error}`);
+      throw error;
+    }
+  }
+  /**
+   * Call OpenAI-compatible API (OpenAI, DeepSeek, etc.)
+   */
+  async _callOpenAICompatible(messages, tools2, stream = false) {
+    if (!this.openaiClient) {
+      throw new ModelError("OpenAI client not initialized");
+    }
+    try {
+      const params = {
         model: this.config.model || "gpt-3.5-turbo",
         messages,
         temperature: this.config.temperature || 0.7,
@@ -3346,197 +4116,66 @@ Arguments: `);
   }
 };
 
-// src/schemas/message.ts
-import * as fs7 from "fs";
-var Message = class _Message {
-  role;
-  content;
-  images;
-  type;
-  constructor(role, content, images, type) {
-    this.role = role;
-    this.content = content;
-    this.images = images;
-    this.type = type;
+// src/runtime/memory/messageHistory.ts
+var MessageHistory = class {
+  messages = [];
+  systemPrompt;
+  model;
+  contextWindowTokens;
+  currentTokens = 0;
+  constructor(model, system, contextWindowTokens) {
+    this.model = model;
+    this.systemPrompt = system;
+    this.contextWindowTokens = contextWindowTokens;
+    if (system) {
+      const systemMessage = new Message("system", system);
+      this.messages.push(systemMessage);
+      this.currentTokens += this.estimateTokens(system);
+    }
   }
-  /**
-   * Create message from user input
-   */
-  static fromUserMsg(content, images) {
-    return new _Message("user", content, images);
+  addMessage(arg1, arg2) {
+    let message;
+    if (arg1 instanceof Message) {
+      message = arg1;
+    } else if (typeof arg1 === "string") {
+      message = new Message(arg1, arg2);
+    } else if (typeof arg1 === "object" && arg1 !== null) {
+      this.messages.push(arg1);
+      const contentStr = arg1.content || JSON.stringify(arg1);
+      this.currentTokens += this.estimateTokens(contentStr);
+      return;
+    } else {
+      throw new Error(`Invalid message format: ${arg1}`);
+    }
+    this.messages.push(message);
+    this.currentTokens += this.estimateTokens(message.content);
   }
   /**
-   * Create message from assistant response
+   * Get all messages
    */
-  static fromAssistantMsg(content) {
-    return new _Message("assistant", content);
+  getMessages() {
+    return [...this.messages];
   }
   /**
-   * Create system message
+   * Get messages formatted for API calls
+   * Async version to handle base64 image encoding
    */
-  static fromSystemMsg(content) {
-    return new _Message("system", content);
-  }
-  /**
-   * Convert to plain object for API calls
-   */
-  toObject() {
-    const obj = {
-      role: this.role,
-      content: this.content
-    };
-    if (this.images) {
-      obj.images = this.images;
-    }
-    if (this.type) {
-      obj.type = this.type;
-    }
-    return obj;
-  }
-  /**
-   * Check if message contains images
-   */
-  hasImages() {
-    return !!this.images && (Array.isArray(this.images) ? this.images.length > 0 : true);
-  }
-  /**
-   * Get message content length
-   */
-  getContentLength() {
-    return this.content.length;
-  }
-  /**
-   * Convert to string representation
-   */
-  toString() {
-    return `${this.role}: ${this.content}`;
-  }
-  /**
-   * Convert to OpenAI Vision API format with base64-encoded images
-   * This method handles:
-   * - HTTP/HTTPS URLs: Downloads and converts to base64
-   * - Local file paths: Reads file and converts to base64
-   * - Already base64 strings: Passes through
-   */
-  async toChatMessage() {
-    const role = this.role;
-    if (!this.hasImages()) {
-      return { role, content: this.content };
-    }
-    const content = [{ type: "text", text: this.content }];
-    const imageArray = Array.isArray(this.images) ? this.images : [this.images];
-    for (const img of imageArray) {
-      let base64Data;
-      if (img.startsWith("http://") || img.startsWith("https://")) {
-        base64Data = await this.encodeHttpImage(img);
-      } else if (fs7.existsSync(img)) {
-        base64Data = await this.encodeLocalFile(img);
-      } else {
-        base64Data = img;
-      }
-      const mimeType = this.getMimeType(img);
-      content.push({
-        type: "image_url",
-        image_url: { url: `data:${mimeType};base64,${base64Data}` }
-      });
-    }
-    return { role, content };
-  }
-  /**
-   * Get MIME type from file path or URL
-   */
-  getMimeType(path5) {
-    const ext = path5.toLowerCase().split(".").pop();
-    const mimeTypes = {
-      png: "image/png",
-      jpg: "image/jpeg",
-      jpeg: "image/jpeg",
-      gif: "image/gif",
-      webp: "image/webp",
-      bmp: "image/bmp"
-    };
-    return mimeTypes[ext || ""] || "image/jpeg";
-  }
-  /**
-   * Encode local file to base64
-   */
-  async encodeLocalFile(filePath) {
-    const fileBuffer = await fs7.promises.readFile(filePath);
-    return fileBuffer.toString("base64");
-  }
-  /**
-   * Fetch and encode HTTP image to base64
-   */
-  async encodeHttpImage(url) {
-    const response = await fetch(url);
-    if (!response.ok) {
-      throw new Error(`Failed to fetch image from ${url}: ${response.statusText}`);
-    }
-    const buffer = await response.arrayBuffer();
-    return Buffer.from(buffer).toString("base64");
-  }
-};
-
-// src/memory/messageHistory.ts
-var MessageHistory = class {
-  messages = [];
-  systemPrompt;
-  model;
-  contextWindowTokens;
-  currentTokens = 0;
-  constructor(model, system, contextWindowTokens) {
-    this.model = model;
-    this.systemPrompt = system;
-    this.contextWindowTokens = contextWindowTokens;
-    if (system) {
-      const systemMessage = new Message("system", system);
-      this.messages.push(systemMessage);
-      this.currentTokens += this.estimateTokens(system);
-    }
-  }
-  addMessage(arg1, arg2) {
-    let message;
-    if (arg1 instanceof Message) {
-      message = arg1;
-    } else if (typeof arg1 === "string") {
-      message = new Message(arg1, arg2);
-    } else if (typeof arg1 === "object" && arg1 !== null) {
-      this.messages.push(arg1);
-      const contentStr = arg1.content || JSON.stringify(arg1);
-      this.currentTokens += this.estimateTokens(contentStr);
-      return;
-    } else {
-      throw new Error(`Invalid message format: ${arg1}`);
-    }
-    this.messages.push(message);
-    this.currentTokens += this.estimateTokens(message.content);
-  }
-  /**
-   * Get all messages
-   */
-  getMessages() {
-    return [...this.messages];
-  }
-  /**
-   * Get messages formatted for API calls
-   * Async version to handle base64 image encoding
-   */
-  async formatForApi() {
-    const results = [];
-    for (const msg of this.messages) {
-      if (msg instanceof Message) {
-        if (msg.hasImages()) {
-          results.push(await msg.toChatMessage());
-        } else {
-          results.push(msg.toObject());
-        }
-      } else if (typeof msg.toObject === "function") {
-        results.push(msg.toObject());
-      } else {
-        results.push(msg);
-      }
-    }
-    return results;
+  async formatForApi() {
+    const results = [];
+    for (const msg of this.messages) {
+      if (msg instanceof Message) {
+        if (msg.hasImages()) {
+          results.push(await msg.toChatMessage());
+        } else {
+          results.push(msg.toObject());
+        }
+      } else if (typeof msg.toObject === "function") {
+        results.push(msg.toObject());
+      } else {
+        results.push(msg);
+      }
+    }
+    return results;
   }
   /**
    * Update system prompt
@@ -3796,7 +4435,7 @@ var ToolcallManager = class {
       return;
     }
     while (this.semaphore.available <= 0) {
-      await new Promise((resolve2) => setTimeout(resolve2, 100));
+      await new Promise((resolve5) => setTimeout(resolve5, 100));
     }
     this.semaphore.available--;
     try {
@@ -3886,7 +4525,7 @@ background process observation: ${backgroundResult.content}`;
   async observe(waitAll = false, timeout = null) {
     await this.execute();
     if (this.tasks.size > 0 && !waitAll) {
-      await new Promise((resolve2) => setTimeout(resolve2, 1e3));
+      await new Promise((resolve5) => setTimeout(resolve5, 1e3));
     }
     if (waitAll && this.tasks.size > 0) {
       if (timeout) {
@@ -3960,7 +4599,7 @@ background process observation: ${backgroundResult.content}`;
    */
   async monitorProcess(processId, process2) {
     try {
-      await new Promise((resolve2, reject) => {
+      await new Promise((resolve5, reject) => {
         process2.on("exit", (code) => {
           if (this.backgroundProcesses.has(processId)) {
             const command = this.backgroundProcesses.get(processId).command;
@@ -3970,7 +4609,7 @@ background process observation: ${backgroundResult.content}`;
           if (this.monitorTasks.has(processId)) {
             this.monitorTasks.delete(processId);
           }
-          resolve2();
+          resolve5();
         });
         process2.on("error", (error) => {
           reject(error);
@@ -4022,17 +4661,17 @@ PID: ${info.pid}`;
         logger.info(`\u7EC8\u6B62\u540E\u53F0\u8FDB\u7A0B: ${command} (PID: ${process2.pid})`);
       }
       try {
-        await new Promise((resolve2) => {
+        await new Promise((resolve5) => {
           const timeoutId = setTimeout(() => {
             if (!force) {
               process2.kill("SIGKILL");
               logger.warn(`\u540E\u53F0\u8FDB\u7A0B\u672A\u54CD\u5E94\u7EC8\u6B62\u4FE1\u53F7\uFF0C\u5DF2\u5F3A\u5236\u6740\u6B7B: ${command}`);
             }
-            resolve2();
+            resolve5();
           }, 5e3);
           process2.on("exit", () => {
             clearTimeout(timeoutId);
-            resolve2();
+            resolve5();
           });
         });
       } catch (error) {
@@ -4116,69 +4755,48 @@ PID: ${info.pid}`;
 };
 
 // src/prompts/tools.ts
-var OUTPUT_FORMAT_PROMPT = `<System Tools OutputFormat>
-
-We have three types of tasks: Generative Tasks, Analytical Tasks, and Operational Tasks.
-You should choose the appropriate task type based on the task description.
-
-#### Generative Tasks Output Format
-<Generative Tasks Purpose>Create Something New</Generative Tasks Purpose> 
-
-<Generative Tasks Definition>
-These tasks focus on creating new artifacts from scratch, such as text, code, designs, or configurations. 
-The model synthesizes information and produces original outputs.
-</Generative Tasks Definition>
-
-<Generative Tasks Output Format>
-Output a sequence of tool calls in the format below. Replace <ToolName.method_name> and <args_name> with actual tool and parameter names.
-
-You may interleave tool calls with reasoning or explanations as needed:
-
-[Your reasoning or explanation here...]
-<ToolName.method_name><args_name1>args_value1</args_name1><args_name2>args_value2</args_name2>...</ToolName.method_name>
-
-[Additional thoughts or context...]
-<ToolName2.method_name2><args_name1>args_value1</args_name1><args_name2>args_value2</args_name2>...</ToolName2.method_name2>
-...
-</Generative Tasks Output Format>
+var REFLECT_OUTPUT_FORMAT_PROMPT = `**Reflection Prompt: Output Format Error**  
+Your output does not follow the required XML format:  
+<OutputFormat>  
+<ToolName.method_name><arg1_name>value1</arg1_name><arg2_name>value2</arg2_name></ToolName.method_name>  
+</OutputFormat>  
 
+Your erroneous output:  
+{output_text}  
 
-### Analytical Tasks Output Format
-<Analytical Tasks Purpose>Understand, Diagnose & Evaluate Existing Information</Analytical Tasks Purpose> 
+Please analyze the format discrepancies and re-output, ensuring:  
 
-<Analytical Tasks Definition>
-Analytical tasks focus on understanding, decomposing, diagnosing, and evaluating existing information.
-They include requirement analysis, code and system comprehension, quality evaluation, debugging and root-cause analysis, and data or behavioral analysis.
-Such tasks produce structured insights and decisions that guide subsequent generative or operational steps.
-</Analytical Tasks Definition>
+- Use the correct XML tag structure  
+- All tags are properly closed  
+- Parameter values are placed within the corresponding tags  
 
-<Analytical Tasks Output Format>
-You should fellow the format below, replace the <ToolName.method_name> and <args_name> with the actual name.
-
-Thoughts: ...
-ToolCall: <ToolName.method_name><args_name1>args_value1</args_name1><args_name2>args_value2</args_name2>...</ToolName.method_name>
-// stop ToolCall here, and wait for the Observation of the ToolCall.
+Re-output:  
+`;
+var OUTPUT_FORMAT_PROMPT = `<OutputFormat>
 
-</Analytical Tasks Output Format>
+You should use one tool or multiple tools (depends on your task), follow the format below, replace the <ToolName.method_name> and <args_name> with the actual tool name.
 
-### Operational Tasks Output Format
+Thought: ...
+Action: <ToolName1.method_name1><args_name1>args_value1</args_name1><args_name2>args_value2</args_name2>...</ToolName1.method_name1>
 
-<Operational Tasks Purpose>Act & Operate Tools</Operational Tasks Purpose> 
+**YOUR OUTPUT MUST INCLUDE THE ACTUAL <args_name> AND <args_value>!!!**
+**If the task is completed, simply return the completion information like <TaskCompletion>your_completion_information</TaskCompletion>, No any tool call should be included.**
+</OutputFormat>
+`;
+var TOOLS_PROMPT = `
+## Tools And Tool Calls Format
 
-<Operational Tasks Definition>
-These tasks involve performing concrete actions through tools, systems, or commands. 
-The focus is on executing operations rather than generating or analyzing content.
-</Operational Tasks Definition>
+Tools are represented by a predefined XML-like syntax structure. This structure encapsulates parameter lists within tags such as \`<ToolName.method_name>\`. 
+By identifying and matching keywords inside these tags, the system automatically parses the target tool name and its corresponding input parameter values to execute subsequent tool calls.
 
-<Operational Tasks Output Format>
-You should follow the format below, replace the <ToolName.method_name> and <args_name> with the actual name.
+### Available Tools
+{available_tools}
 
-<ToolName.method_name><args_name1>args_value1</args_name1><args_name2>args_value2</args_name2>...</ToolName.method_name>
-</Operational Tasks Output Format>
+### Description of Available Tools
+{desc_of_tools}
 
-**YOUR OUTPUT MUST INCLUDE THE ACTUAL <args_name> AND <args_value>!!!**
-**If the task is completed, simply return the completion information like <TaskCompletion>your_completion_information</TaskCompletion>, No any tool call should be included.**
-</System Tools OutputFormat>
+### Output Format
+{output_format}
 `;
 var SYSTEM_TOOLS_PROMPT = `
 ## System Tools And System Tools Call Format
@@ -4196,7 +4814,7 @@ By identifying and matching keywords inside these tags, the system automatically
 {outputFormat}
 `;
 
-// src/agent.ts
+// src/core/agent.ts
 var Agent = class {
   name;
   profile;
@@ -4212,6 +4830,14 @@ var Agent = class {
   toolcallManagerPoolSize;
   postProcessor;
   useFunctionCalling;
+  // New properties from Python 0.2.2
+  agentId;
+  workspaceDir;
+  executor;
+  autoShutdownExecutor;
+  parallelExecution;
+  observeTimeout;
+  skills;
   constructor(config2) {
     const {
       name,
@@ -4221,18 +4847,38 @@ var Agent = class {
       subAgents = [],
       mcpServerNames = [],
       modelConfig,
+      udfModelName,
       verbose = false,
       useFunctionCalling = false,
       postProcessor = null,
-      toolcallManagerPoolSize = 5
+      toolcallManagerPoolSize = 5,
+      // New parameters from Python 0.2.2
+      agentId,
+      workspaceDir = "",
+      executor = null,
+      autoShutdownExecutor = false,
+      parallelExecution = false,
+      observeTimeout = 60,
+      skills = []
     } = config2;
     this.name = name;
     this.profile = profile;
     this.verbose = verbose;
-    this.modelConfig = modelConfig || "deepseek";
+    this.modelConfig = udfModelName || modelConfig || "deepseek";
     this.subAgents = subAgents || [];
     this.postProcessor = postProcessor;
     this.useFunctionCalling = useFunctionCalling;
+    this.agentId = agentId || uuidv4();
+    this.workspaceDir = workspaceDir ? path7.resolve(workspaceDir) : "";
+    this.executor = executor;
+    this.autoShutdownExecutor = autoShutdownExecutor;
+    this.parallelExecution = parallelExecution;
+    this.observeTimeout = observeTimeout;
+    this.skills = skills;
+    if (this.workspaceDir && !fs10.existsSync(this.workspaceDir)) {
+      fs10.mkdirSync(this.workspaceDir, { recursive: true });
+      logger.debug(`Created workspace directory for agent ${this.name}: ${this.workspaceDir}`);
+    }
     const agentToolNames = registerAgentAsTool(this.subAgents, Boolean(this.verbose));
     this.tools = [...tools2, ...agentToolNames];
     this.mcpServerNames = mcpServerNames;
@@ -4501,6 +5147,14 @@ var Agent = class {
       throw error;
     } finally {
       await stack.close();
+      if (this.autoShutdownExecutor && this.executor) {
+        try {
+          await this.executor.shutdown({ wait: true });
+          logger.debug(`Executor shutdown completed for agent ${this.name}`);
+        } catch (error) {
+          logger.warn(`Error during executor shutdown: ${error}`);
+        }
+      }
     }
   }
   /**
@@ -4554,21 +5208,192 @@ var Agent = class {
   getSubAgents() {
     return [...this.subAgents];
   }
+  /**
+   * Get agent ID
+   */
+  getAgentId() {
+    return this.agentId;
+  }
+  /**
+   * Get workspace directory
+   */
+  getWorkspaceDir() {
+    return this.workspaceDir;
+  }
+  /**
+   * Get parallel execution setting
+   */
+  getParallelExecution() {
+    return this.parallelExecution;
+  }
+  /**
+   * Get observe timeout setting
+   */
+  getObserveTimeout() {
+    return this.observeTimeout;
+  }
+  /**
+   * Get skills
+   */
+  getSkills() {
+    return [...this.skills];
+  }
+  /**
+   * Get executor
+   */
+  getExecutor() {
+    return this.executor;
+  }
+  /**
+   * Set executor
+   */
+  setExecutor(executor) {
+    this.executor = executor;
+  }
+  /**
+   * Get chat history message
+   */
+  get chatHistoryMessage() {
+    return this.history;
+  }
+};
+
+// src/schemas/feedback.ts
+var Feedback = class _Feedback {
+  /**
+   * Whether the test/evaluation passed
+   */
+  isPassing;
+  /**
+   * Detailed feedback message
+   */
+  feedback;
+  constructor(isPassing = false, feedback) {
+    this.isPassing = isPassing;
+    this.feedback = feedback || new Message("user", "No feedback provided. Please check feedback settings.");
+    this._validate();
+  }
+  /**
+   * Validate the feedback
+   */
+  _validate() {
+    if (!this.feedback.content) {
+      throw new Error("Feedback content cannot be empty");
+    }
+    if (this.feedback.tag !== void 0) {
+      if (!this.feedback.tag) {
+        this.feedback.tag = "feedback";
+      } else if (!this.feedback.tag.toLowerCase().includes("feedback")) {
+        this.feedback.tag = `feedback_${this.feedback.tag}`;
+      }
+    }
+  }
+  /**
+   * Convert feedback to a Message, optionally with pre/post content
+   *
+   * @param preContent - Content to prepend to the feedback
+   * @param postContent - Content to append to the feedback
+   * @returns Combined Message
+   */
+  toMessage(preContent = "", postContent = "") {
+    const feedbackMsg = new Message(
+      this.feedback.role,
+      this.feedback.content,
+      this.feedback.images,
+      this.feedback.type
+    );
+    if (this.feedback.tag !== void 0) {
+      feedbackMsg.tag = this.feedback.tag;
+    }
+    let result = feedbackMsg;
+    if (preContent) {
+      const preMsg = new Message("user", preContent);
+      result = this._mergeMessages(preMsg, result);
+    }
+    if (postContent) {
+      const postMsg = new Message("user", postContent);
+      result = this._mergeMessages(result, postMsg);
+    }
+    return result;
+  }
+  /**
+   * Merge two messages into one
+   */
+  _mergeMessages(first, second) {
+    const merged = new Message(
+      first.role,
+      `${first.content}
+${second.content}`,
+      first.images || second.images,
+      first.type || second.type
+    );
+    if (second.tag !== void 0) {
+      merged.tag = second.tag;
+    }
+    return merged;
+  }
+  /**
+   * Format feedback for API calls
+   *
+   * @param preContent - Content to prepend
+   * @param postContent - Content to append
+   * @returns Formatted object for API
+   */
+  formatForApi(preContent = "", postContent = "") {
+    const message = this.toMessage(preContent, postContent);
+    return message.toObject();
+  }
+  /**
+   * Create a passing feedback
+   */
+  static pass(content) {
+    return new _Feedback(true, new Message("user", content));
+  }
+  /**
+   * Create a failing feedback
+   */
+  static fail(content) {
+    return new _Feedback(false, new Message("user", content));
+  }
 };
 
-// src/environment/base.ts
-var BaseEnvironment = class {
+// src/runtime/orchestrator/base.ts
+var InstructionType = /* @__PURE__ */ ((InstructionType2) => {
+  InstructionType2["VALID"] = "valid";
+  InstructionType2["QUIT"] = "quit";
+  InstructionType2["SEND_TO_ALL"] = "sendToAll";
+  InstructionType2["NO_AGENT_NAME"] = "noAgentName";
+  InstructionType2["NO_AVAILABLE_AGENT_NAME"] = "noAvailableAgentName";
+  return InstructionType2;
+})(InstructionType || {});
+var BaseOrchestrator = class {
   /**
-   * List of agents in the environment
+   * List of agents in the orchestrator
    */
   agents = [];
   /**
    * Assign skills to agent with their names
    */
   agentSkills = {};
-  constructor(agents = [], agentSkills = {}) {
+  /**
+   * Whether to always wait for human input
+   */
+  alwaysWaitHumanInput = false;
+  /**
+   * Maximum number of rounds for agent execution
+   */
+  maxRounds = 100;
+  constructor(options = {}) {
+    const {
+      agents = [],
+      agentSkills = {},
+      alwaysWaitHumanInput = false,
+      maxRounds = 100
+    } = options;
     this.agents = agents;
     this.agentSkills = agentSkills;
+    this.alwaysWaitHumanInput = alwaysWaitHumanInput;
+    this.maxRounds = maxRounds;
     this.setAgentSkills();
   }
   /**
@@ -4638,12 +5463,21 @@ var BaseEnvironment = class {
     }
     return ["noAvailableAgentName" /* NO_AVAILABLE_AGENT_NAME */, instruction];
   }
+  /**
+   * Shutdown all agent executors
+   */
+  async shutdownAllExecutors(options) {
+    const wait = options?.wait ?? true;
+    for (const agent of this.agents) {
+    }
+    logger.debug("All agent executors shutdown");
+  }
   /**
    * Run with a single goal until completion (non-interactive mode)
    */
   async runGoal(goal) {
     if (this.agents.length === 0) {
-      logger.error("No agents in the environment.");
+      logger.error("No agents in the orchestrator.");
       return;
     }
     const [instructionType, processedInstruction] = this.postProcessInstruction(
@@ -4674,36 +5508,40 @@ var BaseEnvironment = class {
     }
   }
   /**
-   * Run the environment (interactive mode)
+   * Run the orchestrator (interactive mode)
    */
-  async run() {
+  async run(instruction) {
+    if (instruction) {
+      await this.runGoal(instruction);
+      return;
+    }
     const readline = await import("readline");
     const rl = readline.createInterface({
       input: process.stdin,
       output: process.stdout
     });
     const question = (prompt) => {
-      return new Promise((resolve2) => {
-        rl.question(prompt, resolve2);
+      return new Promise((resolve5) => {
+        rl.question(prompt, resolve5);
       });
     };
     try {
       while (true) {
         try {
-          let instruction;
+          let userInstruction;
           if (this.agents.length === 0) {
-            logger.error("No agents in the environment.");
+            logger.error("No agents in the orchestrator.");
             break;
           } else if (this.agents.length === 1) {
-            instruction = await question("Enter your instruction (or '/q' to quit): ");
+            userInstruction = await question("Enter your instruction (or '/q' to quit): ");
           } else {
             const agentNames = this.agents.map((agent) => agent.name).join(", ");
-            instruction = await question(
+            userInstruction = await question(
               `Enter your instruction with '@agent_name' (or '/q' to quit), available agents: ${agentNames}: `
             );
           }
           const [instructionType, processedInstruction] = this.postProcessInstruction(
-            instruction,
+            userInstruction,
             this.agents.map((agent) => agent.name)
           );
           if (instructionType === "quit" /* QUIT */) {
@@ -4729,16 +5567,18 @@ var BaseEnvironment = class {
     }
   }
 };
+var BaseEnvironment = BaseOrchestrator;
 
-// src/environment/coding.ts
-import * as fs8 from "fs";
-var CodingEnvironment = class extends BaseEnvironment {
+// src/runtime/orchestrator/coding.ts
+import * as fs11 from "fs";
+var CodingOrchestrator = class extends BaseOrchestrator {
   /**
    * Workspace directory
    */
   workspaceDir = "";
-  constructor(agents = [], agentSkills = {}, workspaceDir = "") {
-    super(agents, agentSkills);
+  constructor(options = {}) {
+    const { workspaceDir = "", ...baseOptions } = options;
+    super(baseOptions);
     this.workspaceDir = workspaceDir;
     this.setWorkspaceDir();
   }
@@ -4749,8 +5589,8 @@ var CodingEnvironment = class extends BaseEnvironment {
     if (!this.workspaceDir) {
       this.workspaceDir = WORKSPACE_DIR;
     }
-    if (!fs8.existsSync(this.workspaceDir)) {
-      fs8.mkdirSync(this.workspaceDir, { recursive: true });
+    if (!fs11.existsSync(this.workspaceDir)) {
+      fs11.mkdirSync(this.workspaceDir, { recursive: true });
     } else {
       logger.debug(`Workspace directory already exists: ${this.workspaceDir}`);
     }
@@ -4769,32 +5609,1206 @@ Your workspace directory is: <workspace>${this.workspaceDir}</workspace>
     }
   }
 };
+var CodingEnvironment = CodingOrchestrator;
+
+// src/runtime/orchestrator/reflexion.ts
+var CRITIC_SYSTEM_PROMPT = `You are a critic agent specialized in {taskType} tasks.
+
+Your role is to:
+1. Analyze the implementation provided
+2. Identify issues and areas for improvement
+3. Provide constructive feedback in the form of {feedbackType}
+4. Suggest specific improvements
+
+Be thorough but constructive in your feedback.`;
+var ACTOR_SYSTEM_PROMPT = `You are an actor agent specialized in {taskType} tasks.
+
+Your role is to:
+1. Review the feedback and self-reflection
+2. Improve the implementation based on the suggestions
+3. Produce a better version of the code/output
+
+Focus on addressing all issues mentioned in the feedback.`;
+var ReflexionOrchestrator = class {
+  task;
+  taskType;
+  feedbackType;
+  environment;
+  criticAgentConfig;
+  actorAgentConfig;
+  maxIterations;
+  constructor(options) {
+    this.task = options.task;
+    this.taskType = options.taskType;
+    this.feedbackType = options.feedbackType;
+    this.environment = options.environment;
+    this.maxIterations = options.maxIterations ?? 3;
+    this.criticAgentConfig = {
+      name: "CriticAgent",
+      profile: "You are an AI assistant.",
+      tools: ["CommandLineTool.execute", "FileEditor.write", "FileEditor.read"],
+      udfModelName: "deepseek",
+      workspaceDir: "",
+      fewShot: "",
+      verbose: false,
+      saveSelfReflection: false,
+      postContent: "",
+      ...options.criticAgentConfig
+    };
+    this.actorAgentConfig = {
+      name: "ActorAgent",
+      profile: "You are an AI engineer.",
+      tools: ["CommandLineTool.execute", "FileEditor.write", "ThinkTool.execute"],
+      udfModelName: "deepseek",
+      workspaceDir: "",
+      fewShot: "",
+      verbose: false,
+      ...options.actorAgentConfig
+    };
+  }
+  /**
+   * Create system prompt for critic agent
+   */
+  createCriticSystemPrompt() {
+    return CRITIC_SYSTEM_PROMPT.replace("{taskType}", this.taskType).replace("{feedbackType}", this.feedbackType);
+  }
+  /**
+   * Create system prompt for actor agent
+   */
+  createActorSystemPrompt() {
+    return ACTOR_SYSTEM_PROMPT.replace("{taskType}", this.taskType).replace("{feedbackType}", this.feedbackType);
+  }
+  /**
+   * Build history message for critic agent
+   */
+  buildCriticHistoryMessage(impl, feedback) {
+    const preContent = this.criticAgentConfig.workspaceDir ? `Your workspace directory is: ${this.criticAgentConfig.workspaceDir}
+
+` : "";
+    const postContent = (this.criticAgentConfig.postContent || "") + "\nDo not change the impl file, just use tools to find the correct way and give the self-reflection.";
+    return [feedback.toMessage(preContent, postContent)];
+  }
+  /**
+   * Build history message for actor agent
+   */
+  buildActorHistoryMessage(feedback, selfReflection, improvedImplPath) {
+    const messages = [];
+    if (this.actorAgentConfig.fewShot) {
+      messages.push(new Message("user", this.actorAgentConfig.fewShot));
+    }
+    messages.push(feedback);
+    messages.push(new Message(
+      "assistant",
+      `<self_reflection>
+${selfReflection}
+</self_reflection>`
+    ));
+    messages.push(new Message(
+      "user",
+      `Use ThinkTool to recap the feedback and self-reflection, think how to improve the previous impl, and use FileEditor tools to write your improved implementation, and saved it to the file \`${improvedImplPath}\`.`
+    ));
+    return messages;
+  }
+  /**
+   * Run the reflexion loop
+   */
+  async run() {
+    const actor = new Agent({
+      name: this.actorAgentConfig.name || "ActorAgent",
+      profile: this.actorAgentConfig.profile || "You are an AI engineer.",
+      system: this.createActorSystemPrompt(),
+      tools: this.actorAgentConfig.tools,
+      modelConfig: this.actorAgentConfig.udfModelName,
+      verbose: this.actorAgentConfig.verbose
+    });
+    const critic = new Agent({
+      name: this.criticAgentConfig.name || "CriticAgent",
+      profile: this.criticAgentConfig.profile || "You are an AI assistant.",
+      system: this.createCriticSystemPrompt(),
+      tools: this.criticAgentConfig.tools,
+      modelConfig: this.criticAgentConfig.udfModelName,
+      verbose: this.criticAgentConfig.verbose
+    });
+    let currentRound = 0;
+    let feedback = await this.environment.step(this.environment.initStepKwargs);
+    let finalOutput = "";
+    while (!feedback.isPassing && currentRound < this.maxIterations) {
+      logger.debug(`Feedback: ${feedback.feedback.content}`);
+      const criticHistoryMsgs = this.buildCriticHistoryMessage(
+        this.environment.improvedImpl,
+        feedback
+      );
+      let selfReflection = await critic.run(
+        criticHistoryMsgs[0].content
+      );
+      if (selfReflection.includes("<TaskCompletion>")) {
+        selfReflection = selfReflection.replace(/<TaskCompletion>/g, "<self-reflection>").replace(/<\/TaskCompletion>/g, "</self-reflection>").trim();
+      }
+      logger.info(`Critic agent self-reflection: ${selfReflection}`);
+      const actorHistoryMsgs = this.buildActorHistoryMessage(
+        criticHistoryMsgs[criticHistoryMsgs.length - 1],
+        selfReflection,
+        this.environment.improvedImpl
+      );
+      let improvedImplSummary = await actor.run(
+        actorHistoryMsgs[actorHistoryMsgs.length - 1].content
+      );
+      if (improvedImplSummary.includes("<TaskCompletion>")) {
+        improvedImplSummary = improvedImplSummary.replace(/<TaskCompletion>/g, "<improved-impl-summary>").replace(/<\/TaskCompletion>/g, "</improved-impl-summary>").trim();
+      }
+      logger.info(`Actor agent improved impl summary: ${improvedImplSummary}`);
+      finalOutput = improvedImplSummary;
+      feedback = await this.environment.step(this.environment.improvedStepKwargs);
+      currentRound++;
+    }
+    logger.info(`Reflection task completed in ${currentRound} rounds`);
+    try {
+      await this.environment.shutdown();
+      logger.info("Environment shutdown completed");
+    } catch (error) {
+      logger.warn(`Error during environment shutdown: ${error}`);
+    }
+    return {
+      success: feedback.isPassing,
+      iterations: currentRound,
+      finalOutput
+    };
+  }
+};
+
+// src/runtime/environment/base.ts
+import * as fs12 from "fs";
+import * as path8 from "path";
+var Environment = class {
+  /**
+   * Arguments for the step method (initial implementation)
+   */
+  initStepKwargs = {};
+  /**
+   * Arguments for the step method (improved implementation)
+   */
+  improvedStepKwargs = {};
+  /**
+   * Path to the initial implementation file
+   */
+  initImpl;
+  /**
+   * Path to the improved implementation file
+   */
+  improvedImpl;
+  constructor(options) {
+    this.initImpl = path8.resolve(options.initImpl);
+    this.improvedImpl = path8.resolve(options.improvedImpl);
+    this.initStepKwargs = options.initStepKwargs || {};
+    this.improvedStepKwargs = options.improvedStepKwargs || {};
+    this._initImprovedImpl();
+  }
+  /**
+   * Initialize the improved implementation by copying from init
+   */
+  _initImprovedImpl() {
+    if (fs12.existsSync(this.initImpl)) {
+      if (fs12.existsSync(this.improvedImpl)) {
+        const stats = fs12.statSync(this.improvedImpl);
+        if (stats.isDirectory()) {
+          fs12.rmSync(this.improvedImpl, { recursive: true });
+        } else {
+          fs12.unlinkSync(this.improvedImpl);
+        }
+      }
+      fs12.copyFileSync(this.initImpl, this.improvedImpl);
+    }
+  }
+  /**
+   * Check if the improved implementation exists
+   */
+  hasImprovedImpl() {
+    return fs12.existsSync(this.improvedImpl);
+  }
+  /**
+   * Shutdown the environment
+   *
+   * Called when the evaluation is complete or interrupted.
+   * Override to clean up resources.
+   */
+  async shutdown() {
+  }
+  /**
+   * Evaluate the environment on a benchmark
+   *
+   * TODO: Add benchmark support for self-evolving
+   *
+   * @returns Whether the benchmark passed
+   */
+  async bench() {
+    throw new Error("bench() is not implemented");
+  }
+};
+
+// src/runtime/executors/base.ts
+function createGeneratedToolcall(options) {
+  const toolCallId = options.toolCallId || `call_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+  return {
+    toolName: options.toolName,
+    toolArguments: options.toolArguments,
+    toolCallId,
+    source: options.source || "chat",
+    isSuccess: true,
+    rawContentFromLlm: options.rawContentFromLlm,
+    idempotencyKey: `${options.toolName}-${JSON.stringify(options.toolArguments)}-${toolCallId}`
+  };
+}
+function createExecutedToolcall(metadata, isSuccess, result) {
+  return {
+    metadata,
+    isSuccess,
+    result
+  };
+}
+
+// src/runtime/executors/utils.ts
+async function _executeSingleTool(generatedToolcall, toolStore) {
+  const toolStores = Array.isArray(toolStore) ? toolStore : [toolStore];
+  if (!generatedToolcall.isSuccess) {
+    return createExecutedToolcall(
+      generatedToolcall,
+      false,
+      `Tool extraction failed: ${generatedToolcall.failedReason || "Unknown"}`
+    );
+  }
+  if (generatedToolcall.toolName.toLowerCase() === "taskcompletion") {
+    return createExecutedToolcall(
+      generatedToolcall,
+      true,
+      "The task has been completed."
+    );
+  }
+  try {
+    for (const ts of toolStores) {
+      if (ts.hasTool && ts.hasTool(generatedToolcall.toolName)) {
+        const toolDef = ts.getTool(generatedToolcall.toolName);
+        if (!toolDef) {
+          continue;
+        }
+        const toolExecute = toolDef.execute;
+        if (!toolExecute) {
+          return createExecutedToolcall(
+            generatedToolcall,
+            false,
+            `Tool '${generatedToolcall.toolName}' has no execute function`
+          );
+        }
+        const result = await toolExecute(generatedToolcall.toolArguments);
+        const resultValue = result instanceof Message ? result : String(result);
+        return createExecutedToolcall(
+          generatedToolcall,
+          true,
+          resultValue
+        );
+      }
+    }
+    return createExecutedToolcall(
+      generatedToolcall,
+      false,
+      `Tool '${generatedToolcall.toolName}' not found in tool_store. Please check the tool name.`
+    );
+  } catch (error) {
+    const errorMsg = `Error executing tool: ${error instanceof Error ? error.message : String(error)}`;
+    logger.error(errorMsg);
+    return createExecutedToolcall(
+      generatedToolcall,
+      false,
+      errorMsg
+    );
+  }
+}
+async function executeToolsSequential(toolcalls, toolStore) {
+  const results = [];
+  for (const toolcall of toolcalls) {
+    const result = await _executeSingleTool(toolcall, toolStore);
+    results.push(result);
+  }
+  return results;
+}
+async function executeToolsParallel(toolcalls, toolStore, maxConcurrency = 5) {
+  const results = [];
+  const pending = [];
+  let runningCount = 0;
+  for (const toolcall of toolcalls) {
+    while (runningCount >= maxConcurrency) {
+      await Promise.race(pending);
+    }
+    runningCount++;
+    const promise = (async () => {
+      try {
+        const result = await _executeSingleTool(toolcall, toolStore);
+        results.push(result);
+      } finally {
+        runningCount--;
+      }
+    })();
+    pending.push(promise);
+  }
+  await Promise.all(pending);
+  return results;
+}
+
+// src/runtime/executors/localExecutor.ts
+import { v4 as uuidv42 } from "uuid";
+var _currentExecutor = null;
+function getCurrentExecutor() {
+  return _currentExecutor;
+}
+function setCurrentExecutor(executor) {
+  _currentExecutor = executor;
+}
+var LocalToolExecutor = class {
+  poolSize;
+  toolStores;
+  // Concurrency control
+  semaphore;
+  // Task management
+  pendingTasks = [];
+  runningTasks = /* @__PURE__ */ new Set();
+  finishedResults = [];
+  successTasks = /* @__PURE__ */ new Map();
+  failedTasks = /* @__PURE__ */ new Map();
+  // Statistics
+  totalSubmitted = 0;
+  totalFinished = 0;
+  totalFailed = 0;
+  // Lifecycle state
+  started = false;
+  isShutdown = false;
+  // Background process management
+  backgroundProcesses = /* @__PURE__ */ new Map();
+  constructor(poolSize = 5, toolStores = []) {
+    this.poolSize = poolSize;
+    this.toolStores = toolStores;
+    this.semaphore = { available: poolSize };
+  }
+  // ---- Lifecycle Methods ----
+  async start() {
+    if (this.started) {
+      logger.warn("Executor already started");
+      return;
+    }
+    this.semaphore = { available: this.poolSize };
+    this.started = true;
+    this.isShutdown = false;
+    logger.info(`LocalToolExecutor started with max concurrency: ${this.poolSize}`);
+  }
+  async shutdown(options) {
+    const wait = options?.wait ?? true;
+    if (this.isShutdown) {
+      logger.warn("Executor already shutdown");
+      return;
+    }
+    this.isShutdown = true;
+    if (wait && this.runningTasks.size > 0) {
+      logger.info(`Waiting for ${this.runningTasks.size} running tasks to complete...`);
+      await Promise.allSettled(Array.from(this.runningTasks));
+      logger.info("All tasks completed");
+    }
+    if (this.backgroundProcesses.size > 0) {
+      logger.info("Cleaning up background processes...");
+      await this.cleanupBackgroundProcesses();
+    }
+    this.started = false;
+    logger.info("LocalToolExecutor shutdown");
+  }
+  // ---- Execution Methods ----
+  async submit(toolcall) {
+    if (!this.started) {
+      throw new Error("Executor not started. Call start() first.");
+    }
+    if (this.isShutdown) {
+      throw new Error("Executor already shutdown");
+    }
+    this.totalSubmitted++;
+    const task = this._executeToolcall(toolcall);
+    this.runningTasks.add(task);
+    task.finally(() => {
+      this.runningTasks.delete(task);
+    });
+    logger.debug(`Submitted tool call: ${toolcall.toolName}`);
+  }
+  async submitMany(toolcalls, options) {
+    if (!this.started) {
+      throw new Error("Executor not started. Call start() first.");
+    }
+    const toolcallList = Array.from(toolcalls);
+    if (toolcallList.length === 0) {
+      return;
+    }
+    const parallel = options?.parallel ?? true;
+    if (parallel) {
+      for (const toolcall of toolcallList) {
+        await this.submit(toolcall);
+      }
+      logger.debug(`Submitted ${toolcallList.length} tool calls in parallel`);
+    } else {
+      logger.debug(`Starting sequential execution of ${toolcallList.length} tool calls`);
+      for (const toolcall of toolcallList) {
+        await this.submit(toolcall);
+        while (this.runningTasks.size > 0) {
+          await new Promise((resolve5) => setTimeout(resolve5, 100));
+        }
+      }
+      logger.debug("Sequential execution completed");
+    }
+  }
+  // ---- Observation Methods ----
+  async observe(options) {
+    const wait = options?.wait ?? false;
+    const timeout = options?.timeout;
+    const maxItems = options?.maxItems;
+    if (wait && this.finishedResults.length === 0 && this.runningTasks.size > 0) {
+      const startTime = Date.now();
+      while (this.finishedResults.length === 0 && this.runningTasks.size > 0) {
+        if (timeout !== void 0) {
+          const elapsed = (Date.now() - startTime) / 1e3;
+          if (elapsed >= timeout) {
+            logger.warn(`Observe timeout (${timeout}s), no results yet`);
+            break;
+          }
+        }
+        await new Promise((resolve5) => setTimeout(resolve5, 100));
+      }
+    }
+    const results = [];
+    let count = 0;
+    while (this.finishedResults.length > 0 && (maxItems === void 0 || count < maxItems)) {
+      results.push(this.finishedResults.shift());
+      count++;
+    }
+    if (results.length > 0) {
+      logger.debug(`Returning ${results.length} execution results`);
+    }
+    return results;
+  }
+  async waitAll() {
+    if (this.runningTasks.size > 0) {
+      logger.debug(`Waiting for ${this.runningTasks.size} tasks to complete...`);
+      await Promise.allSettled(Array.from(this.runningTasks));
+      logger.info("All tasks completed");
+    }
+  }
+  // ---- Status Methods ----
+  status() {
+    return {
+      pending: this.pendingTasks.length,
+      running: this.runningTasks.size,
+      finished: this.successTasks.size,
+      failed: this.failedTasks.size,
+      totalSubmitted: this.totalSubmitted,
+      isRunning: this.started && !this.isShutdown
+    };
+  }
+  clear() {
+    const cleared = this.finishedResults.length;
+    this.finishedResults = [];
+    this.successTasks.clear();
+    this.failedTasks.clear();
+    if (cleared > 0) {
+      logger.debug(`Cleared ${cleared} execution results`);
+    }
+  }
+  // ---- Private Methods ----
+  async _executeToolcall(toolcall) {
+    if (this.successTasks.has(toolcall.idempotencyKey) || this.failedTasks.has(toolcall.idempotencyKey)) {
+      logger.debug(`Tool call already executed: ${toolcall.toolName}, using cached result`);
+      const result = this.successTasks.get(toolcall.idempotencyKey) || this.failedTasks.get(toolcall.idempotencyKey);
+      if (result) {
+        this.finishedResults.push(result);
+      }
+      return;
+    }
+    if (!toolcall.isSuccess) {
+      logger.warn(`Tool call extraction failed: ${toolcall.toolName}, reason: ${toolcall.failedReason || "Unknown"}`);
+      const result = createExecutedToolcall(
+        toolcall,
+        false,
+        `Tool extraction failed: ${toolcall.failedReason || "Unknown"}`
+      );
+      this.finishedResults.push(result);
+      this.totalFailed++;
+      this.failedTasks.set(toolcall.idempotencyKey, result);
+      return;
+    }
+    while (this.semaphore.available <= 0) {
+      await new Promise((resolve5) => setTimeout(resolve5, 100));
+    }
+    this.semaphore.available--;
+    try {
+      const previousExecutor = _currentExecutor;
+      _currentExecutor = this;
+      try {
+        logger.debug(`Starting execution: ${toolcall.toolName}(${JSON.stringify(toolcall.toolArguments)})`);
+        const executedToolcall = await _executeSingleTool(toolcall, this.toolStores);
+        if (executedToolcall.isSuccess) {
+          logger.debug(`Execution successful: ${executedToolcall.metadata.toolName}`);
+          this.totalFinished++;
+          this.successTasks.set(toolcall.idempotencyKey, executedToolcall);
+        } else {
+          logger.warn(
+            `Execution failed: ${executedToolcall.metadata.toolName}, status: ${executedToolcall.isSuccess}, reason: ${executedToolcall.result}`
+          );
+          this.totalFailed++;
+          this.failedTasks.set(toolcall.idempotencyKey, executedToolcall);
+        }
+        this.finishedResults.push(executedToolcall);
+      } finally {
+        _currentExecutor = previousExecutor;
+      }
+    } catch (error) {
+      logger.error(`Exception executing tool ${toolcall.toolName}: ${error}`);
+      const result = createExecutedToolcall(
+        toolcall,
+        false,
+        `Execution exception: ${error instanceof Error ? error.message : String(error)}`
+      );
+      this.finishedResults.push(result);
+      this.failedTasks.set(toolcall.idempotencyKey, result);
+      this.totalFailed++;
+    } finally {
+      this.semaphore.available++;
+    }
+  }
+  // ---- Background Process Management ----
+  registerBackgroundProcess(process2, command, cwd) {
+    const processId = uuidv42().slice(0, 8);
+    this.backgroundProcesses.set(processId, {
+      process: process2,
+      command,
+      cwd,
+      pid: process2.pid || 0,
+      status: "running"
+    });
+    logger.debug(`Registered background process: ${processId}, PID: ${process2.pid}, Command: ${command}`);
+    return processId;
+  }
+  listBackgroundProcesses() {
+    if (this.backgroundProcesses.size === 0) {
+      return "No running background processes";
+    }
+    const lines = [`Total ${this.backgroundProcesses.size} background processes:
+`];
+    for (const [processId, info] of this.backgroundProcesses) {
+      const status = info.process.exitCode !== null ? "completed" : "running";
+      lines.push(
+        `- Process ID: ${processId}
+  PID: ${info.pid}
+  Command: ${info.command}
+  Working Dir: ${info.cwd}
+  Status: ${status}`
+      );
+      if (info.process.exitCode !== null) {
+        lines.push(`  Exit Code: ${info.process.exitCode}`);
+      }
+    }
+    return lines.join("\n");
+  }
+  async stopBackgroundProcess(processId, force = false) {
+    if (!this.backgroundProcesses.has(processId)) {
+      return `Process ${processId} not found`;
+    }
+    const info = this.backgroundProcesses.get(processId);
+    const process2 = info.process;
+    if (process2.exitCode !== null) {
+      return `Process ${processId} already terminated (exit code: ${process2.exitCode})`;
+    }
+    try {
+      if (force) {
+        process2.kill("SIGKILL");
+        logger.info(`Force killed process ${process2.pid} (Process ID: ${processId})`);
+      } else {
+        process2.kill("SIGTERM");
+        logger.info(`Sent SIGTERM to process ${process2.pid} (Process ID: ${processId})`);
+      }
+      await new Promise((resolve5) => {
+        const timeout = setTimeout(() => {
+          if (process2.exitCode === null && !force) {
+            process2.kill("SIGKILL");
+            logger.warn(`Process ${process2.pid} did not respond to SIGTERM, force killed`);
+          }
+          resolve5();
+        }, 5e3);
+        process2.on("exit", () => {
+          clearTimeout(timeout);
+          resolve5();
+        });
+      });
+      info.status = "stopped";
+      return `Process ${processId} stopped`;
+    } catch (error) {
+      logger.error(`Error stopping process ${processId}: ${error}`);
+      return `Failed to stop process ${processId}: ${error}`;
+    }
+  }
+  async cleanupBackgroundProcesses() {
+    if (this.backgroundProcesses.size === 0) {
+      return "No background processes to clean up";
+    }
+    const total = this.backgroundProcesses.size;
+    let cleaned = 0;
+    const errors = [];
+    for (const processId of Array.from(this.backgroundProcesses.keys())) {
+      const info = this.backgroundProcesses.get(processId);
+      const process2 = info.process;
+      if (process2.exitCode === null) {
+        try {
+          process2.kill("SIGTERM");
+          await new Promise((resolve5) => {
+            const timeout = setTimeout(() => {
+              if (process2.exitCode === null) {
+                process2.kill("SIGKILL");
+              }
+              resolve5();
+            }, 3e3);
+            process2.on("exit", () => {
+              clearTimeout(timeout);
+              resolve5();
+            });
+          });
+        } catch (error) {
+          errors.push(`Process ${processId}: ${error}`);
+          continue;
+        }
+      }
+      this.backgroundProcesses.delete(processId);
+      cleaned++;
+    }
+    if (errors.length > 0) {
+      return `Cleaned ${cleaned}/${total} processes. Errors:
+${errors.join("\n")}`;
+    }
+    return `Successfully cleaned ${cleaned} background processes`;
+  }
+};
+
+// src/runtime/state/store.ts
+function createStateRecord(sessionId, agentName, type, data) {
+  return {
+    sessionId,
+    agentName,
+    timestamp: Date.now() / 1e3,
+    type,
+    data
+  };
+}
+
+// src/runtime/state/jsonlStore.ts
+import * as fs13 from "fs";
+import * as path9 from "path";
+import * as os from "os";
+var JsonlAgentStateStore = class {
+  storageDir;
+  maxSessions;
+  sessionFileMap = /* @__PURE__ */ new Map();
+  /**
+   * Create a new JSONL state store
+   *
+   * @param storageDir - Directory to store JSONL files. Defaults to ~/.evolt/state/
+   * @param maxSessions - Maximum number of session files to keep. Older sessions are automatically cleaned up.
+   */
+  constructor(storageDir, maxSessions = 3) {
+    this.storageDir = storageDir || path9.join(os.homedir(), ".evolt", "state");
+    this.maxSessions = maxSessions;
+    if (!fs13.existsSync(this.storageDir)) {
+      fs13.mkdirSync(this.storageDir, { recursive: true });
+    }
+    this._loadSessionMap();
+  }
+  /**
+   * Load existing session_id to file mappings from disk
+   */
+  _loadSessionMap() {
+    try {
+      const files = fs13.readdirSync(this.storageDir);
+      for (const file of files) {
+        if (file.endsWith(".jsonl")) {
+          const sessionId = path9.basename(file, ".jsonl");
+          this.sessionFileMap.set(sessionId, path9.join(this.storageDir, file));
+        }
+      }
+    } catch (error) {
+      logger.warn(`Failed to load session map: ${error}`);
+    }
+  }
+  /**
+   * Get existing file path for session or create a new one
+   */
+  _getOrCreateFilePath(sessionId) {
+    if (this.sessionFileMap.has(sessionId)) {
+      return this.sessionFileMap.get(sessionId);
+    }
+    const filePath = path9.join(this.storageDir, `${sessionId}.jsonl`);
+    this.sessionFileMap.set(sessionId, filePath);
+    logger.debug(`Created new session file: ${filePath} for session=${sessionId}`);
+    this._cleanupOldSessions();
+    return filePath;
+  }
+  /**
+   * Cleanup old session files to maintain max_sessions limit
+   */
+  _cleanupOldSessions() {
+    try {
+      const files = fs13.readdirSync(this.storageDir).filter((f) => f.endsWith(".jsonl")).map((f) => path9.join(this.storageDir, f));
+      const filesWithTs = [];
+      for (const filePath of files) {
+        const timestamp = this._getLatestTimestamp(filePath);
+        filesWithTs.push({ path: filePath, timestamp });
+      }
+      filesWithTs.sort((a, b) => b.timestamp - a.timestamp);
+      let deleted = 0;
+      for (let i = this.maxSessions; i < filesWithTs.length; i++) {
+        const filePath = filesWithTs[i].path;
+        try {
+          const sessionId = path9.basename(filePath, ".jsonl");
+          this.sessionFileMap.delete(sessionId);
+          fs13.unlinkSync(filePath);
+          deleted++;
+          logger.debug(`Deleted old session file: ${filePath}`);
+        } catch (error) {
+          logger.warn(`Failed to delete ${filePath}: ${error}`);
+        }
+      }
+      if (deleted > 0) {
+        logger.info(`Cleaned up ${deleted} old session files`);
+      }
+      return deleted;
+    } catch (error) {
+      logger.error(`Failed to cleanup old sessions: ${error}`);
+      return 0;
+    }
+  }
+  /**
+   * Get the latest record timestamp from a session file
+   */
+  _getLatestTimestamp(filePath) {
+    try {
+      if (!fs13.existsSync(filePath)) {
+        return 0;
+      }
+      const content = fs13.readFileSync(filePath, "utf-8");
+      const lines = content.trim().split("\n").filter((l) => l.trim());
+      if (lines.length === 0) {
+        return 0;
+      }
+      const lastLine = lines[lines.length - 1];
+      try {
+        const record = JSON.parse(lastLine);
+        return record.timestamp || 0;
+      } catch {
+        return 0;
+      }
+    } catch (error) {
+      return 0;
+    }
+  }
+  async append(sessionId, agentName, record) {
+    const filePath = this._getOrCreateFilePath(sessionId);
+    const fullRecord = {
+      sessionId,
+      agentName,
+      ...record
+    };
+    const line = JSON.stringify(fullRecord) + "\n";
+    await fs13.promises.appendFile(filePath, line, "utf-8");
+    logger.debug(`Appended record to session ${sessionId}: type=${record.type}`);
+  }
+  async getAll(sessionId, agentName) {
+    const filePath = this.sessionFileMap.get(sessionId);
+    if (!filePath || !fs13.existsSync(filePath)) {
+      return [];
+    }
+    try {
+      const content = await fs13.promises.readFile(filePath, "utf-8");
+      const lines = content.trim().split("\n").filter((l) => l.trim());
+      const records = [];
+      for (const line of lines) {
+        try {
+          const record = JSON.parse(line);
+          if (record.agentName === agentName) {
+            records.push(record);
+          }
+        } catch {
+          logger.warn(`Failed to parse record line: ${line}`);
+        }
+      }
+      records.sort((a, b) => a.timestamp - b.timestamp);
+      return records;
+    } catch (error) {
+      logger.error(`Failed to read session file: ${error}`);
+      return [];
+    }
+  }
+  async clear(sessionId, agentName) {
+    const filePath = this.sessionFileMap.get(sessionId);
+    if (!filePath || !fs13.existsSync(filePath)) {
+      return;
+    }
+    try {
+      const content = await fs13.promises.readFile(filePath, "utf-8");
+      const lines = content.trim().split("\n").filter((l) => l.trim());
+      const remainingLines = [];
+      for (const line of lines) {
+        try {
+          const record = JSON.parse(line);
+          if (record.agentName !== agentName) {
+            remainingLines.push(line);
+          }
+        } catch {
+          remainingLines.push(line);
+        }
+      }
+      await fs13.promises.writeFile(filePath, remainingLines.join("\n") + "\n", "utf-8");
+      logger.debug(`Cleared records for agent ${agentName} in session ${sessionId}`);
+    } catch (error) {
+      logger.error(`Failed to clear records: ${error}`);
+    }
+  }
+  exportJson(sessionId, agentName, filename) {
+    const filePath = this.sessionFileMap.get(sessionId);
+    if (!filePath || !fs13.existsSync(filePath)) {
+      fs13.writeFileSync(filename, "[]", "utf-8");
+      return;
+    }
+    const content = fs13.readFileSync(filePath, "utf-8");
+    const lines = content.trim().split("\n").filter((l) => l.trim());
+    const records = [];
+    for (const line of lines) {
+      try {
+        const record = JSON.parse(line);
+        if (record.agentName === agentName) {
+          records.push(record);
+        }
+      } catch {
+      }
+    }
+    fs13.writeFileSync(filename, JSON.stringify(records, null, 2), "utf-8");
+    logger.info(`Exported ${records.length} records to ${filename}`);
+  }
+  importJson(filename) {
+    if (!fs13.existsSync(filename)) {
+      logger.warn(`Import file not found: ${filename}`);
+      return;
+    }
+    const content = fs13.readFileSync(filename, "utf-8");
+    const records = JSON.parse(content);
+    const bySession = /* @__PURE__ */ new Map();
+    for (const record of records) {
+      if (!bySession.has(record.sessionId)) {
+        bySession.set(record.sessionId, []);
+      }
+      bySession.get(record.sessionId).push(record);
+    }
+    for (const [sessionId, sessionRecords] of bySession) {
+      const filePath = this._getOrCreateFilePath(sessionId);
+      const lines = sessionRecords.map((r) => JSON.stringify(r));
+      fs13.appendFileSync(filePath, lines.join("\n") + "\n", "utf-8");
+    }
+    logger.info(`Imported ${records.length} records from ${filename}`);
+  }
+  async deleteLastN(sessionId, agentName, n) {
+    const filePath = this.sessionFileMap.get(sessionId);
+    if (!filePath || !fs13.existsSync(filePath)) {
+      return 0;
+    }
+    try {
+      const content = await fs13.promises.readFile(filePath, "utf-8");
+      const lines = content.trim().split("\n").filter((l) => l.trim());
+      const agentRecordIndices = [];
+      const parsedRecords = [];
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        try {
+          const record = JSON.parse(line);
+          parsedRecords.push({ line, record });
+          if (record.agentName === agentName) {
+            agentRecordIndices.push(i);
+          }
+        } catch {
+          parsedRecords.push({ line, record: null });
+        }
+      }
+      const indicesToDelete = new Set(agentRecordIndices.slice(-n));
+      const deleted = indicesToDelete.size;
+      const remainingLines = parsedRecords.filter((_, i) => !indicesToDelete.has(i)).map((r) => r.line);
+      await fs13.promises.writeFile(filePath, remainingLines.join("\n") + "\n", "utf-8");
+      logger.debug(`Deleted ${deleted} records for agent ${agentName} in session ${sessionId}`);
+      return deleted;
+    } catch (error) {
+      logger.error(`Failed to delete records: ${error}`);
+      return 0;
+    }
+  }
+  async sessionExists(sessionId) {
+    const filePath = this.sessionFileMap.get(sessionId);
+    return filePath !== void 0 && fs13.existsSync(filePath);
+  }
+  listSessions() {
+    const sessions = [];
+    for (const [sessionId, filePath] of this.sessionFileMap) {
+      if (!fs13.existsSync(filePath)) {
+        continue;
+      }
+      try {
+        const content = fs13.readFileSync(filePath, "utf-8");
+        const lines = content.trim().split("\n").filter((l) => l.trim());
+        if (lines.length === 0) {
+          continue;
+        }
+        let firstInstruction;
+        const agents = /* @__PURE__ */ new Set();
+        let timestamp = 0;
+        for (const line of lines) {
+          try {
+            const record = JSON.parse(line);
+            agents.add(record.agentName);
+            if (timestamp === 0) {
+              timestamp = record.timestamp;
+            }
+            if (!firstInstruction && record.type === "instruction") {
+              firstInstruction = record.data.content?.slice(0, 100);
+            }
+          } catch {
+          }
+        }
+        sessions.push({
+          sessionId,
+          timestamp,
+          firstInstruction,
+          agents: Array.from(agents)
+        });
+      } catch (error) {
+        logger.warn(`Failed to read session file ${filePath}: ${error}`);
+      }
+    }
+    sessions.sort((a, b) => b.timestamp - a.timestamp);
+    return sessions;
+  }
+  async getAgentsInSession(sessionId) {
+    const filePath = this.sessionFileMap.get(sessionId);
+    if (!filePath || !fs13.existsSync(filePath)) {
+      return [];
+    }
+    try {
+      const content = await fs13.promises.readFile(filePath, "utf-8");
+      const lines = content.trim().split("\n").filter((l) => l.trim());
+      const agents = /* @__PURE__ */ new Set();
+      for (const line of lines) {
+        try {
+          const record = JSON.parse(line);
+          agents.add(record.agentName);
+        } catch {
+        }
+      }
+      return Array.from(agents);
+    } catch (error) {
+      logger.error(`Failed to read session file: ${error}`);
+      return [];
+    }
+  }
+};
+
+// src/runtime/state/context.ts
+import { v4 as uuidv43 } from "uuid";
+var _sessionId = null;
+var _sessionIdExplicit = false;
+var _skipExecutorRestore = false;
+function useSessionId(sessionId, options) {
+  if (_sessionId !== null) {
+    throw new Error(
+      `Session ID already set to '${_sessionId}'. Cannot change to '${sessionId}'. Call resetSessionId() first.`
+    );
+  }
+  _sessionId = sessionId;
+  _sessionIdExplicit = true;
+  _skipExecutorRestore = options?.skipExecutorRestore ?? false;
+}
+function getOrCreateSessionId() {
+  if (_sessionId === null) {
+    _sessionId = uuidv43();
+    _sessionIdExplicit = false;
+  }
+  return _sessionId;
+}
+function getSessionId() {
+  return _sessionId;
+}
+function isNewSession() {
+  return !_sessionIdExplicit;
+}
+function resetSessionId() {
+  _sessionId = null;
+  _sessionIdExplicit = false;
+  _skipExecutorRestore = false;
+}
+function shouldSkipExecutorRestore() {
+  return _skipExecutorRestore;
+}
+var _globalStore = null;
+function enableStateStore(store, options) {
+  if (store !== void 0) {
+    _globalStore = store;
+  } else if (options?.backend === "jsonl" || !options?.backend) {
+    _globalStore = new JsonlAgentStateStore(options?.storageDir);
+  } else {
+    _globalStore = null;
+  }
+  return _globalStore;
+}
+function getGlobalStore() {
+  return _globalStore;
+}
+function isPersistenceEnabled() {
+  return _globalStore !== null;
+}
+var _agentName = null;
+function setAgentName(agentName) {
+  _agentName = agentName;
+}
+function getAgentName() {
+  return _agentName;
+}
+function resetAgentName() {
+  _agentName = null;
+}
+
+// src/runtime/state/decorator.ts
+function persistentState(recordType) {
+  return function(target, propertyKey, descriptor) {
+    const originalMethod = descriptor.value;
+    descriptor.value = async function(...args) {
+      const result = await originalMethod.apply(this, args);
+      const sessionId = getOrCreateSessionId();
+      const agentName = getAgentName();
+      const store = getGlobalStore();
+      if (store !== null && agentName) {
+        let currentType = recordType;
+        const data = _serializeForPersistence(recordType, args, result);
+        try {
+          await store.append(sessionId, agentName, {
+            type: currentType,
+            data,
+            timestamp: Date.now() / 1e3
+          });
+          logger.debug(`Persisted ${currentType} record for session=${sessionId}, agent=${agentName}`);
+        } catch (error) {
+          logger.error(`Failed to persist state: ${error}`);
+        }
+      }
+      return result;
+    };
+    return descriptor;
+  };
+}
+function _serializeForPersistence(recordType, args, result) {
+  if (recordType === "message") {
+    const message = args[0];
+    if (message !== void 0) {
+      if (typeof message.toDict === "function") {
+        return { message: message.toDict() };
+      } else if (typeof message.toObject === "function") {
+        return { message: message.toObject() };
+      } else if (typeof message === "object") {
+        return { message };
+      }
+    }
+    return { args: String(args) };
+  } else if (recordType === "tool_call") {
+    const toolcalls = [];
+    const toolcallsArg = args[0];
+    if (toolcallsArg !== void 0 && Symbol.iterator in Object(toolcallsArg)) {
+      for (const tc of toolcallsArg) {
+        if (typeof tc.toDict === "function") {
+          toolcalls.push(tc.toDict());
+        } else if (typeof tc === "object") {
+          toolcalls.push(tc);
+        }
+      }
+    }
+    return { toolcalls };
+  }
+  return {};
+}
+function agentAutoRestore(target, propertyKey, descriptor) {
+  const originalMethod = descriptor.value;
+  descriptor.value = async function(instruction, images) {
+    const inst = instruction || "";
+    const sessionId = getOrCreateSessionId();
+    const agentName = this.name;
+    setAgentName(agentName);
+    try {
+      const result = await originalMethod.call(this, inst, images);
+      const store = getGlobalStore();
+      if (store !== null && typeof result === "string") {
+        try {
+          await store.append(sessionId, agentName, {
+            type: "completion",
+            data: { response: result },
+            timestamp: Date.now() / 1e3
+          });
+          logger.debug(`Recorded completion for session=${sessionId}, agent=${agentName}`);
+        } catch (error) {
+          logger.error(`Failed to record completion: ${error}`);
+        }
+      }
+      return result;
+    } catch (error) {
+      logger.error(`Agent ${agentName} run error: ${error}`);
+      throw error;
+    } finally {
+      resetAgentName();
+      if (this.autoShutdownExecutor && this.executor) {
+        await this.executor.shutdown({ wait: true });
+      }
+    }
+  };
+  return descriptor;
+}
 export {
   Agent,
   ApiTool,
   BaseEnvironment,
+  BaseOrchestrator,
   CodingEnvironment,
+  CodingOrchestrator,
   CommandLineTool,
   DEFAULT_CONFIG,
   DEFAULT_SETTINGS,
   ENV_VARS,
   ERROR_MESSAGES,
+  Environment,
   EvoltError,
   ExtendStateMachineTool,
+  Feedback,
   FileEditor,
   FunctionCallingStore,
   GitTool,
+  ImageTool,
+  InstructionType,
+  JsonlAgentStateStore,
   LOG_LEVELS,
+  LocalToolExecutor,
   MESSAGE_ROLES,
   Message,
   MessageHistory,
   Model,
   ModelError,
+  OUTPUT_FORMAT_PROMPT,
+  PatchTool,
+  REFLECT_OUTPUT_FORMAT_PROMPT,
   ReflectTool,
+  ReflexionOrchestrator,
   Reply2HumanTool,
   SKILLS_DIR,
+  SYSTEM_TOOLS_PROMPT,
   SkillsTool,
   SystemToolStore,
+  TOOLS_PROMPT,
   TOOL_CALL_TYPES,
   TOOL_CONSTANTS,
   ThinkTool,
@@ -4804,13 +6818,28 @@ export {
   UserToolStore,
   WORKSPACE_DIR,
   WriteUIDesignDocument,
+  _executeSingleTool,
+  agentAutoRestore,
+  areadImage,
+  createExecutedToolcall,
+  createGeneratedToolcall,
+  createStateRecord,
+  deprecated,
+  enableStateStore,
   ensureDir,
+  executeToolsParallel,
+  executeToolsSequential,
   fileExists,
+  getAgentName,
   getCacheDir,
   getConfigDir,
   getConfigPath2 as getConfigPath,
+  getCurrentExecutor,
   getFileExtension,
+  getGlobalStore,
   getLogsDir,
+  getOrCreateSessionId,
+  getSessionId,
   getSettings,
   getSkillsDir,
   getTempFilePath,
@@ -4818,12 +6847,23 @@ export {
   getWorkspacePath,
   initializeSettings,
   isInWorkspace,
+  isNewSession,
+  isPersistenceEnabled,
+  isSupportedImageFile,
   loadModelConfig,
   logger_default as logger,
   normalizePath,
+  persistentState,
+  readImage,
   registerAgentAsTool,
+  resetAgentName,
+  resetSessionId,
+  setAgentName,
+  setCurrentExecutor,
   settings,
+  shouldSkipExecutorRestore,
   tools,
-  updateSettings
+  updateSettings,
+  useSessionId
 };
 //# sourceMappingURL=index.js.map