@mindstudio-ai/remy 0.1.35 → 0.1.36

package/dist/index.js

@@ -2059,7 +2059,7 @@ var init_screenshot = __esm({
     init_sidecar();
     init_runCli();
     init_logger();
-    SCREENSHOT_ANALYSIS_PROMPT = "Describe everything visible on screen from top to bottom \u2014 every element, its position, its size relative to the viewport, its colors, its content. Be thorough and spatial. After the inventory, note anything that looks visually broken (overlapping elements, clipped text, misaligned components).";
+    SCREENSHOT_ANALYSIS_PROMPT = "Describe everything visible on screen from top to bottom \u2014 every element, its position, its size relative to the viewport, its colors, its content. Be comprehensive, thorough, and spatial. After the inventory, note anything that looks visually broken (overlapping elements, clipped text, misaligned components). Respond only with your analysis as Markdown and absolutely no other text. Do not use emojis - use unicode if you need symbols.";
   }
 });
 
@@ -2097,6 +2097,91 @@ var init_screenshot2 = __esm({
   }
 });
 
+// src/statusWatcher.ts
+function startStatusWatcher(config) {
+  const { apiConfig, getContext, onStatus, interval = 3e3, signal } = config;
+  let lastLabel = "";
+  let inflight = false;
+  let stopped = false;
+  const url = `${apiConfig.baseUrl}/_internal/v2/agent/remy/generate-status`;
+  async function tick() {
+    if (stopped || signal?.aborted || inflight) {
+      return;
+    }
+    inflight = true;
+    try {
+      const ctx = getContext();
+      if (!ctx.assistantText && !ctx.lastToolName) {
+        log.debug("Status watcher: no context, skipping");
+        return;
+      }
+      log.debug("Status watcher: requesting label", {
+        textLength: ctx.assistantText.length,
+        lastToolName: ctx.lastToolName
+      });
+      const res = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${apiConfig.apiKey}`
+        },
+        body: JSON.stringify({
+          assistantText: ctx.assistantText.slice(-500),
+          lastToolName: ctx.lastToolName,
+          lastToolResult: ctx.lastToolResult?.slice(-200),
+          onboardingState: ctx.onboardingState,
+          userMessage: ctx.userMessage?.slice(-200)
+        }),
+        signal
+      });
+      if (!res.ok) {
+        log.debug("Status watcher: endpoint returned non-ok", {
+          status: res.status
+        });
+        return;
+      }
+      const data = await res.json();
+      if (!data.label) {
+        log.debug("Status watcher: no label in response");
+        return;
+      }
+      if (data.label === lastLabel) {
+        log.debug("Status watcher: duplicate label, skipping", {
+          label: data.label
+        });
+        return;
+      }
+      lastLabel = data.label;
+      if (stopped) {
+        return;
+      }
+      log.debug("Status watcher: emitting", { label: data.label });
+      onStatus(data.label);
+    } catch (err) {
+      log.debug("Status watcher: error", { error: err?.message ?? "unknown" });
+    } finally {
+      inflight = false;
+    }
+  }
+  const timer = setInterval(tick, interval);
+  tick().catch(() => {
+  });
+  log.debug("Status watcher started", { interval });
+  return {
+    stop() {
+      stopped = true;
+      clearInterval(timer);
+      log.debug("Status watcher stopped");
+    }
+  };
+}
+var init_statusWatcher = __esm({
+  "src/statusWatcher.ts"() {
+    "use strict";
+    init_logger();
+  }
+});
+
 // src/subagents/common/cleanMessages.ts
 function cleanMessagesForApi(messages) {
   return messages.map((msg) => {
@@ -2145,19 +2230,47 @@ async function runSubAgent(config) {
     signal,
     parentToolId,
     onEvent,
-    resolveExternalTool
+    resolveExternalTool,
+    toolRegistry
   } = config;
   const emit2 = (e) => {
     onEvent({ ...e, parentToolId });
   };
   const messages = [{ role: "user", content: task }];
+  function getPartialText(blocks) {
+    return blocks.filter((b) => b.type === "text").map((b) => b.text).join("");
+  }
+  function abortResult(blocks) {
+    if (signal?.reason === "graceful") {
+      const partial = getPartialText(blocks);
+      return {
+        text: partial ? `[INTERRUPTED]
+
+${partial}` : "[INTERRUPTED] Sub-agent was interrupted before producing output.",
+        messages
+      };
+    }
+    return { text: "Error: cancelled", messages };
+  }
+  let lastToolResult = "";
   while (true) {
     if (signal?.aborted) {
-      return { text: "Error: cancelled", messages };
+      return abortResult([]);
     }
     const contentBlocks = [];
     let thinkingStartedAt = 0;
     let stopReason = "end_turn";
+    let currentToolNames = "";
+    const statusWatcher = startStatusWatcher({
+      apiConfig,
+      getContext: () => ({
+        assistantText: getPartialText(contentBlocks),
+        lastToolName: currentToolNames || void 0,
+        lastToolResult: lastToolResult || void 0
+      }),
+      onStatus: (label) => emit2({ type: "status", message: label }),
+      signal
+    });
     const fullSystem = `${system}
 
 Current date/time: ${(/* @__PURE__ */ new Date()).toISOString().replace("T", " ").replace(/\.\d+Z$/, " UTC")}`;
@@ -2233,7 +2346,8 @@ Current date/time: ${(/* @__PURE__ */ new Date()).toISOString().replace("T", " "
       }
     }
     if (signal?.aborted) {
-      return { text: "Error: cancelled", messages };
+      statusWatcher.stop();
+      return abortResult(contentBlocks);
     }
     messages.push({
       role: "assistant",
@@ -2243,6 +2357,7 @@ Current date/time: ${(/* @__PURE__ */ new Date()).toISOString().replace("T", " "
       (b) => b.type === "tool"
     );
     if (stopReason !== "tool_use" || toolCalls.length === 0) {
+      statusWatcher.stop();
       const text = contentBlocks.filter((b) => b.type === "text").map((b) => b.text).join("");
       return { text, messages };
     }
@@ -2251,46 +2366,82 @@ Current date/time: ${(/* @__PURE__ */ new Date()).toISOString().replace("T", " "
       count: toolCalls.length,
       tools: toolCalls.map((tc) => tc.name)
     });
+    currentToolNames = toolCalls.map((tc) => tc.name).join(", ");
     const results = await Promise.all(
       toolCalls.map(async (tc) => {
         if (signal?.aborted) {
           return { id: tc.id, result: "Error: cancelled", isError: true };
         }
-        try {
-          let result;
-          if (externalTools.has(tc.name) && resolveExternalTool) {
-            result = await resolveExternalTool(tc.id, tc.name, tc.input);
-          } else {
-            const onLog = (line) => emit2({
-              type: "tool_input_delta",
-              id: tc.id,
-              name: tc.name,
-              result: line
+        let settle;
+        const resultPromise = new Promise((res) => {
+          settle = (result, isError) => res({ id: tc.id, result, isError });
+        });
+        let toolAbort = new AbortController();
+        const cascadeAbort = () => toolAbort.abort();
+        signal?.addEventListener("abort", cascadeAbort, { once: true });
+        let settled = false;
+        const safeSettle = (result, isError) => {
+          if (settled) {
+            return;
+          }
+          settled = true;
+          signal?.removeEventListener("abort", cascadeAbort);
+          settle(result, isError);
+        };
+        const run = async (input) => {
+          try {
+            let result;
+            if (externalTools.has(tc.name) && resolveExternalTool) {
+              result = await resolveExternalTool(tc.id, tc.name, input);
+            } else {
+              const onLog = (line) => emit2({
+                type: "tool_input_delta",
+                id: tc.id,
+                name: tc.name,
+                result: line
+              });
+              result = await executeTool2(tc.name, input, tc.id, onLog);
+            }
+            safeSettle(result, result.startsWith("Error"));
+          } catch (err) {
+            safeSettle(`Error: ${err.message}`, true);
+          }
+        };
+        const entry = {
+          id: tc.id,
+          name: tc.name,
+          input: tc.input,
+          parentToolId,
+          abortController: toolAbort,
+          startedAt: Date.now(),
+          settle: safeSettle,
+          rerun: (newInput) => {
+            settled = false;
+            toolAbort = new AbortController();
+            signal?.addEventListener("abort", () => toolAbort.abort(), {
+              once: true
             });
-            result = await executeTool2(tc.name, tc.input, tc.id, onLog);
+            entry.abortController = toolAbort;
+            entry.input = newInput;
+            run(newInput);
           }
-          const isError = result.startsWith("Error");
-          emit2({
-            type: "tool_done",
-            id: tc.id,
-            name: tc.name,
-            result,
-            isError
-          });
-          return { id: tc.id, result, isError };
-        } catch (err) {
-          const errorMsg = `Error: ${err.message}`;
-          emit2({
-            type: "tool_done",
-            id: tc.id,
-            name: tc.name,
-            result: errorMsg,
-            isError: true
-          });
-          return { id: tc.id, result: errorMsg, isError: true };
-        }
+        };
+        toolRegistry?.register(entry);
+        run(tc.input);
+        const r = await resultPromise;
+        toolRegistry?.unregister(tc.id);
+        emit2({
+          type: "tool_done",
+          id: tc.id,
+          name: tc.name,
+          result: r.result,
+          isError: r.isError
+        });
+        return r;
       })
     );
+    statusWatcher.stop();
+    lastToolResult = results.at(-1)?.result ?? "";
     for (const r of results) {
       const block = contentBlocks.find(
         (b) => b.type === "tool" && b.id === r.id
@@ -2298,6 +2449,7 @@ Current date/time: ${(/* @__PURE__ */ new Date()).toISOString().replace("T", " "
       if (block?.type === "tool") {
         block.result = r.result;
         block.isError = r.isError;
+        block.completedAt = Date.now();
       }
       messages.push({
         role: "user",
@@ -2313,6 +2465,7 @@ var init_runner = __esm({
     "use strict";
     init_api();
     init_logger();
+    init_statusWatcher();
     init_cleanMessages();
   }
 });
@@ -2604,7 +2757,8 @@ var init_browserAutomation = __esm({
               }
             }
             return result2;
-          }
+          },
+          toolRegistry: context.toolRegistry
         });
         context.subAgentMessages?.set(context.toolCallId, result.messages);
         return result.text;
@@ -2738,7 +2892,7 @@ Brief description of the types used on the page. If you can identify the actual
 ## Techniques
 Identify the specific design moves that make this page interesting and unique, described in terms of how a designer with a technical background would write them down as notes in their notebook for inspiration. Focus only on the non-obvious, hard-to-think-of techniques \u2014 the things that make this page gallery-worthy. Skip basics like "high contrast CTA" or "generous whitespace" that any competent designer already knows.
 
-Respond only with the analysis and absolutely no other text.
+Respond only with your analysis as Markdown and absolutely no other text. Do not use emojis - use unicode if you need symbols.
 `;
     definition3 = {
       name: "analyzeDesign",
@@ -2781,7 +2935,7 @@ var init_analyzeImage = __esm({
   "src/subagents/designExpert/tools/analyzeImage.ts"() {
     "use strict";
     init_runCli();
-    DEFAULT_PROMPT = "Describe everything visible in this image \u2014 every element, its position, its size relative to the frame, its colors, its content. Be thorough and spatial. After the inventory, note anything that looks visually broken (overlapping elements, clipped text, misaligned components).";
+    DEFAULT_PROMPT = "Describe everything visible in this image \u2014 every element, its position, its size relative to the frame, its colors, its content. Be comprhensive, thorough and spatial. After the inventory, note anything that looks visually broken (overlapping elements, clipped text, misaligned components). Respond only with your analysis as Markdown and absolutely no other text. Do not use emojis - use unicode if you need symbols.";
     definition4 = {
       name: "analyzeImage",
       description: "Analyze an image by URL. Returns a detailed description of everything visible. Provide a custom prompt to ask a specific question instead of the default full description.",
@@ -2880,7 +3034,7 @@ async function seedreamGenerate(opts) {
     );
     try {
       const parsed = JSON.parse(batchResult);
-      imageUrls = parsed.results.map(
+      imageUrls = parsed.map(
         (r) => r.output?.imageUrl ?? `Error: ${r.error}`
       );
     } catch {
@@ -2920,7 +3074,7 @@ var init_seedream = __esm({
   "src/subagents/designExpert/tools/_seedream.ts"() {
     "use strict";
     init_runCli();
-    ANALYZE_PROMPT = "You are reviewing this image for a visual designer sourcing assets for a project. Describe: what the image depicts, the mood and color palette, how the lighting and composition work, whether there are any issues (unwanted text, artifacts, distortions), and how it could be used in a layout (hero background, feature section, card texture, etc). Be concise and practical.";
+    ANALYZE_PROMPT = "You are reviewing this image for a visual designer sourcing assets for a project. Describe: what the image depicts, the mood and color palette, how the lighting and composition work, whether there are any issues (unwanted text, artifacts, distortions), and how it could be used in a layout (hero background, feature section, card texture, etc). Be concise and practical. Respond only with your analysis as Markdown and absolutely no other text. Do not use emojis - use unicode if you need symbols.";
   }
 });
 
@@ -3345,7 +3499,8 @@ Visual design expert. Describe the situation and what you need \u2014 the agent
           signal: context.signal,
           parentToolId: context.toolCallId,
           onEvent: context.onEvent,
-          resolveExternalTool: context.resolveExternalTool
+          resolveExternalTool: context.resolveExternalTool,
+          toolRegistry: context.toolRegistry
         });
         context.subAgentMessages?.set(context.toolCallId, result.messages);
         return result.text;
@@ -3660,7 +3815,8 @@ var init_productVision = __esm({
           signal: context.signal,
           parentToolId: context.toolCallId,
           onEvent: context.onEvent,
-          resolveExternalTool: context.resolveExternalTool
+          resolveExternalTool: context.resolveExternalTool,
+          toolRegistry: context.toolRegistry
         });
         context.subAgentMessages?.set(context.toolCallId, result.messages);
         return result.text;
@@ -3814,7 +3970,8 @@ var init_codeSanityCheck = __esm({
           signal: context.signal,
           parentToolId: context.toolCallId,
           onEvent: context.onEvent,
-          resolveExternalTool: context.resolveExternalTool
+          resolveExternalTool: context.resolveExternalTool,
+          toolRegistry: context.toolRegistry
         });
         context.subAgentMessages?.set(context.toolCallId, result.messages);
         return result.text;
@@ -4186,91 +4343,6 @@ var init_parsePartialJson = __esm({
   }
 });
 
-// src/statusWatcher.ts
-function startStatusWatcher(config) {
-  const { apiConfig, getContext, onStatus, interval = 3e3, signal } = config;
-  let lastLabel = "";
-  let inflight = false;
-  let stopped = false;
-  const url = `${apiConfig.baseUrl}/_internal/v2/agent/remy/generate-status`;
-  async function tick() {
-    if (stopped || signal?.aborted || inflight) {
-      return;
-    }
-    inflight = true;
-    try {
-      const ctx = getContext();
-      if (!ctx.assistantText && !ctx.lastToolName) {
-        log.debug("Status watcher: no context, skipping");
-        return;
-      }
-      log.debug("Status watcher: requesting label", {
-        textLength: ctx.assistantText.length,
-        lastToolName: ctx.lastToolName
-      });
-      const res = await fetch(url, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: `Bearer ${apiConfig.apiKey}`
-        },
-        body: JSON.stringify({
-          assistantText: ctx.assistantText.slice(-500),
-          lastToolName: ctx.lastToolName,
-          lastToolResult: ctx.lastToolResult?.slice(-200),
-          onboardingState: ctx.onboardingState,
-          userMessage: ctx.userMessage?.slice(-200)
-        }),
-        signal
-      });
-      if (!res.ok) {
-        log.debug("Status watcher: endpoint returned non-ok", {
-          status: res.status
-        });
-        return;
-      }
-      const data = await res.json();
-      if (!data.label) {
-        log.debug("Status watcher: no label in response");
-        return;
-      }
-      if (data.label === lastLabel) {
-        log.debug("Status watcher: duplicate label, skipping", {
-          label: data.label
-        });
-        return;
-      }
-      lastLabel = data.label;
-      if (stopped) {
-        return;
-      }
-      log.debug("Status watcher: emitting", { label: data.label });
-      onStatus(data.label);
-    } catch (err) {
-      log.debug("Status watcher: error", { error: err?.message ?? "unknown" });
-    } finally {
-      inflight = false;
-    }
-  }
-  const timer = setInterval(tick, interval);
-  tick().catch(() => {
-  });
-  log.debug("Status watcher started", { interval });
-  return {
-    stop() {
-      stopped = true;
-      clearInterval(timer);
-      log.debug("Status watcher stopped");
-    }
-  };
-}
-var init_statusWatcher = __esm({
-  "src/statusWatcher.ts"() {
-    "use strict";
-    init_logger();
-  }
-});
-
 // src/errors.ts
 function friendlyError(raw) {
   for (const [pattern, message] of patterns) {
@@ -4327,7 +4399,8 @@ async function runTurn(params) {
     signal,
     onEvent,
     resolveExternalTool,
-    hidden
+    hidden,
+    toolRegistry
   } = params;
   const tools2 = getToolDefinitions(onboardingState);
   log.info("Turn started", {
@@ -4380,6 +4453,20 @@ async function runTurn(params) {
     let thinkingStartedAt = 0;
     const toolInputAccumulators = /* @__PURE__ */ new Map();
     let stopReason = "end_turn";
+    let subAgentText = "";
+    let currentToolNames = "";
+    const statusWatcher = startStatusWatcher({
+      apiConfig,
+      getContext: () => ({
+        assistantText: subAgentText || getTextContent(contentBlocks).slice(-500),
+        lastToolName: currentToolNames || getToolCalls(contentBlocks).filter((tc) => !STATUS_EXCLUDED_TOOLS.has(tc.name)).at(-1)?.name || lastCompletedTools || void 0,
+        lastToolResult: lastCompletedResult || void 0,
+        onboardingState,
+        userMessage
+      }),
+      onStatus: (label) => onEvent({ type: "status", message: label }),
+      signal
+    });
     async function handlePartialInput(acc, id, name, partial) {
       const tool = getToolByName(name);
       if (!tool?.streaming) {
@@ -4443,18 +4530,6 @@ async function runTurn(params) {
         onEvent({ type: "tool_input_delta", id, name, result: content });
       }
     }
-    const statusWatcher = startStatusWatcher({
-      apiConfig,
-      getContext: () => ({
-        assistantText: getTextContent(contentBlocks).slice(-500),
-        lastToolName: getToolCalls(contentBlocks).filter((tc) => !STATUS_EXCLUDED_TOOLS.has(tc.name)).at(-1)?.name || lastCompletedTools || void 0,
-        lastToolResult: lastCompletedResult || void 0,
-        onboardingState,
-        userMessage
-      }),
-      onStatus: (label) => onEvent({ type: "status", message: label }),
-      signal
-    });
     try {
       for await (const event of streamChatWithRetry(
         {
@@ -4575,10 +4650,9 @@ async function runTurn(params) {
       } else {
         throw err;
       }
-    } finally {
-      statusWatcher.stop();
     }
     if (signal?.aborted) {
+      statusWatcher.stop();
       if (contentBlocks.length > 0) {
         contentBlocks.push({
           type: "text",
@@ -4600,6 +4674,7 @@ async function runTurn(params) {
     });
     const toolCalls = getToolCalls(contentBlocks);
     if (stopReason !== "tool_use" || toolCalls.length === 0) {
+      statusWatcher.stop();
       saveSession(state);
       onEvent({ type: "turn_done" });
       return;
@@ -4608,8 +4683,7 @@ async function runTurn(params) {
       count: toolCalls.length,
       tools: toolCalls.map((tc) => tc.name)
     });
-    let subAgentText = "";
-    const origOnEvent = onEvent;
+    currentToolNames = toolCalls.filter((tc) => !STATUS_EXCLUDED_TOOLS.has(tc.name)).map((tc) => tc.name).join(", ");
     const wrappedOnEvent = (e) => {
       if ("parentToolId" in e && e.parentToolId) {
         if (e.type === "text") {
@@ -4618,86 +4692,103 @@ async function runTurn(params) {
           subAgentText = `Using ${e.name}`;
         }
       }
-      origOnEvent(e);
+      onEvent(e);
     };
-    const toolStatusWatcher = startStatusWatcher({
-      apiConfig,
-      getContext: () => ({
-        assistantText: subAgentText || getTextContent(contentBlocks).slice(-500),
-        lastToolName: toolCalls.filter((tc) => !STATUS_EXCLUDED_TOOLS.has(tc.name)).map((tc) => tc.name).join(", ") || void 0,
-        lastToolResult: lastCompletedResult || void 0,
-        onboardingState,
-        userMessage
-      }),
-      onStatus: (label) => origOnEvent({ type: "status", message: label }),
-      signal
-    });
     const subAgentMessages = /* @__PURE__ */ new Map();
     const results = await Promise.all(
       toolCalls.map(async (tc) => {
         if (signal?.aborted) {
-          return {
-            id: tc.id,
-            result: "Error: cancelled",
-            isError: true
-          };
+          return { id: tc.id, result: "Error: cancelled", isError: true };
         }
         const toolStart = Date.now();
-        try {
-          let result;
-          if (EXTERNAL_TOOLS.has(tc.name) && resolveExternalTool) {
-            saveSession(state);
-            log.info("Waiting for external tool result", {
-              name: tc.name,
-              id: tc.id
-            });
-            result = await resolveExternalTool(tc.id, tc.name, tc.input);
-          } else {
-            result = await executeTool(tc.name, tc.input, {
-              apiConfig,
-              model,
-              signal,
-              onEvent: wrappedOnEvent,
-              resolveExternalTool,
-              toolCallId: tc.id,
-              subAgentMessages,
-              onLog: (line) => wrappedOnEvent({
-                type: "tool_input_delta",
-                id: tc.id,
+        let settle;
+        const resultPromise = new Promise((res) => {
+          settle = (result, isError) => res({ id: tc.id, result, isError });
+        });
+        let toolAbort = new AbortController();
+        const cascadeAbort = () => toolAbort.abort();
+        signal?.addEventListener("abort", cascadeAbort, { once: true });
+        let settled = false;
+        const safeSettle = (result, isError) => {
+          if (settled) {
+            return;
+          }
+          settled = true;
+          signal?.removeEventListener("abort", cascadeAbort);
+          settle(result, isError);
+        };
+        const run = async (input) => {
+          try {
+            let result;
+            if (EXTERNAL_TOOLS.has(tc.name) && resolveExternalTool) {
+              saveSession(state);
+              log.info("Waiting for external tool result", {
                 name: tc.name,
-                result: line
-              })
+                id: tc.id
+              });
+              result = await resolveExternalTool(tc.id, tc.name, input);
+            } else {
+              result = await executeTool(tc.name, input, {
+                apiConfig,
+                model,
+                signal: toolAbort.signal,
+                onEvent: wrappedOnEvent,
+                resolveExternalTool,
+                toolCallId: tc.id,
+                subAgentMessages,
+                toolRegistry,
+                onLog: (line) => wrappedOnEvent({
+                  type: "tool_input_delta",
+                  id: tc.id,
+                  name: tc.name,
+                  result: line
+                })
+              });
+            }
+            safeSettle(result, result.startsWith("Error"));
+          } catch (err) {
+            safeSettle(`Error: ${err.message}`, true);
+          }
+        };
+        const entry = {
+          id: tc.id,
+          name: tc.name,
+          input: tc.input,
+          abortController: toolAbort,
+          startedAt: toolStart,
+          settle: safeSettle,
+          rerun: (newInput) => {
+            settled = false;
+            toolAbort = new AbortController();
+            signal?.addEventListener("abort", () => toolAbort.abort(), {
+              once: true
             });
+            entry.abortController = toolAbort;
+            entry.input = newInput;
+            run(newInput);
           }
-          const isError = result.startsWith("Error");
-          log.info("Tool completed", {
-            name: tc.name,
-            elapsed: `${Date.now() - toolStart}ms`,
-            isError,
-            resultLength: result.length
-          });
-          onEvent({
-            type: "tool_done",
-            id: tc.id,
-            name: tc.name,
-            result,
-            isError
-          });
-          return { id: tc.id, result, isError };
-        } catch (err) {
-          const errorMsg = `Error: ${err.message}`;
-          onEvent({
-            type: "tool_done",
-            id: tc.id,
-            name: tc.name,
-            result: errorMsg,
-            isError: true
-          });
-          return { id: tc.id, result: errorMsg, isError: true };
-        }
+        };
+        toolRegistry?.register(entry);
+        run(tc.input);
+        const r = await resultPromise;
+        toolRegistry?.unregister(tc.id);
+        log.info("Tool completed", {
+          name: tc.name,
+          elapsed: `${Date.now() - toolStart}ms`,
+          isError: r.isError,
+          resultLength: r.result.length
+        });
+        onEvent({
+          type: "tool_done",
+          id: tc.id,
+          name: tc.name,
+          result: r.result,
+          isError: r.isError
+        });
+        return r;
       })
     );
-    toolStatusWatcher.stop();
+    statusWatcher.stop();
     for (const r of results) {
       const block = contentBlocks.find(
         (b) => b.type === "tool" && b.id === r.id
@@ -4705,6 +4796,7 @@ async function runTurn(params) {
       if (block?.type === "tool") {
         block.result = r.result;
         block.isError = r.isError;
+        block.completedAt = Date.now();
         const msgs = subAgentMessages.get(r.id);
         if (msgs) {
           block.subAgentMessages = msgs;
@@ -5063,6 +5155,84 @@ var init_config = __esm({
   }
 });
 
+// src/toolRegistry.ts
+var ToolRegistry;
+var init_toolRegistry = __esm({
+  "src/toolRegistry.ts"() {
+    "use strict";
+    ToolRegistry = class {
+      entries = /* @__PURE__ */ new Map();
+      onEvent;
+      register(entry) {
+        this.entries.set(entry.id, entry);
+      }
+      unregister(id) {
+        this.entries.delete(id);
+      }
+      get(id) {
+        return this.entries.get(id);
+      }
+      /**
+       * Stop a running tool.
+       *
+       * - graceful: abort and settle with [INTERRUPTED] + partial result
+       * - hard: abort and settle with a generic error
+       *
+       * Returns true if the tool was found and stopped.
+       */
+      stop(id, mode) {
+        const entry = this.entries.get(id);
+        if (!entry) {
+          return false;
+        }
+        entry.abortController.abort(mode);
+        if (mode === "graceful") {
+          const partial = entry.getPartialResult?.() ?? "";
+          const result = partial ? `[INTERRUPTED]
+
+${partial}` : "[INTERRUPTED] Tool execution was stopped.";
+          entry.settle(result, false);
+        } else {
+          entry.settle("Error: tool was cancelled", true);
+        }
+        this.onEvent?.({
+          type: "tool_stopped",
+          id: entry.id,
+          name: entry.name,
+          mode,
+          ...entry.parentToolId && { parentToolId: entry.parentToolId }
+        });
+        this.entries.delete(id);
+        return true;
+      }
+      /**
+       * Restart a running tool with the same or patched input.
+       * The original controllable promise stays pending and settles
+       * when the new execution finishes.
+       *
+       * Returns true if the tool was found and restarted.
+       */
+      restart(id, patchedInput) {
+        const entry = this.entries.get(id);
+        if (!entry) {
+          return false;
+        }
+        entry.abortController.abort("restart");
+        const newInput = patchedInput ? { ...entry.input, ...patchedInput } : entry.input;
+        this.onEvent?.({
+          type: "tool_restarted",
+          id: entry.id,
+          name: entry.name,
+          input: newInput,
+          ...entry.parentToolId && { parentToolId: entry.parentToolId }
+        });
+        entry.rerun(newInput);
+        return true;
+      }
+    };
+  }
+});
+
 // src/headless.ts
 var headless_exports = {};
 __export(headless_exports, {
@@ -5134,6 +5304,7 @@ async function startHeadless(opts = {}) {
   const EXTERNAL_TOOL_TIMEOUT_MS = 3e5;
   const pendingTools = /* @__PURE__ */ new Map();
   const earlyResults = /* @__PURE__ */ new Map();
+  const toolRegistry = new ToolRegistry();
   const USER_FACING_TOOLS = /* @__PURE__ */ new Set([
     "promptUser",
     "confirmDestructiveAction",
@@ -5238,14 +5409,46 @@ async function startHeadless(opts = {}) {
           rid
         );
         return;
+      case "tool_stopped":
+        emit(
+          "tool_stopped",
+          {
+            id: e.id,
+            name: e.name,
+            mode: e.mode,
+            ...e.parentToolId && { parentToolId: e.parentToolId }
+          },
+          rid
+        );
+        return;
+      case "tool_restarted":
+        emit(
+          "tool_restarted",
+          {
+            id: e.id,
+            name: e.name,
+            input: e.input,
+            ...e.parentToolId && { parentToolId: e.parentToolId }
+          },
+          rid
+        );
+        return;
       case "status":
-        emit("status", { message: e.message }, rid);
+        emit(
+          "status",
+          {
+            message: e.message,
+            ...e.parentToolId && { parentToolId: e.parentToolId }
+          },
+          rid
+        );
         return;
       case "error":
         emit("error", { error: e.error }, rid);
         return;
     }
   }
+  toolRegistry.onEvent = onEvent;
   async function handleMessage(parsed, requestId) {
     if (running) {
       emit(
@@ -5297,7 +5500,8 @@ async function startHeadless(opts = {}) {
         signal: currentAbort.signal,
         onEvent,
         resolveExternalTool,
-        hidden: isCommand
+        hidden: isCommand,
+        toolRegistry
       });
       if (!completedEmitted) {
         emit(
@@ -5351,6 +5555,36 @@ async function startHeadless(opts = {}) {
       emit("completed", { success: true }, requestId);
       return;
     }
+    if (action === "stop_tool") {
+      const id = parsed.id;
+      const mode = parsed.mode ?? "hard";
+      const found = toolRegistry.stop(id, mode);
+      if (found) {
+        emit("completed", { success: true }, requestId);
+      } else {
+        emit(
+          "completed",
+          { success: false, error: "Tool not found" },
+          requestId
+        );
+      }
+      return;
+    }
+    if (action === "restart_tool") {
+      const id = parsed.id;
+      const patchedInput = parsed.input;
+      const found = toolRegistry.restart(id, patchedInput);
+      if (found) {
+        emit("completed", { success: true }, requestId);
+      } else {
+        emit(
+          "completed",
+          { success: false, error: "Tool not found" },
+          requestId
+        );
+      }
+      return;
+    }
     if (action === "message") {
       await handleMessage(parsed, requestId);
       return;
@@ -5385,6 +5619,7 @@ var init_headless = __esm({
     init_lsp();
     init_agent();
     init_session();
+    init_toolRegistry();
   }
 });