V1: Enhancements to ToolManager, LocalShell, and RunningJVM

Author: priyanahata

src/main/java/uno/anahata/ai/Chat.java

@@ -411,7 +411,10 @@ private boolean processAndReloopForFunctionCalls(ChatMessage modelMessageWithCal
             contextManager.add(message);
         }
 
-        return !executedCalls.isEmpty();
+        boolean anyKilled = processingResult.getOutcomes().stream()
+                .anyMatch(outcome -> outcome.getStatus() == ToolCallStatus.KILLED);
+
+        return !executedCalls.isEmpty() && !anyKilled;
     }
 
     private GenerateContentResponse sendToModelWithRetry(List<Content> context) {

src/main/java/uno/anahata/ai/tools/ToolCallOutcome.java

@@ -60,6 +60,12 @@ public String toFeedbackString(boolean dialogShown) {
             case CANCELLED: 
                 statusLabel = "NOT_EXECUTED (Dialog-cancelled)"; 
                 break;
+            case ERROR:
+                statusLabel = "ERROR";
+                break;
+            case KILLED:
+                statusLabel = "KILLED";
+                break;
             default: 
                 statusLabel = "NOT_EXECUTED";
         }

src/main/java/uno/anahata/ai/tools/ToolCallStatus.java

@@ -29,5 +29,11 @@ public enum ToolCallStatus {
     CANCELLED,
 
     /** The model attempted to call a tool while function calling was disabled by the user. */
-    DISABLED;
-}
+    DISABLED,
+
+    /** The tool was approved for execution, but the execution failed with an exception. */
+    ERROR,
+
+    /** The tool execution was explicitly killed/interrupted by the user. */
+    KILLED;
+}

src/main/java/uno/anahata/ai/tools/ToolManager.java

@@ -398,8 +398,15 @@ public FunctionProcessingResult processFunctionCalls(ChatMessage modelResponseMe
                     executedCalls.add(new ExecutedToolCall(idc.getSourcePart(), fr, rawResult));
 
                 } catch (Exception e) {
-                    log.error("Error executing tool call: {}", toolName, e);
-                    failureTracker.recordFailure(idc.getCall(), e);
+                    if (Thread.interrupted() || ExceptionUtils.indexOfThrowable(e, InterruptedException.class) != -1) {
+                        log.info("Tool call '{}' was interrupted/killed.", toolName);
+                        status = ToolCallStatus.KILLED;
+                    } else {
+                        log.error("Error executing tool call: {}", toolName, e);
+                        failureTracker.recordFailure(idc.getCall(), e);
+                        status = ToolCallStatus.ERROR;
+                    }
+                    
                     Map<String, Object> errorMap = new HashMap<>();
                     errorMap.put("error", ExceptionUtils.getStackTrace(e));
                     FunctionResponse errorResponse = FunctionResponse.builder()

src/main/java/uno/anahata/ai/tools/spi/LocalShell.java

@@ -10,21 +10,23 @@
 import java.util.Map;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Future;
+import lombok.extern.slf4j.Slf4j;
 import uno.anahata.ai.tools.AIToolMethod;
 import uno.anahata.ai.tools.AIToolParam;
 
 /**
  * A tool provider that allows the AI model to execute commands in the local
- * bash shell.
+ * shell (bash on Unix, cmd.exe on Windows).
  * <p>
  * This tool is powerful and should be used with caution. It captures standard
  * output, standard error, and execution metadata.
  * </p>
  */
+@Slf4j
 public class LocalShell {
 
     /**
-     * Executes a shell command using {@code bash -c}.
+     * Executes a shell command using the appropriate system shell.
      *
      * @param command The shell command to execute.
      * @return A map containing execution results:
@@ -40,8 +42,8 @@ public class LocalShell {
      * </ul>
      * @throws Exception if the command fails to start or execution is interrupted.
      */
-    @AIToolMethod("Runs a shell command with bash -c: <command> and returns a map with the following values:\n"
-            + " \n\tthreadId (it of the thread that executed the shell command, "
+    @AIToolMethod("Runs a shell command using the system's default shell (cmd.exe on Windows, bash on Unix) and returns a map with the following values:\n"
+            + " \n\tthreadId (id of the thread that executed the shell command, "
             + " \n\tpid, process id"
             + " \n\tstartTime, process start time as an ISO-8601 string"
             + " \n\tendTime, process end time as an ISO-8601 string"
@@ -51,10 +53,17 @@ public class LocalShell {
             + " \n\tstderr, process standard error"
     )
     public static Map<String, Object> runShell(@AIToolParam("The command to run") String command) throws Exception {
-        System.out.println("executeShellCommand: " + command);
+        log.info("executeShellCommand: {}", command);
         Map<String, Object> result = new HashMap<>();
 
-        ProcessBuilder pb = new ProcessBuilder("bash", "-c", command);
+        String os = System.getProperty("os.name").toLowerCase();
+        ProcessBuilder pb;
+        if (os.contains("win")) {
+            pb = new ProcessBuilder("cmd.exe", "/c", command);
+        } else {
+            pb = new ProcessBuilder("bash", "-c", command);
+        }
+        
         pb.redirectErrorStream(false);
 
         Instant startTime = Instant.now();
@@ -110,4 +119,4 @@ public String call() throws IOException {
             return sb.toString();
         }
     }
-}
+}

src/main/java/uno/anahata/ai/tools/spi/RunningJVM.java

@@ -38,6 +38,22 @@
  * test, and run code dynamically. It uses an in-memory file manager and a
  * custom classloader to ensure that newly compiled classes take precedence.
  * </p>
+ * 
+ * <h3>The Hot-Reload Mechanism:</h3>
+ * <p>
+ * When code is compiled via {@link #compileJava(String, String, String, String[])}, the resulting 
+ * bytecode is stored in memory. A custom {@link URLClassLoader} is then created with a 
+ * <b>Child-First</b> strategy:
+ * </p>
+ * <ol>
+ *   <li>It first checks if the class is the one just compiled in memory.</li>
+ *   <li>If not, it attempts to load the class from the {@code extraClassPath} (e.g., a project's {@code target/classes}).</li>
+ *   <li>Only if the class is not found in either location does it delegate to the parent classloader (e.g. the IDE's classpath or the host application's classpath).</li>
+ * </ol>
+ * <p>
+ * This ensures that any changes you make to the code are reflected immediately, even if a version 
+ * of that class already exists in the IDE's main classpath.
+ * </p>
  *
  * @author anahata
  */
@@ -339,4 +355,4 @@ private static Object ensureJsonSerializable(Object value) {
 
         return value.toString();
     }
-}
+}