amai 0.0.11 → 0.0.12

package/dist/cli.cjs

@@ -2340,6 +2340,81 @@ var connectToUserStreams = async (serverUrl) => {
   });
   return ws;
 };
+var toolCallSchema = zod.z.object({
+  tool: zod.z.string().describe("The name of the tool to execute"),
+  parameters: zod.z.record(zod.z.string(), zod.z.unknown()).describe("Parameters for the tool")
+});
+zod.z.object({
+  tool_calls: zod.z.array(toolCallSchema).min(1, "Provide at least one tool call").max(10, "Maximum of 10 tools allowed in batch").describe("Array of tool calls to execute in parallel")
+});
+var DISALLOWED_TOOLS = /* @__PURE__ */ new Set(["batch"]);
+var batchableToolExecutors = {
+  deleteFile,
+  grep: grepTool,
+  glob: globTool,
+  listDirectory: list,
+  readFile: read_file,
+  runTerminalCommand
+};
+var batchTool = async function(input, projectCwd) {
+  const { tool_calls } = input;
+  const callsToExecute = tool_calls.slice(0, 10);
+  const discardedCalls = tool_calls.slice(10);
+  const executeCall = async (call) => {
+    try {
+      if (DISALLOWED_TOOLS.has(call.tool)) {
+        return {
+          tool: call.tool,
+          success: false,
+          error: `Tool '${call.tool}' is not allowed in batch. Disallowed tools: ${Array.from(DISALLOWED_TOOLS).join(", ")}`
+        };
+      }
+      const executor = batchableToolExecutors[call.tool];
+      if (!executor) {
+        const availableTools = Object.keys(batchableToolExecutors).join(", ");
+        return {
+          tool: call.tool,
+          success: false,
+          error: `Tool '${call.tool}' not found. Available tools for batching: ${availableTools}`
+        };
+      }
+      const result = await executor(call.parameters, projectCwd);
+      return {
+        tool: call.tool,
+        success: result.success !== false,
+        // Treat undefined success as true
+        result
+      };
+    } catch (error) {
+      return {
+        tool: call.tool,
+        success: false,
+        error: error.message || String(error)
+      };
+    }
+  };
+  const results = await Promise.all(callsToExecute.map(executeCall));
+  for (const call of discardedCalls) {
+    results.push({
+      tool: call.tool,
+      success: false,
+      error: "Maximum of 10 tools allowed in batch"
+    });
+  }
+  const successfulCalls = results.filter((r) => r.success).length;
+  const failedCalls = results.length - successfulCalls;
+  const outputMessage = failedCalls > 0 ? `Executed ${successfulCalls}/${results.length} tools successfully. ${failedCalls} failed.` : `All ${successfulCalls} tools executed successfully.
+
+Keep using the batch tool for optimal performance in your next response!`;
+  return {
+    success: failedCalls === 0,
+    message: outputMessage,
+    totalCalls: results.length,
+    successful: successfulCalls,
+    failed: failedCalls,
+    results
+  };
+};
 
 // src/server.ts
 var INITIAL_RECONNECT_DELAY2 = 1e3;
@@ -2362,7 +2437,8 @@ var toolExecutors = {
   listDirectory: list,
   readFile: read_file,
   stringReplace: apply_patch,
-  runTerminalCommand
+  runTerminalCommand,
+  batch: batchTool
 };
 function connectToServer(serverUrl = DEFAULT_SERVER_URL) {
   const tokens = getTokens();
@@ -2680,7 +2756,7 @@ function getDaemonPid() {
     return null;
   }
 }
-var VERSION = "0.0.11";
+var VERSION = "0.0.12";
 var PROJECT_DIR = process.cwd();
 var LOGO = `
    __ _ _ __ ___   __ _ 

package/dist/cli.js

@@ -2327,6 +2327,81 @@ var connectToUserStreams = async (serverUrl) => {
   });
   return ws;
 };
+var toolCallSchema = z.object({
+  tool: z.string().describe("The name of the tool to execute"),
+  parameters: z.record(z.string(), z.unknown()).describe("Parameters for the tool")
+});
+z.object({
+  tool_calls: z.array(toolCallSchema).min(1, "Provide at least one tool call").max(10, "Maximum of 10 tools allowed in batch").describe("Array of tool calls to execute in parallel")
+});
+var DISALLOWED_TOOLS = /* @__PURE__ */ new Set(["batch"]);
+var batchableToolExecutors = {
+  deleteFile,
+  grep: grepTool,
+  glob: globTool,
+  listDirectory: list,
+  readFile: read_file,
+  runTerminalCommand
+};
+var batchTool = async function(input, projectCwd) {
+  const { tool_calls } = input;
+  const callsToExecute = tool_calls.slice(0, 10);
+  const discardedCalls = tool_calls.slice(10);
+  const executeCall = async (call) => {
+    try {
+      if (DISALLOWED_TOOLS.has(call.tool)) {
+        return {
+          tool: call.tool,
+          success: false,
+          error: `Tool '${call.tool}' is not allowed in batch. Disallowed tools: ${Array.from(DISALLOWED_TOOLS).join(", ")}`
+        };
+      }
+      const executor = batchableToolExecutors[call.tool];
+      if (!executor) {
+        const availableTools = Object.keys(batchableToolExecutors).join(", ");
+        return {
+          tool: call.tool,
+          success: false,
+          error: `Tool '${call.tool}' not found. Available tools for batching: ${availableTools}`
+        };
+      }
+      const result = await executor(call.parameters, projectCwd);
+      return {
+        tool: call.tool,
+        success: result.success !== false,
+        // Treat undefined success as true
+        result
+      };
+    } catch (error) {
+      return {
+        tool: call.tool,
+        success: false,
+        error: error.message || String(error)
+      };
+    }
+  };
+  const results = await Promise.all(callsToExecute.map(executeCall));
+  for (const call of discardedCalls) {
+    results.push({
+      tool: call.tool,
+      success: false,
+      error: "Maximum of 10 tools allowed in batch"
+    });
+  }
+  const successfulCalls = results.filter((r) => r.success).length;
+  const failedCalls = results.length - successfulCalls;
+  const outputMessage = failedCalls > 0 ? `Executed ${successfulCalls}/${results.length} tools successfully. ${failedCalls} failed.` : `All ${successfulCalls} tools executed successfully.
+
+Keep using the batch tool for optimal performance in your next response!`;
+  return {
+    success: failedCalls === 0,
+    message: outputMessage,
+    totalCalls: results.length,
+    successful: successfulCalls,
+    failed: failedCalls,
+    results
+  };
+};
 
 // src/server.ts
 var INITIAL_RECONNECT_DELAY2 = 1e3;
@@ -2349,7 +2424,8 @@ var toolExecutors = {
   listDirectory: list,
   readFile: read_file,
   stringReplace: apply_patch,
-  runTerminalCommand
+  runTerminalCommand,
+  batch: batchTool
 };
 function connectToServer(serverUrl = DEFAULT_SERVER_URL) {
   const tokens = getTokens();
@@ -2667,7 +2743,7 @@ function getDaemonPid() {
     return null;
   }
 }
-var VERSION = "0.0.11";
+var VERSION = "0.0.12";
 var PROJECT_DIR = process.cwd();
 var LOGO = `
    __ _ _ __ ___   __ _ 

package/dist/lib/daemon-entry.cjs

@@ -2206,6 +2206,81 @@ var connectToUserStreams = async (serverUrl) => {
   });
   return ws;
 };
+var toolCallSchema = zod.z.object({
+  tool: zod.z.string().describe("The name of the tool to execute"),
+  parameters: zod.z.record(zod.z.string(), zod.z.unknown()).describe("Parameters for the tool")
+});
+zod.z.object({
+  tool_calls: zod.z.array(toolCallSchema).min(1, "Provide at least one tool call").max(10, "Maximum of 10 tools allowed in batch").describe("Array of tool calls to execute in parallel")
+});
+var DISALLOWED_TOOLS = /* @__PURE__ */ new Set(["batch"]);
+var batchableToolExecutors = {
+  deleteFile,
+  grep: grepTool,
+  glob: globTool,
+  listDirectory: list,
+  readFile: read_file,
+  runTerminalCommand
+};
+var batchTool = async function(input, projectCwd) {
+  const { tool_calls } = input;
+  const callsToExecute = tool_calls.slice(0, 10);
+  const discardedCalls = tool_calls.slice(10);
+  const executeCall = async (call) => {
+    try {
+      if (DISALLOWED_TOOLS.has(call.tool)) {
+        return {
+          tool: call.tool,
+          success: false,
+          error: `Tool '${call.tool}' is not allowed in batch. Disallowed tools: ${Array.from(DISALLOWED_TOOLS).join(", ")}`
+        };
+      }
+      const executor = batchableToolExecutors[call.tool];
+      if (!executor) {
+        const availableTools = Object.keys(batchableToolExecutors).join(", ");
+        return {
+          tool: call.tool,
+          success: false,
+          error: `Tool '${call.tool}' not found. Available tools for batching: ${availableTools}`
+        };
+      }
+      const result = await executor(call.parameters, projectCwd);
+      return {
+        tool: call.tool,
+        success: result.success !== false,
+        // Treat undefined success as true
+        result
+      };
+    } catch (error) {
+      return {
+        tool: call.tool,
+        success: false,
+        error: error.message || String(error)
+      };
+    }
+  };
+  const results = await Promise.all(callsToExecute.map(executeCall));
+  for (const call of discardedCalls) {
+    results.push({
+      tool: call.tool,
+      success: false,
+      error: "Maximum of 10 tools allowed in batch"
+    });
+  }
+  const successfulCalls = results.filter((r) => r.success).length;
+  const failedCalls = results.length - successfulCalls;
+  const outputMessage = failedCalls > 0 ? `Executed ${successfulCalls}/${results.length} tools successfully. ${failedCalls} failed.` : `All ${successfulCalls} tools executed successfully.
+
+Keep using the batch tool for optimal performance in your next response!`;
+  return {
+    success: failedCalls === 0,
+    message: outputMessage,
+    totalCalls: results.length,
+    successful: successfulCalls,
+    failed: failedCalls,
+    results
+  };
+};
 
 // src/server.ts
 var INITIAL_RECONNECT_DELAY2 = 1e3;
@@ -2228,7 +2303,8 @@ var toolExecutors = {
   listDirectory: list,
   readFile: read_file,
   stringReplace: apply_patch,
-  runTerminalCommand
+  runTerminalCommand,
+  batch: batchTool
 };
 function connectToServer(serverUrl = DEFAULT_SERVER_URL) {
   const tokens = getTokens();

package/dist/lib/daemon-entry.js

@@ -2195,6 +2195,81 @@ var connectToUserStreams = async (serverUrl) => {
   });
   return ws;
 };
+var toolCallSchema = z.object({
+  tool: z.string().describe("The name of the tool to execute"),
+  parameters: z.record(z.string(), z.unknown()).describe("Parameters for the tool")
+});
+z.object({
+  tool_calls: z.array(toolCallSchema).min(1, "Provide at least one tool call").max(10, "Maximum of 10 tools allowed in batch").describe("Array of tool calls to execute in parallel")
+});
+var DISALLOWED_TOOLS = /* @__PURE__ */ new Set(["batch"]);
+var batchableToolExecutors = {
+  deleteFile,
+  grep: grepTool,
+  glob: globTool,
+  listDirectory: list,
+  readFile: read_file,
+  runTerminalCommand
+};
+var batchTool = async function(input, projectCwd) {
+  const { tool_calls } = input;
+  const callsToExecute = tool_calls.slice(0, 10);
+  const discardedCalls = tool_calls.slice(10);
+  const executeCall = async (call) => {
+    try {
+      if (DISALLOWED_TOOLS.has(call.tool)) {
+        return {
+          tool: call.tool,
+          success: false,
+          error: `Tool '${call.tool}' is not allowed in batch. Disallowed tools: ${Array.from(DISALLOWED_TOOLS).join(", ")}`
+        };
+      }
+      const executor = batchableToolExecutors[call.tool];
+      if (!executor) {
+        const availableTools = Object.keys(batchableToolExecutors).join(", ");
+        return {
+          tool: call.tool,
+          success: false,
+          error: `Tool '${call.tool}' not found. Available tools for batching: ${availableTools}`
+        };
+      }
+      const result = await executor(call.parameters, projectCwd);
+      return {
+        tool: call.tool,
+        success: result.success !== false,
+        // Treat undefined success as true
+        result
+      };
+    } catch (error) {
+      return {
+        tool: call.tool,
+        success: false,
+        error: error.message || String(error)
+      };
+    }
+  };
+  const results = await Promise.all(callsToExecute.map(executeCall));
+  for (const call of discardedCalls) {
+    results.push({
+      tool: call.tool,
+      success: false,
+      error: "Maximum of 10 tools allowed in batch"
+    });
+  }
+  const successfulCalls = results.filter((r) => r.success).length;
+  const failedCalls = results.length - successfulCalls;
+  const outputMessage = failedCalls > 0 ? `Executed ${successfulCalls}/${results.length} tools successfully. ${failedCalls} failed.` : `All ${successfulCalls} tools executed successfully.
+
+Keep using the batch tool for optimal performance in your next response!`;
+  return {
+    success: failedCalls === 0,
+    message: outputMessage,
+    totalCalls: results.length,
+    successful: successfulCalls,
+    failed: failedCalls,
+    results
+  };
+};
 
 // src/server.ts
 var INITIAL_RECONNECT_DELAY2 = 1e3;
@@ -2217,7 +2292,8 @@ var toolExecutors = {
   listDirectory: list,
   readFile: read_file,
   stringReplace: apply_patch,
-  runTerminalCommand
+  runTerminalCommand,
+  batch: batchTool
 };
 function connectToServer(serverUrl = DEFAULT_SERVER_URL) {
   const tokens = getTokens();

package/dist/server.cjs

@@ -2206,6 +2206,81 @@ var connectToUserStreams = async (serverUrl) => {
   });
   return ws;
 };
+var toolCallSchema = zod.z.object({
+  tool: zod.z.string().describe("The name of the tool to execute"),
+  parameters: zod.z.record(zod.z.string(), zod.z.unknown()).describe("Parameters for the tool")
+});
+zod.z.object({
+  tool_calls: zod.z.array(toolCallSchema).min(1, "Provide at least one tool call").max(10, "Maximum of 10 tools allowed in batch").describe("Array of tool calls to execute in parallel")
+});
+var DISALLOWED_TOOLS = /* @__PURE__ */ new Set(["batch"]);
+var batchableToolExecutors = {
+  deleteFile,
+  grep: grepTool,
+  glob: globTool,
+  listDirectory: list,
+  readFile: read_file,
+  runTerminalCommand
+};
+var batchTool = async function(input, projectCwd) {
+  const { tool_calls } = input;
+  const callsToExecute = tool_calls.slice(0, 10);
+  const discardedCalls = tool_calls.slice(10);
+  const executeCall = async (call) => {
+    try {
+      if (DISALLOWED_TOOLS.has(call.tool)) {
+        return {
+          tool: call.tool,
+          success: false,
+          error: `Tool '${call.tool}' is not allowed in batch. Disallowed tools: ${Array.from(DISALLOWED_TOOLS).join(", ")}`
+        };
+      }
+      const executor = batchableToolExecutors[call.tool];
+      if (!executor) {
+        const availableTools = Object.keys(batchableToolExecutors).join(", ");
+        return {
+          tool: call.tool,
+          success: false,
+          error: `Tool '${call.tool}' not found. Available tools for batching: ${availableTools}`
+        };
+      }
+      const result = await executor(call.parameters, projectCwd);
+      return {
+        tool: call.tool,
+        success: result.success !== false,
+        // Treat undefined success as true
+        result
+      };
+    } catch (error) {
+      return {
+        tool: call.tool,
+        success: false,
+        error: error.message || String(error)
+      };
+    }
+  };
+  const results = await Promise.all(callsToExecute.map(executeCall));
+  for (const call of discardedCalls) {
+    results.push({
+      tool: call.tool,
+      success: false,
+      error: "Maximum of 10 tools allowed in batch"
+    });
+  }
+  const successfulCalls = results.filter((r) => r.success).length;
+  const failedCalls = results.length - successfulCalls;
+  const outputMessage = failedCalls > 0 ? `Executed ${successfulCalls}/${results.length} tools successfully. ${failedCalls} failed.` : `All ${successfulCalls} tools executed successfully.
+
+Keep using the batch tool for optimal performance in your next response!`;
+  return {
+    success: failedCalls === 0,
+    message: outputMessage,
+    totalCalls: results.length,
+    successful: successfulCalls,
+    failed: failedCalls,
+    results
+  };
+};
 
 // src/server.ts
 var INITIAL_RECONNECT_DELAY2 = 1e3;
@@ -2228,7 +2303,8 @@ var toolExecutors = {
   listDirectory: list,
   readFile: read_file,
   stringReplace: apply_patch,
-  runTerminalCommand
+  runTerminalCommand,
+  batch: batchTool
 };
 function getConnectionStatus(ws) {
   return ws.readyState === WebSocket2__default.default.CONNECTING ? "connecting" : ws.readyState === WebSocket2__default.default.OPEN ? "open" : ws.readyState === WebSocket2__default.default.CLOSING ? "closing" : "closed";

package/dist/server.js

@@ -2195,6 +2195,81 @@ var connectToUserStreams = async (serverUrl) => {
   });
   return ws;
 };
+var toolCallSchema = z.object({
+  tool: z.string().describe("The name of the tool to execute"),
+  parameters: z.record(z.string(), z.unknown()).describe("Parameters for the tool")
+});
+z.object({
+  tool_calls: z.array(toolCallSchema).min(1, "Provide at least one tool call").max(10, "Maximum of 10 tools allowed in batch").describe("Array of tool calls to execute in parallel")
+});
+var DISALLOWED_TOOLS = /* @__PURE__ */ new Set(["batch"]);
+var batchableToolExecutors = {
+  deleteFile,
+  grep: grepTool,
+  glob: globTool,
+  listDirectory: list,
+  readFile: read_file,
+  runTerminalCommand
+};
+var batchTool = async function(input, projectCwd) {
+  const { tool_calls } = input;
+  const callsToExecute = tool_calls.slice(0, 10);
+  const discardedCalls = tool_calls.slice(10);
+  const executeCall = async (call) => {
+    try {
+      if (DISALLOWED_TOOLS.has(call.tool)) {
+        return {
+          tool: call.tool,
+          success: false,
+          error: `Tool '${call.tool}' is not allowed in batch. Disallowed tools: ${Array.from(DISALLOWED_TOOLS).join(", ")}`
+        };
+      }
+      const executor = batchableToolExecutors[call.tool];
+      if (!executor) {
+        const availableTools = Object.keys(batchableToolExecutors).join(", ");
+        return {
+          tool: call.tool,
+          success: false,
+          error: `Tool '${call.tool}' not found. Available tools for batching: ${availableTools}`
+        };
+      }
+      const result = await executor(call.parameters, projectCwd);
+      return {
+        tool: call.tool,
+        success: result.success !== false,
+        // Treat undefined success as true
+        result
+      };
+    } catch (error) {
+      return {
+        tool: call.tool,
+        success: false,
+        error: error.message || String(error)
+      };
+    }
+  };
+  const results = await Promise.all(callsToExecute.map(executeCall));
+  for (const call of discardedCalls) {
+    results.push({
+      tool: call.tool,
+      success: false,
+      error: "Maximum of 10 tools allowed in batch"
+    });
+  }
+  const successfulCalls = results.filter((r) => r.success).length;
+  const failedCalls = results.length - successfulCalls;
+  const outputMessage = failedCalls > 0 ? `Executed ${successfulCalls}/${results.length} tools successfully. ${failedCalls} failed.` : `All ${successfulCalls} tools executed successfully.
+
+Keep using the batch tool for optimal performance in your next response!`;
+  return {
+    success: failedCalls === 0,
+    message: outputMessage,
+    totalCalls: results.length,
+    successful: successfulCalls,
+    failed: failedCalls,
+    results
+  };
+};
 
 // src/server.ts
 var INITIAL_RECONNECT_DELAY2 = 1e3;
@@ -2217,7 +2292,8 @@ var toolExecutors = {
   listDirectory: list,
   readFile: read_file,
   stringReplace: apply_patch,
-  runTerminalCommand
+  runTerminalCommand,
+  batch: batchTool
 };
 function getConnectionStatus(ws) {
   return ws.readyState === WebSocket2.CONNECTING ? "connecting" : ws.readyState === WebSocket2.OPEN ? "open" : ws.readyState === WebSocket2.CLOSING ? "closing" : "closed";

package/package.json

@@ -1,62 +1,62 @@
 {
-    "name": "amai",
-    "type": "module",
-    "version": "0.0.11",
-    "description": "ama cli",
-    "keywords": [
-        "ama",
-        "cli",
-        "agent",
-        "local",
-        "tools"
-    ],
-    "author": "",
-    "license": "ISC",
-    "repository": {
-        "type": "git"
+  "name": "amai",
+  "type": "module",
+  "version": "0.0.12",
+  "description": "ama cli",
+  "keywords": [
+    "ama",
+    "cli",
+    "agent",
+    "local",
+    "tools"
+  ],
+  "author": "",
+  "license": "ISC",
+  "repository": {
+    "type": "git"
+  },
+  "prepare": "bun run build",
+  "bin": {
+    "amai": "./dist/cli.js"
+  },
+  "main": "./dist/cli.js",
+  "types": "./dist/cli.d.ts",
+  "exports": {
+    "./server": {
+      "types": "./dist/server.d.ts",
+      "import": "./dist/server.js",
+      "require": "./dist/server.cjs"
     },
-    "prepare": "bun run build",
-    "bin": {
-        "amai": "./dist/cli.js"
-    },
-    "main": "./dist/cli.js",
-    "types": "./dist/cli.d.ts",
-    "exports": {
-        "./server": {
-            "types": "./dist/server.d.ts",
-            "import": "./dist/server.js",
-            "require": "./dist/server.cjs"
-        },
-        "./dist/*": "./dist/*.js",
-        "./dist/*.js": "./dist/*.js"
-    },
-    "browser": "dist/client.global.js",
-    "files": [
-        "dist"
-    ],
-    "scripts": {
-        "dev": "tsup --watch",
-        "build": "rm -rf dist && NODE_ENV=production tsup",
-        "prepublishOnly": "bun run build",
-        "install-global": "bun run build && npm link || bun link"
-    },
-    "devDependencies": {
-        "@types/bun": "latest",
-        "@types/ws": "^8.18.1"
-    },
-    "peerDependencies": {
-        "typescript": "^5"
-    },
-    "dependencies": {
-        "@hono/node-server": "^1.19.7",
-        "hono": "^4.10.7",
-        "picocolors": "^1.1.1",
-        "react-grab": "^0.0.74",
-        "tsup": "^8.5.1",
-        "ws": "^8.18.3",
-        "zod": "^4.1.13"
-    },
-    "publishConfig": {
-        "access": "public"
-    }
-}
+    "./dist/*": "./dist/*.js",
+    "./dist/*.js": "./dist/*.js"
+  },
+  "browser": "dist/client.global.js",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "dev": "tsup --watch",
+    "build": "rm -rf dist && NODE_ENV=production tsup",
+    "prepublishOnly": "bun run build",
+    "install-global": "bun run build && npm link || bun link"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "@types/ws": "^8.18.1"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "dependencies": {
+    "@hono/node-server": "^1.19.7",
+    "hono": "^4.10.7",
+    "picocolors": "^1.1.1",
+    "react-grab": "^0.0.74",
+    "tsup": "^8.5.1",
+    "ws": "^8.18.3",
+    "zod": "^4.1.13"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}