@within-7/minto 0.1.7 → 0.3.0

package/dist/tools/TaskTool/TaskTool.js

@@ -11,7 +11,8 @@ import { formatDuration, formatNumber } from "../../utils/format.js";
 import {
   getMessagesPath,
   getNextAvailableLogSidechainNumber,
-  overwriteLog
+  overwriteLog,
+  logError
 } from "../../utils/log.js";
 import {
   createAssistantMessage,
@@ -24,12 +25,30 @@ import { getModelManager } from "../../utils/model.js";
 import { getMaxThinkingTokens } from "../../utils/thinking.js";
 import { getTheme } from "../../utils/theme.js";
 import { generateAgentId } from "../../utils/agentStorage.js";
+import { debug as debugLogger } from "../../utils/debugLogger.js";
 import { getTaskTools, getPrompt } from "./prompt.js";
 import { TOOL_NAME } from "./constants.js";
 import {
   getAgentByType,
   getAvailableAgentTypes
 } from "../../utils/agentLoader.js";
+import {
+  createAgentTranscript,
+  getResumableTranscript,
+  appendMessageToTranscript,
+  updateAgentTranscript,
+  completeAgentTranscript,
+  failAgentTranscript,
+  interruptAgentTranscript,
+  canResumeTranscript,
+  registerToolUseAgent
+} from "../../utils/agentTranscripts.js";
+import { UserFriendlyError } from "../../utils/userFriendlyError.js";
+import {
+  pushAgentContext,
+  popAgentContext,
+  cleanupAgentStreamingState
+} from "../../components/Spinner.js";
 const inputSchema = z.object({
   description: z.string().describe("A short (3-5 word) description of the task"),
   prompt: z.string().describe("The task for the agent to perform"),
@@ -37,8 +56,12 @@ const inputSchema = z.object({
     "Optional: Specific model name to use for this task. If not provided, uses the default task model pointer."
   ),
   subagent_type: z.string().optional().describe(
-    'The specialized agent type (MUST use hyphens, e.g., "strategic-market-analyzer"). For research/analysis use "strategic-market-analyzer" or "business-analyst", for data use "data-scientist", for general use "general-purpose". NEVER use underscores or invent names like "researcher".'
+    'The specialized agent type to use. MUST be an exact name from the available agents list in the tool description. Defaults to "general-purpose" if not specified.'
+  ),
+  resume: z.string().optional().describe(
+    "Optional agent ID to resume from. If provided, the agent will continue from the previous execution transcript."
   )
+  // run_in_background parameter removed - concurrent execution is automatic
 });
 const TaskTool = {
   async prompt({ safeMode }) {
@@ -47,17 +70,49 @@ const TaskTool = {
   name: TOOL_NAME,
   async description() {
     const availableTypes = await getAvailableAgentTypes();
-    const typesList = availableTypes.slice(0, 10).join(", ") + (availableTypes.length > 10 ? "..." : "");
-    return `Launch a specialized agent to handle tasks autonomously. CRITICAL: Use exact agent type names with hyphens (e.g., "strategic-market-analyzer", NOT "researcher" or "market_analyzer"). Available: ${typesList}`;
+    const typesList = availableTypes.join(", ");
+    return `Launch a specialized agent to handle tasks autonomously. You MUST use an exact agent type name from this list: ${typesList}. Default to "general-purpose" if unsure.`;
   },
   inputSchema,
-  async *call({ description, prompt, model_name, subagent_type }, {
+  async *call({ description, prompt, model_name, subagent_type, resume }, {
     abortController,
     options: { safeMode = false, forkNumber, messageLogName, verbose },
-    readFileTimestamps
+    readFileTimestamps,
+    toolUseId
   }) {
     const startTime = Date.now();
     const agentType = subagent_type || "general-purpose";
+    let resumedTranscript = null;
+    let agentId;
+    if (resume) {
+      resumedTranscript = getResumableTranscript(resume);
+      if (!resumedTranscript) {
+        yield {
+          type: "result",
+          data: [
+            {
+              type: "text",
+              text: `Cannot resume agent '${resume}': transcript not found or not resumable (status must be 'running' or 'interrupted')`
+            }
+          ],
+          resultForAssistant: `Cannot resume agent '${resume}': transcript not found or not resumable`
+        };
+        return;
+      }
+      agentId = resume;
+      debugLogger.info("TASK_AGENT_RESUMING", {
+        agentId,
+        agentType: resumedTranscript.agentType,
+        messageCount: resumedTranscript.messages.length,
+        previousStatus: resumedTranscript.status
+      });
+    } else {
+      agentId = generateAgentId();
+    }
+    if (toolUseId) {
+      registerToolUseAgent(toolUseId, agentId);
+    }
+    let hasYieldedResult = false;
     let effectivePrompt = prompt;
     let effectiveModel = model_name || "task";
     let toolFilter = null;
@@ -77,6 +132,7 @@ Use /agents command to manage agent configurations.`;
           data: [{ type: "text", text: helpMessage }],
           resultForAssistant: helpMessage
         };
+        hasYieldedResult = true;
         return;
       }
       if (agentConfig.systemPrompt) {
@@ -91,7 +147,7 @@ ${prompt}`;
       }
       toolFilter = agentConfig.tools;
     }
-    const messages = [createUserMessage(effectivePrompt)];
+    const messages = resumedTranscript ? [...resumedTranscript.messages] : [createUserMessage(effectivePrompt)];
     let tools = await getTaskTools(safeMode);
     if (toolFilter) {
       const isAllArray = Array.isArray(toolFilter) && toolFilter.length === 1 && toolFilter[0] === "*";
@@ -101,12 +157,31 @@ ${prompt}`;
       }
     }
     const modelToUse = effectiveModel;
-    yield {
-      type: "progress",
-      content: createAssistantMessage(`Starting agent: ${agentType}`),
-      normalizedMessages: normalizeMessages(messages),
-      tools
-    };
+    if (resumedTranscript) {
+      yield {
+        type: "progress",
+        content: createAssistantMessage(
+          `Resuming agent: ${agentType} (${agentId})`
+        ),
+        normalizedMessages: normalizeMessages(messages),
+        tools
+      };
+      yield {
+        type: "progress",
+        content: createAssistantMessage(
+          `Restored ${resumedTranscript.messages.length} messages, ${resumedTranscript.toolUseCount} tool uses`
+        ),
+        normalizedMessages: normalizeMessages(messages),
+        tools
+      };
+    } else {
+      yield {
+        type: "progress",
+        content: createAssistantMessage(`Starting agent: ${agentType}`),
+        normalizedMessages: normalizeMessages(messages),
+        tools
+      };
+    }
     yield {
       type: "progress",
       content: createAssistantMessage(`Using model: ${modelToUse}`),
@@ -136,11 +211,30 @@ ${prompt}`;
       `
 IMPORTANT: You are currently running as ${modelToUse}. You do not need to consult ${modelToUse} via AskExpertModel since you ARE ${modelToUse}. Complete tasks directly using your capabilities.`
     );
-    let toolUseCount = 0;
+    let toolUseCount = resumedTranscript?.toolUseCount || 0;
     const getSidechainNumber = memoize(
       () => getNextAvailableLogSidechainNumber(messageLogName, forkNumber)
     );
-    const taskId = generateAgentId();
+    if (!resumedTranscript) {
+      createAgentTranscript({
+        agentId,
+        agentType,
+        toolUseId,
+        // Include toolUseId for event-driven UI updates
+        description,
+        prompt,
+        model: modelToUse,
+        forkNumber,
+        messageLogName,
+        messages: [...messages],
+        toolUseCount: 0
+      });
+    } else {
+      appendMessageToTranscript(
+        agentId,
+        createUserMessage(`[Resumed] ${prompt}`)
+      );
+    }
     const queryOptions = {
       safeMode,
       forkNumber,
@@ -154,103 +248,195 @@ IMPORTANT: You are currently running as ${modelToUse}. You do not need to consul
     if (temperature !== void 0) {
       queryOptions["temperature"] = temperature;
     }
-    for await (const message of query(
-      messages,
-      taskPrompt,
-      context,
-      hasPermissionsToUseTool,
-      {
-        abortController,
-        options: queryOptions,
-        messageId: getLastAssistantMessageId(messages),
-        agentId: taskId,
-        readFileTimestamps,
-        setToolJSX: () => {
+    pushAgentContext(agentId);
+    try {
+      for await (const message of query(
+        messages,
+        taskPrompt,
+        context,
+        hasPermissionsToUseTool,
+        {
+          abortController,
+          options: queryOptions,
+          messageId: getLastAssistantMessageId(messages),
+          agentId,
+          readFileTimestamps,
+          setToolJSX: () => {
+          }
+          // No-op implementation for TaskTool
         }
-        // No-op implementation for TaskTool
-      }
-    )) {
-      messages.push(message);
-      overwriteLog(
-        getMessagesPath(messageLogName, forkNumber, getSidechainNumber()),
-        messages.filter((_) => _.type !== "progress")
-      );
-      if (message.type !== "assistant") {
-        continue;
-      }
-      const normalizedMessages2 = normalizeMessages(messages);
-      for (const content of message.message.content) {
-        if (content.type === "text" && content.text && content.text !== INTERRUPT_MESSAGE) {
-          const preview = content.text.length > 200 ? content.text.substring(0, 200) + "..." : content.text;
-          yield {
-            type: "progress",
-            content: createAssistantMessage(`${preview}`),
-            normalizedMessages: normalizedMessages2,
-            tools
-          };
-        } else if (content.type === "tool_use") {
-          toolUseCount++;
-          const toolMessage = normalizedMessages2.find(
-            (_) => _.type === "assistant" && _.message.content[0]?.type === "tool_use" && _.message.content[0].id === content.id
-          );
-          if (toolMessage) {
-            const modifiedMessage = {
-              ...toolMessage,
-              message: {
-                ...toolMessage.message,
-                content: toolMessage.message.content.map((c) => {
-                  if (c.type === "tool_use" && c.id === content.id) {
-                    return {
-                      ...c,
-                      name: c.name
-                      // Keep original name, UI will handle display
-                    };
-                  }
-                  return c;
-                })
-              }
-            };
+      )) {
+        messages.push(message);
+        appendMessageToTranscript(agentId, message);
+        overwriteLog(
+          getMessagesPath(messageLogName, forkNumber, getSidechainNumber()),
+          messages.filter((_) => _.type !== "progress")
+        );
+        if (message.type !== "assistant") {
+          continue;
+        }
+        if (message.message.usage) {
+          updateAgentTranscript(agentId, {
+            tokenUsage: {
+              inputTokens: message.message.usage.input_tokens,
+              outputTokens: message.message.usage.output_tokens,
+              cacheReadTokens: message.message.usage.cache_read_input_tokens,
+              cacheCreationTokens: message.message.usage.cache_creation_input_tokens
+            }
+          });
+        }
+        const normalizedMessages2 = normalizeMessages(messages);
+        for (const content of message.message.content) {
+          if (content.type === "text" && content.text && content.text !== INTERRUPT_MESSAGE) {
+            const preview = content.text.length > 200 ? content.text.substring(0, 200) + "..." : content.text;
             yield {
               type: "progress",
-              content: modifiedMessage,
+              content: createAssistantMessage(`${preview}`),
               normalizedMessages: normalizedMessages2,
               tools
             };
+          } else if (content.type === "tool_use") {
+            toolUseCount++;
+            const toolMessage = normalizedMessages2.find(
+              (_) => _.type === "assistant" && _.message.content[0]?.type === "tool_use" && _.message.content[0].id === content.id
+            );
+            if (toolMessage) {
+              const modifiedMessage = {
+                ...toolMessage,
+                message: {
+                  ...toolMessage.message,
+                  content: toolMessage.message.content.map((c) => {
+                    if (c.type === "tool_use" && c.id === content.id) {
+                      return {
+                        ...c,
+                        name: c.name
+                        // Keep original name, UI will handle display
+                      };
+                    }
+                    return c;
+                  })
+                }
+              };
+              yield {
+                type: "progress",
+                content: modifiedMessage,
+                normalizedMessages: normalizedMessages2,
+                tools
+              };
+            }
           }
         }
       }
-    }
-    const normalizedMessages = normalizeMessages(messages);
-    const lastMessage = last(messages);
-    if (lastMessage?.type !== "assistant") {
-      throw new Error("Last message was not an assistant message");
-    }
-    if (lastMessage.message.content.some(
-      (_) => _.type === "text" && _.text === INTERRUPT_MESSAGE
-    )) {
-    } else {
-      const result = [
-        toolUseCount === 1 ? "1 tool use" : `${toolUseCount} tool uses`,
-        formatNumber(
-          (lastMessage.message.usage.cache_creation_input_tokens ?? 0) + (lastMessage.message.usage.cache_read_input_tokens ?? 0) + lastMessage.message.usage.input_tokens + lastMessage.message.usage.output_tokens
-        ) + " tokens",
-        formatDuration(Date.now() - startTime)
-      ];
+      const normalizedMessages = normalizeMessages(messages);
+      const lastMessage = last(messages);
+      if (lastMessage?.type !== "assistant") {
+        throw new Error("Last message was not an assistant message");
+      }
+      const tokenUsage = {
+        inputTokens: lastMessage.message.usage.input_tokens,
+        outputTokens: lastMessage.message.usage.output_tokens,
+        cacheReadTokens: lastMessage.message.usage.cache_read_input_tokens,
+        cacheCreationTokens: lastMessage.message.usage.cache_creation_input_tokens
+      };
+      const isInterrupted = lastMessage.message.content.some(
+        (_) => _.type === "text" && _.text === INTERRUPT_MESSAGE
+      );
+      if (isInterrupted) {
+        interruptAgentTranscript(agentId);
+        debugLogger.info("TASK_AGENT_INTERRUPTED", { agentId, toolUseCount });
+      } else {
+        completeAgentTranscript(agentId, tokenUsage);
+        debugLogger.info("TASK_AGENT_COMPLETED", { agentId, toolUseCount });
+        const result = [
+          toolUseCount === 1 ? "1 tool use" : `${toolUseCount} tool uses`,
+          formatNumber(
+            (lastMessage.message.usage.cache_creation_input_tokens ?? 0) + (lastMessage.message.usage.cache_read_input_tokens ?? 0) + lastMessage.message.usage.input_tokens + lastMessage.message.usage.output_tokens
+          ) + " tokens",
+          formatDuration(Date.now() - startTime)
+        ];
+        yield {
+          type: "progress",
+          content: createAssistantMessage(`Done (${result.join(" \xB7 ")})`),
+          normalizedMessages,
+          tools
+        };
+      }
+      const data = lastMessage.message.content.filter((_) => _.type === "text");
+      const resultWithAgentId = isInterrupted ? `[Interrupted - Agent ID: ${agentId}]
+${this.renderResultForAssistant(data)}` : this.renderResultForAssistant(data);
       yield {
-        type: "progress",
-        content: createAssistantMessage(
-          `Task completed (${result.join(" \xB7 ")})`
-        ),
-        normalizedMessages,
-        tools
+        type: "result",
+        data,
+        resultForAssistant: resultWithAgentId
       };
+      hasYieldedResult = true;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      const isAbortError = error instanceof Error && (error.name === "AbortError" || error.message.includes("aborted") || error.message.includes("abort"));
+      if (isAbortError) {
+        interruptAgentTranscript(agentId);
+        debugLogger.info("TASK_AGENT_INTERRUPTED_BY_ABORT", {
+          agentId,
+          toolUseCount
+        });
+        yield {
+          type: "result",
+          data: [
+            {
+              type: "text",
+              text: `Task [${agentType}] interrupted
+[Agent ID: ${agentId}]`
+            }
+          ],
+          resultForAssistant: `Task [${agentType}] interrupted by user
+[Agent ID: ${agentId} - can be resumed]`
+        };
+      } else {
+        const friendlyError = error instanceof UserFriendlyError ? error : new UserFriendlyError(error, {
+          operation: "agent task",
+          model: agentType
+        });
+        const friendlyMessage = friendlyError.getUserMessage();
+        logError(`TaskTool [${agentType}] error: ${errorMessage}`);
+        failAgentTranscript(agentId, friendlyMessage);
+        debugLogger.error("TASK_AGENT_FAILED", {
+          agentId,
+          error: errorMessage,
+          errorId: friendlyError.id
+        });
+        yield {
+          type: "result",
+          data: [
+            {
+              type: "text",
+              text: `${friendlyMessage}
+[Agent ID: ${agentId}]`
+            }
+          ],
+          resultForAssistant: `Task [${agentType}] failed: ${errorMessage}
+[Agent ID: ${agentId} - can be resumed]`
+        };
+      }
+      hasYieldedResult = true;
+    } finally {
+      popAgentContext();
+      cleanupAgentStreamingState(agentId);
+      if (!hasYieldedResult) {
+        interruptAgentTranscript(agentId);
+        yield {
+          type: "result",
+          data: [
+            {
+              type: "text",
+              text: `Task [${agentType}] terminated unexpectedly
+[Agent ID: ${agentId}]`
+            }
+          ],
+          resultForAssistant: `Task [${agentType}] terminated unexpectedly
+[Agent ID: ${agentId} - can be resumed]`
+        };
+      }
     }
-    const data = lastMessage.message.content.filter((_) => _.type === "text");
-    yield {
-      type: "result",
-      data,
-      resultForAssistant: this.renderResultForAssistant(data)
-    };
   },
   isReadOnly() {
     return true;
@@ -298,6 +484,17 @@ IMPORTANT: You are currently running as ${modelToUse}. You do not need to consul
         };
       }
     }
+    if (input.resume) {
+      if (!canResumeTranscript(input.resume)) {
+        return {
+          result: false,
+          message: `Cannot resume agent '${input.resume}': transcript not found or not resumable (status must be 'running' or 'interrupted')`,
+          meta: {
+            resume: input.resume
+          }
+        };
+      }
+    }
     return { result: true };
   },
   async isEnabled() {
@@ -337,10 +534,11 @@ IMPORTANT: You are currently running as ${modelToUse}. You do not need to consul
   renderToolUseRejectedMessage() {
     return /* @__PURE__ */ React.createElement(FallbackToolUseRejectedMessage, null);
   },
-  renderToolResultMessage(content) {
+  renderToolResultMessage(content, options) {
     const theme = getTheme();
+    const verbose = options?.verbose ?? false;
     if (!content) {
-      return /* @__PURE__ */ React.createElement(Box, { flexDirection: "row" }, /* @__PURE__ */ React.createElement(Text, null, "\xA0\xA0\u23BF \xA0"), /* @__PURE__ */ React.createElement(Text, { color: theme.secondaryText }, "Task completed"));
+      return /* @__PURE__ */ React.createElement(Box, { flexDirection: "row" }, /* @__PURE__ */ React.createElement(Text, null, "\xA0\xA0\u23BF \xA0"), /* @__PURE__ */ React.createElement(Text, { color: theme.success }, "Done"));
     }
     if (Array.isArray(content)) {
       const textBlocks = content.filter(
@@ -356,9 +554,17 @@ IMPORTANT: You are currently running as ${modelToUse}. You do not need to consul
       if (isInterrupted) {
         return /* @__PURE__ */ React.createElement(Box, { flexDirection: "row" }, /* @__PURE__ */ React.createElement(Text, null, "\xA0\xA0\u23BF \xA0"), /* @__PURE__ */ React.createElement(Text, { color: theme.error }, "Interrupted by user"));
       }
-      return /* @__PURE__ */ React.createElement(Box, { flexDirection: "column" }, /* @__PURE__ */ React.createElement(Box, { justifyContent: "space-between", width: "100%" }, /* @__PURE__ */ React.createElement(Box, { flexDirection: "row" }, /* @__PURE__ */ React.createElement(Text, null, "\xA0\xA0\u23BF \xA0"), /* @__PURE__ */ React.createElement(Text, null, "Task completed"), textBlocks.length > 0 && /* @__PURE__ */ React.createElement(Text, { color: theme.secondaryText }, " ", "(", totalLength, " characters)"))));
+      const outputText = textBlocks.map((b) => b.text).join("\n");
+      const getOutputPreview = () => {
+        if (!verbose || !outputText) return null;
+        const maxLen = 500;
+        if (outputText.length <= maxLen) return outputText;
+        return outputText.substring(0, maxLen) + "...";
+      };
+      const outputPreview = getOutputPreview();
+      return /* @__PURE__ */ React.createElement(Box, { flexDirection: "column" }, /* @__PURE__ */ React.createElement(Box, { justifyContent: "space-between", width: "100%" }, /* @__PURE__ */ React.createElement(Box, { flexDirection: "row" }, /* @__PURE__ */ React.createElement(Text, null, "\xA0\xA0\u23BF \xA0"), /* @__PURE__ */ React.createElement(Text, { color: theme.success }, "Done"), textBlocks.length > 0 && verbose && /* @__PURE__ */ React.createElement(Text, { color: theme.secondaryText }, " (", totalLength, " chars)"))), outputPreview && /* @__PURE__ */ React.createElement(Box, { marginTop: 1, paddingLeft: 4 }, /* @__PURE__ */ React.createElement(Text, { color: theme.mutedText }, outputPreview)));
     }
-    return /* @__PURE__ */ React.createElement(Box, { flexDirection: "row" }, /* @__PURE__ */ React.createElement(Text, null, "\xA0\xA0\u23BF \xA0"), /* @__PURE__ */ React.createElement(Text, { color: theme.secondaryText }, "Task completed"));
+    return /* @__PURE__ */ React.createElement(Box, { flexDirection: "row" }, /* @__PURE__ */ React.createElement(Text, null, "\xA0\xA0\u23BF \xA0"), /* @__PURE__ */ React.createElement(Text, { color: theme.success }, "Done"));
   }
 };
 export {