@lov3kaizen/agentsea-core 0.5.2 → 0.8.0

package/dist/index.js

@@ -34,7 +34,6 @@ __export(index_exports, {
   ACPClient: () => ACPClient,
   Agent: () => Agent,
   AnthropicProvider: () => AnthropicProvider,
-  AudioFormat: () => import_agentsea_types.AudioFormat,
   BufferMemory: () => BufferMemory,
   Cache: () => Cache,
   ContentFormatter: () => ContentFormatter,
@@ -64,35 +63,19 @@ __export(index_exports, {
   RateLimiter: () => RateLimiter,
   RedisMemory: () => RedisMemory,
   SSETransport: () => SSETransport,
-  STTConfig: () => import_agentsea_types.STTConfig,
-  STTProvider: () => import_agentsea_types.STTProvider,
-  STTResult: () => import_agentsea_types.STTResult,
   SequentialWorkflow: () => SequentialWorkflow,
   SlidingWindowRateLimiter: () => SlidingWindowRateLimiter,
   StdioTransport: () => StdioTransport,
   SummaryMemory: () => SummaryMemory,
   SupervisorWorkflow: () => SupervisorWorkflow,
-  TTSConfig: () => import_agentsea_types.TTSConfig,
-  TTSProvider: () => import_agentsea_types.TTSProvider,
-  TTSResult: () => import_agentsea_types.TTSResult,
-  Tenant: () => import_agentsea_types2.Tenant,
-  TenantApiKey: () => import_agentsea_types2.TenantApiKey,
   TenantBufferMemory: () => TenantBufferMemory,
-  TenantContext: () => import_agentsea_types2.TenantContext,
   TenantManager: () => TenantManager,
-  TenantQuota: () => import_agentsea_types2.TenantQuota,
-  TenantResolver: () => import_agentsea_types2.TenantResolver,
-  TenantSettings: () => import_agentsea_types2.TenantSettings,
-  TenantStatus: () => import_agentsea_types2.TenantStatus,
-  TenantStorage: () => import_agentsea_types2.TenantStorage,
+  TenantStatus: () => import_agentsea_types.TenantStatus,
   TextGenerationWebUIProvider: () => TextGenerationWebUIProvider,
   ToolRegistry: () => ToolRegistry,
   Tracer: () => Tracer,
   VLLMProvider: () => VLLMProvider,
   VoiceAgent: () => VoiceAgent,
-  VoiceAgentConfig: () => import_agentsea_types.VoiceAgentConfig,
-  VoiceMessage: () => import_agentsea_types.VoiceMessage,
-  VoiceType: () => import_agentsea_types.VoiceType,
   Workflow: () => Workflow,
   WorkflowFactory: () => WorkflowFactory,
   calculatorClient: () => calculatorClient,
@@ -100,6 +83,7 @@ __export(index_exports, {
   calculatorServer: () => calculatorServer,
   calculatorTool: () => calculatorTool,
   clientTool: () => clientTool,
+  codeEditTool: () => codeEditTool,
   createACPTools: () => createACPTools,
   createAnthropicProvider: () => createAnthropicProvider,
   createGeminiProvider: () => createGeminiProvider,
@@ -115,8 +99,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,
@@ -126,6 +118,7 @@ __export(index_exports, {
   n8nListWorkflowsTool: () => n8nListWorkflowsTool,
   n8nTriggerWebhookTool: () => n8nTriggerWebhookTool,
   serverTool: () => serverTool,
+  shellExecuteTool: () => shellExecuteTool,
   stringTransformTool: () => stringTransformTool,
   textSummaryTool: () => textSummaryTool,
   toLegacyTool: () => toLegacyTool,
@@ -302,6 +295,10 @@ var Agent = class {
     this.toolRegistry = toolRegistry;
     this.memory = memory;
   }
+  config;
+  provider;
+  toolRegistry;
+  memory;
   iterationCount = 0;
   /**
    * Execute the agent with the given input
@@ -1455,17 +1452,551 @@ async function pollExecutionStatus(executionId, apiKey, baseUrl, maxAttempts = 3
   );
 }
 
-// src/tools/built-in/calculator.isomorphic.ts
+// src/tools/built-in/shell.tool.ts
+var import_child_process = require("child_process");
+var import_zod7 = require("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: import_zod7.z.object({
+    command: import_zod7.z.string().describe("The shell command to execute"),
+    cwd: import_zod7.z.string().optional().describe(
+      "Working directory for the command (defaults to process.cwd())"
+    ),
+    timeout: import_zod7.z.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 = (0, import_child_process.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
+var import_fs2 = require("fs");
 var import_zod8 = require("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: import_zod8.z.object({
+    path: import_zod8.z.string().describe("Path to the file to edit"),
+    oldString: import_zod8.z.string().describe(
+      "The exact string to find and replace. Must match file content exactly including whitespace and indentation."
+    ),
+    newString: import_zod8.z.string().describe(
+      "The replacement string. Use empty string to delete the matched text."
+    ),
+    expectedReplacements: import_zod8.z.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 import_fs2.promises.readFile(params.path, "utf8");
+      if (params.oldString === "") {
+        const newContent2 = params.newString + content;
+        await import_fs2.promises.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 import_fs2.promises.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
+var import_fs3 = require("fs");
+var import_fast_glob = __toESM(require("fast-glob"));
+var import_zod9 = require("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: import_zod9.z.object({
+    pattern: import_zod9.z.string().describe(
+      'Glob pattern to match (e.g., "**/*.ts", "src/**/*.{ts,tsx}", "*.json")'
+    ),
+    cwd: import_zod9.z.string().optional().describe("Directory to search in (defaults to process.cwd())"),
+    ignore: import_zod9.z.array(import_zod9.z.string()).optional().describe("Additional patterns to ignore"),
+    maxResults: import_zod9.z.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 (0, import_fast_glob.default)(params.pattern, {
+        cwd,
+        ignore: ignorePatterns,
+        absolute: true,
+        dot: false,
+        onlyFiles: true
+      });
+      const withStats = await Promise.all(
+        files.map(async (filePath) => {
+          try {
+            const stats = await import_fs3.promises.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
+var import_fs4 = require("fs");
+var import_path2 = require("path");
+var import_zod10 = require("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 import_fs4.promises.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 = (0, import_path2.join)(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 import_fs4.promises.stat(filePath);
+  if (stats.size > MAX_FILE_SIZE) return [];
+  const content = await import_fs4.promises.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: import_zod10.z.object({
+    pattern: import_zod10.z.string().describe("Regex pattern to search for"),
+    path: import_zod10.z.string().optional().describe("Directory or file to search in (defaults to process.cwd())"),
+    include: import_zod10.z.string().optional().describe('File name pattern to include (e.g., "*.ts", "*.{js,jsx}")'),
+    caseInsensitive: import_zod10.z.boolean().default(false).describe("Whether to perform case-insensitive matching"),
+    contextLines: import_zod10.z.number().int().min(0).max(10).default(0).describe("Number of context lines before and after each match"),
+    maxResults: import_zod10.z.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 import_fs4.promises.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 : (0, import_path2.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
+var import_child_process2 = require("child_process");
+var import_zod11 = require("zod");
+var GIT_TIMEOUT_MS = 3e4;
+function gitExec(args, cwd) {
+  return (0, import_child_process2.execSync)(`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: import_zod11.z.object({
+    cwd: import_zod11.z.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: import_zod11.z.object({
+    staged: import_zod11.z.boolean().default(false).describe("Show staged changes (--cached)"),
+    path: import_zod11.z.string().optional().describe("Limit diff to specific path"),
+    cwd: import_zod11.z.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: import_zod11.z.object({
+    paths: import_zod11.z.array(import_zod11.z.string()).min(1).describe("Files to add to staging"),
+    cwd: import_zod11.z.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: import_zod11.z.object({
+    message: import_zod11.z.string().min(1).describe("Commit message"),
+    cwd: import_zod11.z.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: import_zod11.z.object({
+    maxCount: import_zod11.z.number().int().min(1).max(100).default(10).describe("Maximum number of commits to show"),
+    oneline: import_zod11.z.boolean().default(true).describe("Show each commit on a single line"),
+    path: import_zod11.z.string().optional().describe("Limit to commits affecting this path"),
+    cwd: import_zod11.z.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: import_zod11.z.object({
+    action: import_zod11.z.enum(["list", "create", "switch"]).default("list").describe("Action to perform"),
+    name: import_zod11.z.string().optional().describe("Branch name (required for create/switch)"),
+    cwd: import_zod11.z.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
+var import_zod13 = require("zod");
 
 // src/tools/tool-definition.ts
-var import_zod7 = require("zod");
+var import_zod12 = require("zod");
 function toolDefinition(options) {
   const {
     name,
     description,
     inputSchema,
-    outputSchema = import_zod7.z.unknown(),
+    outputSchema = import_zod12.z.unknown(),
     needsApproval = false,
     retryConfig
   } = options;
@@ -1573,13 +2104,13 @@ function toLegacyTools(tools) {
 }
 
 // src/tools/built-in/calculator.isomorphic.ts
-var calculatorInputSchema = import_zod8.z.object({
-  operation: import_zod8.z.enum(["add", "subtract", "multiply", "divide"]).describe("The arithmetic operation to perform"),
-  a: import_zod8.z.number().describe("First number"),
-  b: import_zod8.z.number().describe("Second number")
+var calculatorInputSchema = import_zod13.z.object({
+  operation: import_zod13.z.enum(["add", "subtract", "multiply", "divide"]).describe("The arithmetic operation to perform"),
+  a: import_zod13.z.number().describe("First number"),
+  b: import_zod13.z.number().describe("Second number")
 });
-var calculatorOutputSchema = import_zod8.z.object({
-  result: import_zod8.z.number().describe("The result of the calculation")
+var calculatorOutputSchema = import_zod13.z.object({
+  result: import_zod13.z.number().describe("The result of the calculation")
 });
 var calculatorDef = toolDefinition({
   name: "calculator",
@@ -1614,6 +2145,8 @@ var calculatorClient = calculatorDef.client(({ operation, a, b }) => {
 // src/providers/anthropic.ts
 var import_sdk = __toESM(require("@anthropic-ai/sdk"));
 var import_zod_to_json_schema = require("zod-to-json-schema");
+var SAMPLING_REMOVED = /^claude-(opus-4-[789]|fable-5|mythos-5)/;
+var ADAPTIVE_THINKING = /^claude-(opus-4-[6789]|sonnet-4-6|fable-5|mythos-5)/;
 var AnthropicProvider = class {
   client;
   constructor(apiKey) {
@@ -1621,6 +2154,30 @@ var AnthropicProvider = class {
       apiKey: apiKey || process.env.ANTHROPIC_API_KEY
     });
   }
+  /**
+   * Build model-aware request parameters. Modern Claude models reject
+   * removed sampling params, and Claude 4+ rejects temperature and
+   * top_p together — temperature wins when both are configured.
+   */
+  buildRequestParams(config, defaultMaxTokens) {
+    const params = {
+      max_tokens: config.maxTokens || defaultMaxTokens
+    };
+    if (!SAMPLING_REMOVED.test(config.model)) {
+      if (config.temperature !== void 0) {
+        params.temperature = config.temperature;
+      } else if (config.topP !== void 0) {
+        params.top_p = config.topP;
+      }
+    }
+    if (config.thinking && ADAPTIVE_THINKING.test(config.model)) {
+      params.thinking = config.thinking === true ? { type: "adaptive" } : config.thinking;
+    }
+    if (config.effort && ADAPTIVE_THINKING.test(config.model)) {
+      params.output_config = { effort: config.effort };
+    }
+    return params;
+  }
   /**
    * Generate a response from Claude
    */
@@ -1633,14 +2190,12 @@ var AnthropicProvider = class {
     })) : void 0;
     const response = await this.client.messages.create({
       model: config.model,
-      max_tokens: config.maxTokens || 1024,
-      temperature: config.temperature,
       system: config.systemPrompt,
       messages: anthropicMessages,
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       tools,
-      top_p: config.topP,
-      stop_sequences: config.stopSequences
+      stop_sequences: config.stopSequences,
+      ...this.buildRequestParams(config, 16e3)
     });
     const textContent = response.content.filter((block) => block.type === "text").map((block) => block.text).join("\n");
     return {
@@ -1665,14 +2220,12 @@ var AnthropicProvider = class {
     })) : void 0;
     const stream = await this.client.messages.stream({
       model: config.model,
-      max_tokens: config.maxTokens || 1024,
-      temperature: config.temperature,
       system: config.systemPrompt,
       messages: anthropicMessages,
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       tools,
-      top_p: config.topP,
-      stop_sequences: config.stopSequences
+      stop_sequences: config.stopSequences,
+      ...this.buildRequestParams(config, 64e3)
     });
     for await (const event of stream) {
       if (event.type === "content_block_delta") {
@@ -1854,6 +2407,9 @@ var OpenAIProvider = class {
     const choice = rawResponse.choices[0];
     if (choice?.message.tool_calls) {
       for (const toolCall of choice.message.tool_calls) {
+        if (toolCall.type !== "function") {
+          continue;
+        }
         toolCalls.push({
           id: toolCall.id,
           tool: toolCall.function.name,
@@ -1913,7 +2469,7 @@ var GeminiProvider = class {
    * Generate a response from the Gemini model
    */
   async generateResponse(messages, config) {
-    const model = this.getModel(config.model || "gemini-pro");
+    const model = this.getModel(config.model || "gemini-3.1-pro-preview");
     const contents = this.convertMessages(messages);
     const generationConfig = {
       temperature: config.temperature || 0.7,
@@ -1947,7 +2503,7 @@ var GeminiProvider = class {
    * Stream responses from Gemini
    */
   async *streamResponse(messages, config) {
-    const model = this.getModel(config.model || "gemini-pro");
+    const model = this.getModel(config.model || "gemini-3.1-pro-preview");
     const contents = this.convertMessages(messages);
     const generationConfig = {
       temperature: config.temperature || 0.7,
@@ -2430,6 +2986,9 @@ var OpenAICompatibleProvider = class {
     const choice = rawResponse.choices[0];
     if (choice?.message.tool_calls) {
       for (const toolCall of choice.message.tool_calls) {
+        if (toolCall.type !== "function") {
+          continue;
+        }
         toolCalls.push({
           id: toolCall.id,
           tool: toolCall.function.name,
@@ -2535,6 +3094,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;
@@ -2612,6 +3189,7 @@ var BufferMemory = class {
   constructor(maxMessages) {
     this.maxMessages = maxMessages;
   }
+  maxMessages;
   store = /* @__PURE__ */ new Map();
   /**
    * Save messages to memory
@@ -2732,11 +3310,14 @@ var RedisMemory = class {
 
 // src/memory/summary-memory.ts
 var SummaryMemory = class {
-  constructor(provider, maxRecentMessages = 10, summaryModel = "claude-3-haiku-20240307") {
+  constructor(provider, maxRecentMessages = 10, summaryModel = "claude-haiku-4-5") {
     this.provider = provider;
     this.maxRecentMessages = maxRecentMessages;
     this.summaryModel = summaryModel;
   }
+  provider;
+  maxRecentMessages;
+  summaryModel;
   store = /* @__PURE__ */ new Map();
   /**
    * Save messages with automatic summarization
@@ -2826,6 +3407,7 @@ var TenantBufferMemory = class {
   constructor(maxMessages) {
     this.maxMessages = maxMessages;
   }
+  maxMessages;
   store = /* @__PURE__ */ new Map();
   /**
    * Save messages to memory with tenant isolation
@@ -2935,6 +3517,10 @@ var Workflow = class {
     this.memory = memory;
     this.initializeAgents();
   }
+  config;
+  provider;
+  toolRegistry;
+  memory;
   agents = /* @__PURE__ */ new Map();
   /**
    * Initialize all agents in the workflow
@@ -3483,6 +4069,8 @@ var RateLimiter = class {
     this.tokens = maxTokens;
     this.lastRefill = Date.now();
   }
+  maxTokens;
+  refillRate;
   tokens;
   lastRefill;
   /**
@@ -3541,6 +4129,8 @@ var SlidingWindowRateLimiter = class {
     this.maxRequests = maxRequests;
     this.windowMs = windowMs;
   }
+  maxRequests;
+  windowMs;
   requests = /* @__PURE__ */ new Map();
   /**
    * Check if request is allowed
@@ -3585,6 +4175,7 @@ var Cache = class {
   constructor(defaultTTL) {
     this.defaultTTL = defaultTTL;
   }
+  defaultTTL;
   store = /* @__PURE__ */ new Map();
   /**
    * Set a value in the cache
@@ -3687,6 +4278,7 @@ var LRUCache = class {
   constructor(maxSize) {
     this.maxSize = maxSize;
   }
+  maxSize;
   cache = /* @__PURE__ */ new Map();
   /**
    * Get a value from the cache
@@ -3745,7 +4337,7 @@ var LRUCache = class {
 var import_events2 = require("events");
 
 // src/mcp/transport.ts
-var import_child_process = require("child_process");
+var import_child_process3 = require("child_process");
 var import_events = require("events");
 var StdioTransport = class extends import_events.EventEmitter {
   constructor(command, args = [], env) {
@@ -3754,13 +4346,16 @@ var StdioTransport = class extends import_events.EventEmitter {
     this.args = args;
     this.env = env;
   }
+  command;
+  args;
+  env;
   process = null;
   connected = false;
   buffer = "";
   async connect() {
     return new Promise((resolve, reject) => {
       try {
-        this.process = (0, import_child_process.spawn)(this.command, this.args, {
+        this.process = (0, import_child_process3.spawn)(this.command, this.args, {
           env: { ...process.env, ...this.env },
           stdio: ["pipe", "pipe", "pipe"]
         });
@@ -3825,6 +4420,7 @@ var SSETransport = class extends import_events.EventEmitter {
     super();
     this.url = url;
   }
+  url;
   eventSource = null;
   connected = false;
   async connect() {
@@ -3892,6 +4488,7 @@ var MCPClient = class extends import_events2.EventEmitter {
     super();
     this.config = config;
   }
+  config;
   transport = null;
   serverInfo = null;
   requestId = 0;
@@ -4098,7 +4695,7 @@ var MCPClient = class extends import_events2.EventEmitter {
 };
 
 // src/mcp/tool-adapter.ts
-var import_zod9 = require("zod");
+var import_zod14 = require("zod");
 function mcpToolToAgenticTool(mcpTool, client) {
   const zodSchema = jsonSchemaToZod(mcpTool.inputSchema);
   return {
@@ -4133,25 +4730,25 @@ function jsonSchemaToZod(schema) {
       let zodType;
       switch (propSchema.type) {
         case "string":
-          zodType = import_zod9.z.string();
+          zodType = import_zod14.z.string();
           if (typeof propSchema.description === "string") {
             zodType = zodType.describe(propSchema.description);
           }
           break;
         case "number":
-          zodType = import_zod9.z.number();
+          zodType = import_zod14.z.number();
           if (typeof propSchema.description === "string") {
             zodType = zodType.describe(propSchema.description);
           }
           break;
         case "boolean":
-          zodType = import_zod9.z.boolean();
+          zodType = import_zod14.z.boolean();
           if (typeof propSchema.description === "string") {
             zodType = zodType.describe(propSchema.description);
           }
           break;
         case "array":
-          zodType = import_zod9.z.array(
+          zodType = import_zod14.z.array(
             jsonSchemaToZod(
               propSchema.items || {}
             )
@@ -4164,7 +4761,7 @@ function jsonSchemaToZod(schema) {
           zodType = jsonSchemaToZod(propSchema);
           break;
         default:
-          zodType = import_zod9.z.any();
+          zodType = import_zod14.z.any();
       }
       const required = schema.required;
       if (!required?.includes(key)) {
@@ -4172,9 +4769,9 @@ function jsonSchemaToZod(schema) {
       }
       shape[key] = zodType;
     }
-    return import_zod9.z.object(shape);
+    return import_zod14.z.object(shape);
   }
-  return import_zod9.z.any();
+  return import_zod14.z.any();
 }
 
 // src/mcp/registry.ts
@@ -4571,7 +5168,7 @@ var ACPClient = class {
 };
 
 // src/acp/tools.ts
-var import_zod10 = require("zod");
+var import_zod15 = require("zod");
 function createACPTools(client) {
   return [
     createSearchProductsTool(client),
@@ -4594,15 +5191,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: import_zod10.z.object({
-      query: import_zod10.z.string().optional().describe("Search query text"),
-      category: import_zod10.z.string().optional().describe("Product category filter"),
-      minPrice: import_zod10.z.number().optional().describe("Minimum price filter"),
-      maxPrice: import_zod10.z.number().optional().describe("Maximum price filter"),
-      limit: import_zod10.z.number().optional().default(10).describe("Maximum number of results"),
-      offset: import_zod10.z.number().optional().default(0).describe("Pagination offset"),
-      sortBy: import_zod10.z.enum(["price", "name", "popularity", "newest"]).optional().describe("Sort field"),
-      sortOrder: import_zod10.z.enum(["asc", "desc"]).optional().default("asc").describe("Sort order")
+    parameters: import_zod15.z.object({
+      query: import_zod15.z.string().optional().describe("Search query text"),
+      category: import_zod15.z.string().optional().describe("Product category filter"),
+      minPrice: import_zod15.z.number().optional().describe("Minimum price filter"),
+      maxPrice: import_zod15.z.number().optional().describe("Maximum price filter"),
+      limit: import_zod15.z.number().optional().default(10).describe("Maximum number of results"),
+      offset: import_zod15.z.number().optional().default(0).describe("Pagination offset"),
+      sortBy: import_zod15.z.enum(["price", "name", "popularity", "newest"]).optional().describe("Sort field"),
+      sortOrder: import_zod15.z.enum(["asc", "desc"]).optional().default("asc").describe("Sort order")
     }),
     execute: async (params) => {
       const response = await client.searchProducts(params);
@@ -4621,8 +5218,8 @@ function createGetProductTool(client) {
   return {
     name: "acp_get_product",
     description: "Get detailed information about a specific product by its ID.",
-    parameters: import_zod10.z.object({
-      productId: import_zod10.z.string().describe("Product ID")
+    parameters: import_zod15.z.object({
+      productId: import_zod15.z.string().describe("Product ID")
     }),
     execute: async (params) => {
       const response = await client.getProduct(params.productId);
@@ -4637,7 +5234,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: import_zod10.z.object({}),
+    parameters: import_zod15.z.object({}),
     execute: async () => {
       const response = await client.createCart();
       if (response.error) {
@@ -4651,14 +5248,14 @@ function createAddToCartTool(client) {
   return {
     name: "acp_add_to_cart",
     description: "Add a product to the shopping cart with specified quantity.",
-    parameters: import_zod10.z.object({
-      cartId: import_zod10.z.string().describe("Cart ID"),
-      productId: import_zod10.z.string().describe("Product ID to add"),
-      variantId: import_zod10.z.string().optional().describe("Product variant ID"),
-      quantity: import_zod10.z.number().min(1).describe("Quantity to add"),
-      price: import_zod10.z.object({
-        amount: import_zod10.z.number().describe("Price amount"),
-        currency: import_zod10.z.string().describe("Currency code (e.g., USD, EUR)")
+    parameters: import_zod15.z.object({
+      cartId: import_zod15.z.string().describe("Cart ID"),
+      productId: import_zod15.z.string().describe("Product ID to add"),
+      variantId: import_zod15.z.string().optional().describe("Product variant ID"),
+      quantity: import_zod15.z.number().min(1).describe("Quantity to add"),
+      price: import_zod15.z.object({
+        amount: import_zod15.z.number().describe("Price amount"),
+        currency: import_zod15.z.string().describe("Currency code (e.g., USD, EUR)")
       }).describe("Product price")
     }),
     execute: async (params) => {
@@ -4681,10 +5278,10 @@ function createUpdateCartItemTool(client) {
   return {
     name: "acp_update_cart_item",
     description: "Update the quantity of an item in the shopping cart.",
-    parameters: import_zod10.z.object({
-      cartId: import_zod10.z.string().describe("Cart ID"),
-      productId: import_zod10.z.string().describe("Product ID to update"),
-      quantity: import_zod10.z.number().min(0).describe("New quantity (0 to remove)")
+    parameters: import_zod15.z.object({
+      cartId: import_zod15.z.string().describe("Cart ID"),
+      productId: import_zod15.z.string().describe("Product ID to update"),
+      quantity: import_zod15.z.number().min(0).describe("New quantity (0 to remove)")
     }),
     execute: async (params) => {
       const response = await client.updateCartItem(
@@ -4705,9 +5302,9 @@ function createRemoveFromCartTool(client) {
   return {
     name: "acp_remove_from_cart",
     description: "Remove a product from the shopping cart.",
-    parameters: import_zod10.z.object({
-      cartId: import_zod10.z.string().describe("Cart ID"),
-      productId: import_zod10.z.string().describe("Product ID to remove")
+    parameters: import_zod15.z.object({
+      cartId: import_zod15.z.string().describe("Cart ID"),
+      productId: import_zod15.z.string().describe("Product ID to remove")
     }),
     execute: async (params) => {
       const response = await client.removeFromCart(
@@ -4727,8 +5324,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: import_zod10.z.object({
-      cartId: import_zod10.z.string().describe("Cart ID")
+    parameters: import_zod15.z.object({
+      cartId: import_zod15.z.string().describe("Cart ID")
     }),
     execute: async (params) => {
       const response = await client.getCart(params.cartId);
@@ -4743,12 +5340,12 @@ function createCheckoutTool(client) {
   return {
     name: "acp_create_checkout",
     description: "Create a checkout session from a shopping cart to begin the purchase process.",
-    parameters: import_zod10.z.object({
-      cartId: import_zod10.z.string().describe("Cart ID"),
-      customer: import_zod10.z.object({
-        email: import_zod10.z.string().email().describe("Customer email"),
-        name: import_zod10.z.string().optional().describe("Customer name"),
-        phone: import_zod10.z.string().optional().describe("Customer phone number")
+    parameters: import_zod15.z.object({
+      cartId: import_zod15.z.string().describe("Cart ID"),
+      customer: import_zod15.z.object({
+        email: import_zod15.z.string().email().describe("Customer email"),
+        name: import_zod15.z.string().optional().describe("Customer name"),
+        phone: import_zod15.z.string().optional().describe("Customer phone number")
       }).optional().describe("Customer information")
     }),
     execute: async (params) => {
@@ -4769,15 +5366,15 @@ function createUpdateShippingAddressTool(client) {
   return {
     name: "acp_update_shipping_address",
     description: "Update the shipping address for a checkout session.",
-    parameters: import_zod10.z.object({
-      sessionId: import_zod10.z.string().describe("Checkout session ID"),
-      address: import_zod10.z.object({
-        line1: import_zod10.z.string().describe("Address line 1"),
-        line2: import_zod10.z.string().optional().describe("Address line 2"),
-        city: import_zod10.z.string().describe("City"),
-        state: import_zod10.z.string().optional().describe("State/Province"),
-        postalCode: import_zod10.z.string().describe("Postal/ZIP code"),
-        country: import_zod10.z.string().describe("Country code (e.g., US, GB)")
+    parameters: import_zod15.z.object({
+      sessionId: import_zod15.z.string().describe("Checkout session ID"),
+      address: import_zod15.z.object({
+        line1: import_zod15.z.string().describe("Address line 1"),
+        line2: import_zod15.z.string().optional().describe("Address line 2"),
+        city: import_zod15.z.string().describe("City"),
+        state: import_zod15.z.string().optional().describe("State/Province"),
+        postalCode: import_zod15.z.string().describe("Postal/ZIP code"),
+        country: import_zod15.z.string().describe("Country code (e.g., US, GB)")
       }).describe("Shipping address")
     }),
     execute: async (params) => {
@@ -4798,12 +5395,12 @@ function createUpdatePaymentMethodTool(client) {
   return {
     name: "acp_update_payment_method",
     description: "Update the payment method for a checkout session.",
-    parameters: import_zod10.z.object({
-      sessionId: import_zod10.z.string().describe("Checkout session ID"),
-      paymentMethod: import_zod10.z.object({
-        type: import_zod10.z.enum(["card", "delegated", "wallet", "bank_transfer"]).describe("Payment method type"),
-        token: import_zod10.z.string().optional().describe("Payment token"),
-        delegatedProvider: import_zod10.z.string().optional().describe("Delegated payment provider (e.g., stripe, paypal)")
+    parameters: import_zod15.z.object({
+      sessionId: import_zod15.z.string().describe("Checkout session ID"),
+      paymentMethod: import_zod15.z.object({
+        type: import_zod15.z.enum(["card", "delegated", "wallet", "bank_transfer"]).describe("Payment method type"),
+        token: import_zod15.z.string().optional().describe("Payment token"),
+        delegatedProvider: import_zod15.z.string().optional().describe("Delegated payment provider (e.g., stripe, paypal)")
       }).describe("Payment method details")
     }),
     execute: async (params) => {
@@ -4824,8 +5421,8 @@ function createCompleteCheckoutTool(client) {
   return {
     name: "acp_complete_checkout",
     description: "Complete the checkout process and create an order. This finalizes the purchase.",
-    parameters: import_zod10.z.object({
-      sessionId: import_zod10.z.string().describe("Checkout session ID")
+    parameters: import_zod15.z.object({
+      sessionId: import_zod15.z.string().describe("Checkout session ID")
     }),
     execute: async (params) => {
       const response = await client.completeCheckout(params.sessionId);
@@ -4842,8 +5439,8 @@ function createGetOrderTool(client) {
   return {
     name: "acp_get_order",
     description: "Get detailed information about an order by its ID.",
-    parameters: import_zod10.z.object({
-      orderId: import_zod10.z.string().describe("Order ID")
+    parameters: import_zod15.z.object({
+      orderId: import_zod15.z.string().describe("Order ID")
     }),
     execute: async (params) => {
       const response = await client.getOrder(params.orderId);
@@ -4858,8 +5455,8 @@ function createCancelOrderTool(client) {
   return {
     name: "acp_cancel_order",
     description: "Cancel an order. Only orders that have not been shipped can be cancelled.",
-    parameters: import_zod10.z.object({
-      orderId: import_zod10.z.string().describe("Order ID")
+    parameters: import_zod15.z.object({
+      orderId: import_zod15.z.string().describe("Order ID")
     }),
     execute: async (params) => {
       const response = await client.cancelOrder(params.orderId);
@@ -4874,8 +5471,8 @@ function createGetOrderTrackingTool(client) {
   return {
     name: "acp_get_order_tracking",
     description: "Get shipping tracking information for an order.",
-    parameters: import_zod10.z.object({
-      orderId: import_zod10.z.string().describe("Order ID")
+    parameters: import_zod15.z.object({
+      orderId: import_zod15.z.string().describe("Order ID")
     }),
     execute: async (params) => {
       const response = await client.getOrderTracking(params.orderId);
@@ -5184,12 +5781,9 @@ Respond naturally while ensuring you gather the required information.`;
   }
 };
 
-// src/types/voice.ts
-var import_agentsea_types = require("@lov3kaizen/agentsea-types");
-
 // src/voice/voice-agent.ts
-var import_fs2 = require("fs");
-var import_path2 = require("path");
+var import_fs5 = require("fs");
+var import_path3 = require("path");
 var VoiceAgent = class {
   agent;
   sttProvider;
@@ -5345,7 +5939,7 @@ var VoiceAgent = class {
    * Save audio to file
    */
   saveAudio(audio, outputPath) {
-    (0, import_fs2.writeFileSync)(outputPath, audio);
+    (0, import_fs5.writeFileSync)(outputPath, audio);
   }
   /**
    * Export conversation history with audio
@@ -5353,11 +5947,11 @@ var VoiceAgent = class {
   exportConversation(outputDir) {
     for (let i = 0; i < this.conversationHistory.length; i++) {
       const message = this.conversationHistory[i];
-      const textPath = (0, import_path2.join)(outputDir, `${i}-${message.role}.txt`);
-      (0, import_fs2.writeFileSync)(textPath, message.text);
+      const textPath = (0, import_path3.join)(outputDir, `${i}-${message.role}.txt`);
+      (0, import_fs5.writeFileSync)(textPath, message.text);
       if (message.audio) {
-        const audioPath = (0, import_path2.join)(outputDir, `${i}-${message.role}.mp3`);
-        (0, import_fs2.writeFileSync)(audioPath, message.audio);
+        const audioPath = (0, import_path3.join)(outputDir, `${i}-${message.role}.mp3`);
+        (0, import_fs5.writeFileSync)(audioPath, message.audio);
       }
     }
   }
@@ -5391,7 +5985,7 @@ var VoiceAgent = class {
 };
 
 // src/voice/stt/openai-whisper.ts
-var import_fs3 = require("fs");
+var import_fs6 = require("fs");
 var import_openai4 = __toESM(require("openai"));
 var OpenAIWhisperProvider = class {
   client;
@@ -5415,7 +6009,7 @@ var OpenAIWhisperProvider = class {
       if (Buffer.isBuffer(audio)) {
         audioFile = await (0, import_openai4.toFile)(audio, "audio.mp3", { type: "audio/mpeg" });
       } else if (typeof audio === "string") {
-        audioFile = (0, import_fs3.createReadStream)(audio);
+        audioFile = (0, import_fs6.createReadStream)(audio);
       } else {
         throw new Error(
           "Invalid audio input. Expected Buffer or file path string."
@@ -5574,12 +6168,12 @@ var OpenAIWhisperProvider = class {
 };
 
 // src/voice/stt/local-whisper.ts
-var import_child_process2 = require("child_process");
-var import_fs4 = require("fs");
+var import_child_process4 = require("child_process");
+var import_fs7 = require("fs");
 var import_os = require("os");
-var import_path3 = require("path");
+var import_path4 = require("path");
 var import_util = require("util");
-var execAsync = (0, import_util.promisify)(import_child_process2.exec);
+var execAsync = (0, import_util.promisify)(import_child_process4.exec);
 var LocalWhisperProvider = class {
   whisperPath;
   modelPath;
@@ -5595,13 +6189,13 @@ var LocalWhisperProvider = class {
     let isTemporary = false;
     try {
       if (Buffer.isBuffer(audio)) {
-        audioPath = (0, import_path3.join)((0, import_os.tmpdir)(), `audio-${Date.now()}.wav`);
-        (0, import_fs4.writeFileSync)(audioPath, audio);
+        audioPath = (0, import_path4.join)((0, import_os.tmpdir)(), `audio-${Date.now()}.wav`);
+        (0, import_fs7.writeFileSync)(audioPath, audio);
         isTemporary = true;
       } else {
         audioPath = audio;
       }
-      if (!(0, import_fs4.existsSync)(audioPath)) {
+      if (!(0, import_fs7.existsSync)(audioPath)) {
         throw new Error(`Audio file not found: ${audioPath}`);
       }
       const model = config?.model || "base";
@@ -5621,10 +6215,10 @@ var LocalWhisperProvider = class {
       let text;
       if (outputFormat === "txt") {
         const outputFile = audioPath.replace(/\.[^.]+$/, ".txt");
-        if ((0, import_fs4.existsSync)(outputFile)) {
+        if ((0, import_fs7.existsSync)(outputFile)) {
           const { readFileSync: readFileSync2 } = await import("fs");
           text = readFileSync2(outputFile, "utf-8").trim();
-          (0, import_fs4.unlinkSync)(outputFile);
+          (0, import_fs7.unlinkSync)(outputFile);
         } else {
           text = stdout.trim();
         }
@@ -5640,8 +6234,8 @@ var LocalWhisperProvider = class {
         `Local Whisper transcription failed: ${error instanceof Error ? error.message : String(error)}`
       );
     } finally {
-      if (isTemporary && (0, import_fs4.existsSync)(audioPath)) {
-        (0, import_fs4.unlinkSync)(audioPath);
+      if (isTemporary && (0, import_fs7.existsSync)(audioPath)) {
+        (0, import_fs7.unlinkSync)(audioPath);
       }
     }
   }
@@ -5959,12 +6553,12 @@ var ElevenLabsTTSProvider = class {
 };
 
 // src/voice/tts/piper-tts.ts
-var import_child_process3 = require("child_process");
-var import_fs5 = require("fs");
+var import_child_process5 = require("child_process");
+var import_fs8 = require("fs");
 var import_os2 = require("os");
-var import_path4 = require("path");
+var import_path5 = require("path");
 var import_util2 = require("util");
-var execAsync2 = (0, import_util2.promisify)(import_child_process3.exec);
+var execAsync2 = (0, import_util2.promisify)(import_child_process5.exec);
 var PiperTTSProvider = class {
   piperPath;
   modelPath;
@@ -5979,25 +6573,25 @@ var PiperTTSProvider = class {
    */
   async synthesize(text, config) {
     try {
-      const outputPath = (0, import_path4.join)((0, import_os2.tmpdir)(), `speech-${Date.now()}.wav`);
+      const outputPath = (0, import_path5.join)((0, import_os2.tmpdir)(), `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 = (0, import_path4.join)((0, import_os2.tmpdir)(), `text-${Date.now()}.txt`);
-      (0, import_fs5.writeFileSync)(textPath, text, "utf-8");
+      const textPath = (0, import_path5.join)((0, import_os2.tmpdir)(), `text-${Date.now()}.txt`);
+      (0, import_fs8.writeFileSync)(textPath, text, "utf-8");
       const command = `${this.piperPath} --model ${model} --config ${modelConfig} --output_file ${outputPath} < ${textPath}`;
       await execAsync2(command, {
         maxBuffer: 50 * 1024 * 1024
         // 50MB buffer
       });
-      if (!(0, import_fs5.existsSync)(outputPath)) {
+      if (!(0, import_fs8.existsSync)(outputPath)) {
         throw new Error("Piper failed to generate audio file");
       }
-      const audio = (0, import_fs5.readFileSync)(outputPath);
-      (0, import_fs5.unlinkSync)(outputPath);
-      (0, import_fs5.unlinkSync)(textPath);
+      const audio = (0, import_fs8.readFileSync)(outputPath);
+      (0, import_fs8.unlinkSync)(outputPath);
+      (0, import_fs8.unlinkSync)(textPath);
       return {
         audio,
         format: "wav",
@@ -6144,7 +6738,7 @@ var LemonFoxTTSProvider = class extends OpenAITTSProvider {
 var import_crypto2 = require("crypto");
 
 // src/types/tenant.ts
-var import_agentsea_types2 = require("@lov3kaizen/agentsea-types");
+var import_agentsea_types = require("@lov3kaizen/agentsea-types");
 
 // src/tenant/tenant-manager.ts
 var TenantManager = class {
@@ -6173,7 +6767,7 @@ var TenantManager = class {
       slug: data.slug,
       metadata: data.metadata,
       settings: { ...this.defaultSettings, ...data.settings },
-      status: import_agentsea_types2.TenantStatus.ACTIVE
+      status: import_agentsea_types.TenantStatus.ACTIVE
     });
     return tenant;
   }
@@ -6203,13 +6797,13 @@ var TenantManager = class {
    * Suspend tenant
    */
   async suspendTenant(tenantId) {
-    return this.updateTenant(tenantId, { status: import_agentsea_types2.TenantStatus.SUSPENDED });
+    return this.updateTenant(tenantId, { status: import_agentsea_types.TenantStatus.SUSPENDED });
   }
   /**
    * Activate tenant
    */
   async activateTenant(tenantId) {
-    return this.updateTenant(tenantId, { status: import_agentsea_types2.TenantStatus.ACTIVE });
+    return this.updateTenant(tenantId, { status: import_agentsea_types.TenantStatus.ACTIVE });
   }
   /**
    * Delete tenant and all associated data
@@ -6259,7 +6853,7 @@ var TenantManager = class {
       return null;
     }
     const tenant = await this.storage.getTenant(apiKey.tenantId);
-    if (!tenant || tenant.status !== import_agentsea_types2.TenantStatus.ACTIVE) {
+    if (!tenant || tenant.status !== import_agentsea_types.TenantStatus.ACTIVE) {
       return null;
     }
     return tenant;
@@ -6473,7 +7067,6 @@ var MemoryTenantStorage = class {
   ACPClient,
   Agent,
   AnthropicProvider,
-  AudioFormat,
   BufferMemory,
   Cache,
   ContentFormatter,
@@ -6503,35 +7096,19 @@ var MemoryTenantStorage = class {
   RateLimiter,
   RedisMemory,
   SSETransport,
-  STTConfig,
-  STTProvider,
-  STTResult,
   SequentialWorkflow,
   SlidingWindowRateLimiter,
   StdioTransport,
   SummaryMemory,
   SupervisorWorkflow,
-  TTSConfig,
-  TTSProvider,
-  TTSResult,
-  Tenant,
-  TenantApiKey,
   TenantBufferMemory,
-  TenantContext,
   TenantManager,
-  TenantQuota,
-  TenantResolver,
-  TenantSettings,
   TenantStatus,
-  TenantStorage,
   TextGenerationWebUIProvider,
   ToolRegistry,
   Tracer,
   VLLMProvider,
   VoiceAgent,
-  VoiceAgentConfig,
-  VoiceMessage,
-  VoiceType,
   Workflow,
   WorkflowFactory,
   calculatorClient,
@@ -6539,6 +7116,7 @@ var MemoryTenantStorage = class {
   calculatorServer,
   calculatorTool,
   clientTool,
+  codeEditTool,
   createACPTools,
   createAnthropicProvider,
   createGeminiProvider,
@@ -6554,8 +7132,16 @@ var MemoryTenantStorage = class {
   fileListTool,
   fileReadTool,
   fileWriteTool,
+  gitAddTool,
+  gitBranchTool,
+  gitCommitTool,
+  gitDiffTool,
+  gitLogTool,
+  gitStatusTool,
+  globTool,
   globalMetrics,
   globalTracer,
+  grepTool,
   httpRequestTool,
   hybridTool,
   mcpToolToAgenticTool,
@@ -6565,6 +7151,7 @@ var MemoryTenantStorage = class {
   n8nListWorkflowsTool,
   n8nTriggerWebhookTool,
   serverTool,
+  shellExecuteTool,
   stringTransformTool,
   textSummaryTool,
   toLegacyTool,