@lov3kaizen/agentsea-core 0.5.1 → 0.6.0

package/dist/index.mjs

@@ -88,6 +88,7 @@ __export(index_exports, {
   calculatorServer: () => calculatorServer,
   calculatorTool: () => calculatorTool,
   clientTool: () => clientTool,
+  codeEditTool: () => codeEditTool,
   createACPTools: () => createACPTools,
   createAnthropicProvider: () => createAnthropicProvider,
   createGeminiProvider: () => createGeminiProvider,
@@ -103,8 +104,16 @@ __export(index_exports, {
   fileListTool: () => fileListTool,
   fileReadTool: () => fileReadTool,
   fileWriteTool: () => fileWriteTool,
+  gitAddTool: () => gitAddTool,
+  gitBranchTool: () => gitBranchTool,
+  gitCommitTool: () => gitCommitTool,
+  gitDiffTool: () => gitDiffTool,
+  gitLogTool: () => gitLogTool,
+  gitStatusTool: () => gitStatusTool,
+  globTool: () => globTool,
   globalMetrics: () => globalMetrics,
   globalTracer: () => globalTracer,
+  grepTool: () => grepTool,
   httpRequestTool: () => httpRequestTool,
   hybridTool: () => hybridTool,
   mcpToolToAgenticTool: () => mcpToolToAgenticTool,
@@ -114,6 +123,7 @@ __export(index_exports, {
   n8nListWorkflowsTool: () => n8nListWorkflowsTool,
   n8nTriggerWebhookTool: () => n8nTriggerWebhookTool,
   serverTool: () => serverTool,
+  shellExecuteTool: () => shellExecuteTool,
   stringTransformTool: () => stringTransformTool,
   textSummaryTool: () => textSummaryTool,
   toLegacyTool: () => toLegacyTool,
@@ -1443,17 +1453,551 @@ async function pollExecutionStatus(executionId, apiKey, baseUrl, maxAttempts = 3
   );
 }
 
-// src/tools/built-in/calculator.isomorphic.ts
+// src/tools/built-in/shell.tool.ts
+import { execSync } from "child_process";
+import { z as z7 } from "zod";
+var MAX_OUTPUT_BYTES = 100 * 1024;
+var DEFAULT_TIMEOUT_MS = 3e4;
+var MAX_TIMEOUT_MS = 12e4;
+var DANGEROUS_PATTERNS = [
+  /\brm\s+-[^\s]*r[^\s]*f[^\s]*\s+\/\s*$/,
+  // rm -rf /
+  /\brm\s+-[^\s]*f[^\s]*r[^\s]*\s+\/\s*$/,
+  // rm -fr /
+  /\bmkfs\b/,
+  // mkfs (format disk)
+  /:(){ :\|:& };:/,
+  // fork bomb
+  /\bdd\b.*\bof=\/dev\//,
+  // dd to device
+  /\b>\s*\/dev\/sd[a-z]/,
+  // redirect to raw device
+  /\bchmod\s+-R\s+777\s+\//,
+  // chmod -R 777 /
+  /\bchown\s+-R\s+.*\s+\/\s*$/
+  // chown -R ... /
+];
+var shellExecuteTool = {
+  name: "shell_execute",
+  description: "Execute a shell command and return stdout/stderr. Commands are checked against a safety blocklist. Non-zero exit codes return results (not errors) since tools like grep exit 1 on no matches.",
+  parameters: z7.object({
+    command: z7.string().describe("The shell command to execute"),
+    cwd: z7.string().optional().describe(
+      "Working directory for the command (defaults to process.cwd())"
+    ),
+    timeout: z7.number().min(1e3).max(MAX_TIMEOUT_MS).default(DEFAULT_TIMEOUT_MS).describe("Timeout in milliseconds (default 30s, max 120s)")
+  }),
+  execute: (params) => {
+    for (const pattern of DANGEROUS_PATTERNS) {
+      if (pattern.test(params.command)) {
+        throw new Error(
+          `Command blocked by safety filter: matches dangerous pattern. If you need to run this command, please do so directly in your terminal.`
+        );
+      }
+    }
+    const timeout = Math.min(params.timeout, MAX_TIMEOUT_MS);
+    try {
+      const output = execSync(params.command, {
+        cwd: params.cwd || process.cwd(),
+        timeout,
+        encoding: "utf8",
+        maxBuffer: MAX_OUTPUT_BYTES * 2,
+        // allow some headroom
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      const truncated = output.length > MAX_OUTPUT_BYTES;
+      const content = truncated ? output.slice(0, MAX_OUTPUT_BYTES) + "\n... [output truncated at 100KB]" : output;
+      return Promise.resolve({
+        exitCode: 0,
+        stdout: content,
+        stderr: "",
+        truncated
+      });
+    } catch (error) {
+      const execError = error;
+      if (execError.killed || execError.signal) {
+        throw new Error(`Shell execution timed out after ${timeout}ms`);
+      }
+      if (execError.status !== void 0 && execError.status !== null) {
+        const stdout = String(execError.stdout || "");
+        const stderr = String(execError.stderr || "");
+        const truncated = stdout.length > MAX_OUTPUT_BYTES;
+        return Promise.resolve({
+          exitCode: execError.status,
+          stdout: truncated ? stdout.slice(0, MAX_OUTPUT_BYTES) + "\n... [output truncated at 100KB]" : stdout,
+          stderr: stderr.slice(0, MAX_OUTPUT_BYTES),
+          truncated
+        });
+      }
+      throw new Error(
+        `Shell execution failed: ${execError.message || String(error)}`
+      );
+    }
+  }
+};
+
+// src/tools/built-in/code-edit.tool.ts
+import { promises as fs2 } from "fs";
 import { z as z8 } from "zod";
+var codeEditTool = {
+  name: "code_edit",
+  description: "Edit a file by replacing an exact string match with new content. Uses literal string matching (not regex). Set oldString to empty and newString to content to insert at the beginning of the file. Set newString to empty to delete the matched text.",
+  parameters: z8.object({
+    path: z8.string().describe("Path to the file to edit"),
+    oldString: z8.string().describe(
+      "The exact string to find and replace. Must match file content exactly including whitespace and indentation."
+    ),
+    newString: z8.string().describe(
+      "The replacement string. Use empty string to delete the matched text."
+    ),
+    expectedReplacements: z8.number().int().min(1).default(1).describe(
+      "Expected number of occurrences to replace. Fails if actual count differs. Defaults to 1."
+    )
+  }),
+  execute: async (params) => {
+    try {
+      const content = await fs2.readFile(params.path, "utf8");
+      if (params.oldString === "") {
+        const newContent2 = params.newString + content;
+        await fs2.writeFile(params.path, newContent2, "utf8");
+        return {
+          success: true,
+          path: params.path,
+          replacements: 1,
+          message: "Content inserted at beginning of file"
+        };
+      }
+      let count = 0;
+      let searchFrom = 0;
+      let idx = content.indexOf(params.oldString, searchFrom);
+      while (idx !== -1) {
+        count++;
+        searchFrom = idx + params.oldString.length;
+        idx = content.indexOf(params.oldString, searchFrom);
+      }
+      if (count === 0) {
+        throw new Error(
+          `String not found in ${params.path}. Make sure the oldString matches exactly, including whitespace and indentation.`
+        );
+      }
+      if (count !== params.expectedReplacements) {
+        throw new Error(
+          `Expected ${params.expectedReplacements} occurrence(s) of the string, but found ${count} in ${params.path}. Provide more context in oldString to make the match unique, or set expectedReplacements to ${count}.`
+        );
+      }
+      const newContent = content.split(params.oldString).join(params.newString);
+      await fs2.writeFile(params.path, newContent, "utf8");
+      return {
+        success: true,
+        path: params.path,
+        replacements: count,
+        message: `Replaced ${count} occurrence(s)`
+      };
+    } catch (error) {
+      if (error instanceof Error) {
+        throw new Error(`Code edit failed: ${error.message}`);
+      }
+      throw error;
+    }
+  }
+};
+
+// src/tools/built-in/glob.tool.ts
+import { promises as fs3 } from "fs";
+import fg from "fast-glob";
+import { z as z9 } from "zod";
+var DEFAULT_IGNORE = [
+  "**/node_modules/**",
+  "**/dist/**",
+  "**/.git/**",
+  "**/.next/**",
+  "**/coverage/**",
+  "**/.cache/**",
+  "**/build/**"
+];
+var globTool = {
+  name: "glob",
+  description: "Find files matching a glob pattern. Returns file paths sorted by modification time (newest first). Ignores node_modules, dist, .git, .next, coverage, .cache, and build directories by default.",
+  parameters: z9.object({
+    pattern: z9.string().describe(
+      'Glob pattern to match (e.g., "**/*.ts", "src/**/*.{ts,tsx}", "*.json")'
+    ),
+    cwd: z9.string().optional().describe("Directory to search in (defaults to process.cwd())"),
+    ignore: z9.array(z9.string()).optional().describe("Additional patterns to ignore"),
+    maxResults: z9.number().int().min(1).max(1e4).default(1e3).describe("Maximum number of results to return (default 1000)")
+  }),
+  execute: async (params) => {
+    try {
+      const cwd = params.cwd || process.cwd();
+      const ignorePatterns = [...DEFAULT_IGNORE, ...params.ignore || []];
+      const files = await fg(params.pattern, {
+        cwd,
+        ignore: ignorePatterns,
+        absolute: true,
+        dot: false,
+        onlyFiles: true
+      });
+      const withStats = await Promise.all(
+        files.map(async (filePath) => {
+          try {
+            const stats = await fs3.stat(filePath);
+            return { path: filePath, mtime: stats.mtimeMs };
+          } catch {
+            return { path: filePath, mtime: 0 };
+          }
+        })
+      );
+      withStats.sort((a, b) => b.mtime - a.mtime);
+      const limited = withStats.slice(0, params.maxResults);
+      return {
+        files: limited.map((f) => f.path),
+        count: limited.length,
+        totalMatches: files.length,
+        truncated: files.length > params.maxResults
+      };
+    } catch (error) {
+      if (error instanceof Error) {
+        throw new Error(`Glob failed: ${error.message}`);
+      }
+      throw error;
+    }
+  }
+};
+
+// src/tools/built-in/grep.tool.ts
+import { promises as fs4 } from "fs";
+import { join as join2, relative } from "path";
+import { z as z10 } from "zod";
+var MAX_FILE_SIZE = 5 * 1024 * 1024;
+var DEFAULT_IGNORE_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  "dist",
+  ".git",
+  ".next",
+  "coverage",
+  ".cache",
+  "build",
+  "__pycache__",
+  ".venv"
+]);
+async function walkDir(dir, includePattern) {
+  const results = [];
+  const entries = await fs4.readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (DEFAULT_IGNORE_DIRS.has(entry.name)) continue;
+    if (entry.name.startsWith(".") && entry.name !== ".env.example") continue;
+    const fullPath = join2(dir, entry.name);
+    if (entry.isDirectory()) {
+      const subResults = await walkDir(fullPath, includePattern);
+      results.push(...subResults);
+    } else if (entry.isFile()) {
+      if (includePattern && !includePattern.test(entry.name)) continue;
+      results.push(fullPath);
+    }
+  }
+  return results;
+}
+async function searchFile(filePath, regex, contextLines) {
+  const stats = await fs4.stat(filePath);
+  if (stats.size > MAX_FILE_SIZE) return [];
+  const content = await fs4.readFile(filePath, "utf8");
+  const lines = content.split("\n");
+  const matches = [];
+  for (let i = 0; i < lines.length; i++) {
+    regex.lastIndex = 0;
+    if (regex.test(lines[i])) {
+      const match = {
+        file: filePath,
+        line: i + 1,
+        content: lines[i]
+      };
+      if (contextLines > 0) {
+        const beforeStart = Math.max(0, i - contextLines);
+        match.contextBefore = lines.slice(beforeStart, i);
+        const afterEnd = Math.min(lines.length, i + 1 + contextLines);
+        match.contextAfter = lines.slice(i + 1, afterEnd);
+      }
+      matches.push(match);
+    }
+  }
+  return matches;
+}
+var grepTool = {
+  name: "grep",
+  description: "Search for a regex pattern across files recursively. Skips files larger than 5MB and ignores common non-source directories. Returns matching lines with optional context.",
+  parameters: z10.object({
+    pattern: z10.string().describe("Regex pattern to search for"),
+    path: z10.string().optional().describe("Directory or file to search in (defaults to process.cwd())"),
+    include: z10.string().optional().describe('File name pattern to include (e.g., "*.ts", "*.{js,jsx}")'),
+    caseInsensitive: z10.boolean().default(false).describe("Whether to perform case-insensitive matching"),
+    contextLines: z10.number().int().min(0).max(10).default(0).describe("Number of context lines before and after each match"),
+    maxResults: z10.number().int().min(1).max(1e3).default(100).describe("Maximum number of matches to return")
+  }),
+  execute: async (params) => {
+    try {
+      const searchPath = params.path || process.cwd();
+      const flags = params.caseInsensitive ? "gi" : "g";
+      let includePattern = null;
+      if (params.include) {
+        const escaped = params.include.replace(/\./g, "\\.").replace(/\*/g, ".*").replace(/\{([^}]+)\}/g, (_match, group) => {
+          return `(${group.split(",").join("|")})`;
+        });
+        includePattern = new RegExp(`^${escaped}$`);
+      }
+      const stat = await fs4.stat(searchPath);
+      let files;
+      if (stat.isFile()) {
+        files = [searchPath];
+      } else {
+        files = await walkDir(searchPath, includePattern);
+      }
+      const allMatches = [];
+      for (const file of files) {
+        if (allMatches.length >= params.maxResults) break;
+        try {
+          const matches = await searchFile(
+            file,
+            new RegExp(params.pattern, flags),
+            params.contextLines
+          );
+          for (const match of matches) {
+            if (allMatches.length >= params.maxResults) break;
+            match.file = stat.isFile() ? match.file : relative(searchPath, match.file);
+            allMatches.push(match);
+          }
+        } catch {
+        }
+      }
+      return {
+        matches: allMatches,
+        count: allMatches.length,
+        filesSearched: files.length,
+        truncated: allMatches.length >= params.maxResults
+      };
+    } catch (error) {
+      if (error instanceof Error) {
+        throw new Error(`Grep failed: ${error.message}`);
+      }
+      throw error;
+    }
+  }
+};
+
+// src/tools/built-in/git.tool.ts
+import { execSync as execSync2 } from "child_process";
+import { z as z11 } from "zod";
+var GIT_TIMEOUT_MS = 15e3;
+function gitExec(args, cwd) {
+  return execSync2(`git ${args}`, {
+    cwd: cwd || process.cwd(),
+    timeout: GIT_TIMEOUT_MS,
+    encoding: "utf8",
+    stdio: ["pipe", "pipe", "pipe"]
+  }).trim();
+}
+var gitStatusTool = {
+  name: "git_status",
+  description: "Show the working tree status. Returns staged, unstaged, and untracked files.",
+  parameters: z11.object({
+    cwd: z11.string().optional().describe("Repository directory")
+  }),
+  execute: (params) => {
+    try {
+      const output = gitExec("status --porcelain", params.cwd);
+      const branch = gitExec("branch --show-current", params.cwd);
+      const staged = [];
+      const unstaged = [];
+      const untracked = [];
+      for (const line of output.split("\n")) {
+        if (!line.trim()) continue;
+        const index = line[0];
+        const worktree = line[1];
+        const file = line.slice(3);
+        if (index === "?") {
+          untracked.push(file);
+        } else {
+          if (index !== " " && index !== "?") staged.push(file);
+          if (worktree !== " " && worktree !== "?") unstaged.push(file);
+        }
+      }
+      return Promise.resolve({
+        branch,
+        staged,
+        unstaged,
+        untracked,
+        clean: staged.length === 0 && unstaged.length === 0 && untracked.length === 0,
+        raw: output
+      });
+    } catch (error) {
+      if (error instanceof Error) {
+        throw new Error(`Git status failed: ${error.message}`);
+      }
+      throw error;
+    }
+  }
+};
+var gitDiffTool = {
+  name: "git_diff",
+  description: "Show changes between commits, commit and working tree, etc.",
+  parameters: z11.object({
+    staged: z11.boolean().default(false).describe("Show staged changes (--cached)"),
+    path: z11.string().optional().describe("Limit diff to specific path"),
+    cwd: z11.string().optional().describe("Repository directory")
+  }),
+  execute: (params) => {
+    try {
+      let args = "diff";
+      if (params.staged) args += " --cached";
+      if (params.path) args += ` -- ${params.path}`;
+      const output = gitExec(args, params.cwd);
+      return Promise.resolve({
+        diff: output,
+        hasChanges: output.length > 0
+      });
+    } catch (error) {
+      if (error instanceof Error) {
+        throw new Error(`Git diff failed: ${error.message}`);
+      }
+      throw error;
+    }
+  }
+};
+var gitAddTool = {
+  name: "git_add",
+  description: "Add file contents to the staging area.",
+  parameters: z11.object({
+    paths: z11.array(z11.string()).min(1).describe("Files to add to staging"),
+    cwd: z11.string().optional().describe("Repository directory")
+  }),
+  execute: (params) => {
+    try {
+      const escapedPaths = params.paths.map((p) => `"${p}"`).join(" ");
+      gitExec(`add ${escapedPaths}`, params.cwd);
+      return Promise.resolve({
+        success: true,
+        added: params.paths
+      });
+    } catch (error) {
+      if (error instanceof Error) {
+        throw new Error(`Git add failed: ${error.message}`);
+      }
+      throw error;
+    }
+  }
+};
+var gitCommitTool = {
+  name: "git_commit",
+  description: "Record changes to the repository.",
+  parameters: z11.object({
+    message: z11.string().min(1).describe("Commit message"),
+    cwd: z11.string().optional().describe("Repository directory")
+  }),
+  execute: (params) => {
+    try {
+      const safeMessage = params.message.replace(/'/g, "'\\''");
+      const output = gitExec(`commit -m '${safeMessage}'`, params.cwd);
+      return Promise.resolve({
+        success: true,
+        output
+      });
+    } catch (error) {
+      if (error instanceof Error) {
+        throw new Error(`Git commit failed: ${error.message}`);
+      }
+      throw error;
+    }
+  }
+};
+var gitLogTool = {
+  name: "git_log",
+  description: "Show commit logs.",
+  parameters: z11.object({
+    maxCount: z11.number().int().min(1).max(100).default(10).describe("Maximum number of commits to show"),
+    oneline: z11.boolean().default(true).describe("Show each commit on a single line"),
+    path: z11.string().optional().describe("Limit to commits affecting this path"),
+    cwd: z11.string().optional().describe("Repository directory")
+  }),
+  execute: (params) => {
+    try {
+      let args = `log -${params.maxCount}`;
+      if (params.oneline) {
+        args += " --oneline";
+      } else {
+        args += " --format=%H%n%an%n%ae%n%ai%n%s%n---";
+      }
+      if (params.path) args += ` -- ${params.path}`;
+      const output = gitExec(args, params.cwd);
+      if (params.oneline) {
+        const commits = output.split("\n").filter(Boolean).map((line) => {
+          const spaceIdx = line.indexOf(" ");
+          return {
+            hash: line.slice(0, spaceIdx),
+            message: line.slice(spaceIdx + 1)
+          };
+        });
+        return Promise.resolve({ commits, count: commits.length });
+      }
+      return Promise.resolve({ log: output });
+    } catch (error) {
+      if (error instanceof Error) {
+        throw new Error(`Git log failed: ${error.message}`);
+      }
+      throw error;
+    }
+  }
+};
+var gitBranchTool = {
+  name: "git_branch",
+  description: "List, create, or switch branches.",
+  parameters: z11.object({
+    action: z11.enum(["list", "create", "switch"]).default("list").describe("Action to perform"),
+    name: z11.string().optional().describe("Branch name (required for create/switch)"),
+    cwd: z11.string().optional().describe("Repository directory")
+  }),
+  execute: (params) => {
+    try {
+      switch (params.action) {
+        case "list": {
+          const output = gitExec("branch -a", params.cwd);
+          const current = gitExec("branch --show-current", params.cwd);
+          const branches = output.split("\n").filter(Boolean).map((b) => b.replace(/^\*?\s+/, "").trim());
+          return Promise.resolve({ branches, current });
+        }
+        case "create": {
+          if (!params.name) {
+            throw new Error("Branch name is required for create action");
+          }
+          gitExec(`branch ${params.name}`, params.cwd);
+          return Promise.resolve({ success: true, created: params.name });
+        }
+        case "switch": {
+          if (!params.name) {
+            throw new Error("Branch name is required for switch action");
+          }
+          gitExec(`checkout ${params.name}`, params.cwd);
+          return Promise.resolve({ success: true, switched: params.name });
+        }
+      }
+    } catch (error) {
+      if (error instanceof Error) {
+        throw new Error(`Git branch failed: ${error.message}`);
+      }
+      throw error;
+    }
+  }
+};
+
+// src/tools/built-in/calculator.isomorphic.ts
+import { z as z13 } from "zod";
 
 // src/tools/tool-definition.ts
-import { z as z7 } from "zod";
+import { z as z12 } from "zod";
 function toolDefinition(options) {
   const {
     name,
     description,
     inputSchema,
-    outputSchema = z7.unknown(),
+    outputSchema = z12.unknown(),
     needsApproval = false,
     retryConfig
   } = options;
@@ -1561,13 +2105,13 @@ function toLegacyTools(tools) {
 }
 
 // src/tools/built-in/calculator.isomorphic.ts
-var calculatorInputSchema = z8.object({
-  operation: z8.enum(["add", "subtract", "multiply", "divide"]).describe("The arithmetic operation to perform"),
-  a: z8.number().describe("First number"),
-  b: z8.number().describe("Second number")
+var calculatorInputSchema = z13.object({
+  operation: z13.enum(["add", "subtract", "multiply", "divide"]).describe("The arithmetic operation to perform"),
+  a: z13.number().describe("First number"),
+  b: z13.number().describe("Second number")
 });
-var calculatorOutputSchema = z8.object({
-  result: z8.number().describe("The result of the calculation")
+var calculatorOutputSchema = z13.object({
+  result: z13.number().describe("The result of the calculation")
 });
 var calculatorDef = toolDefinition({
   name: "calculator",
@@ -2525,6 +3069,24 @@ function createProvider(config) {
     case "gemini":
       provider = new GeminiProvider();
       break;
+    case "mistral":
+      provider = new OpenAICompatibleProvider({
+        baseUrl: "https://api.mistral.ai/v1",
+        apiKey: process.env.MISTRAL_API_KEY
+      });
+      break;
+    case "deepseek":
+      provider = new OpenAICompatibleProvider({
+        baseUrl: "https://api.deepseek.com/v1",
+        apiKey: process.env.DEEPSEEK_API_KEY
+      });
+      break;
+    case "xai":
+      provider = new OpenAICompatibleProvider({
+        baseUrl: "https://api.x.ai/v1",
+        apiKey: process.env.XAI_API_KEY
+      });
+      break;
     case "ollama":
       provider = new OllamaProvider();
       break;
@@ -4088,7 +4650,7 @@ var MCPClient = class extends EventEmitter2 {
 };
 
 // src/mcp/tool-adapter.ts
-import { z as z9 } from "zod";
+import { z as z14 } from "zod";
 function mcpToolToAgenticTool(mcpTool, client) {
   const zodSchema = jsonSchemaToZod(mcpTool.inputSchema);
   return {
@@ -4123,25 +4685,25 @@ function jsonSchemaToZod(schema) {
       let zodType;
       switch (propSchema.type) {
         case "string":
-          zodType = z9.string();
+          zodType = z14.string();
           if (typeof propSchema.description === "string") {
             zodType = zodType.describe(propSchema.description);
           }
           break;
         case "number":
-          zodType = z9.number();
+          zodType = z14.number();
           if (typeof propSchema.description === "string") {
             zodType = zodType.describe(propSchema.description);
           }
           break;
         case "boolean":
-          zodType = z9.boolean();
+          zodType = z14.boolean();
           if (typeof propSchema.description === "string") {
             zodType = zodType.describe(propSchema.description);
           }
           break;
         case "array":
-          zodType = z9.array(
+          zodType = z14.array(
             jsonSchemaToZod(
               propSchema.items || {}
             )
@@ -4154,7 +4716,7 @@ function jsonSchemaToZod(schema) {
           zodType = jsonSchemaToZod(propSchema);
           break;
         default:
-          zodType = z9.any();
+          zodType = z14.any();
       }
       const required = schema.required;
       if (!required?.includes(key)) {
@@ -4162,9 +4724,9 @@ function jsonSchemaToZod(schema) {
       }
       shape[key] = zodType;
     }
-    return z9.object(shape);
+    return z14.object(shape);
   }
-  return z9.any();
+  return z14.any();
 }
 
 // src/mcp/registry.ts
@@ -4561,7 +5123,7 @@ var ACPClient = class {
 };
 
 // src/acp/tools.ts
-import { z as z10 } from "zod";
+import { z as z15 } from "zod";
 function createACPTools(client) {
   return [
     createSearchProductsTool(client),
@@ -4584,15 +5146,15 @@ function createSearchProductsTool(client) {
   return {
     name: "acp_search_products",
     description: "Search for products in the commerce catalog. Supports filtering by query text, category, price range, and sorting.",
-    parameters: z10.object({
-      query: z10.string().optional().describe("Search query text"),
-      category: z10.string().optional().describe("Product category filter"),
-      minPrice: z10.number().optional().describe("Minimum price filter"),
-      maxPrice: z10.number().optional().describe("Maximum price filter"),
-      limit: z10.number().optional().default(10).describe("Maximum number of results"),
-      offset: z10.number().optional().default(0).describe("Pagination offset"),
-      sortBy: z10.enum(["price", "name", "popularity", "newest"]).optional().describe("Sort field"),
-      sortOrder: z10.enum(["asc", "desc"]).optional().default("asc").describe("Sort order")
+    parameters: z15.object({
+      query: z15.string().optional().describe("Search query text"),
+      category: z15.string().optional().describe("Product category filter"),
+      minPrice: z15.number().optional().describe("Minimum price filter"),
+      maxPrice: z15.number().optional().describe("Maximum price filter"),
+      limit: z15.number().optional().default(10).describe("Maximum number of results"),
+      offset: z15.number().optional().default(0).describe("Pagination offset"),
+      sortBy: z15.enum(["price", "name", "popularity", "newest"]).optional().describe("Sort field"),
+      sortOrder: z15.enum(["asc", "desc"]).optional().default("asc").describe("Sort order")
     }),
     execute: async (params) => {
       const response = await client.searchProducts(params);
@@ -4611,8 +5173,8 @@ function createGetProductTool(client) {
   return {
     name: "acp_get_product",
     description: "Get detailed information about a specific product by its ID.",
-    parameters: z10.object({
-      productId: z10.string().describe("Product ID")
+    parameters: z15.object({
+      productId: z15.string().describe("Product ID")
     }),
     execute: async (params) => {
       const response = await client.getProduct(params.productId);
@@ -4627,7 +5189,7 @@ function createCreateCartTool(client) {
   return {
     name: "acp_create_cart",
     description: "Create a new shopping cart for the customer. Returns the cart ID for subsequent operations.",
-    parameters: z10.object({}),
+    parameters: z15.object({}),
     execute: async () => {
       const response = await client.createCart();
       if (response.error) {
@@ -4641,14 +5203,14 @@ function createAddToCartTool(client) {
   return {
     name: "acp_add_to_cart",
     description: "Add a product to the shopping cart with specified quantity.",
-    parameters: z10.object({
-      cartId: z10.string().describe("Cart ID"),
-      productId: z10.string().describe("Product ID to add"),
-      variantId: z10.string().optional().describe("Product variant ID"),
-      quantity: z10.number().min(1).describe("Quantity to add"),
-      price: z10.object({
-        amount: z10.number().describe("Price amount"),
-        currency: z10.string().describe("Currency code (e.g., USD, EUR)")
+    parameters: z15.object({
+      cartId: z15.string().describe("Cart ID"),
+      productId: z15.string().describe("Product ID to add"),
+      variantId: z15.string().optional().describe("Product variant ID"),
+      quantity: z15.number().min(1).describe("Quantity to add"),
+      price: z15.object({
+        amount: z15.number().describe("Price amount"),
+        currency: z15.string().describe("Currency code (e.g., USD, EUR)")
       }).describe("Product price")
     }),
     execute: async (params) => {
@@ -4671,10 +5233,10 @@ function createUpdateCartItemTool(client) {
   return {
     name: "acp_update_cart_item",
     description: "Update the quantity of an item in the shopping cart.",
-    parameters: z10.object({
-      cartId: z10.string().describe("Cart ID"),
-      productId: z10.string().describe("Product ID to update"),
-      quantity: z10.number().min(0).describe("New quantity (0 to remove)")
+    parameters: z15.object({
+      cartId: z15.string().describe("Cart ID"),
+      productId: z15.string().describe("Product ID to update"),
+      quantity: z15.number().min(0).describe("New quantity (0 to remove)")
     }),
     execute: async (params) => {
       const response = await client.updateCartItem(
@@ -4695,9 +5257,9 @@ function createRemoveFromCartTool(client) {
   return {
     name: "acp_remove_from_cart",
     description: "Remove a product from the shopping cart.",
-    parameters: z10.object({
-      cartId: z10.string().describe("Cart ID"),
-      productId: z10.string().describe("Product ID to remove")
+    parameters: z15.object({
+      cartId: z15.string().describe("Cart ID"),
+      productId: z15.string().describe("Product ID to remove")
     }),
     execute: async (params) => {
       const response = await client.removeFromCart(
@@ -4717,8 +5279,8 @@ function createGetCartTool(client) {
   return {
     name: "acp_get_cart",
     description: "Get the current state of a shopping cart including all items and total amount.",
-    parameters: z10.object({
-      cartId: z10.string().describe("Cart ID")
+    parameters: z15.object({
+      cartId: z15.string().describe("Cart ID")
     }),
     execute: async (params) => {
       const response = await client.getCart(params.cartId);
@@ -4733,12 +5295,12 @@ function createCheckoutTool(client) {
   return {
     name: "acp_create_checkout",
     description: "Create a checkout session from a shopping cart to begin the purchase process.",
-    parameters: z10.object({
-      cartId: z10.string().describe("Cart ID"),
-      customer: z10.object({
-        email: z10.string().email().describe("Customer email"),
-        name: z10.string().optional().describe("Customer name"),
-        phone: z10.string().optional().describe("Customer phone number")
+    parameters: z15.object({
+      cartId: z15.string().describe("Cart ID"),
+      customer: z15.object({
+        email: z15.string().email().describe("Customer email"),
+        name: z15.string().optional().describe("Customer name"),
+        phone: z15.string().optional().describe("Customer phone number")
       }).optional().describe("Customer information")
     }),
     execute: async (params) => {
@@ -4759,15 +5321,15 @@ function createUpdateShippingAddressTool(client) {
   return {
     name: "acp_update_shipping_address",
     description: "Update the shipping address for a checkout session.",
-    parameters: z10.object({
-      sessionId: z10.string().describe("Checkout session ID"),
-      address: z10.object({
-        line1: z10.string().describe("Address line 1"),
-        line2: z10.string().optional().describe("Address line 2"),
-        city: z10.string().describe("City"),
-        state: z10.string().optional().describe("State/Province"),
-        postalCode: z10.string().describe("Postal/ZIP code"),
-        country: z10.string().describe("Country code (e.g., US, GB)")
+    parameters: z15.object({
+      sessionId: z15.string().describe("Checkout session ID"),
+      address: z15.object({
+        line1: z15.string().describe("Address line 1"),
+        line2: z15.string().optional().describe("Address line 2"),
+        city: z15.string().describe("City"),
+        state: z15.string().optional().describe("State/Province"),
+        postalCode: z15.string().describe("Postal/ZIP code"),
+        country: z15.string().describe("Country code (e.g., US, GB)")
       }).describe("Shipping address")
     }),
     execute: async (params) => {
@@ -4788,12 +5350,12 @@ function createUpdatePaymentMethodTool(client) {
   return {
     name: "acp_update_payment_method",
     description: "Update the payment method for a checkout session.",
-    parameters: z10.object({
-      sessionId: z10.string().describe("Checkout session ID"),
-      paymentMethod: z10.object({
-        type: z10.enum(["card", "delegated", "wallet", "bank_transfer"]).describe("Payment method type"),
-        token: z10.string().optional().describe("Payment token"),
-        delegatedProvider: z10.string().optional().describe("Delegated payment provider (e.g., stripe, paypal)")
+    parameters: z15.object({
+      sessionId: z15.string().describe("Checkout session ID"),
+      paymentMethod: z15.object({
+        type: z15.enum(["card", "delegated", "wallet", "bank_transfer"]).describe("Payment method type"),
+        token: z15.string().optional().describe("Payment token"),
+        delegatedProvider: z15.string().optional().describe("Delegated payment provider (e.g., stripe, paypal)")
       }).describe("Payment method details")
     }),
     execute: async (params) => {
@@ -4814,8 +5376,8 @@ function createCompleteCheckoutTool(client) {
   return {
     name: "acp_complete_checkout",
     description: "Complete the checkout process and create an order. This finalizes the purchase.",
-    parameters: z10.object({
-      sessionId: z10.string().describe("Checkout session ID")
+    parameters: z15.object({
+      sessionId: z15.string().describe("Checkout session ID")
     }),
     execute: async (params) => {
       const response = await client.completeCheckout(params.sessionId);
@@ -4832,8 +5394,8 @@ function createGetOrderTool(client) {
   return {
     name: "acp_get_order",
     description: "Get detailed information about an order by its ID.",
-    parameters: z10.object({
-      orderId: z10.string().describe("Order ID")
+    parameters: z15.object({
+      orderId: z15.string().describe("Order ID")
     }),
     execute: async (params) => {
       const response = await client.getOrder(params.orderId);
@@ -4848,8 +5410,8 @@ function createCancelOrderTool(client) {
   return {
     name: "acp_cancel_order",
     description: "Cancel an order. Only orders that have not been shipped can be cancelled.",
-    parameters: z10.object({
-      orderId: z10.string().describe("Order ID")
+    parameters: z15.object({
+      orderId: z15.string().describe("Order ID")
     }),
     execute: async (params) => {
       const response = await client.cancelOrder(params.orderId);
@@ -4864,8 +5426,8 @@ function createGetOrderTrackingTool(client) {
   return {
     name: "acp_get_order_tracking",
     description: "Get shipping tracking information for an order.",
-    parameters: z10.object({
-      orderId: z10.string().describe("Order ID")
+    parameters: z15.object({
+      orderId: z15.string().describe("Order ID")
     }),
     execute: async (params) => {
       const response = await client.getOrderTracking(params.orderId);
@@ -5190,7 +5752,7 @@ import {
 
 // src/voice/voice-agent.ts
 import { writeFileSync } from "fs";
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 var VoiceAgent = class {
   agent;
   sttProvider;
@@ -5354,10 +5916,10 @@ var VoiceAgent = class {
   exportConversation(outputDir) {
     for (let i = 0; i < this.conversationHistory.length; i++) {
       const message = this.conversationHistory[i];
-      const textPath = join2(outputDir, `${i}-${message.role}.txt`);
+      const textPath = join3(outputDir, `${i}-${message.role}.txt`);
       writeFileSync(textPath, message.text);
       if (message.audio) {
-        const audioPath = join2(outputDir, `${i}-${message.role}.mp3`);
+        const audioPath = join3(outputDir, `${i}-${message.role}.mp3`);
         writeFileSync(audioPath, message.audio);
       }
     }
@@ -5578,7 +6140,7 @@ var OpenAIWhisperProvider = class {
 import { exec } from "child_process";
 import { writeFileSync as writeFileSync2, unlinkSync, existsSync } from "fs";
 import { tmpdir } from "os";
-import { join as join3 } from "path";
+import { join as join4 } from "path";
 import { promisify } from "util";
 var execAsync = promisify(exec);
 var LocalWhisperProvider = class {
@@ -5596,7 +6158,7 @@ var LocalWhisperProvider = class {
     let isTemporary = false;
     try {
       if (Buffer.isBuffer(audio)) {
-        audioPath = join3(tmpdir(), `audio-${Date.now()}.wav`);
+        audioPath = join4(tmpdir(), `audio-${Date.now()}.wav`);
         writeFileSync2(audioPath, audio);
         isTemporary = true;
       } else {
@@ -5963,7 +6525,7 @@ var ElevenLabsTTSProvider = class {
 import { exec as exec2 } from "child_process";
 import { writeFileSync as writeFileSync3, readFileSync, unlinkSync as unlinkSync2, existsSync as existsSync2 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 import { promisify as promisify2 } from "util";
 var execAsync2 = promisify2(exec2);
 var PiperTTSProvider = class {
@@ -5980,13 +6542,13 @@ var PiperTTSProvider = class {
    */
   async synthesize(text, config) {
     try {
-      const outputPath = join4(tmpdir2(), `speech-${Date.now()}.wav`);
+      const outputPath = join5(tmpdir2(), `speech-${Date.now()}.wav`);
       const model = this.modelPath || config?.model;
       if (!model) {
         throw new Error("Model path is required for Piper TTS");
       }
       const modelConfig = this.configPath || model.replace(".onnx", ".json");
-      const textPath = join4(tmpdir2(), `text-${Date.now()}.txt`);
+      const textPath = join5(tmpdir2(), `text-${Date.now()}.txt`);
       writeFileSync3(textPath, text, "utf-8");
       const command = `${this.piperPath} --model ${model} --config ${modelConfig} --output_file ${outputPath} < ${textPath}`;
       await execAsync2(command, {
@@ -6548,6 +7110,7 @@ export {
   calculatorServer,
   calculatorTool,
   clientTool,
+  codeEditTool,
   createACPTools,
   createAnthropicProvider,
   createGeminiProvider,
@@ -6563,8 +7126,16 @@ export {
   fileListTool,
   fileReadTool,
   fileWriteTool,
+  gitAddTool,
+  gitBranchTool,
+  gitCommitTool,
+  gitDiffTool,
+  gitLogTool,
+  gitStatusTool,
+  globTool,
   globalMetrics,
   globalTracer,
+  grepTool,
   httpRequestTool,
   hybridTool,
   mcpToolToAgenticTool,
@@ -6574,6 +7145,7 @@ export {
   n8nListWorkflowsTool,
   n8nTriggerWebhookTool,
   serverTool,
+  shellExecuteTool,
   stringTransformTool,
   textSummaryTool,
   toLegacyTool,