evoltagent 1.1.1 → 1.1.2

package/dist/index.js

@@ -0,0 +1,4829 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+
+// src/utils/connections.ts
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+
+// src/schemas/toolCall.ts
+import { randomUUID } from "crypto";
+var Toolcall = class {
+  name;
+  input;
+  isExtractedSuccess;
+  failedExtractedReason;
+  executedState;
+  executedContent;
+  toolCallId;
+  type;
+  rawContentFromLlm;
+  constructor(config2) {
+    this.name = config2.name;
+    this.input = config2.input || {};
+    this.isExtractedSuccess = config2.isExtractedSuccess ?? true;
+    this.failedExtractedReason = config2.failedExtractedReason;
+    this.executedState = config2.executedState || "pending";
+    this.executedContent = config2.executedContent;
+    this.toolCallId = config2.toolCallId || randomUUID();
+    this.type = config2.type || "system";
+    this.rawContentFromLlm = config2.rawContentFromLlm;
+  }
+  /**
+   * Toolcall extraction result description
+   */
+  extractedResult() {
+    if (this.type === "TaskCompletion") {
+      return this.rawContentFromLlm || "";
+    }
+    if (this.type === "user") {
+      if (!this.isExtractedSuccess) {
+        return [
+          {
+            role: "assistant",
+            tool_calls: [
+              {
+                id: `user_tool_${this.toolCallId}`,
+                type: "function",
+                function: {
+                  name: this.name,
+                  arguments: this.rawContentFromLlm
+                }
+              }
+            ]
+          },
+          {
+            role: "tool",
+            tool_call_id: `user_tool_${this.toolCallId}`,
+            name: this.name,
+            content: this.failedExtractedReason || "Unknown reason"
+          }
+        ];
+      }
+      logger.debug(`User Toolcall: ${this.name}(${JSON.stringify(this.input)})`);
+      return {
+        role: "assistant",
+        tool_calls: [
+          {
+            id: `user_tool_${this.toolCallId}`,
+            type: "function",
+            function: {
+              name: this.name,
+              arguments: JSON.stringify(this.input)
+            }
+          }
+        ]
+      };
+    }
+    if (!this.isExtractedSuccess) {
+      return `Toolcall ${this.name} failed to extract: ${this.failedExtractedReason || "Unknown reason"}`;
+    }
+    if (this.name) {
+      const inputStr = Object.entries(this.input).map(([k, v]) => `<${k}>${v}</${k}>`).join("");
+      return `<${this.name}>${inputStr}</${this.name}>`;
+    }
+    return `Invalid Toolcall: name ${this.name}, arguments ${JSON.stringify(this.input)}.`;
+  }
+  /**
+   * Toolcall execution result: Feedback to LLM
+   */
+  executedResult() {
+    if (this.type === "TaskCompletion") {
+      return "The task has been completed.";
+    }
+    if (this.type === "user") {
+      if (!this.isExtractedSuccess) {
+        return "";
+      }
+      return {
+        role: "tool",
+        tool_call_id: this.toolCallId,
+        // Use the original tool_call_id without prefix
+        name: this.name,
+        content: (this.executedContent || "No execution result found.").trim()
+      };
+    }
+    if (this.name.startsWith("ThinkTool.execute") || this.name.startsWith("TodoListTool.write")) {
+      return (this.executedContent || "No thinking result found.").trim();
+    }
+    let toolcallDescription = "";
+    let observation = "";
+    if (this.name.startsWith("FileEditor.write")) {
+      toolcallDescription = `FileEditor.write(${this.input.path})`;
+    } else {
+      toolcallDescription = `${this.name}(${JSON.stringify(this.input)})`;
+    }
+    observation += `Executed content: ${(this.executedContent || "None").trim()}
+`;
+    return `Toolcall: ${toolcallDescription}
+Observation: ${observation}`;
+  }
+};
+
+// src/utils/toolUtil.ts
+function isWriteJsonFile(argumentsTxt, toolName) {
+  if (!toolName.startsWith("FileEditor.") && !toolName.startsWith("ApiTool.")) {
+    return false;
+  }
+  const pattern = /\.json\s*<\/(path|filePath|apiFilePath)>/;
+  return pattern.test(argumentsTxt);
+}
+function unescapeHtmlEntities(str) {
+  let result = str;
+  result = result.replace(/&#(\d+);/g, (_, dec) => String.fromCharCode(parseInt(dec, 10)));
+  result = result.replace(/&#x([0-9a-fA-F]+);/g, (_, hex) => String.fromCharCode(parseInt(hex, 16)));
+  result = result.replace(/&(?:quot|amp|lt|gt|apos);/g, (match) => {
+    const entities = {
+      "&quot;": '"',
+      "&amp;": "&",
+      "&lt;": "<",
+      "&gt;": ">",
+      "&apos;": "'"
+    };
+    return entities[match] || match;
+  });
+  return result;
+}
+function convertStrToObject(txt, toolName, argNames) {
+  const result = {};
+  const startTag = `<${toolName}>`;
+  const endTag = `</${toolName}>`;
+  const toolPattern = new RegExp(`${escapeRegExp(startTag)}(.*?)${escapeRegExp(endTag)}`, "s");
+  const toolMatch = toolPattern.exec(txt);
+  if (!toolMatch) {
+    return result;
+  }
+  const innerContent = toolMatch[1];
+  for (const argName of argNames) {
+    const argStartTag = `<${argName}>`;
+    const argEndTag = `</${argName}>`;
+    const argPattern = new RegExp(`${escapeRegExp(argStartTag)}(.*?)${escapeRegExp(argEndTag)}`, "s");
+    const argMatch = argPattern.exec(innerContent);
+    if (argMatch) {
+      let value = argMatch[1].trim();
+      value = unescapeHtmlEntities(value);
+      if (isWriteJsonFile(txt, toolName)) {
+        result[argName] = value;
+        continue;
+      }
+      try {
+        const parsedValue = JSON.parse(value);
+        result[argName] = parsedValue;
+      } catch {
+        result[argName] = value;
+      }
+    }
+  }
+  return result;
+}
+function extractToolcallsFromStr(txt, toolStore) {
+  const matches = [];
+  for (const toolName of Object.keys(toolStore)) {
+    const pattern = new RegExp(`<${escapeRegExp(toolName)}>(.*?)</${escapeRegExp(toolName)}>`, "gs");
+    let match;
+    while ((match = pattern.exec(txt)) !== null) {
+      const argumentsTxt = match[1].trim();
+      if (!isWriteJsonFile(argumentsTxt, toolName) && argumentsTxt.startsWith("{") && argumentsTxt.endsWith("}")) {
+        matches.push([
+          match.index,
+          new Toolcall({
+            name: toolName,
+            input: {},
+            isExtractedSuccess: false,
+            type: "system",
+            rawContentFromLlm: txt
+          })
+        ]);
+        continue;
+      }
+      const rawInput = `<${toolName}>${argumentsTxt}</${toolName}>`;
+      let pythonObjectInput = {};
+      if (rawInput) {
+        const argNames = toolStore[toolName].argNames || [];
+        pythonObjectInput = convertStrToObject(rawInput, toolName, argNames);
+      }
+      matches.push([
+        match.index,
+        new Toolcall({
+          name: toolName,
+          input: pythonObjectInput,
+          type: "system"
+        })
+      ]);
+    }
+  }
+  matches.sort((a, b) => a[0] - b[0]);
+  return matches.map(([, tc]) => tc);
+}
+async function executeSingleTool(toolcall, toolStore) {
+  if (!Array.isArray(toolStore)) {
+    toolStore = [toolStore];
+  }
+  if (!toolcall.isExtractedSuccess) {
+    return toolcall;
+  }
+  try {
+    if (toolcall.name && !toolcall.name.startsWith("FileEditor.") && !toolcall.name.startsWith("ThinkTool.")) {
+      logger.info(`Executing Tool ${toolcall.name} with arguments: ${JSON.stringify(toolcall.input)}`);
+    }
+    for (const ts of toolStore) {
+      let toolCall;
+      let argNames = [];
+      if (typeof ts.hasTool === "function" && ts.hasTool(toolcall.name)) {
+        const toolDesc = ts.getTool(toolcall.name);
+        toolCall = toolDesc ? toolDesc.execute : void 0;
+        argNames = toolDesc ? toolDesc.argNames : [];
+      } else if (toolcall.name in ts) {
+        toolCall = ts[toolcall.name].execute;
+        argNames = ts[toolcall.name].argNames || [];
+      }
+      if (toolCall) {
+        let result;
+        if (typeof toolCall === "function") {
+          if (argNames && argNames.length > 0) {
+            const args = argNames.map((name) => toolcall.input[name]);
+            result = await toolCall(...args);
+          } else {
+            result = await toolCall(toolcall.input);
+          }
+        } else {
+          logger.error(`Tool ${toolcall.name} is not callable`);
+          toolcall.executedContent = `Tool '${toolcall.name}' is not callable`;
+          toolcall.executedState = "failed";
+          return toolcall;
+        }
+        toolcall.executedContent = String(result);
+        toolcall.executedState = "success";
+        return toolcall;
+      }
+    }
+    toolcall.executedContent = `Tool '${toolcall.name}' not found in tool_store. Please check the tool name.`;
+    toolcall.executedState = "failed";
+    return toolcall;
+  } catch (error) {
+    const errorMsg = `Error executing tool: ${error}`;
+    toolcall.executedContent = errorMsg;
+    toolcall.executedState = "failed";
+    return toolcall;
+  }
+}
+function escapeRegExp(string) {
+  return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/utils/logger.ts
+import * as winston from "winston";
+import * as fs from "fs";
+import * as dotenv from "dotenv";
+dotenv.config();
+var getDisableLog = () => {
+  return process.env.DISABLE_LOG == "true" || !("DISABLE_LOG" in process.env);
+};
+var winstonLevels = {
+  error: 0,
+  warn: 1,
+  info: 2,
+  http: 3,
+  verbose: 4,
+  debug: 5,
+  silly: 6
+};
+var getLogLevel = () => {
+  const envLevel = process.env.LOG_LEVEL?.toLowerCase() || "error";
+  const levelMapping = {
+    fatal: "error",
+    trace: "debug"
+  };
+  return levelMapping[envLevel] || envLevel;
+};
+var loguruFormat = winston.format.combine(
+  winston.format.timestamp({ format: "YYYY-MM-DD HH:mm:ss" }),
+  winston.format.errors({ stack: true }),
+  winston.format.printf(({ timestamp, level, message, stack, ...meta }) => {
+    const formattedLevel = level.toUpperCase().padEnd(7);
+    const caller = meta.caller || meta[0]?.caller;
+    const location = caller ? `${String(caller).padEnd(35)} | ` : "";
+    const msg = stack || message;
+    return `${timestamp} | ${formattedLevel} | ${location}${msg}`;
+  })
+);
+var loguruFormatColored = winston.format.combine(
+  winston.format.timestamp({ format: "YYYY-MM-DD HH:mm:ss" }),
+  winston.format.errors({ stack: true }),
+  winston.format.printf(({ timestamp, level, message, stack, ...meta }) => {
+    const levelUpper = level.toUpperCase().padEnd(7);
+    let coloredLevel = levelUpper;
+    if (level === "error") {
+      coloredLevel = `\x1B[31m${levelUpper}\x1B[39m`;
+    } else if (level === "warn") {
+      coloredLevel = `\x1B[33m${levelUpper}\x1B[39m`;
+    } else if (level === "info") {
+      coloredLevel = `\x1B[36m${levelUpper}\x1B[39m`;
+    } else if (level === "debug") {
+      coloredLevel = `\x1B[34m${levelUpper}\x1B[39m`;
+    }
+    const caller = meta.caller || meta[0]?.caller;
+    const location = caller ? `\x1B[90m${String(caller).padEnd(35)}\x1B[39m | ` : "";
+    const msg = stack || message;
+    return `${timestamp} | ${coloredLevel} | ${location}${msg}`;
+  })
+);
+var createLoggerTransports = () => {
+  if (getDisableLog()) {
+    return [];
+  }
+  const output = process.env.LOG_OUTPUT;
+  if (!output || output === "console") {
+    return [
+      new winston.transports.Console({
+        level: getLogLevel(),
+        format: loguruFormatColored,
+        stderrLevels: ["error"]
+        // Only error goes to stderr
+      })
+    ];
+  } else if (output === "stdout") {
+    return [
+      new winston.transports.Stream({
+        stream: process.stdout,
+        format: loguruFormat
+      })
+    ];
+  } else if (output === "stderr") {
+    return [
+      new winston.transports.Stream({
+        stream: process.stderr,
+        format: loguruFormat
+      })
+    ];
+  } else {
+    return [
+      new winston.transports.Console({
+        level: getLogLevel(),
+        format: loguruFormatColored,
+        stderrLevels: ["error"]
+        // Only error goes to stderr
+      }),
+      new winston.transports.File({
+        filename: output,
+        format: loguruFormat
+      })
+    ];
+  }
+};
+var logger2 = winston.createLogger({
+  levels: winstonLevels,
+  level: getLogLevel(),
+  transports: createLoggerTransports()
+});
+winston.addColors({
+  error: "red",
+  warn: "yellow",
+  info: "cyan",
+  http: "green",
+  verbose: "blue",
+  debug: "blue",
+  silly: "magenta"
+});
+function captureCallerInfo() {
+  const stack = new Error().stack;
+  if (!stack) return "";
+  const lines = stack.split("\n");
+  for (let i = 3; i < lines.length; i++) {
+    const line = lines[i];
+    const match = line.match(/\(([^)]+):(\d+):\d+\)/) || line.match(/at\s+([^()\s]+):(\d+):\d+/);
+    if (match && match[1]) {
+      const fullPath = match[1];
+      const lineNum = match[2];
+      if (fullPath.includes("node_modules") || fullPath.endsWith("logger.ts") || fullPath.endsWith("logger.js")) {
+        continue;
+      }
+      const workspaceRoot = process.cwd();
+      let displayPath = fullPath;
+      if (fullPath.startsWith(workspaceRoot)) {
+        displayPath = fullPath.substring(workspaceRoot.length + 1);
+      } else {
+        const parts = fullPath.split(/[/\\]/);
+        displayPath = parts[parts.length - 1];
+      }
+      return `${displayPath}:${lineNum}`;
+    }
+  }
+  return "";
+}
+var dummyLogger = {
+  error: () => {
+  },
+  warn: () => {
+  },
+  info: () => {
+  },
+  debug: () => {
+  },
+  http: () => {
+  },
+  verbose: () => {
+  },
+  silly: () => {
+  }
+};
+var enhancedLogger = {
+  error: (message, ...meta) => {
+    const caller = captureCallerInfo();
+    logger2.error(message, { ...meta, caller });
+  },
+  warn: (message, ...meta) => {
+    const caller = captureCallerInfo();
+    logger2.warn(message, { ...meta, caller });
+  },
+  info: (message, ...meta) => {
+    const caller = captureCallerInfo();
+    logger2.info(message, { ...meta, caller });
+  },
+  debug: (message, ...meta) => {
+    const caller = captureCallerInfo();
+    logger2.debug(message, { ...meta, caller });
+  },
+  http: (message, ...meta) => {
+    const caller = captureCallerInfo();
+    logger2.http(message, { ...meta, caller });
+  },
+  verbose: (message, ...meta) => {
+    const caller = captureCallerInfo();
+    logger2.verbose(message, { ...meta, caller });
+  },
+  silly: (message, ...meta) => {
+    const caller = captureCallerInfo();
+    logger2.silly(message, { ...meta, caller });
+  }
+};
+var streamLogger = {
+  /**
+   * Write content directly to stdout without formatting
+   * Used for streaming output where content comes in chunks
+   */
+  info: (message) => {
+    if (!getDisableLog()) {
+      process.stdout.write(message);
+      if (process.env.LOG_OUTPUT) {
+        fs.appendFileSync(process.env.LOG_OUTPUT, message);
+      }
+    }
+  },
+  /**
+   * Write error content to stderr
+   */
+  error: (message) => {
+    if (!getDisableLog()) {
+      process.stderr.write(message);
+      if (process.env.LOG_OUTPUT) {
+        fs.appendFileSync(process.env.LOG_OUTPUT, message);
+      }
+    }
+  },
+  /**
+   * Write content with newline
+   */
+  log: (message) => {
+    if (!getDisableLog()) {
+      process.stdout.write(message + "\n");
+      if (process.env.LOG_OUTPUT) {
+        fs.appendFileSync(process.env.LOG_OUTPUT, message + "\n");
+      }
+    }
+  },
+  debug: (message) => {
+    if (!getDisableLog()) {
+      process.stdout.write(message);
+      if (process.env.LOG_OUTPUT) {
+        fs.appendFileSync(process.env.LOG_OUTPUT, message);
+      }
+    }
+  }
+};
+var logger_default = { enhancedLogger, dummyLogger, streamLogger, getDisableLog };
+
+// src/utils/index.ts
+var logger = logger_default.getDisableLog() ? logger_default.dummyLogger : logger_default.enhancedLogger;
+var streamLogger2 = logger_default.getDisableLog() ? logger_default.dummyLogger : logger_default.streamLogger;
+if (process.env.LOG_LEVEL) {
+  logger.info(`LOG_LEVEL: ${process.env.LOG_LEVEL}`);
+} else {
+  logger.info("LOG_LEVEL is not set");
+}
+if (process.env.LOG_OUTPUT) {
+  logger.info(`LOG_OUTPUT: ${process.env.LOG_OUTPUT}`);
+}
+if (process.env.ENABLE_LOG === "true") {
+  logger.info("ENABLE_LOG is set to true");
+} else {
+  logger.info("ENABLE_LOG is not set");
+}
+
+// src/utils/connections.ts
+var AsyncExitStack = class {
+  stack = [];
+  /**
+   * Enter a context manager and add it to the stack
+   */
+  async enterContext(context) {
+    const result = await context.enter();
+    this.stack.push(context);
+    return result;
+  }
+  /**
+   * Close all context managers in reverse order
+   */
+  async close() {
+    while (this.stack.length > 0) {
+      const context = this.stack.pop();
+      if (context) {
+        try {
+          await context.exit(null, null, null);
+        } catch (error) {
+          logger.error("Error closing context:", error);
+        }
+      }
+    }
+  }
+  /**
+   * Alias for close to match Python's close method if needed,
+   * though Python uses __aexit__ usually.
+   */
+  async aclose() {
+    await this.close();
+  }
+  /**
+   * Push a callback to be called when closing
+   */
+  push(callback) {
+    const contextManager = {
+      enter: async () => {
+      },
+      exit: async (exc_type, exc_val, exc_tb) => {
+        await callback();
+      }
+    };
+    this.stack.push(contextManager);
+  }
+};
+var MCPConnection = class {
+  session = null;
+  transport = null;
+  async enter() {
+    this.transport = await this.createTransport();
+    this.session = new Client(
+      {
+        name: "evoltagent-client",
+        version: "1.0.0"
+      },
+      {
+        capabilities: {
+          // Client capabilities
+        }
+      }
+    );
+    await this.session.connect(this.transport);
+    return this;
+  }
+  async exit(exc_type, exc_val, exc_tb) {
+    try {
+      if (this.session) {
+        await this.session.close();
+      }
+    } catch (e) {
+      logger.error(`Error during cleanup: ${e}`);
+    } finally {
+      this.session = null;
+      this.transport = null;
+    }
+  }
+  async listTools() {
+    if (!this.session) throw new Error("Session not initialized");
+    const result = await this.session.listTools();
+    return result.tools;
+  }
+  async callTool(toolName, argumentsDict) {
+    if (!this.session) throw new Error("Session not initialized");
+    return await this.session.callTool({
+      name: toolName,
+      arguments: argumentsDict
+    });
+  }
+};
+var MCPConnectionStdio = class extends MCPConnection {
+  command;
+  args;
+  env;
+  constructor(command, args = [], env) {
+    super();
+    this.command = command;
+    this.args = args;
+    this.env = env;
+  }
+  async createTransport() {
+    return new StdioClientTransport({
+      command: this.command,
+      args: this.args,
+      env: this.env
+    });
+  }
+};
+var MCPConnectionSSE = class extends MCPConnection {
+  url;
+  headers;
+  constructor(url, headers) {
+    super();
+    this.url = url;
+    this.headers = headers;
+  }
+  async createTransport() {
+    return new SSEClientTransport(new URL(this.url), {
+      eventSourceInit: {
+        // headers: this.headers, // TypeScript doesn't like headers in EventSourceInit
+      }
+    });
+  }
+};
+function createMcpConnection(config2) {
+  const connType = (config2.type || "stdio").toLowerCase();
+  if (connType === "stdio") {
+    if (!config2.command) {
+      throw new Error("Command is required for STDIO connections");
+    }
+    return new MCPConnectionStdio(config2.command, config2.args || [], config2.env);
+  } else if (connType === "sse") {
+    if (!config2.url) {
+      throw new Error("URL is required for SSE connections");
+    }
+    return new MCPConnectionSSE(config2.url, config2.headers);
+  } else {
+    throw new Error(`Unsupported connection type: ${connType}`);
+  }
+}
+
+// src/configs/configLoader.ts
+import * as fs2 from "fs";
+import * as path from "path";
+import * as yaml from "yaml";
+function getConfigPath() {
+  return path.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");
+      configData = yaml.parse(fileContent);
+    } else {
+      logger.warn(`Config file not found at ${configPath}, using defaults`);
+      configData = getDefaultConfig();
+    }
+  } catch (error) {
+    logger.warn(`Failed to load config from ${configPath}, using defaults:`, error);
+    configData = getDefaultConfig();
+  }
+  const models = configData.models || {};
+  const defaultModel = modelName || configData.defaultModel || "deepseek";
+  const modelConfig = models[defaultModel] || models.deepseek || getDefaultModelConfig();
+  const params = modelConfig.params || {};
+  return {
+    provider: modelConfig.provider || "openai",
+    model: modelConfig.model || "gpt-3.5-turbo",
+    contextWindowTokens: modelConfig.contextWindowTokens || 4096,
+    maxOutputTokens: params.maxCompletionTokens || params.maxTokens || modelConfig.maxOutputTokens || 1024,
+    temperature: params.temperature || modelConfig.temperature || 0.7,
+    topP: modelConfig.topP || 0.9,
+    apiKey: modelConfig.apiKey,
+    baseUrl: modelConfig.baseUrl,
+    ...modelConfig
+  };
+}
+function getDefaultConfig() {
+  return {
+    defaultModel: "deepseek",
+    models: {
+      deepseek: getDefaultModelConfig(),
+      openai: {
+        provider: "openai",
+        model: "gpt-3.5-turbo",
+        contextWindowTokens: 4096,
+        maxOutputTokens: 1024,
+        temperature: 0.7,
+        topP: 0.9
+      },
+      anthropic: {
+        provider: "anthropic",
+        model: "claude-3-sonnet-20240229",
+        contextWindowTokens: 2e5,
+        maxOutputTokens: 4096,
+        temperature: 0.7,
+        topP: 0.9
+      }
+    }
+  };
+}
+function getDefaultModelConfig() {
+  return {
+    provider: "deepseek",
+    model: "deepseek-chat",
+    contextWindowTokens: 32768,
+    maxOutputTokens: 4096,
+    temperature: 0.7,
+    topP: 0.9,
+    apiKey: process.env.DEEPSEEK_API_KEY,
+    baseUrl: process.env.DEEPSEEK_BASE_URL || "https://api.deepseek.com/v1"
+  };
+}
+function convertTypeNameToOpenai(typeName) {
+  const typeMap = {
+    str: "string",
+    string: "string",
+    int: "integer",
+    integer: "integer",
+    float: "number",
+    number: "number",
+    bool: "boolean",
+    boolean: "boolean",
+    list: "array",
+    array: "array",
+    dict: "object",
+    object: "object"
+  };
+  return typeMap[typeName.toLowerCase()] || "string";
+}
+
+// src/configs/constants.ts
+var DEFAULT_CONFIG = {
+  MODEL: "deepseek",
+  PROVIDER: "deepseek",
+  CONTEXT_WINDOW: 32768,
+  MAX_OUTPUT_TOKENS: 4096,
+  TEMPERATURE: 0.7,
+  TOP_P: 0.9
+};
+var TOOL_CONSTANTS = {
+  SYSTEM_TOOL_PREFIX: "SystemTool.",
+  USER_TOOL_PREFIX: "UserTool.",
+  AGENT_TOOL_PREFIX: "Agent.",
+  MCP_TOOL_PREFIX: "MCP."
+};
+var MESSAGE_ROLES = {
+  SYSTEM: "system",
+  USER: "user",
+  ASSISTANT: "assistant"
+};
+var TOOL_CALL_TYPES = {
+  SYSTEM: "system",
+  USER: "user"
+};
+var ENV_VARS = {
+  EVOLT_CONFIG_PATH: "EVOLT_CONFIG_PATH",
+  DEEPSEEK_API_KEY: "DEEPSEEK_API_KEY",
+  DEEPSEEK_BASE_URL: "DEEPSEEK_BASE_URL",
+  OPENAI_API_KEY: "OPENAI_API_KEY",
+  ANTHROPIC_API_KEY: "ANTHROPIC_API_KEY"
+};
+var ERROR_MESSAGES = {
+  CONFIG_LOAD_FAILED: "Failed to load configuration",
+  MODEL_NOT_FOUND: "Model configuration not found",
+  TOOL_NOT_REGISTERED: "Tool not registered in tool store",
+  INVALID_MESSAGE_FORMAT: "Invalid message format",
+  TOOL_EXECUTION_FAILED: "Tool execution failed"
+};
+var LOG_LEVELS = {
+  DEBUG: 0,
+  INFO: 1,
+  WARNING: 2,
+  ERROR: 3
+};
+
+// src/configs/paths.ts
+import * as path2 from "path";
+import * as fs3 from "fs";
+function getWorkspaceDir() {
+  return process.env.EVOLT_WORKSPACE || path2.join(process.cwd(), "workspace");
+}
+function getConfigDir() {
+  return process.env.EVOLT_CONFIG_DIR || path2.join(process.cwd(), "config");
+}
+function getLogsDir() {
+  return process.env.EVOLT_LOGS_DIR || path2.join(getWorkspaceDir(), "logs");
+}
+function getCacheDir() {
+  return process.env.EVOLT_CACHE_DIR || path2.join(getWorkspaceDir(), "cache");
+}
+function getSkillsDir() {
+  return process.env.EVOLT_SKILLS_DIR || path2.join(getWorkspaceDir(), "skills");
+}
+function ensureDir(dirPath) {
+  if (!fs3.existsSync(dirPath)) {
+    fs3.mkdirSync(dirPath, { recursive: true });
+  }
+}
+function getWorkspacePath(relativePath) {
+  const workspaceDir = getWorkspaceDir();
+  ensureDir(workspaceDir);
+  return path2.join(workspaceDir, relativePath);
+}
+function getConfigPath2(relativePath) {
+  const configDir = getConfigDir();
+  ensureDir(configDir);
+  return path2.join(configDir, relativePath);
+}
+function isInWorkspace(filePath) {
+  const workspaceDir = getWorkspaceDir();
+  const absolutePath = path2.resolve(filePath);
+  return absolutePath.startsWith(path2.resolve(workspaceDir));
+}
+function normalizePath(filePath) {
+  return path2.normalize(filePath).replace(/\\/g, "/");
+}
+function getFileExtension(filePath) {
+  return path2.extname(filePath).toLowerCase();
+}
+function fileExists(filePath) {
+  try {
+    return fs3.existsSync(filePath);
+  } catch {
+    return false;
+  }
+}
+function getTempFilePath(prefix = "evolt") {
+  const tempDir = path2.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`);
+}
+var WORKSPACE_DIR = getWorkspaceDir();
+var SKILLS_DIR = getSkillsDir();
+
+// src/configs/settings.ts
+var DEFAULT_SETTINGS = {
+  logLevel: LOG_LEVELS.INFO,
+  verbose: false,
+  debug: false,
+  workspace: process.env.EVOLT_WORKSPACE || "./workspace",
+  maxRetries: 3,
+  timeout: 3e4,
+  // 30 seconds
+  enableCache: true,
+  enableTelemetry: false
+};
+var SettingsManager = class {
+  settings = { ...DEFAULT_SETTINGS };
+  /**
+   * Update settings
+   */
+  update(newSettings) {
+    this.settings = { ...this.settings, ...newSettings };
+  }
+  /**
+   * Get current settings
+   */
+  get() {
+    return { ...this.settings };
+  }
+  /**
+   * Reset to default settings
+   */
+  reset() {
+    this.settings = { ...DEFAULT_SETTINGS };
+  }
+  /**
+   * Get specific setting value
+   */
+  getValue(key) {
+    return this.settings[key];
+  }
+  /**
+   * Set specific setting value
+   */
+  setValue(key, value) {
+    this.settings[key] = value;
+  }
+};
+var settings = new SettingsManager();
+function initializeSettings() {
+  const envSettings = {};
+  const logLevelEnv = process.env.EVOLT_LOG_LEVEL;
+  if (logLevelEnv) {
+    const levelMap = {
+      debug: LOG_LEVELS.DEBUG,
+      info: LOG_LEVELS.INFO,
+      warning: LOG_LEVELS.WARNING,
+      error: LOG_LEVELS.ERROR
+    };
+    const normalizedLevel = logLevelEnv.toLowerCase();
+    envSettings.logLevel = levelMap[normalizedLevel] ?? LOG_LEVELS.INFO;
+  }
+  if (process.env.EVOLT_VERBOSE === "true" || process.env.EVOLT_VERBOSE === "1") {
+    envSettings.verbose = true;
+  }
+  if (process.env.EVOLT_DEBUG === "true" || process.env.EVOLT_DEBUG === "1") {
+    envSettings.debug = true;
+    envSettings.logLevel = LOG_LEVELS.DEBUG;
+  }
+  if (process.env.EVOLT_WORKSPACE) {
+    envSettings.workspace = process.env.EVOLT_WORKSPACE;
+  }
+  if (process.env.EVOLT_MAX_RETRIES) {
+    const maxRetries = parseInt(process.env.EVOLT_MAX_RETRIES, 10);
+    if (!isNaN(maxRetries)) {
+      envSettings.maxRetries = maxRetries;
+    }
+  }
+  if (process.env.EVOLT_TIMEOUT) {
+    const timeout = parseInt(process.env.EVOLT_TIMEOUT, 10);
+    if (!isNaN(timeout)) {
+      envSettings.timeout = timeout;
+    }
+  }
+  if (process.env.EVOLT_ENABLE_CACHE === "false" || process.env.EVOLT_ENABLE_CACHE === "0") {
+    envSettings.enableCache = false;
+  }
+  if (process.env.EVOLT_ENABLE_TELEMETRY === "true" || process.env.EVOLT_ENABLE_TELEMETRY === "1") {
+    envSettings.enableTelemetry = true;
+  }
+  settings.update(envSettings);
+}
+function getSettings() {
+  return settings.get();
+}
+function updateSettings(newSettings) {
+  settings.update(newSettings);
+}
+initializeSettings();
+
+// src/configs/mcpConfig.ts
+var MCP_SERVERS_CONFIG = {
+  playwright: {
+    type: "stdio",
+    command: "npx",
+    args: ["-y", "@playwright/mcp@latest"]
+  },
+  filesystem: {
+    type: "stdio",
+    command: "npx",
+    args: ["-y", "@modelcontextprotocol/server-filesystem", "."]
+  }
+};
+
+// src/tools/toolStore.ts
+async function mcpTool(connection, toolName, args) {
+  try {
+    const argumentsDict = typeof args === "object" ? args : {};
+    const result = await connection.callTool(toolName, argumentsDict);
+    if (result && result.content) {
+      for (const item of result.content) {
+        if (item.type === "text") {
+          return item.text;
+        }
+      }
+    }
+    return "No text content in tool response";
+  } catch (e) {
+    return `Error executing ${toolName}: ${e}`;
+  }
+}
+var ToolStore = class {
+  tools = {};
+  /**
+   * Add a tool to the store
+   */
+  addTool(name, desc, execute, argNames, serverName, inputSchema) {
+    if (name in this.tools) {
+      logger.warn(`Tool ${name} already exists in store.`);
+      return;
+    }
+    this.tools[name] = {
+      desc,
+      execute,
+      argNames,
+      serverName,
+      inputSchema
+    };
+  }
+  /**
+   * Add MCP tools to the store
+   */
+  async addMcpTools(agentName, serverName, stack) {
+    const config2 = MCP_SERVERS_CONFIG[serverName];
+    if (!config2) {
+      logger.warn(`No MCP server config found for ${serverName}, agent: ${agentName}.`);
+      return;
+    }
+    let numMcpTools = 0;
+    try {
+      const connection = createMcpConnection(config2);
+      if (stack && typeof stack.enterContext === "function") {
+        await stack.enterContext(connection);
+      } else {
+        logger.warn("No AsyncExitStack provided for MCP connection, connection might leak.");
+        await connection.enter();
+      }
+      const toolDefinitions = await connection.listTools();
+      for (const toolInfo of toolDefinitions) {
+        if (toolInfo && toolInfo.name && toolInfo.inputSchema) {
+          const toolDesc = toolInfo.description || `tool: ${toolInfo.name}`;
+          const executeFn = async (args) => {
+            return await mcpTool(connection, toolInfo.name, args);
+          };
+          const existingTool = this.getTool(toolInfo.name);
+          if (existingTool && existingTool.agentName !== agentName) {
+            logger.warn(`Tool ${toolInfo.name} already exists in store for different agent.`);
+            continue;
+          }
+          this.addTool(
+            toolInfo.name,
+            toolDesc,
+            executeFn,
+            [],
+            // Empty argNames implies expecting a single object argument (the dict)
+            serverName,
+            toolInfo.inputSchema
+          );
+          const tool = this.getTool(toolInfo.name);
+          if (tool) {
+            tool.agentName = agentName;
+          }
+          numMcpTools++;
+        }
+      }
+      logger.info(`Loaded ${numMcpTools} MCP tools from ${serverName}, config: ${JSON.stringify(config2)}.`);
+    } catch (e) {
+      logger.error(`Error setting up MCP server ${serverName}, config: ${JSON.stringify(config2)}: ${e}`);
+    }
+  }
+  /**
+   * Get MCP tools schemas for a specific agent and server
+   */
+  getMcpToolsSchemas(agentName, serverName, provider) {
+    const toolcallSchemas = [];
+    for (const name of this.listTools()) {
+      const tool = this.getTool(name);
+      if (!tool) continue;
+      if (serverName && tool.serverName !== serverName) {
+        continue;
+      }
+      if (tool.agentName && tool.agentName !== agentName) {
+        continue;
+      }
+      if (tool.inputSchema) {
+        toolcallSchemas.push(this.toToolSchema(name, tool, provider));
+      }
+    }
+    return toolcallSchemas;
+  }
+  /**
+   * Convert tool to schema format for specific provider
+   */
+  toToolSchema(name, tool, provider = "openai") {
+    if (provider === "openai") {
+      return {
+        type: "function",
+        function: {
+          name,
+          description: tool.desc,
+          parameters: tool.inputSchema
+        }
+      };
+    } else if (provider === "anthropic") {
+      return {
+        name,
+        description: tool.desc,
+        input_schema: tool.inputSchema
+      };
+    }
+    return {};
+  }
+  /**
+   * Get tool schema by name (Python: get_toolcall_schema)
+   */
+  getToolcallSchema(toolName, provider = "openai") {
+    const tool = this.getTool(toolName);
+    if (!tool) {
+      return {};
+    }
+    return this.toToolSchema(toolName, tool, provider);
+  }
+  /**
+   * Get tool by name
+   */
+  getTool(name) {
+    return this.tools[name];
+  }
+  /**
+   * Check if tool exists
+   */
+  hasTool(name) {
+    return name in this.tools;
+  }
+  /**
+   * Get all tool names (Python: list_tools)
+   */
+  listTools() {
+    return Object.keys(this.tools);
+  }
+  /**
+   * Convert all tools to schema format
+   */
+  toDict(provider = "openai") {
+    const toolSchemas = [];
+    for (const [name, tool] of Object.entries(this.tools)) {
+      if (tool.inputSchema) {
+        toolSchemas.push(this.toToolSchema(name, tool, provider));
+      }
+    }
+    return toolSchemas;
+  }
+  /**
+   * Get number of tools in store
+   */
+  get length() {
+    return Object.keys(this.tools).length;
+  }
+  /**
+   * Check if tool exists (Python __contains__ equivalent)
+   */
+  contains(name) {
+    return this.hasTool(name);
+  }
+  /**
+   * Get tool by index operator (Python __getitem__ equivalent)
+   */
+  getItem(name) {
+    const tool = this.getTool(name);
+    if (!tool) {
+      throw new Error(`Tool ${name} not found in store.`);
+    }
+    return tool;
+  }
+  /**
+   * Get all tool entries
+   */
+  items() {
+    return Object.entries(this.tools);
+  }
+  /**
+   * Get all tool names (alias for listTools)
+   */
+  keys() {
+    return this.listTools();
+  }
+};
+var SystemToolStore = new ToolStore();
+var FunctionCallingStore = new ToolStore();
+var UserToolStore = FunctionCallingStore;
+
+// src/tools/toolRegister.ts
+function buildToolDescription(fullToolName, config2) {
+  let toolDesc = `
+<${fullToolName}>
+<${fullToolName}.description> ${config2.description}
+`;
+  if (config2.params) {
+    for (const param of config2.params) {
+      toolDesc += `<argument name="${param.name}" type="${param.type}"> ${param.description} </argument>
+`;
+    }
+  }
+  if (config2.returns) {
+    toolDesc += `<returns type="${config2.returns.type}"> ${config2.returns.description} </returns>
+`;
+  }
+  toolDesc += `</${fullToolName}.description>
+`;
+  if (config2.examples && config2.examples.length > 0) {
+    for (const example of config2.examples) {
+      toolDesc += `<${fullToolName}.example>
+${example}
+</${fullToolName}.example>
+`;
+    }
+  }
+  toolDesc += `</${fullToolName}>`;
+  return toolDesc;
+}
+function buildInputSchema(config2) {
+  const inputSchema = {
+    type: "object",
+    properties: {},
+    required: []
+  };
+  if (config2.params) {
+    for (const param of config2.params) {
+      inputSchema.properties[param.name] = {
+        type: convertTypeNameToOpenai(param.type),
+        description: param.description
+      };
+      if (!param.optional) {
+        inputSchema.required.push(param.name);
+      }
+    }
+  }
+  return inputSchema;
+}
+function tools(config2) {
+  return function(target) {
+    const instance = new target();
+    for (const [methodName, methodConfig] of Object.entries(config2)) {
+      const method = instance[methodName];
+      if (!method || typeof method !== "function") {
+        throw new Error(`Tool ${target.name}.${methodName} not found`);
+      }
+      const execute = method.bind(instance);
+      const argNames = methodConfig.params?.map((p) => p.name) || [];
+      const systemToolName = `${target.name}.${methodName}`;
+      const systemToolDesc = buildToolDescription(systemToolName, methodConfig);
+      SystemToolStore.addTool(systemToolName, systemToolDesc, execute, argNames, target.name);
+      const userToolName = `${target.name}-${methodName}`;
+      const userToolDesc = `
+Tool \`${userToolName}\` function is: ${methodConfig.description}
+`;
+      const inputSchema = buildInputSchema(methodConfig);
+      FunctionCallingStore.addTool(userToolName, userToolDesc, execute, argNames, target.name, inputSchema);
+      logger.debug(`Registered unified tool: ${systemToolName} / ${userToolName}`);
+    }
+    return target;
+  };
+}
+function registerAgentAsTool(agents, verbose = false) {
+  if (!agents) {
+    return [];
+  }
+  const agentList = Array.isArray(agents) ? agents : [agents];
+  const registeredAgentNames = [];
+  for (const agent of agentList) {
+    if (!agent || typeof agent !== "object") {
+      logger.warn(`Invalid agent: ${agent}, skipping`);
+      continue;
+    }
+    const agentName = `Agent.${agent.name}`;
+    if (SystemToolStore.hasTool(agentName)) {
+      logger.debug(`Agent ${agent.name} already registered as ${agentName}, change agent name`);
+      registeredAgentNames.push(agentName);
+      continue;
+    }
+    const toolDesc = `Delegate tasks to sub-agent ${agent.name}.
+    
+    Profile: ${agent.profile}
+    
+    Args:
+        instruction (str): Detailed task description or instruction for the agent. 
+                        Be specific about what you want the agent to accomplish.
+    
+    Returns:
+        str: The agent's execution result, including analysis, outputs, or conclusions.
+    
+    Examples:
+        <${agentName}>
+            <instruction>
+                Please analyze this data and provide insights on trends and patterns.
+            </instruction>
+        </${agentName}>
+    `;
+    const agentExecute = async (instruction) => {
+      try {
+        const response = await agent.run(instruction);
+        if (typeof response === "string") {
+          return response;
+        }
+        if (Array.isArray(response)) {
+          return response.map((r) => String(r)).join("\n");
+        }
+        return JSON.stringify(response);
+      } catch (error) {
+        logger.error(`Error executing agent ${agent.name}:`, error);
+        return `Error: ${error instanceof Error ? error.message : String(error)}`;
+      }
+    };
+    SystemToolStore.addTool(agentName, toolDesc, agentExecute, ["instruction"], agent.name);
+    registeredAgentNames.push(agentName);
+    if (verbose) {
+      logger.info(`Registered agent as tool: ${agentName}`);
+    }
+  }
+  if (registeredAgentNames.length > 0) {
+    logger.debug(`Successfully registered ${registeredAgentNames.length} Agent tool(s): ${registeredAgentNames.join(", ")}`);
+  }
+  return registeredAgentNames;
+}
+
+// src/tools/think.ts
+var ThinkTool = class {
+  async execute(thought) {
+    return "Thinking complete!";
+  }
+};
+ThinkTool = __decorateClass([
+  tools({
+    execute: {
+      description: "Use the tool to think about something when complex reasoning.",
+      params: [
+        {
+          name: "thought",
+          type: "str",
+          description: "The thought to think about."
+        }
+      ],
+      returns: {
+        type: "str",
+        description: "The complete thought result."
+      },
+      examples: [
+        "Good example:\n<ThinkTool.execute><thought> your thought here </thought></ThinkTool.execute>",
+        'Bad example:\n<ThinkTool.execute>{"thought":"your thought here"}</ThinkTool.execute>'
+      ]
+    }
+  })
+], ThinkTool);
+
+// src/tools/cmdTool.ts
+import { spawn } from "child_process";
+
+// src/types.ts
+var EvoltError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "EvoltError";
+  }
+};
+var ToolExecutionError = class extends EvoltError {
+  constructor(message) {
+    super(message);
+    this.name = "ToolExecutionError";
+  }
+};
+var ModelError = class extends EvoltError {
+  constructor(message) {
+    super(message);
+    this.name = "ModelError";
+  }
+};
+
+// src/tools/context.ts
+import { AsyncLocalStorage } from "async_hooks";
+var toolcallManagerContext = new AsyncLocalStorage();
+function getCurrentManager() {
+  return toolcallManagerContext.getStore() || null;
+}
+function runWithManager(manager, fn) {
+  return toolcallManagerContext.run(manager, fn);
+}
+
+// src/tools/cmdTool.ts
+var CommandLineTool = class {
+  async execute(command, cwd, env) {
+    try {
+      const workDir = cwd || process.cwd();
+      try {
+        const fs9 = await import("fs");
+        if (!fs9.existsSync(workDir)) {
+          return `Working directory does not exist: ${workDir}`;
+        }
+      } catch (error) {
+        return `Cannot access working directory: ${workDir}`;
+      }
+      const execEnv = { ...process.env, ...env };
+      const childProcess = spawn(command, {
+        shell: true,
+        cwd: workDir,
+        env: execEnv,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      const manager = getCurrentManager();
+      if (!manager) {
+        throw new ToolExecutionError("Cannot get ToolcallManager, please execute this tool through ToolcallManager");
+      }
+      const processId = manager.registerBackgroundProcess(childProcess, command, workDir);
+      logger.debug(`Register background process: Command: ${command}
+ Process ID: ${processId}`);
+      return new Promise((resolve2) => {
+        const timeout = setTimeout(async () => {
+          resolve2(
+            `COMMAND: ${command}
+PROCESS ID: ${processId}
+STATUS: The process may still be executing (waited 5 seconds, not completed)
+TIP: Please use the list command later to check the process status, or wait for the process to complete and then check the result`
+          );
+        }, 5e3);
+        let stdout = "";
+        let stderr = "";
+        childProcess.stdout?.on("data", (data) => {
+          stdout += data.toString();
+        });
+        childProcess.stderr?.on("data", (data) => {
+          stderr += data.toString();
+        });
+        childProcess.on("close", (code) => {
+          clearTimeout(timeout);
+          const stdoutText = stdout.trim();
+          const stderrText = stderr.trim();
+          const resultParts = [`COMMAND: ${command}`];
+          if (stdoutText) {
+            resultParts.push(`STDOUT:
+${stdoutText}`);
+          }
+          if (stderrText) {
+            resultParts.push(`STDERR:
+${stderrText}`);
+          }
+          resultParts.push(`EXIT CODE: ${code}`);
+          resolve2(resultParts.join("\n\n"));
+        });
+        childProcess.on("error", (error) => {
+          clearTimeout(timeout);
+          resolve2(`COMMAND: ${command}
+ERROR: ${error.message}`);
+        });
+      });
+    } catch (error) {
+      throw new ToolExecutionError(`Error executing background process '${command}': ${error.message}`);
+    }
+  }
+  /**
+   * List all background processes.
+   *
+   * Returns:
+   *     str: The natural language description of the background process list
+   */
+  async list() {
+    const manager = getCurrentManager();
+    if (!manager) {
+      throw new ToolExecutionError("Cannot get ToolcallManager, please execute this tool through ToolcallManager");
+    }
+    const [status, result] = manager.listBackgroundProcesses();
+    return result;
+  }
+  /**
+   * Stop the specified background process.
+   *
+   * Args:
+   *     process_id (str): The process ID to stop
+   *     force (bool): Whether to force kill the process (using SIGKILL)
+   *
+   * Returns:
+   *     str: Natural language description of the operation result
+   */
+  async stop(processId, force = false) {
+    const manager = getCurrentManager();
+    if (!manager) {
+      throw new ToolExecutionError("Cannot get ToolcallManager, please execute this tool through ToolcallManager");
+    }
+    return await manager.stopBackgroundProcess(processId, force);
+  }
+  /**
+   * Clean up all background processes.
+   *
+   * Returns:
+   *     str: The natural language description of the cleanup result
+   */
+  async cleanup() {
+    const manager = getCurrentManager();
+    if (!manager) {
+      throw new ToolExecutionError("Cannot get ToolcallManager, please execute this tool through ToolcallManager");
+    }
+    return await manager.cleanupBackgroundProcesses();
+  }
+};
+CommandLineTool = __decorateClass([
+  tools({
+    execute: {
+      description: "Execute bash command in background (non-blocking, returns result).",
+      params: [
+        { name: "command", type: "str", description: "The bash command to execute" },
+        {
+          name: "cwd",
+          type: "Optional[str]",
+          description: "Working directory, uses current directory if None",
+          optional: true
+        },
+        {
+          name: "env",
+          type: "Optional[Dict[str, str]]",
+          description: "Environment variables dictionary, uses current environment if None",
+          optional: true
+        }
+      ],
+      returns: { type: "str", description: "Background process startup information, including process ID and PID" }
+    },
+    list: {
+      description: "List all background processes.",
+      returns: { type: "str", description: "Information about all background processes" }
+    },
+    stop: {
+      description: "Stop the specified background process.",
+      params: [
+        { name: "processId", type: "str", description: "The process ID to stop" },
+        {
+          name: "force",
+          type: "bool",
+          description: "Whether to force kill the process (using SIGKILL)",
+          optional: true
+        }
+      ],
+      returns: { type: "str", description: "Result information of stopping the process" }
+    },
+    cleanup: {
+      description: "Clean up all background processes.",
+      returns: { type: "str", description: "Cleanup result information" }
+    }
+  })
+], CommandLineTool);
+
+// src/tools/fileTool.ts
+import * as fs4 from "fs/promises";
+import * as pathModule from "path";
+var FileEditor = class {
+  async read(path5, lineRange = "all") {
+    try {
+      await fs4.access(path5);
+    } catch {
+      throw new ToolExecutionError(`File does not exist: ${path5}`);
+    }
+    try {
+      let content;
+      try {
+        content = await fs4.readFile(path5, "utf-8");
+      } catch (error) {
+        if (error.code === "ENCODING_NOT_SUPPORTED" || error.message.includes("encoding")) {
+          const buffer = await fs4.readFile(path5);
+          content = buffer.toString("latin1");
+        } else {
+          throw error;
+        }
+      }
+      const lines = content.split("\n");
+      if (lineRange === "all") {
+        return content;
+      }
+      if (lineRange.includes("-")) {
+        try {
+          const [startStr, endStr] = lineRange.split("-", 2);
+          const start = parseInt(startStr) - 1;
+          const end = parseInt(endStr);
+          if (start < 0 || end <= start) {
+            throw new ToolExecutionError(`Line range is invalid: ${lineRange}`);
+          }
+          const selectedLines = lines.slice(start, end);
+          return `Lines ${start + 1} to ${end} of file ${path5}:
+` + selectedLines.join("\n");
+        } catch (error) {
+          throw new ToolExecutionError(
+            `Invalid line range format when reading file ${path5}: ${lineRange}, error: ${error.message}`
+          );
+        }
+      } else {
+        try {
+          const lineNum = parseInt(lineRange) - 1;
+          if (lineNum < 0) {
+            throw new ToolExecutionError(`Line number is less than 0: ${lineRange}`);
+          }
+          if (lineNum >= lines.length) {
+            throw new ToolExecutionError(`Line number ${lineNum + 1} exceeds file length ${lines.length}`);
+          }
+          return `Line ${lineNum + 1} of file ${path5}:
+` + lines[lineNum];
+        } catch (error) {
+          throw new ToolExecutionError(
+            `Invalid line number format when reading file ${path5}: ${lineRange}, error: ${error.message}`
+          );
+        }
+      }
+    } catch (error) {
+      if (error instanceof ToolExecutionError) {
+        throw error;
+      }
+      throw new ToolExecutionError(`Error reading file ${path5}: ${error.message}`);
+    }
+  }
+  async write(path5, content) {
+    try {
+      const dirPath = pathModule.dirname(path5);
+      if (dirPath) {
+        await fs4.mkdir(dirPath, { recursive: true });
+      }
+      await fs4.writeFile(path5, content, "utf-8");
+      const bytesWritten = Buffer.from(content, "utf-8").length;
+      return `Successfully wrote content to file ${path5}, wrote ${bytesWritten} bytes`;
+    } catch (error) {
+      if (error.code === "EACCES") {
+        throw new ToolExecutionError(`No write permission: ${path5}`);
+      }
+      throw new ToolExecutionError(`Error writing to file ${path5}: ${error.message}`);
+    }
+  }
+  async find(path5, pattern) {
+    try {
+      await fs4.access(path5);
+    } catch {
+      throw new ToolExecutionError(`File does not exist: ${path5}`);
+    }
+    let compiledPattern;
+    try {
+      compiledPattern = new RegExp(pattern, "g");
+    } catch (error) {
+      throw new ToolExecutionError(`Invalid regex pattern: ${pattern}, error: ${error.message}`);
+    }
+    const matches = [];
+    try {
+      let content;
+      try {
+        content = await fs4.readFile(path5, "utf-8");
+      } catch (error) {
+        if (error.code === "ENCODING_NOT_SUPPORTED" || error.message.includes("encoding")) {
+          const buffer = await fs4.readFile(path5);
+          content = buffer.toString("latin1");
+        } else {
+          throw error;
+        }
+      }
+      const lines = content.split("\n");
+      for (let lineNumber = 0; lineNumber < lines.length; lineNumber++) {
+        const line = lines[lineNumber];
+        let match;
+        compiledPattern.lastIndex = 0;
+        while ((match = compiledPattern.exec(line)) !== null) {
+          matches.push({
+            lineNumber: lineNumber + 1,
+            lineContent: line,
+            match: match[0],
+            startPos: match.index,
+            endPos: match.index + match[0].length
+          });
+        }
+      }
+    } catch (error) {
+      throw new ToolExecutionError(`Error reading file ${path5}: ${error.message}`);
+    }
+    if (matches.length === 0) {
+      return `No content matching pattern '${pattern}' found in file ${path5}`;
+    }
+    const resultLines = [`Found ${matches.length} matches in file ${path5}:`];
+    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) {
+    try {
+      await fs4.access(path5);
+    } catch {
+      throw new ToolExecutionError(`File does not exist: ${path5}`);
+    }
+    let compiledPattern;
+    try {
+      compiledPattern = new RegExp(pattern, "g");
+    } catch (error) {
+      throw new ToolExecutionError(`Invalid regex pattern ${pattern}, error: ${error.message}`);
+    }
+    let content;
+    try {
+      try {
+        content = await fs4.readFile(path5, "utf-8");
+      } catch (error) {
+        if (error.code === "ENCODING_NOT_SUPPORTED" || error.message.includes("encoding")) {
+          const buffer = await fs4.readFile(path5);
+          content = buffer.toString("latin1");
+        } else {
+          throw error;
+        }
+      }
+    } catch (error) {
+      throw new ToolExecutionError(`Error reading file ${path5}: ${error.message}`);
+    }
+    const newContent = content.replace(compiledPattern, replacement);
+    const replacementCount = (content.match(compiledPattern) || []).length;
+    let modifiedLines = 0;
+    if (replacementCount > 0) {
+      const originalLines = content.split("\n");
+      const newLines = newContent.split("\n");
+      modifiedLines = originalLines.filter((line, index) => line !== newLines[index]).length;
+      try {
+        await fs4.writeFile(path5, newContent, "utf-8");
+      } catch (error) {
+        if (error.code === "EACCES") {
+          throw new ToolExecutionError(`No write permission: ${path5}`);
+        }
+        throw new ToolExecutionError(`Error writing to file ${path5}: ${error.message}`);
+      }
+    }
+    return `In file ${path5}, found and replaced pattern '${pattern}' with '${replacement}', successfully replaced ${replacementCount} occurrences, modified ${modifiedLines} lines`;
+  }
+  async insert(path5, content, line) {
+    try {
+      await fs4.access(path5);
+    } catch {
+      throw new ToolExecutionError(`File does not exist: ${path5}`);
+    }
+    let lines;
+    try {
+      let fileContent;
+      try {
+        fileContent = await fs4.readFile(path5, "utf-8");
+      } catch (error) {
+        if (error.code === "ENCODING_NOT_SUPPORTED" || error.message.includes("encoding")) {
+          const buffer = await fs4.readFile(path5);
+          fileContent = buffer.toString("latin1");
+        } else {
+          throw error;
+        }
+      }
+      lines = fileContent.split("\n");
+    } catch (error) {
+      throw new ToolExecutionError(`Error reading file ${path5}: ${error.message}`);
+    }
+    let actionDesc;
+    if (line === void 0) {
+      lines.push(content);
+      actionDesc = `Appended content to end of file ${path5}`;
+    } else {
+      if (!(0 < line && line <= lines.length + 1)) {
+        throw new ToolExecutionError(`Line number ${line} exceeds file ${path5} bounds (1 to ${lines.length + 1})`);
+      }
+      lines.splice(line - 1, 0, content);
+      actionDesc = `Inserted content at line ${line} of file ${path5}`;
+    }
+    try {
+      await fs4.writeFile(path5, lines.join("\n"), "utf-8");
+      return actionDesc;
+    } catch (error) {
+      if (error.code === "EACCES") {
+        throw new ToolExecutionError(`No write permission: ${path5}`);
+      }
+      throw new ToolExecutionError(`Error writing to file ${path5}: ${error.message}`);
+    }
+  }
+};
+FileEditor = __decorateClass([
+  tools({
+    read: {
+      description: "Read the content of only one file. **Read one file at a time**.",
+      params: [
+        { name: "path", type: "string", description: "The path of only one file, must include workspace directory" },
+        {
+          name: "lineRange",
+          type: "string",
+          description: "Line range, format 'start-end' or 'start'. If 'all', reads entire file.",
+          optional: true
+        }
+      ],
+      returns: { type: "string", description: "The content of the file" }
+    },
+    write: {
+      description: "Write content to a file.",
+      params: [
+        { name: "path", type: "string", description: "File path, must include workspace directory" },
+        { name: "content", type: "string", description: "Content to write" }
+      ],
+      returns: { type: "string", description: "Natural language description of operation result" }
+    },
+    find: {
+      description: "Find content matching specified pattern in file. **Folder searching is not supported.**",
+      params: [
+        { name: "path", type: "string", description: "File path, must include workspace directory" },
+        { name: "pattern", type: "string", description: "Regex pattern to search for" }
+      ],
+      returns: { type: "string", description: "Natural language description of search results" }
+    },
+    findAndReplace: {
+      description: "Find and replace content matching specified pattern in file. **Folder searching is not supported.**",
+      params: [
+        { name: "path", type: "string", description: "File path, must include workspace directory" },
+        {
+          name: "pattern",
+          type: "string",
+          description: 'Regex pattern to search for. Escape special chars [ ] ( ) . * + ? $ ^ | \\ with backslash. Example: CSS class "pt-[30]" \u2192 use pattern "pt-\\[30\\]"'
+        },
+        { name: "replacement", type: "string", description: "Replacement text" }
+      ],
+      returns: { type: "string", description: "Natural language description of operation result" }
+    },
+    insert: {
+      description: "Insert content at specified line in file. **Folder searching is not supported.**",
+      params: [
+        { name: "path", type: "string", description: "File path, must include workspace directory" },
+        { name: "content", type: "string", description: "Content to insert" },
+        { name: "line", type: "integer", description: "Line number to insert at. If None, appends to end of file.", optional: true }
+      ],
+      returns: { type: "string", description: "Natural language description of operation result" }
+    }
+  })
+], FileEditor);
+
+// src/tools/esmTool.ts
+var ExtendStateMachineTool = class {
+  async writeEsm(esmContent, filepath) {
+    try {
+      const fileEditor = new FileEditor();
+      await fileEditor.write(filepath, esmContent);
+      return `Successfully wrote the ESM content to the yaml file ${filepath}`;
+    } catch (error) {
+      throw new ToolExecutionError(`Failed to write the ESM content to the yaml file ${filepath}: ${error.message}`);
+    }
+  }
+};
+ExtendStateMachineTool = __decorateClass([
+  tools({
+    writeEsm: {
+      description: "Write the yaml format ExtendStateMachine(ESM) content to the yaml file",
+      params: [
+        {
+          name: "esmContent",
+          type: "str",
+          description: "The yaml format ESM content to write. follow the format of the ESM content."
+        },
+        {
+          name: "filepath",
+          type: "str",
+          description: "The path to write the yaml format ESM content to."
+        }
+      ],
+      returns: {
+        type: "str",
+        description: "Successfully wrote the ESM content to the yaml file {filepath}"
+      }
+    }
+  })
+], ExtendStateMachineTool);
+
+// src/tools/apiTool.ts
+var ApiTool = class {
+  async write(apiFilePath, apiContent) {
+    const fileEditor = new FileEditor();
+    await fileEditor.write(apiFilePath, apiContent);
+    return `Write api file ${apiFilePath} complete!`;
+  }
+  async generateGolangFilesFromApi(apiFilePath, dir) {
+    const cmdTool = new CommandLineTool();
+    await cmdTool.execute(`goctl api go -api ${apiFilePath} -dir ${dir}`);
+    return `Generate golang files from ${apiFilePath} complete! The files are in ${dir}`;
+  }
+};
+ApiTool = __decorateClass([
+  tools({
+    write: {
+      description: "Use the tool to write api file based on goctl.",
+      params: [
+        {
+          name: "apiFilePath",
+          type: "str",
+          description: "The api file path to write."
+        },
+        {
+          name: "apiContent",
+          type: "str",
+          description: "The api content to write."
+        }
+      ],
+      returns: { type: "str", description: "The complete api file result." },
+      examples: [
+        'Good example:\n<ApiTool.write><apiFilePath>to/your/workspace/your_api_file_name.api</apiFilePath><apiContent>type ( Request { Name string `path:"name,options=[you,me]"` } Response { Message string `json:"message"` } ) service greet-api { @handler GreetHandler get /greet/from/:name (Request) returns (Response) }</apiContent></ApiTool.write>'
+      ]
+    },
+    generateGolangFilesFromApi: {
+      description: "Use the tool to generate golang files from api file.",
+      params: [
+        {
+          name: "apiFilePath",
+          type: "str",
+          description: "The api file path to generate golang files."
+        },
+        {
+          name: "dir",
+          type: "str",
+          description: "The directory to generate golang files."
+        }
+      ],
+      returns: { type: "str", description: "The complete golang files result." }
+    }
+  })
+], ApiTool);
+
+// src/tools/reply2human.ts
+var Reply2HumanTool = class {
+  async reply(reply) {
+    return "Reply complete!";
+  }
+};
+Reply2HumanTool = __decorateClass([
+  tools({
+    reply: {
+      description: "Emit the reply text in a unified and formatted manner.",
+      params: [{ name: "reply", type: "str", description: "Raw reply text to be sent to the user." }],
+      returns: { type: "str", description: "The complete, formatted reply." }
+    }
+  })
+], Reply2HumanTool);
+
+// src/tools/todoList.ts
+var TodoListTool = class {
+  async write(projectName, todoList, projectDir) {
+    const content = `# ${projectName}
+## Todo List
+${todoList}`;
+    const fileEditor = new FileEditor();
+    await fileEditor.write(`${projectDir}/todo.md`, content);
+    return `Write todo list file for project ${projectName} complete! The file is in ${projectDir}/todo.md`;
+  }
+};
+TodoListTool = __decorateClass([
+  tools({
+    write: {
+      description: "Use the tool to write todo list file for project.",
+      params: [
+        { name: "projectName", type: "str", description: "The project name to write todo list file." },
+        { name: "todoList", type: "str", description: "The todo list to write." },
+        { name: "projectDir", type: "str", description: "The project directory to write todo list file." }
+      ],
+      returns: { type: "str", description: "The complete todo list file result." },
+      examples: [
+        "Good example:\n<TodoListTool.write><projectName>your project name here</projectName><todoList>- [ ] Write todo list file for project\n- [ ] Write todo list file for project</todoList><projectDir>your project directory here</projectDir></TodoListTool.write>"
+      ]
+    }
+  })
+], TodoListTool);
+
+// src/tools/designUI.ts
+var WriteUIDesignDocument = class {
+  async write(uiDesignDocumentFileDir, elements, composites, pages, functions, styles) {
+    const fileEditor = new FileEditor();
+    await fileEditor.write(`${uiDesignDocumentFileDir}/AtomicElements.json`, JSON.stringify(elements, null, 2));
+    await fileEditor.write(`${uiDesignDocumentFileDir}/Composites.json`, JSON.stringify(composites, null, 2));
+    await fileEditor.write(`${uiDesignDocumentFileDir}/Pages.json`, JSON.stringify(pages, null, 2));
+    await fileEditor.write(`${uiDesignDocumentFileDir}/Functions.json`, JSON.stringify(functions, null, 2));
+    await fileEditor.write(`${uiDesignDocumentFileDir}/Styles.json`, JSON.stringify(styles, null, 2));
+    return `Write UI Design Document files ${uiDesignDocumentFileDir} complete!`;
+  }
+};
+WriteUIDesignDocument = __decorateClass([
+  tools({
+    write: {
+      description: "Use the tool to write UI Design Document files.",
+      params: [
+        {
+          name: "uiDesignDocumentFileDir",
+          type: "str",
+          description: "The UI Design Document file directory to write."
+        },
+        {
+          name: "elements",
+          type: "List[Dict]",
+          description: "The elements to write."
+        },
+        {
+          name: "composites",
+          type: "List[Dict]",
+          description: "The composites to write."
+        },
+        { name: "pages", type: "List[Dict]", description: "The pages to write." },
+        {
+          name: "functions",
+          type: "List[Dict]",
+          description: "The functions to write."
+        },
+        {
+          name: "styles",
+          type: "List[Dict]",
+          description: "The styles to write."
+        }
+      ],
+      returns: {
+        type: "str",
+        description: "The complete UI Design Document files result."
+      }
+    }
+  })
+], WriteUIDesignDocument);
+
+// src/tools/reflect.ts
+var ReflectTool = class {
+  async reflect(state) {
+    return "Reflected complete!";
+  }
+  /**
+   * Set the reflection for agent to see.
+   */
+  setReflection(reflection) {
+    return `<ReflectTool.setReflection><reflection>${reflection}</reflection></ReflectTool.setReflection>`;
+  }
+};
+ReflectTool = __decorateClass([
+  tools({
+    reflect: {
+      description: "Use the tool to reflect on the state.",
+      params: [{ name: "state", type: "str", description: "The state to reflect on." }],
+      returns: { type: "str", description: "The reflected result." }
+    }
+  })
+], ReflectTool);
+
+// src/tools/skills.ts
+import * as fs5 from "fs";
+import * as path3 from "path";
+var SkillsTool = class {
+  /**
+   * Skills directory
+   */
+  skillsDir;
+  constructor(skillsDir = SKILLS_DIR) {
+    this.skillsDir = skillsDir;
+  }
+  /**
+   * Read the content of the skill description file.
+   *
+   * Args:
+   *     name (str): The name of the skill
+   *
+   * Returns:
+   *     str: The content of the skill description file
+   */
+  async readSkillDescription(name) {
+    const skillsPath = path3.join(this.skillsDir, name, "SKILL.md");
+    if (!fs5.existsSync(skillsPath)) {
+      throw new ToolExecutionError(`Skill description file not found: ${skillsPath}`);
+    }
+    const fileEditor = new FileEditor();
+    const skillDescription = await fileEditor.read(skillsPath);
+    const formattedDescription = `<${name}.SkillDescription>${skillDescription}</${name}.SkillDescription>`;
+    logger.debug(formattedDescription);
+    return formattedDescription;
+  }
+  /**
+   * List the skills in the skills root directory
+   */
+  async listSkills() {
+    if (!fs5.existsSync(this.skillsDir)) {
+      throw new ToolExecutionError(`Skills path not found: ${this.skillsDir}`);
+    }
+    const skillsDict = {};
+    const items = fs5.readdirSync(this.skillsDir);
+    for (const skillName of items) {
+      const skillPath = path3.join(this.skillsDir, skillName, "SKILL.md");
+      if (!fs5.existsSync(skillPath)) {
+        continue;
+      }
+      const fileEditor = new FileEditor();
+      try {
+        const skillContent = await fileEditor.read(skillPath, "1-3");
+        skillsDict[skillName] = skillContent;
+      } catch (error) {
+        logger.warn(`Failed to read skill ${skillName}:`, error);
+      }
+    }
+    const skillsInfo = "<SkillsInformation>" + Object.entries(skillsDict).map(([skillName, content]) => `<${skillName}> ${content} </${skillName}>`).join("\n") + "</SkillsInformation>";
+    logger.debug(skillsInfo);
+    return skillsInfo;
+  }
+};
+SkillsTool = __decorateClass([
+  tools({
+    readSkillDescription: {
+      description: "Read the content of the skill description file.",
+      params: [{ name: "name", type: "str", description: "The name of the skill" }],
+      returns: { type: "str", description: "The content of the skill description file" }
+    },
+    listSkills: {
+      description: "List the skills in the skills root directory",
+      returns: { type: "str", description: "The list of skills with their descriptions" }
+    }
+  })
+], SkillsTool);
+
+// src/tools/gitTool.ts
+import { exec } from "child_process";
+import * as fs6 from "fs";
+import * as path4 from "path";
+function quote(str) {
+  if (/^[a-zA-Z0-9_\-.\/]+$/.test(str)) {
+    return str;
+  }
+  return `'${str.replace(/'/g, "'\\''")}'`;
+}
+var gitToolConfig = {
+  init: {
+    description: "Initialize a git repository.",
+    params: [
+      {
+        name: "cwd",
+        type: "string",
+        description: "Working directory, defaults to current directory if None",
+        optional: true
+      },
+      {
+        name: "bare",
+        type: "boolean",
+        description: "Create a bare repository",
+        optional: true
+      },
+      {
+        name: "initialBranch",
+        type: "string",
+        description: "Initial branch name",
+        optional: true
+      },
+      {
+        name: "config",
+        type: "object",
+        description: "Git config options {key: value}",
+        optional: true
+      }
+    ],
+    returns: { type: "string", description: "Initialization result" }
+  },
+  status: {
+    description: "View git repository status, showing changes in working directory and staging area.",
+    params: [
+      {
+        name: "cwd",
+        type: "string",
+        description: "Working directory, defaults to current directory if None",
+        optional: true
+      },
+      {
+        name: "config",
+        type: "object",
+        description: "Git config options {key: value}",
+        optional: true
+      }
+    ],
+    returns: { type: "string", description: "Output of git status" }
+  },
+  add: {
+    description: "Add files to staging area.",
+    params: [
+      {
+        name: "files",
+        type: "string",
+        description: 'File paths to add, can be single file, multiple files (space separated), "." (all files) or path patterns'
+      },
+      {
+        name: "cwd",
+        type: "string",
+        description: "Working directory, defaults to current directory if None",
+        optional: true
+      },
+      {
+        name: "config",
+        type: "object",
+        description: "Git config options {key: value}",
+        optional: true
+      }
+    ],
+    returns: { type: "string", description: "Operation result description" }
+  },
+  commit: {
+    description: "Commit changes in staging area.",
+    params: [
+      { name: "message", type: "string", description: "Commit message" },
+      {
+        name: "cwd",
+        type: "string",
+        description: "Working directory, defaults to current directory if None",
+        optional: true
+      },
+      {
+        name: "allowEmpty",
+        type: "boolean",
+        description: "Whether to allow empty commits, default False",
+        optional: true
+      },
+      {
+        name: "config",
+        type: "object",
+        description: "Git config options {key: value}",
+        optional: true
+      }
+    ],
+    returns: {
+      type: "string",
+      description: "Commit result, including commit hash and change statistics"
+    }
+  },
+  push: {
+    description: "Push local commits to remote repository.",
+    params: [
+      {
+        name: "remote",
+        type: "string",
+        description: "Remote repository name, defaults to origin",
+        optional: true
+      },
+      {
+        name: "branch",
+        type: "string",
+        description: "Branch name to push, defaults to current branch",
+        optional: true
+      },
+      {
+        name: "cwd",
+        type: "string",
+        description: "Working directory, defaults to current directory if None",
+        optional: true
+      },
+      {
+        name: "force",
+        type: "boolean",
+        description: "Whether to force push, default False",
+        optional: true
+      },
+      {
+        name: "config",
+        type: "object",
+        description: "Git config options {key: value}",
+        optional: true
+      }
+    ],
+    returns: { type: "string", description: "Push result description" }
+  },
+  pull: {
+    description: "Pull latest changes from remote repository.",
+    params: [
+      {
+        name: "remote",
+        type: "string",
+        description: "Remote repository name, defaults to origin",
+        optional: true
+      },
+      {
+        name: "branch",
+        type: "string",
+        description: "Branch name to pull, defaults to current branch",
+        optional: true
+      },
+      {
+        name: "cwd",
+        type: "string",
+        description: "Working directory, defaults to current directory if None",
+        optional: true
+      },
+      {
+        name: "config",
+        type: "object",
+        description: "Git config options {key: value}",
+        optional: true
+      }
+    ],
+    returns: { type: "string", description: "Pull result description" }
+  },
+  checkout: {
+    description: "Switch branch or checkout files.",
+    params: [
+      {
+        name: "target",
+        type: "string",
+        description: "Target branch name or file path"
+      },
+      {
+        name: "cwd",
+        type: "string",
+        description: "Working directory, defaults to current directory if None",
+        optional: true
+      },
+      {
+        name: "createBranch",
+        type: "boolean",
+        description: "Whether to create new branch if target doesn't exist, default True",
+        optional: true
+      },
+      {
+        name: "config",
+        type: "object",
+        description: "Git config options {key: value}",
+        optional: true
+      }
+    ],
+    returns: { type: "string", description: "Checkout result description" }
+  },
+  branch: {
+    description: "List all branches or create/delete branch.",
+    params: [
+      {
+        name: "name",
+        type: "string",
+        description: "Branch name, lists all branches if None",
+        optional: true
+      },
+      {
+        name: "cwd",
+        type: "string",
+        description: "Working directory, defaults to current directory if None",
+        optional: true
+      },
+      {
+        name: "delete",
+        type: "boolean",
+        description: "Whether to delete branch, default False",
+        optional: true
+      },
+      {
+        name: "config",
+        type: "object",
+        description: "Git config options {key: value}",
+        optional: true
+      }
+    ],
+    returns: { type: "string", description: "Branch operation result" }
+  },
+  log: {
+    description: "View commit history.",
+    params: [
+      {
+        name: "cwd",
+        type: "string",
+        description: "Working directory, defaults to current directory if None",
+        optional: true
+      },
+      {
+        name: "maxCount",
+        type: "integer",
+        description: "Maximum number of commits to show",
+        optional: true
+      },
+      {
+        name: "oneline",
+        type: "boolean",
+        description: "Whether to show in oneline format, default False",
+        optional: true
+      },
+      {
+        name: "filePath",
+        type: "string",
+        description: "View commit history for specific file",
+        optional: true
+      },
+      {
+        name: "config",
+        type: "object",
+        description: "Git config options {key: value}",
+        optional: true
+      }
+    ],
+    returns: { type: "string", description: "Commit history" }
+  },
+  diff: {
+    description: "View file differences.",
+    params: [
+      {
+        name: "cwd",
+        type: "string",
+        description: "Working directory, defaults to current directory if None",
+        optional: true
+      },
+      {
+        name: "staged",
+        type: "boolean",
+        description: "Whether to view staged changes, default False",
+        optional: true
+      },
+      {
+        name: "filePath",
+        type: "string",
+        description: "View diff for specific file",
+        optional: true
+      },
+      {
+        name: "commit1",
+        type: "string",
+        description: "First commit hash or branch name",
+        optional: true
+      },
+      {
+        name: "commit2",
+        type: "string",
+        description: "Second commit hash or branch name",
+        optional: true
+      },
+      {
+        name: "config",
+        type: "object",
+        description: "Git config options {key: value}",
+        optional: true
+      }
+    ],
+    returns: { type: "string", description: "Diff content" }
+  },
+  remote: {
+    description: "Manage remote repositories.",
+    params: [
+      {
+        name: "action",
+        type: "string",
+        description: 'Action type: "list", "add", "remove", "set-url", default "list"',
+        optional: true
+      },
+      {
+        name: "name",
+        type: "string",
+        description: 'Remote repository name, usually "origin"',
+        optional: true
+      },
+      {
+        name: "url",
+        type: "string",
+        description: "Remote repository URL (for add or set-url)",
+        optional: true
+      },
+      {
+        name: "cwd",
+        type: "string",
+        description: "Working directory, defaults to current directory if None",
+        optional: true
+      },
+      {
+        name: "config",
+        type: "object",
+        description: "Git config options {key: value}",
+        optional: true
+      }
+    ],
+    returns: { type: "string", description: "Operation result" }
+  },
+  clone: {
+    description: "Clone remote repository to local.",
+    params: [
+      { name: "url", type: "string", description: "Remote repository URL" },
+      {
+        name: "directory",
+        type: "string",
+        description: "Local directory name, defaults to repository name if None",
+        optional: true
+      },
+      {
+        name: "cwd",
+        type: "string",
+        description: "Working directory, defaults to current directory if None",
+        optional: true
+      },
+      {
+        name: "config",
+        type: "object",
+        description: "Git config options {key: value}",
+        optional: true
+      }
+    ],
+    returns: { type: "string", description: "Clone result description" }
+  },
+  fetch: {
+    description: "Fetch latest changes from remote without merging.",
+    params: [
+      {
+        name: "remote",
+        type: "string",
+        description: "Remote repository name, defaults to origin",
+        optional: true
+      },
+      {
+        name: "cwd",
+        type: "string",
+        description: "Working directory, defaults to current directory if None",
+        optional: true
+      },
+      {
+        name: "config",
+        type: "object",
+        description: "Git config options {key: value}",
+        optional: true
+      }
+    ],
+    returns: { type: "string", description: "Fetch result description" }
+  },
+  merge: {
+    description: "Merge specified branch into current branch.",
+    params: [
+      { name: "branch", type: "string", description: "Branch name to merge" },
+      {
+        name: "cwd",
+        type: "string",
+        description: "Working directory, defaults to current directory if None",
+        optional: true
+      },
+      {
+        name: "config",
+        type: "object",
+        description: "Git config options {key: value}",
+        optional: true
+      }
+    ],
+    returns: { type: "string", description: "Merge result description" }
+  },
+  show: {
+    description: "Show detailed information about git objects (commits, tags, trees, etc).",
+    params: [
+      {
+        name: "object",
+        type: "string",
+        description: "Object to show (commit hash, tag, branch, etc.), defaults to HEAD",
+        optional: true
+      },
+      {
+        name: "cwd",
+        type: "string",
+        description: "Working directory",
+        optional: true
+      },
+      {
+        name: "stat",
+        type: "boolean",
+        description: "Show status info",
+        optional: true
+      },
+      {
+        name: "nameOnly",
+        type: "boolean",
+        description: "Show only filenames",
+        optional: true
+      },
+      {
+        name: "format",
+        type: "string",
+        description: "Custom format string",
+        optional: true
+      },
+      {
+        name: "config",
+        type: "object",
+        description: "Git config options {key: value}",
+        optional: true
+      }
+    ],
+    returns: { type: "string", description: "Object details" }
+  },
+  tag: {
+    description: "Create, list or delete tags.",
+    params: [
+      {
+        name: "name",
+        type: "string",
+        description: "Tag name, lists all tags if None",
+        optional: true
+      },
+      {
+        name: "cwd",
+        type: "string",
+        description: "Working directory",
+        optional: true
+      },
+      {
+        name: "message",
+        type: "string",
+        description: "Tag message",
+        optional: true
+      },
+      {
+        name: "delete",
+        type: "boolean",
+        description: "Delete tag",
+        optional: true
+      },
+      {
+        name: "listAll",
+        type: "boolean",
+        description: "List all tags",
+        optional: true
+      },
+      {
+        name: "annotate",
+        type: "boolean",
+        description: "Create annotated tag",
+        optional: true
+      },
+      {
+        name: "config",
+        type: "object",
+        description: "Git config options {key: value}",
+        optional: true
+      }
+    ],
+    returns: { type: "string", description: "Tag operation result" }
+  },
+  revert: {
+    description: "Revert existing commits.",
+    params: [
+      {
+        name: "commit",
+        type: "string",
+        description: "Commit hash to revert"
+      },
+      {
+        name: "cwd",
+        type: "string",
+        description: "Working directory",
+        optional: true
+      },
+      {
+        name: "noCommit",
+        type: "boolean",
+        description: "Revert changes but do not commit",
+        optional: true
+      },
+      {
+        name: "noEdit",
+        type: "boolean",
+        description: "Do not edit commit message, default True",
+        optional: true
+      },
+      {
+        name: "mainline",
+        type: "integer",
+        description: "Mainline parent number for merge commits",
+        optional: true
+      },
+      {
+        name: "config",
+        type: "object",
+        description: "Git config options {key: value}",
+        optional: true
+      }
+    ],
+    returns: { type: "string", description: "Revert result" }
+  }
+};
+var GitTool = class {
+  /**
+   * Helper method to execute git commands.
+   */
+  async _executeGitCommand(command, cwd, timeout = 3e4, config2) {
+    const workDir = cwd || process.cwd();
+    if (!fs6.existsSync(workDir)) {
+      throw new ToolExecutionError(`\u5DE5\u4F5C\u76EE\u5F55\u4E0D\u5B58\u5728: ${workDir}`);
+    }
+    const gitDir = path4.join(workDir, ".git");
+    const isInitOrClone = command.includes("clone") || command.includes("init");
+    if (!fs6.existsSync(gitDir) && !isInitOrClone) {
+      throw new ToolExecutionError(`\u5F53\u524D\u76EE\u5F55\u4E0D\u662F git \u4ED3\u5E93: ${workDir}`);
+    }
+    let gitCmd = "git";
+    if (config2) {
+      for (const [key, value] of Object.entries(config2)) {
+        gitCmd += ` -c ${key}=${quote(value)}`;
+      }
+    }
+    gitCmd += ` ${command}`;
+    return new Promise((resolve2, reject) => {
+      exec(gitCmd, { cwd: workDir, timeout, encoding: "utf-8" }, (error, stdout, stderr) => {
+        const stdoutText = stdout ? stdout.trim() : "";
+        const stderrText = stderr ? stderr.trim() : "";
+        if (error) {
+          if (error.signal === "SIGTERM") {
+            reject(new ToolExecutionError(`Git \u547D\u4EE4\u6267\u884C\u8D85\u65F6\uFF08\u8D85\u8FC7 ${timeout / 1e3} \u79D2\uFF09`));
+            return;
+          }
+          const errorMsg = stderrText || stdoutText || error.message;
+          reject(new ToolExecutionError(`Git \u547D\u4EE4\u6267\u884C\u5931\u8D25: ${errorMsg}`));
+          return;
+        }
+        resolve2(stdoutText || "\u547D\u4EE4\u6267\u884C\u6210\u529F\uFF0C\u65E0\u8F93\u51FA");
+      });
+    });
+  }
+  /**
+   * Get current branch name.
+   */
+  async _getCurrentBranch(cwd, config2) {
+    const result = await this._executeGitCommand("rev-parse --abbrev-ref HEAD", cwd, 3e4, config2);
+    return result.trim();
+  }
+  async init(cwd, bare = false, initialBranch, config2) {
+    let command = "init";
+    if (bare) command += " --bare";
+    if (initialBranch) command += ` --initial-branch=${initialBranch}`;
+    const result = await this._executeGitCommand(command, cwd, 3e4, config2);
+    return `Git \u4ED3\u5E93\u521D\u59CB\u5316\u5B8C\u6210
+${result}`;
+  }
+  async status(cwd, config2) {
+    return await this._executeGitCommand("status", cwd, 3e4, config2);
+  }
+  async add(files, cwd, config2) {
+    const result = await this._executeGitCommand(`add ${files}`, cwd, 3e4, config2);
+    return `\u6210\u529F\u5C06\u6587\u4EF6\u6DFB\u52A0\u5230\u6682\u5B58\u533A: ${files}
+${result}`;
+  }
+  async commit(message, cwd, allowEmpty = false, config2) {
+    const allowEmptyFlag = allowEmpty ? " --allow-empty" : "";
+    const result = await this._executeGitCommand(`commit -m ${quote(message)}${allowEmptyFlag}`, cwd, 3e4, config2);
+    return `\u63D0\u4EA4\u6210\u529F
+${result}`;
+  }
+  async push(remote = "origin", branch, cwd, force = false, config2) {
+    const targetBranch = branch || await this._getCurrentBranch(cwd, config2);
+    const forceFlag = force ? " --force" : "";
+    const result = await this._executeGitCommand(`push${forceFlag} ${remote} ${targetBranch}`, cwd, 6e4, config2);
+    return `\u6210\u529F\u63A8\u9001\u5230 ${remote}/${targetBranch}
+${result}`;
+  }
+  async pull(remote = "origin", branch, cwd, config2) {
+    const targetBranch = branch || await this._getCurrentBranch(cwd, config2);
+    const result = await this._executeGitCommand(`pull ${remote} ${targetBranch}`, cwd, 6e4, config2);
+    return `\u6210\u529F\u4ECE ${remote}/${targetBranch} \u62C9\u53D6\u66F4\u6539
+${result}`;
+  }
+  async checkout(target, cwd, createBranch = true, config2) {
+    const createFlag = createBranch ? " -b" : "";
+    const result = await this._executeGitCommand(`checkout${createFlag} ${target}`, cwd, 3e4, config2);
+    return `\u6210\u529F\u5207\u6362\u5230 ${target}
+${result}`;
+  }
+  async branch(name, cwd, deleteBranch = false, config2) {
+    if (!name) {
+      const result = await this._executeGitCommand("branch -a", cwd, 3e4, config2);
+      return `\u6240\u6709\u5206\u652F\u5217\u8868:
+${result}`;
+    } else if (deleteBranch) {
+      const result = await this._executeGitCommand(`branch -d ${name}`, cwd, 3e4, config2);
+      return `\u6210\u529F\u5220\u9664\u5206\u652F ${name}
+${result}`;
+    } else {
+      const result = await this._executeGitCommand(`branch ${name}`, cwd, 3e4, config2);
+      return `\u6210\u529F\u521B\u5EFA\u5206\u652F ${name}
+${result}`;
+    }
+  }
+  async log(cwd, maxCount, oneline = false, filePath, config2) {
+    let command = "log";
+    if (oneline) command += " --oneline";
+    if (maxCount) command += ` -${maxCount}`;
+    if (filePath) command += ` -- ${filePath}`;
+    const result = await this._executeGitCommand(command, cwd, 3e4, config2);
+    return `\u63D0\u4EA4\u5386\u53F2:
+${result}`;
+  }
+  async diff(cwd, staged = false, filePath, commit1, commit2, config2) {
+    let command = "diff";
+    if (staged) command += " --staged";
+    if (commit1 && commit2) {
+      command += ` ${commit1} ${commit2}`;
+    } else if (commit1) {
+      command += ` ${commit1}`;
+    }
+    if (filePath) command += ` -- ${filePath}`;
+    const result = await this._executeGitCommand(command, cwd, 3e4, config2);
+    return `\u5DEE\u5F02\u5185\u5BB9:
+${result}`;
+  }
+  async remote(action = "list", name, url, cwd, config2) {
+    if (action === "list") {
+      const result = await this._executeGitCommand("remote -v", cwd, 3e4, config2);
+      return `\u8FDC\u7A0B\u4ED3\u5E93\u5217\u8868:
+${result}`;
+    } else if (action === "add") {
+      if (!name || !url) throw new ToolExecutionError("\u6DFB\u52A0\u8FDC\u7A0B\u4ED3\u5E93\u9700\u8981\u63D0\u4F9B name \u548C url \u53C2\u6570");
+      const result = await this._executeGitCommand(`remote add ${name} ${url}`, cwd, 3e4, config2);
+      return `\u6210\u529F\u6DFB\u52A0\u8FDC\u7A0B\u4ED3\u5E93 ${name}: ${url}
+${result}`;
+    } else if (action === "remove") {
+      if (!name) throw new ToolExecutionError("\u5220\u9664\u8FDC\u7A0B\u4ED3\u5E93\u9700\u8981\u63D0\u4F9B name \u53C2\u6570");
+      const result = await this._executeGitCommand(`remote remove ${name}`, cwd, 3e4, config2);
+      return `\u6210\u529F\u5220\u9664\u8FDC\u7A0B\u4ED3\u5E93 ${name}
+${result}`;
+    } else if (action === "set-url") {
+      if (!name || !url) throw new ToolExecutionError("\u8BBE\u7F6E\u8FDC\u7A0B\u4ED3\u5E93 URL \u9700\u8981\u63D0\u4F9B name \u548C url \u53C2\u6570");
+      const result = await this._executeGitCommand(`remote set-url ${name} ${url}`, cwd, 3e4, config2);
+      return `\u6210\u529F\u8BBE\u7F6E\u8FDC\u7A0B\u4ED3\u5E93 ${name} \u7684 URL \u4E3A {url}
+${result}`;
+    } else {
+      throw new ToolExecutionError(`\u4E0D\u652F\u6301\u7684\u64CD\u4F5C\u7C7B\u578B: ${action}\uFF0C\u652F\u6301\u7684\u64CD\u4F5C: list, add, remove, set-url`);
+    }
+  }
+  async clone(url, directory, cwd, config2) {
+    const workDir = cwd || process.cwd();
+    let command = `clone ${url}`;
+    if (directory) command += ` ${directory}`;
+    const result = await this._executeGitCommand(command, workDir, 12e4, config2);
+    return `\u6210\u529F\u514B\u9686\u4ED3\u5E93 ${url}
+${result}`;
+  }
+  async fetch(remote = "origin", cwd, config2) {
+    const result = await this._executeGitCommand(`fetch ${remote}`, cwd, 6e4, config2);
+    return `\u6210\u529F\u4ECE ${remote} \u83B7\u53D6\u66F4\u65B0
+${result}`;
+  }
+  async merge(branch, cwd, config2) {
+    const noFfFlag = "";
+    const result = await this._executeGitCommand(`merge${noFfFlag} ${branch}`, cwd, 3e4, config2);
+    return `\u6210\u529F\u5408\u5E76\u5206\u652F ${branch}
+${result}`;
+  }
+  async show(object, cwd, stat = false, nameOnly = false, format2, config2) {
+    let command = "show";
+    if (object) command += ` ${object}`;
+    if (stat) command += " --stat";
+    if (nameOnly) command += " --name-only";
+    if (format2) command += ` --format=${format2}`;
+    const result = await this._executeGitCommand(command, cwd, 3e4, config2);
+    return `\u663E\u793A\u5BF9\u8C61\u4FE1\u606F:
+${result}`;
+  }
+  async tag(name, cwd, message, deleteTag = false, listAll = false, annotate = false, config2) {
+    if (!name) {
+      let command = "tag";
+      if (listAll) command += " -l";
+      const result = await this._executeGitCommand(command, cwd, 3e4, config2);
+      return `\u6807\u7B7E\u5217\u8868:
+${result}`;
+    } else if (deleteTag) {
+      const result = await this._executeGitCommand(`tag -d ${name}`, cwd, 3e4, config2);
+      return `\u6210\u529F\u5220\u9664\u6807\u7B7E ${name}
+${result}`;
+    } else {
+      let command = "tag";
+      if (annotate || message) command += " -a";
+      if (message) command += ` -m ${quote(message)}`;
+      command += ` ${name}`;
+      const result = await this._executeGitCommand(command, cwd, 3e4, config2);
+      return `\u6210\u529F\u521B\u5EFA\u6807\u7B7E ${name}
+${result}`;
+    }
+  }
+  async revert(commit, cwd, noCommit = false, noEdit = true, mainline, config2) {
+    let command = "revert";
+    if (noCommit) command += " --no-commit";
+    if (noEdit) command += " --no-edit";
+    if (mainline) command += ` -m ${mainline}`;
+    command += ` ${commit}`;
+    const result = await this._executeGitCommand(command, cwd, 3e4, config2);
+    return `\u6210\u529F\u64A4\u9500\u63D0\u4EA4 ${commit}
+${result}`;
+  }
+};
+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";
+    }
+    this._initializeClient();
+  }
+  /**
+   * Initialize the appropriate SDK client based on provider
+   */
+  _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);
+        }
+        this.anthropicClient = new Anthropic({
+          apiKey: this.config.apiKey || process.env.ANTHROPIC_API_KEY,
+          baseURL: this.config.baseUrl,
+          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":
+          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}`);
+      }
+    } 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,
+        max_tokens: this.config.maxOutputTokens || 1024,
+        top_p: this.config.topP || 0.9,
+        stream
+      };
+      if (tools2 && tools2.length > 0) {
+        params.tools = tools2;
+        params.tool_choice = "auto";
+      }
+      if (stream) {
+        const streamResponse = await this.openaiClient.chat.completions.create({
+          ...params,
+          stream: true
+        });
+        let fullContent = "";
+        let toolCallsMap = {};
+        for await (const chunk of streamResponse) {
+          const delta = chunk.choices[0]?.delta;
+          if (!delta) continue;
+          if (delta.content) {
+            streamLogger2.info(delta.content);
+            fullContent += delta.content;
+          }
+          if (delta.tool_calls) {
+            for (const tc of delta.tool_calls) {
+              const index = tc.index;
+              if (!toolCallsMap[index]) {
+                toolCallsMap[index] = {
+                  id: tc.id || "",
+                  type: "function",
+                  function: {
+                    name: tc.function?.name || "",
+                    arguments: tc.function?.arguments || ""
+                  }
+                };
+                if (tc.function?.name) {
+                  streamLogger2.info(`
+Tool Call: ${tc.function.name}
+Arguments: `);
+                }
+              } else {
+                if (tc.function?.arguments) {
+                  toolCallsMap[index].function.arguments += tc.function.arguments;
+                  streamLogger2.info(tc.function.arguments);
+                }
+              }
+            }
+          }
+        }
+        streamLogger2.info("\n");
+        const toolCalls = Object.values(toolCallsMap);
+        const hasContent = fullContent.trim().length > 0;
+        const hasToolCalls = toolCalls.length > 0;
+        if (hasToolCalls) {
+          return [
+            {
+              type: "user",
+              extractedResult: () => ({
+                role: "assistant",
+                content: fullContent,
+                tool_calls: toolCalls
+              })
+            }
+          ];
+        }
+        return [
+          {
+            type: "system",
+            extractedResult: () => fullContent,
+            rawContentFromLlm: fullContent
+          }
+        ];
+      } else {
+        const response = await this.openaiClient.chat.completions.create(params);
+        if (!response.choices || response.choices.length === 0) {
+          throw new ModelError("No choices returned from OpenAI API");
+        }
+        const message = response.choices[0].message;
+        const messageContent = message.content || "";
+        const hasToolCalls = message.tool_calls && message.tool_calls.length > 0;
+        if (hasToolCalls) {
+          return [
+            {
+              type: "user",
+              extractedResult: () => ({
+                role: "assistant",
+                content: messageContent,
+                tool_calls: message.tool_calls
+              })
+            }
+          ];
+        }
+        return [
+          {
+            type: "system",
+            extractedResult: () => messageContent,
+            rawContentFromLlm: messageContent
+          }
+        ];
+      }
+    } catch (error) {
+      const errorMsg = error.message || "Unknown error";
+      throw new ModelError(`OpenAI-compatible API call failed: ${errorMsg}, model config: ${JSON.stringify(this.config)}`);
+    }
+  }
+  /**
+   * Call Anthropic API
+   */
+  async _callAnthropic(messages, tools2, stream = false) {
+    if (!this.anthropicClient) {
+      throw new ModelError("Anthropic client not initialized");
+    }
+    try {
+      const systemMessage = messages.find((m) => m.role === "system");
+      const nonSystemMessages = messages.filter((m) => m.role !== "system");
+      const params = {
+        model: this.config.model || "claude-3-sonnet-20240229",
+        messages: nonSystemMessages,
+        max_tokens: this.config.maxOutputTokens || 4096,
+        temperature: this.config.temperature || 0.7,
+        top_p: this.config.topP || 0.9,
+        stream
+      };
+      if (systemMessage) {
+        params.system = systemMessage.content;
+      }
+      if (tools2 && tools2.length > 0) {
+        params.tools = tools2.map((tool) => ({
+          name: tool.function?.name || tool.name,
+          description: tool.function?.description || tool.description,
+          input_schema: tool.function?.parameters || tool.input_schema
+        }));
+      }
+      if (stream) {
+        const streamResponse = await this.anthropicClient.messages.stream({
+          ...params,
+          stream: true
+        });
+        let fullContent = "";
+        let toolUses = [];
+        for await (const event of streamResponse) {
+          if (event.type === "content_block_start") {
+            if (event.content_block.type === "tool_use") {
+              const toolUse = event.content_block;
+              streamLogger2.info(`
+Tool Call: ${toolUse.name}
+Arguments: `);
+            }
+          } else if (event.type === "content_block_delta") {
+            if (event.delta.type === "text_delta") {
+              streamLogger2.info(event.delta.text);
+              fullContent += event.delta.text;
+            } else if (event.delta.type === "input_json_delta") {
+              streamLogger2.info(event.delta.partial_json);
+            }
+          } else if (event.type === "message_delta") {
+          }
+        }
+        streamLogger2.info("\n");
+        const hasContent = fullContent.trim().length > 0;
+        const hasToolUses = toolUses.length > 0;
+        return [
+          {
+            type: "system",
+            extractedResult: () => fullContent || toolUses,
+            rawContentFromLlm: fullContent
+          }
+        ];
+      } else {
+        const response = await this.anthropicClient.messages.create(params);
+        if (!response.content || response.content.length === 0) {
+          throw new ModelError("No content returned from Anthropic API");
+        }
+        const toolUse = response.content.find((c) => c.type === "tool_use");
+        if (toolUse) {
+          return [
+            {
+              type: "system",
+              extractedResult: () => [toolUse]
+            }
+          ];
+        }
+        const textContent = response.content.find((c) => c.type === "text");
+        const messageContent = textContent?.text || "";
+        return [
+          {
+            type: "system",
+            extractedResult: () => messageContent,
+            rawContentFromLlm: messageContent
+          }
+        ];
+      }
+    } catch (error) {
+      const errorMsg = error.message || "Unknown error";
+      throw new ModelError(`Anthropic API call failed: ${errorMsg}`);
+    }
+  }
+  /**
+   * Call Google Gemini API
+   */
+  async _callGemini(messages, tools2, stream = false) {
+    if (!this.geminiClient) {
+      throw new ModelError("Gemini client not initialized");
+    }
+    try {
+      const modelName = this.config.model || "gemini-pro";
+      const model = this.geminiClient.getGenerativeModel({
+        model: modelName,
+        generationConfig: {
+          temperature: this.config.temperature || 0.7,
+          maxOutputTokens: this.config.maxOutputTokens || 2048,
+          topP: this.config.topP || 0.9
+        }
+      });
+      const contents = this._convertMessagesToGeminiFormat(messages);
+      if (stream) {
+        const result = await model.generateContentStream({ contents });
+        let fullContent = "";
+        let functionCalls = [];
+        for await (const chunk of result.stream) {
+          try {
+            const chunkText = await chunk.text();
+            if (chunkText) {
+              streamLogger2.info(chunkText);
+              fullContent += chunkText;
+            }
+          } catch (e) {
+          }
+          const candidates = chunk.candidates;
+          if (candidates && candidates[0]?.content?.parts) {
+            for (const part of candidates[0].content.parts) {
+              if (part.functionCall) {
+                functionCalls.push(part.functionCall);
+              }
+            }
+          }
+        }
+        streamLogger2.info("\n");
+        const hasContent = fullContent.trim().length > 0;
+        const hasFunctionCalls = functionCalls.length > 0;
+        if (hasFunctionCalls) {
+          const toolCalls = functionCalls.map((fc, index) => ({
+            id: `call_${Date.now()}_${index}`,
+            type: "function",
+            function: {
+              name: fc.name,
+              arguments: JSON.stringify(fc.args)
+            }
+          }));
+          return [
+            {
+              type: "user",
+              extractedResult: () => ({
+                role: "assistant",
+                content: fullContent,
+                tool_calls: toolCalls
+              })
+            }
+          ];
+        }
+        return [
+          {
+            type: "system",
+            extractedResult: () => fullContent,
+            rawContentFromLlm: fullContent
+          }
+        ];
+      } else {
+        const result = await model.generateContent({ contents });
+        const response = result.response;
+        if (!response.candidates || response.candidates.length === 0) {
+          throw new ModelError("No candidates returned from Gemini API");
+        }
+        const candidate = response.candidates[0];
+        const content = candidate.content;
+        if (!content || !content.parts || content.parts.length === 0) {
+          throw new ModelError("No content parts returned from Gemini API");
+        }
+        const functionCalls = content.parts.filter((part) => part.functionCall);
+        const hasFunctionCalls = functionCalls.length > 0;
+        if (hasFunctionCalls) {
+          const toolCalls = functionCalls.map((part, index) => ({
+            id: `call_${Date.now()}_${index}`,
+            type: "function",
+            function: {
+              name: part.functionCall.name,
+              arguments: JSON.stringify(part.functionCall.args)
+            }
+          }));
+          const textParts2 = content.parts.filter((part) => part.text);
+          const textContent2 = textParts2.map((part) => part.text).join("");
+          return [
+            {
+              type: "user",
+              extractedResult: () => ({
+                role: "assistant",
+                content: textContent2,
+                tool_calls: toolCalls
+              })
+            }
+          ];
+        }
+        const textParts = content.parts.filter((part) => part.text);
+        const textContent = textParts.map((part) => part.text).join("");
+        return [
+          {
+            type: "system",
+            extractedResult: () => textContent,
+            rawContentFromLlm: textContent
+          }
+        ];
+      }
+    } catch (error) {
+      const errorMsg = error.message || "Unknown error";
+      throw new ModelError(`Gemini API call failed: ${errorMsg}`);
+    }
+  }
+  /**
+   * Convert OpenAI format messages to Gemini format
+   */
+  _convertMessagesToGeminiFormat(messages) {
+    const contents = [];
+    for (const message of messages) {
+      if (message.role === "system") {
+        contents.push({
+          role: "user",
+          parts: [{ text: message.content }]
+        });
+      } else if (message.role === "user") {
+        contents.push({
+          role: "user",
+          parts: [{ text: message.content }]
+        });
+      } else if (message.role === "assistant") {
+        const parts = [];
+        if (message.content) {
+          parts.push({ text: message.content });
+        }
+        if (message.tool_calls) {
+          for (const toolCall of message.tool_calls) {
+            parts.push({
+              functionCall: {
+                name: toolCall.function.name,
+                args: JSON.parse(toolCall.function.arguments)
+              }
+            });
+          }
+        }
+        contents.push({
+          role: "model",
+          parts
+        });
+      } else if (message.role === "tool") {
+        contents.push({
+          role: "function",
+          parts: [
+            {
+              functionResponse: {
+                name: message.name,
+                response: {
+                  content: message.content
+                }
+              }
+            }
+          ]
+        });
+      }
+    }
+    return contents;
+  }
+  /**
+   * Get model configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Get model name
+   */
+  getName() {
+    return this.modelName;
+  }
+  /**
+   * Check if model supports tool calling
+   */
+  supportsToolCalling() {
+    const supportedModels = ["gpt-3.5-turbo", "gpt-4", "claude-3", "deepseek-chat", "gemini-pro", "gemini-1.5"];
+    return supportedModels.some((model) => this.config.model.includes(model));
+  }
+};
+
+// 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;
+  }
+  /**
+   * 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);
+  }
+  /**
+   * 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;
+  }
+  /**
+   * Update system prompt
+   */
+  updateSystem(system) {
+    this.messages = this.messages.filter((msg) => {
+      if (msg instanceof Message) {
+        return msg.role !== "system";
+      }
+      return msg.role !== "system";
+    });
+    this.currentTokens = 0;
+    if (system) {
+      const systemMessage = new Message("system", system);
+      this.messages.unshift(systemMessage);
+      this.currentTokens += this.estimateTokens(system);
+    }
+    for (const message of this.messages) {
+      if (message instanceof Message) {
+        if (message.role !== "system") {
+          this.currentTokens += this.estimateTokens(message.content);
+        }
+      } else {
+        const contentStr = message.content || JSON.stringify(message);
+        this.currentTokens += this.estimateTokens(contentStr);
+      }
+    }
+  }
+  /**
+   * Truncate history to fit context window
+   * Preserves tool call chains: assistant(with tool_calls) → tool messages
+   */
+  truncate() {
+    if (this.currentTokens <= this.contextWindowTokens) {
+      return;
+    }
+    let systemMessageIndex = -1;
+    for (let i2 = 0; i2 < this.messages.length; i2++) {
+      const msg = this.messages[i2];
+      if (msg instanceof Message && msg.role === "system" || msg.role === "system") {
+        systemMessageIndex = i2;
+        break;
+      }
+    }
+    const systemMessage = systemMessageIndex >= 0 ? this.messages[systemMessageIndex] : null;
+    const otherMessages = this.messages.filter((msg, index) => index !== systemMessageIndex);
+    const toolCallDependencies = /* @__PURE__ */ new Map();
+    for (let i2 = 0; i2 < otherMessages.length; i2++) {
+      const msg = otherMessages[i2];
+      const role = msg instanceof Message ? msg.role : msg.role;
+      if (role === "assistant" && !(msg instanceof Message)) {
+        const toolCalls = msg.tool_calls;
+        if (toolCalls && Array.isArray(toolCalls)) {
+          for (const tc of toolCalls) {
+            if (tc.id) {
+              toolCallDependencies.set(tc.id, i2);
+            }
+          }
+        }
+      }
+    }
+    const mustKeepIndices = /* @__PURE__ */ new Set();
+    for (let i2 = 0; i2 < otherMessages.length; i2++) {
+      const msg = otherMessages[i2];
+      const role = msg instanceof Message ? msg.role : msg.role;
+      if (role === "tool" && !(msg instanceof Message)) {
+        const toolCallId = msg.tool_call_id;
+        if (toolCallId) {
+          const assistantIndex = toolCallDependencies.get(toolCallId);
+          if (assistantIndex !== void 0) {
+            mustKeepIndices.add(assistantIndex);
+            mustKeepIndices.add(i2);
+          }
+        }
+      }
+    }
+    let i = 0;
+    while (this.currentTokens > this.contextWindowTokens && i < otherMessages.length) {
+      if (mustKeepIndices.has(i)) {
+        i++;
+        continue;
+      }
+      const msg = otherMessages[i];
+      const role = msg instanceof Message ? msg.role : msg.role;
+      let hasDependentToolMessages = false;
+      if (role === "assistant" && !(msg instanceof Message)) {
+        const toolCalls = msg.tool_calls;
+        if (toolCalls && Array.isArray(toolCalls)) {
+          for (const tc of toolCalls) {
+            if (tc.id) {
+              for (let j = i + 1; j < otherMessages.length; j++) {
+                const laterMsg = otherMessages[j];
+                const laterRole = laterMsg instanceof Message ? laterMsg.role : laterMsg.role;
+                if (laterRole === "tool" && !(laterMsg instanceof Message)) {
+                  const laterToolCallId = laterMsg.tool_call_id;
+                  if (laterToolCallId === tc.id) {
+                    hasDependentToolMessages = true;
+                    break;
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+      if (hasDependentToolMessages) {
+        i++;
+        continue;
+      }
+      const removed = otherMessages.splice(i, 1)[0];
+      if (removed) {
+        let contentStr = "";
+        if (removed instanceof Message) {
+          contentStr = removed.content;
+        } else {
+          contentStr = removed.content || JSON.stringify(removed);
+        }
+        this.currentTokens -= this.estimateTokens(contentStr);
+        const newMustKeepIndices = /* @__PURE__ */ new Set();
+        for (const idx of mustKeepIndices) {
+          if (idx > i) {
+            newMustKeepIndices.add(idx - 1);
+          } else if (idx < i) {
+            newMustKeepIndices.add(idx);
+          }
+        }
+        mustKeepIndices.clear();
+        for (const idx of newMustKeepIndices) {
+          mustKeepIndices.add(idx);
+        }
+      }
+    }
+    this.messages = [];
+    if (systemMessage) {
+      this.messages.push(systemMessage);
+    }
+    this.messages.push(...otherMessages);
+  }
+  /**
+   * Clear all messages except system
+   */
+  clear() {
+    let systemMessage;
+    for (const msg of this.messages) {
+      if (msg instanceof Message && msg.role === "system" || msg.role === "system") {
+        systemMessage = msg;
+        break;
+      }
+    }
+    this.messages = systemMessage ? [systemMessage] : [];
+    if (systemMessage) {
+      if (systemMessage instanceof Message) {
+        this.currentTokens = this.estimateTokens(systemMessage.content);
+      } else {
+        this.currentTokens = this.estimateTokens(systemMessage.content || JSON.stringify(systemMessage));
+      }
+    } else {
+      this.currentTokens = 0;
+    }
+  }
+  /**
+   * Get the last message
+   */
+  getLastMessage() {
+    return this.messages.length > 0 ? this.messages[this.messages.length - 1] : null;
+  }
+  /**
+   * Get message count
+   */
+  getMessageCount() {
+    return this.messages.length;
+  }
+  /**
+   * Get formatted context usage information
+   */
+  get formattedContextUsage() {
+    const usagePercent = this.currentTokens / this.contextWindowTokens * 100;
+    return `Tokens: ${this.currentTokens}/${this.contextWindowTokens} (${usagePercent.toFixed(1)}%)`;
+  }
+  /**
+   * Estimate tokens for text (simplified implementation)
+   */
+  estimateTokens(text) {
+    if (!text) return 0;
+    return Math.ceil(text.length / 4);
+  }
+  /**
+   * Get conversation as string
+   */
+  toString() {
+    return this.messages.map((msg) => {
+      if (msg instanceof Message) {
+        return msg.toString();
+      }
+      return JSON.stringify(msg);
+    }).join("\n");
+  }
+};
+
+// src/tools/toolcallManager.ts
+import { randomUUID as randomUUID2 } from "crypto";
+var ToolcallManager = class {
+  poolSize;
+  semaphore;
+  tasks = /* @__PURE__ */ new Set();
+  todo = /* @__PURE__ */ new Map();
+  done = /* @__PURE__ */ new Map();
+  failed = /* @__PURE__ */ new Map();
+  toolStores;
+  executedResults = [];
+  // Background process management
+  backgroundProcesses = /* @__PURE__ */ new Map();
+  monitorTasks = /* @__PURE__ */ new Map();
+  constructor(poolSize = 5, toolStore = []) {
+    this.poolSize = poolSize;
+    this.semaphore = { available: poolSize };
+    this.toolStores = toolStore;
+  }
+  /**
+   * Get executed results
+   */
+  getExecutedResults() {
+    return Array.from(this.done.values()).concat(Array.from(this.failed.values()));
+  }
+  /**
+   * Clear executed results
+   */
+  clear() {
+    this.todo.clear();
+    this.done.clear();
+    this.failed.clear();
+    this.executedResults = [];
+  }
+  /**
+   * Add tool calls to be executed
+   */
+  addToolcall(toolCall) {
+    if (Array.isArray(toolCall)) {
+      toolCall.forEach((tc) => {
+        this.todo.set(tc.toolCallId, tc);
+      });
+      logger.debug(`ToolcallManager: Added ${toolCall.length} toolcalls`);
+    } else {
+      this.todo.set(toolCall.toolCallId, toolCall);
+      logger.debug(`ToolcallManager: Added toolcall: ${toolCall.name}`);
+    }
+  }
+  /**
+   * Execute single task with pool control
+   */
+  async executeWithPool(toolcall) {
+    if (!toolcall || !toolcall.name) {
+      return;
+    }
+    if (!toolcall.isExtractedSuccess && toolcall.type === "user") {
+      this.failed.set(toolcall.toolCallId, toolcall);
+      return;
+    }
+    while (this.semaphore.available <= 0) {
+      await new Promise((resolve2) => setTimeout(resolve2, 100));
+    }
+    this.semaphore.available--;
+    try {
+      toolcall.executedState = "running";
+      let toolcallInputStr = JSON.stringify(toolcall.input);
+      if (toolcallInputStr.length > 200) {
+        toolcallInputStr = toolcallInputStr.substring(0, 100) + " ...(truncated by 100 characters)";
+      }
+      const toolcallDescription = `${toolcall.name}(${toolcallInputStr})`;
+      logger.debug(`\u5F00\u59CB\u6267\u884C\u4EFB\u52A1: ${toolcallDescription}`);
+      const result = await runWithManager(this, () => executeSingleTool(toolcall, this.toolStores));
+      const obs = result.executedResult();
+      if (typeof obs === "object" && "content" in obs) {
+        logger.debug(`Observation of ${toolcall.name}, tool_call_id: ${toolcall.toolCallId}:
+${obs.content}`);
+      } else {
+        logger.debug(`Observation of ${toolcall.name}:
+${obs}`);
+      }
+      if (result.executedState === "success") {
+        logger.debug(`\u4EFB\u52A1\u6267\u884C\u6210\u529F: ${toolcallDescription}`);
+        this.done.set(toolcall.toolCallId, result);
+      } else if (result.executedState === "failed") {
+        logger.error(`\u4EFB\u52A1\u6267\u884C\u5931\u8D25: ${toolcallDescription}, \u9519\u8BEF: ${result.executedContent || "Unknown error"}`);
+        this.failed.set(toolcall.toolCallId, result);
+      } else if (result.executedState === "running") {
+        logger.warn(`\u4EFB\u52A1\u6267\u884C\u4E2D: ${toolcallDescription}`);
+      } else {
+        logger.warn(`\u4EFB\u52A1\u6267\u884C\u72B6\u6001\u672A\u77E5: ${toolcallDescription}`);
+      }
+      const [backgroundProcessStatus, backgroundResult] = this.listBackgroundProcesses();
+      if (backgroundProcessStatus === "running" /* RUNNING */) {
+        if (typeof obs === "object" && "content" in obs) {
+          const newObs = { ...obs };
+          if (typeof backgroundResult === "string") {
+            newObs.content = `${newObs.content}
+
+${backgroundResult}`;
+          } else if (typeof backgroundResult === "object") {
+            newObs.content = `${newObs.content}
+
+background process observation: ${backgroundResult.content}`;
+          }
+          this.executedResults.push(newObs);
+        } else if (typeof obs === "string") {
+          if (typeof backgroundResult === "string") {
+            this.executedResults.push(obs + "\n\n" + backgroundResult);
+          } else {
+            this.executedResults.push(obs + "\n\nbackground process observation: " + backgroundResult.content);
+          }
+        } else {
+          this.executedResults.push(obs);
+        }
+      } else {
+        this.executedResults.push(obs);
+      }
+    } catch (error) {
+      logger.error(`\u4EFB\u52A1\u6267\u884C\u5F02\u5E38: ${toolcall.name}, \u9519\u8BEF: ${error}`);
+      toolcall.executedState = "failed";
+      toolcall.executedContent = String(error);
+      this.failed.set(toolcall.toolCallId, toolcall);
+      this.executedResults.push(toolcall.executedResult());
+    } finally {
+      this.semaphore.available++;
+    }
+  }
+  /**
+   * Execute all pending tasks (background execution, returns immediately)
+   */
+  async execute() {
+    const executionPromises = [];
+    for (const [toolcallId, toolcall] of this.todo) {
+      this.todo.delete(toolcallId);
+      const executionPromise = this.executeWithPool(toolcall);
+      this.tasks.add(executionPromise);
+      executionPromise.finally(() => {
+        this.tasks.delete(executionPromise);
+      });
+      executionPromises.push(executionPromise);
+    }
+    await Promise.all(executionPromises);
+    return this.executedResults;
+  }
+  /**
+   * Observe execution results
+   */
+  async observe(waitAll = false, timeout = null) {
+    await this.execute();
+    if (this.tasks.size > 0 && !waitAll) {
+      await new Promise((resolve2) => setTimeout(resolve2, 1e3));
+    }
+    if (waitAll && this.tasks.size > 0) {
+      if (timeout) {
+        try {
+          await Promise.race([
+            Promise.all(Array.from(this.tasks)),
+            new Promise((_, reject) => setTimeout(() => reject(new Error(`Timeout after ${timeout}ms`)), timeout * 1e3))
+          ]);
+        } catch (error) {
+          logger.warn(`\u7B49\u5F85\u4EFB\u52A1\u5B8C\u6210\u8D85\u65F6 (${timeout}\u79D2)\uFF0C\u5F53\u524D\u8FD8\u6709 ${this.tasks.size} \u4E2A\u4EFB\u52A1\u5728\u8FD0\u884C`);
+        }
+      } else {
+        await Promise.all(Array.from(this.tasks));
+      }
+    }
+    if (this.executedResults.length === 0) {
+      return "";
+    }
+    const results = [...this.executedResults];
+    this.clear();
+    return results;
+  }
+  /**
+   * Wait for all tasks to complete
+   */
+  async waitAll() {
+    if (this.tasks.size > 0) {
+      await Promise.all(Array.from(this.tasks));
+      logger.info("\u6240\u6709\u4EFB\u52A1\u5DF2\u5B8C\u6210");
+    }
+  }
+  /**
+   * Get current status
+   */
+  getStatus() {
+    return {
+      pool_size: this.poolSize,
+      running_tasks: this.tasks.size,
+      pending: this.todo.size,
+      done: this.done.size,
+      failed: this.failed.size,
+      background_processes: this.backgroundProcesses.size,
+      monitor_tasks: this.monitorTasks.size
+    };
+  }
+  /**
+   * Get pending tool call count
+   */
+  getPendingCount() {
+    return this.todo.size;
+  }
+  // Background process management methods
+  /**
+   * Register a background process
+   */
+  registerBackgroundProcess(process2, command, cwd) {
+    const processId = randomUUID2();
+    this.backgroundProcesses.set(processId, {
+      process: process2,
+      command,
+      pid: process2.pid,
+      cwd
+    });
+    const monitorTask = this.monitorProcess(processId, process2);
+    this.monitorTasks.set(processId, monitorTask);
+    logger.info(`\u6CE8\u518C\u540E\u53F0\u8FDB\u7A0B: ${command} (PID: ${process2.pid}, ID: ${processId})`);
+    return processId;
+  }
+  /**
+   * Monitor process until it ends
+   */
+  async monitorProcess(processId, process2) {
+    try {
+      await new Promise((resolve2, reject) => {
+        process2.on("exit", (code) => {
+          if (this.backgroundProcesses.has(processId)) {
+            const command = this.backgroundProcesses.get(processId).command;
+            this.backgroundProcesses.delete(processId);
+            logger.info(`\u540E\u53F0\u8FDB\u7A0B\u5DF2\u7ED3\u675F: ${command} (PID: ${process2.pid}, \u8FD4\u56DE\u7801: ${code})`);
+          }
+          if (this.monitorTasks.has(processId)) {
+            this.monitorTasks.delete(processId);
+          }
+          resolve2();
+        });
+        process2.on("error", (error) => {
+          reject(error);
+        });
+      });
+    } catch (error) {
+      logger.error(`\u76D1\u63A7\u8FDB\u7A0B ${processId} \u65F6\u53D1\u751F\u9519\u8BEF: ${error}`);
+      if (this.monitorTasks.has(processId)) {
+        this.monitorTasks.delete(processId);
+      }
+    }
+  }
+  /**
+   * Observe process stdout and stderr
+   */
+  async observeProcess(processId, timeout = 5) {
+    if (!this.backgroundProcesses.has(processId)) {
+      return `\u672A\u627E\u5230\u8FDB\u7A0BID: ${processId}`;
+    }
+    const info = this.backgroundProcesses.get(processId);
+    const process2 = info.process;
+    return `\u8FDB\u7A0BID: ${processId}
+\u547D\u4EE4: ${info.command}
+PID: ${info.pid}`;
+  }
+  /**
+   * Stop specified background process
+   */
+  async stopBackgroundProcess(processId, force = false) {
+    if (!this.backgroundProcesses.has(processId)) {
+      return `\u672A\u627E\u5230\u8FDB\u7A0BID: ${processId}`;
+    }
+    try {
+      const info = this.backgroundProcesses.get(processId);
+      if (!info) {
+        return `\u8FDB\u7A0BID ${processId} \u5DF2\u88AB\u79FB\u9664`;
+      }
+      const process2 = info.process;
+      const command = info.command;
+      if (process2.exitCode !== null) {
+        return `\u8FDB\u7A0B\u5DF2\u7ECF\u7ED3\u675F (\u8FD4\u56DE\u7801: ${process2.exitCode})
+\u547D\u4EE4: ${command}`;
+      }
+      if (force) {
+        process2.kill("SIGKILL");
+        logger.info(`\u5F3A\u5236\u6740\u6B7B\u540E\u53F0\u8FDB\u7A0B: ${command} (PID: ${process2.pid})`);
+      } else {
+        process2.kill("SIGTERM");
+        logger.info(`\u7EC8\u6B62\u540E\u53F0\u8FDB\u7A0B: ${command} (PID: ${process2.pid})`);
+      }
+      try {
+        await new Promise((resolve2) => {
+          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();
+          }, 5e3);
+          process2.on("exit", () => {
+            clearTimeout(timeoutId);
+            resolve2();
+          });
+        });
+      } catch (error) {
+        logger.error(`\u7B49\u5F85\u8FDB\u7A0B\u7ED3\u675F\u5931\u8D25: ${error}`);
+      }
+      if (this.monitorTasks.has(processId)) {
+        const task = this.monitorTasks.get(processId);
+        if (task) {
+          this.monitorTasks.delete(processId);
+        }
+      }
+      this.backgroundProcesses.delete(processId);
+      return `\u540E\u53F0\u8FDB\u7A0B\u5DF2\u505C\u6B62
+\u8FDB\u7A0BID: ${processId}
+\u547D\u4EE4: ${command}
+\u8FD4\u56DE\u7801: ${process2.exitCode}`;
+    } catch (error) {
+      logger.error(`\u505C\u6B62\u540E\u53F0\u8FDB\u7A0B ${processId} \u65F6\u53D1\u751F\u9519\u8BEF: ${error}`);
+      throw error;
+    }
+  }
+  /**
+   * Clean up all background processes
+   */
+  async cleanupBackgroundProcesses() {
+    if (this.backgroundProcesses.size === 0) {
+      return "\u6CA1\u6709\u9700\u8981\u6E05\u7406\u7684\u540E\u53F0\u8FDB\u7A0B";
+    }
+    const count = this.backgroundProcesses.size;
+    const processIds = Array.from(this.backgroundProcesses.keys());
+    const results = [];
+    for (const processId of processIds) {
+      try {
+        const result = await this.stopBackgroundProcess(processId);
+        results.push(result);
+      } catch (error) {
+        logger.error(`\u6E05\u7406\u540E\u53F0\u8FDB\u7A0B ${processId} \u65F6\u53D1\u751F\u9519\u8BEF: ${error}`);
+        results.push(`\u6E05\u7406\u8FDB\u7A0B ${processId} \u5931\u8D25: ${error}`);
+      }
+    }
+    return `\u5DF2\u6E05\u7406 ${count} \u4E2A\u540E\u53F0\u8FDB\u7A0B:
+` + results.join("\n---\n");
+  }
+  /**
+   * List all background processes
+   */
+  listBackgroundProcesses() {
+    if (this.backgroundProcesses.size === 0) {
+      return ["idle" /* IDLE */, "\u5F53\u524D\u6CA1\u6709\u8FD0\u884C\u7684\u540E\u53F0\u8FDB\u7A0B\u3002"];
+    }
+    const finishedIds = [];
+    for (const [processId, info] of this.backgroundProcesses) {
+      if (info.process.exitCode !== null) {
+        finishedIds.push(processId);
+      }
+    }
+    for (const processId of finishedIds) {
+      this.backgroundProcesses.delete(processId);
+    }
+    if (this.backgroundProcesses.size === 0) {
+      return ["idle" /* IDLE */, "\u5F53\u524D\u6CA1\u6709\u8FD0\u884C\u7684\u540E\u53F0\u8FDB\u7A0B\u3002"];
+    }
+    const result = `\u5F53\u524D\u6709 ${this.backgroundProcesses.size} \u4E2A\u540E\u53F0\u8FDB\u7A0B:
+` + Array.from(this.backgroundProcesses.values()).map((process2) => `PID: ${process2.pid}, Command: ${process2.command}
+`).join("");
+    return ["running" /* RUNNING */, result];
+  }
+  /**
+   * Async context manager entry
+   */
+  async enter() {
+    return this;
+  }
+  /**
+   * Async context manager exit, clean up all resources
+   */
+  async exit() {
+    await this.cleanupBackgroundProcesses();
+    await this.waitAll();
+  }
+};
+
+// 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>
+
+
+### Analytical Tasks Output Format
+<Analytical Tasks Purpose>Understand, Diagnose & Evaluate Existing Information</Analytical Tasks Purpose> 
+
+<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>
+
+<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.
+
+</Analytical Tasks Output Format>
+
+### Operational Tasks Output Format
+
+<Operational Tasks Purpose>Act & Operate Tools</Operational Tasks Purpose> 
+
+<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>
+
+<Operational Tasks Output Format>
+You should follow the format below, replace the <ToolName.method_name> and <args_name> with the actual name.
+
+<ToolName.method_name><args_name1>args_value1</args_name1><args_name2>args_value2</args_name2>...</ToolName.method_name>
+</Operational Tasks Output Format>
+
+**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>
+`;
+var SYSTEM_TOOLS_PROMPT = `
+## System Tools And System Tools Call Format
+
+System 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.
+
+### Available System Tools
+{availableSystemTools}
+
+### Description of Available System Tools
+{descOfSystemTools}
+
+### System Tools Output Format
+{outputFormat}
+`;
+
+// src/agent.ts
+var Agent = class {
+  name;
+  profile;
+  system;
+  tools;
+  functionCallingTools = [];
+  mcpServerNames;
+  modelConfig;
+  verbose;
+  model;
+  history;
+  subAgents = [];
+  toolcallManagerPoolSize;
+  postProcessor;
+  useFunctionCalling;
+  constructor(config2) {
+    const {
+      name,
+      profile,
+      system,
+      tools: tools2 = [],
+      subAgents = [],
+      mcpServerNames = [],
+      modelConfig,
+      verbose = false,
+      useFunctionCalling = false,
+      postProcessor = null,
+      toolcallManagerPoolSize = 5
+    } = config2;
+    this.name = name;
+    this.profile = profile;
+    this.verbose = verbose;
+    this.modelConfig = modelConfig || "deepseek";
+    this.subAgents = subAgents || [];
+    this.postProcessor = postProcessor;
+    this.useFunctionCalling = useFunctionCalling;
+    const agentToolNames = registerAgentAsTool(this.subAgents, Boolean(this.verbose));
+    this.tools = [...tools2, ...agentToolNames];
+    this.mcpServerNames = mcpServerNames;
+    const systemPrompt = system || profile || "";
+    this.system = this.tools.length > 0 ? this.setSystem(systemPrompt, this.tools) : systemPrompt;
+    this.model = new Model(this.modelConfig);
+    const modelNameForHistory = typeof this.modelConfig === "string" ? this.modelConfig : this.modelConfig.model || "deepseek";
+    this.history = new MessageHistory(modelNameForHistory, this.system, this.model.getConfig().contextWindowTokens);
+    if (this.useFunctionCalling) {
+      this.functionCallingTools = this.setFunctionCallingTools(this.tools);
+    }
+    if (this.verbose) {
+      logger.info(`
+========== [${this.name}] System Prompt ==========`);
+      logger.info(this.system);
+      logger.info(`========================================
+`);
+      if (typeof this.verbose === "number" && this.verbose > 1) {
+        logger.info(`[${this.name}] Tools: ${this.tools.join(", ")}`);
+        logger.info("");
+      }
+    }
+    this.toolcallManagerPoolSize = toolcallManagerPoolSize;
+  }
+  /**
+   * Get the current system prompt
+   */
+  get systemPrompt() {
+    return this.system;
+  }
+  /**
+   * Set the system prompt and update history
+   */
+  set systemPrompt(value) {
+    this.system = value;
+    if (this.history) {
+      this.history.updateSystem(value);
+    }
+  }
+  /**
+   * Set the system prompt with system tools descriptions
+   * @private
+   */
+  setSystem(system, systemTools) {
+    let toolDescriptions = "";
+    for (const tool of systemTools) {
+      if (SystemToolStore.hasTool(tool)) {
+        const toolDesc = SystemToolStore.getTool(tool);
+        toolDescriptions += (toolDesc?.desc || "") + "\n\n";
+      }
+    }
+    if (systemTools.length > 0) {
+      const availableSystemTools = systemTools.map((t) => `- ${t}`).join("\n");
+      return system + "\n" + SYSTEM_TOOLS_PROMPT.replace("{availableSystemTools}", availableSystemTools).replace("{descOfSystemTools}", toolDescriptions).replace("{outputFormat}", OUTPUT_FORMAT_PROMPT);
+    }
+    return system;
+  }
+  /**
+   * Set up function calling tools for OpenAI-style function calling
+   * @private
+   */
+  setFunctionCallingTools(tools2) {
+    const openaiToolCalls = [];
+    for (let tool of tools2) {
+      tool = tool.replace(".", "-");
+      if (!FunctionCallingStore.hasTool(tool)) {
+        logger.warn(`Tool ${tool} not registered in FunctionCallingStore.`);
+      } else {
+        const toolSchema = FunctionCallingStore.getToolcallSchema(tool, "openai");
+        if (toolSchema && Object.keys(toolSchema).length > 0) {
+          openaiToolCalls.push(toolSchema);
+        }
+      }
+    }
+    return openaiToolCalls;
+  }
+  /**
+   * Agent loop - processes user input and handles tool calls
+   * @private
+   */
+  async _agentLoop(instruction, images) {
+    const instructionMsg = Message.fromUserMsg(instruction, images);
+    this.history.addMessage(instructionMsg);
+    if (this.verbose) {
+      logger.info(`
+[${this.name}] Received: ${instruction}`);
+    }
+    while (true) {
+      this.history.truncate();
+      if (typeof this.verbose === "number" && this.verbose > 2) {
+        logger.debug(
+          `History raw messages before extract toolcall messages:
+ ${JSON.stringify(await this.history.formatForApi())}`
+        );
+      }
+      const response = await this.model.achat(
+        await this.history.formatForApi(),
+        this.useFunctionCalling ? this.functionCallingTools : void 0
+      );
+      const systemToolcallResponses = response.filter((r) => r.type === "system").map((r) => r.extractedResult()).filter((r) => typeof r === "string");
+      if (systemToolcallResponses.length > 0) {
+        const systemToolcallResponse = systemToolcallResponses.join("\n");
+        this.history.addMessage("assistant", systemToolcallResponse);
+      }
+      const userToolcallMessages = response.filter((r) => r.type === "user").map((r) => r.extractedResult());
+      if (userToolcallMessages.length > 0) {
+        const userToolcallMessagesFlattened = [];
+        for (const item of userToolcallMessages) {
+          if (Array.isArray(item)) {
+            userToolcallMessagesFlattened.push(...item);
+          } else {
+            userToolcallMessagesFlattened.push(item);
+          }
+        }
+        for (const toolcall of userToolcallMessagesFlattened) {
+          this.history.addMessage(toolcall);
+        }
+      }
+      if (typeof this.verbose === "number" && this.verbose > 1) {
+        const messages = await this.history.formatForApi();
+        const last3 = messages.slice(-3);
+        logger.debug(`History raw messages after extract toolcall messages (last 3):
+ ${JSON.stringify(last3)}`);
+      }
+      logger.debug(`History usage: ${this.history.formattedContextUsage}`);
+      const toolcallManager = new ToolcallManager(this.toolcallManagerPoolSize, [SystemToolStore, FunctionCallingStore]);
+      const allToolCalls = [];
+      const systemToolMap = {};
+      const systemToolNames = SystemToolStore.listTools();
+      for (const name of systemToolNames) {
+        const tool = SystemToolStore.getTool(name);
+        if (tool) {
+          systemToolMap[name] = tool;
+        }
+      }
+      for (const r of response) {
+        const result = r.extractedResult();
+        if (typeof result === "string") {
+          if (result.trim().length > 0) {
+            const extracted = extractToolcallsFromStr(result, systemToolMap);
+            allToolCalls.push(...extracted);
+          }
+        } else if (typeof result === "object" && result !== null) {
+          if (!Array.isArray(result) && result.role === "assistant" && result.tool_calls && Array.isArray(result.tool_calls)) {
+            for (const tc of result.tool_calls) {
+              if (tc.type === "function" && tc.function) {
+                let args = {};
+                try {
+                  args = JSON.parse(tc.function.arguments);
+                } catch (e) {
+                  logger.warn(`Failed to parse arguments for tool ${tc.function.name}: ${tc.function.arguments}`);
+                  args = { raw_args: tc.function.arguments };
+                }
+                allToolCalls.push(
+                  new Toolcall({
+                    name: tc.function.name,
+                    input: args,
+                    toolCallId: tc.id,
+                    type: "user",
+                    rawContentFromLlm: tc.function.arguments
+                  })
+                );
+              }
+            }
+          } else if (Array.isArray(result)) {
+            for (const item of result) {
+              if (item.type === "function" && item.function) {
+                let args = {};
+                try {
+                  args = JSON.parse(item.function.arguments);
+                } catch (e) {
+                  logger.warn(`Failed to parse arguments for tool ${item.function.name}: ${item.function.arguments}`);
+                  args = { raw_args: item.function.arguments };
+                }
+                allToolCalls.push(
+                  new Toolcall({
+                    name: item.function.name,
+                    input: args,
+                    toolCallId: item.id,
+                    type: "user",
+                    rawContentFromLlm: item.function.arguments
+                  })
+                );
+              } else if (item.type === "tool_use") {
+                allToolCalls.push(
+                  new Toolcall({
+                    name: item.name,
+                    input: item.input,
+                    toolCallId: item.id,
+                    type: "user"
+                  })
+                );
+              }
+            }
+          }
+        }
+      }
+      if (allToolCalls.length > 0) {
+        toolcallManager.addToolcall(allToolCalls);
+        const obs = await toolcallManager.observe(true, 60);
+        if (Array.isArray(obs)) {
+          for (const item of obs) {
+            if (typeof item === "object") {
+              this.history.addMessage(item);
+            } else if (typeof item === "string") {
+              this.history.addMessage("user", item);
+            }
+          }
+        } else if (typeof obs === "string") {
+          this.history.addMessage("user", obs);
+        } else if (typeof obs === "object") {
+          this.history.addMessage(obs);
+        } else {
+          logger.warn(`Unknown observation type: ${typeof obs}`);
+        }
+      } else {
+        for (const r of response) {
+          if (r.type === "system") {
+            const result = r.extractedResult();
+            if (typeof result === "string") {
+              const cleanResult = result.replace(/<TaskCompletion>/g, "").replace(/<\/TaskCompletion>/g, "").trim();
+              return cleanResult;
+            }
+          }
+        }
+        return "";
+      }
+    }
+  }
+  /**
+   * Run the agent with given instruction
+   */
+  async run(instruction, images) {
+    const stack = new AsyncExitStack();
+    try {
+      for (const serverName of this.mcpServerNames) {
+        await FunctionCallingStore.addMcpTools?.(this.name, serverName, stack);
+        const mcpTools = FunctionCallingStore.getMcpToolsSchemas?.(this.name, serverName, "openai") || [];
+        if (this.verbose) {
+          logger.info(`[${this.name}] Loaded MCP tools from ${serverName}: ${mcpTools.length} tools found.`);
+          if (typeof this.verbose === "number" && this.verbose > 1) {
+            logger.info(`[${this.name}] MCP tools sample: ${JSON.stringify(mcpTools).substring(0, 200)} ...`);
+          }
+        }
+        if (this.useFunctionCalling) {
+          this.functionCallingTools.push(...mcpTools);
+        }
+      }
+      const responseText = await this._agentLoop(instruction, images);
+      if (this.postProcessor) {
+        try {
+          return await this.postProcessor(responseText);
+        } catch (error) {
+          logger.error(`Post-processor error in agent ${this.name}:`, error);
+          throw new Error(`Post-processor failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+      }
+      return responseText;
+    } catch (error) {
+      logger.error(`Agent ${this.name} execution error:`);
+      logger.error(error);
+      if (error instanceof Error) {
+        logger.error(`Error message: ${error.message}`);
+        logger.error(`Error stack: ${error.stack}`);
+      }
+      throw error;
+    } finally {
+      await stack.close();
+    }
+  }
+  /**
+   * Get agent profile
+   */
+  getProfile() {
+    return this.profile;
+  }
+  /**
+   * Get tools
+   */
+  getTools() {
+    return [...this.tools];
+  }
+  /**
+   * Get function calling tools schemas
+   */
+  getFunctionCallingTools() {
+    return [...this.functionCallingTools];
+  }
+  /**
+   * Get MCP server names
+   */
+  getMcpServerNames() {
+    return [...this.mcpServerNames];
+  }
+  /**
+   * Get model config (string or ModelConfig object)
+   */
+  getModelConfig() {
+    return this.modelConfig;
+  }
+  /**
+   * Get model name (for backward compatibility)
+   */
+  getModelName() {
+    if (typeof this.modelConfig === "string") {
+      return this.modelConfig;
+    }
+    return this.modelConfig.model || "deepseek";
+  }
+  /**
+   * Get verbose setting
+   */
+  getVerbose() {
+    return this.verbose;
+  }
+  /**
+   * Get sub-agents
+   */
+  getSubAgents() {
+    return [...this.subAgents];
+  }
+};
+
+// src/environment/base.ts
+var BaseEnvironment = class {
+  /**
+   * List of agents in the environment
+   */
+  agents = [];
+  /**
+   * Assign skills to agent with their names
+   */
+  agentSkills = {};
+  constructor(agents = [], agentSkills = {}) {
+    this.agents = agents;
+    this.agentSkills = agentSkills;
+    this.setAgentSkills();
+  }
+  /**
+   * Set agent skills after initialization
+   */
+  setAgentSkills() {
+    if (this.agents.length === 0 || Object.keys(this.agentSkills).length === 0) {
+      return;
+    }
+    const skiller = new SkillsTool(SKILLS_DIR);
+    if ("all" in this.agentSkills) {
+      for (const agent of this.agents) {
+        this.agentSkills[agent.name] = this.agentSkills["all"];
+      }
+      delete this.agentSkills["all"];
+    }
+    logger.debug(`Assigning skills to agents: ${JSON.stringify(this.agentSkills)}`);
+    for (const [agentName, skillNames] of Object.entries(this.agentSkills)) {
+      for (const agent of this.agents) {
+        if (agent.name === agentName) {
+          const skillDescriptions = [];
+          (async () => {
+            for (const skillName of skillNames) {
+              try {
+                const skillDescription2 = await skiller.readSkillDescription(skillName);
+                skillDescriptions.push(skillDescription2);
+              } catch (error) {
+                logger.warn(`Failed to read skill description for ${skillName}:`, error);
+              }
+            }
+            const skillDescription = "\n--- <SKILLS START> ---\n" + skillDescriptions.join("\n-----\n") + "\n--- <SKILLS END> ---\n";
+            agent.systemPrompt = agent.systemPrompt + skillDescription;
+          })();
+        }
+      }
+    }
+  }
+  /**
+   * Check if instruction has agent name
+   */
+  hasAgentName(instruction) {
+    if (!instruction.includes("@")) {
+      return false;
+    }
+    for (const agent of this.agents) {
+      if (instruction.includes(`@${agent.name}`)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Post process instruction
+   */
+  postProcessInstruction(instruction, agentNames) {
+    if (["/q", "exit", "quit"].includes(instruction.toLowerCase()) || agentNames.length === 0) {
+      return ["quit" /* QUIT */, instruction];
+    }
+    if (agentNames.length === 1) {
+      return ["valid" /* VALID */, `${instruction}@${agentNames[0]}`];
+    }
+    if (instruction.includes("@all")) {
+      return ["sendToAll" /* SEND_TO_ALL */, instruction];
+    }
+    if (this.hasAgentName(instruction)) {
+      return ["valid" /* VALID */, instruction];
+    }
+    return ["noAvailableAgentName" /* NO_AVAILABLE_AGENT_NAME */, instruction];
+  }
+  /**
+   * 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.");
+      return;
+    }
+    const [instructionType, processedInstruction] = this.postProcessInstruction(
+      goal,
+      this.agents.map((agent) => agent.name)
+    );
+    if (instructionType === "quit" /* QUIT */) {
+      logger.info("Invalid goal instruction.");
+      return;
+    }
+    if (instructionType === "noAvailableAgentName" /* NO_AVAILABLE_AGENT_NAME */) {
+      logger.warn("No available agent name in instruction. Please provide instruction with '@agent_name'.");
+      return;
+    }
+    logger.info("Goal:", goal);
+    logger.info("Processing goal...\n");
+    for (const agent of this.agents) {
+      if (instructionType === "sendToAll" /* SEND_TO_ALL */ || processedInstruction.includes(`@${agent.name}`)) {
+        try {
+          const response = await agent.run(processedInstruction);
+          logger.info(`
+> Agent ${agent.name} completed the goal.`);
+          logger.info(`Final response: ${response}`);
+        } catch (error) {
+          logger.error(`Error running agent ${agent.name}:`, error);
+        }
+      }
+    }
+  }
+  /**
+   * Run the environment (interactive mode)
+   */
+  async run() {
+    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);
+      });
+    };
+    try {
+      while (true) {
+        try {
+          let instruction;
+          if (this.agents.length === 0) {
+            logger.error("No agents in the environment.");
+            break;
+          } else if (this.agents.length === 1) {
+            instruction = await question("Enter your instruction (or '/q' to quit): ");
+          } else {
+            const agentNames = this.agents.map((agent) => agent.name).join(", ");
+            instruction = await question(
+              `Enter your instruction with '@agent_name' (or '/q' to quit), available agents: ${agentNames}: `
+            );
+          }
+          const [instructionType, processedInstruction] = this.postProcessInstruction(
+            instruction,
+            this.agents.map((agent) => agent.name)
+          );
+          if (instructionType === "quit" /* QUIT */) {
+            logger.info("Quitting...");
+            break;
+          } else if (instructionType === "noAvailableAgentName" /* NO_AVAILABLE_AGENT_NAME */) {
+            logger.warn("No available agent name in instruction. Please enter your instruction with '@agent_name'.");
+            continue;
+          }
+          logger.info("Processing your request...");
+          for (const agent of this.agents) {
+            if (instructionType === "sendToAll" /* SEND_TO_ALL */ || processedInstruction.includes(`@${agent.name}`)) {
+              const response = await agent.run(processedInstruction);
+              logger.info(`Agent ${agent.name} response:`, response);
+            }
+          }
+        } catch (error) {
+          logger.error("Error processing instruction:", error);
+        }
+      }
+    } finally {
+      rl.close();
+    }
+  }
+};
+
+// src/environment/coding.ts
+import * as fs8 from "fs";
+var CodingEnvironment = class extends BaseEnvironment {
+  /**
+   * Workspace directory
+   */
+  workspaceDir = "";
+  constructor(agents = [], agentSkills = {}, workspaceDir = "") {
+    super(agents, agentSkills);
+    this.workspaceDir = workspaceDir;
+    this.setWorkspaceDir();
+  }
+  /**
+   * Set workspace directory after initialization
+   */
+  setWorkspaceDir() {
+    if (!this.workspaceDir) {
+      this.workspaceDir = WORKSPACE_DIR;
+    }
+    if (!fs8.existsSync(this.workspaceDir)) {
+      fs8.mkdirSync(this.workspaceDir, { recursive: true });
+    } else {
+      logger.debug(`Workspace directory already exists: ${this.workspaceDir}`);
+    }
+    for (const agent of this.agents) {
+      if (!agent.systemPrompt.includes(this.workspaceDir)) {
+        agent.systemPrompt = agent.systemPrompt + `
+
+Your workspace directory is: <workspace>${this.workspaceDir}</workspace>
+
+**Note**: your any output files must be saved in ${this.workspaceDir}`;
+      }
+    }
+    logger.debug(`Setting workspace directory: ${this.workspaceDir}`);
+    for (const agent of this.agents) {
+      logger.debug(`Agent ${agent.name} system: ${agent.systemPrompt}`);
+    }
+  }
+};
+export {
+  Agent,
+  ApiTool,
+  BaseEnvironment,
+  CodingEnvironment,
+  CommandLineTool,
+  DEFAULT_CONFIG,
+  DEFAULT_SETTINGS,
+  ENV_VARS,
+  ERROR_MESSAGES,
+  EvoltError,
+  ExtendStateMachineTool,
+  FileEditor,
+  FunctionCallingStore,
+  GitTool,
+  LOG_LEVELS,
+  MESSAGE_ROLES,
+  Message,
+  MessageHistory,
+  Model,
+  ModelError,
+  ReflectTool,
+  Reply2HumanTool,
+  SKILLS_DIR,
+  SkillsTool,
+  SystemToolStore,
+  TOOL_CALL_TYPES,
+  TOOL_CONSTANTS,
+  ThinkTool,
+  TodoListTool,
+  ToolExecutionError,
+  Toolcall,
+  UserToolStore,
+  WORKSPACE_DIR,
+  WriteUIDesignDocument,
+  ensureDir,
+  fileExists,
+  getCacheDir,
+  getConfigDir,
+  getConfigPath2 as getConfigPath,
+  getFileExtension,
+  getLogsDir,
+  getSettings,
+  getSkillsDir,
+  getTempFilePath,
+  getWorkspaceDir,
+  getWorkspacePath,
+  initializeSettings,
+  isInWorkspace,
+  loadModelConfig,
+  logger_default as logger,
+  normalizePath,
+  registerAgentAsTool,
+  settings,
+  tools,
+  updateSettings
+};
+//# sourceMappingURL=index.js.map