@within-7/minto 0.4.1 → 0.4.3

package/dist/tools/TaskTool/TaskTool.js

@@ -1,861 +0,0 @@
-import { last, memoize } from "lodash-es";
-import { dirname } from "path";
-import React from "react";
-import { Box, Text } from "ink";
-import { z } from "zod";
-import { FallbackToolUseRejectedMessage } from "../../components/FallbackToolUseRejectedMessage.js";
-import { getAgentPrompt } from "../../constants/prompts/index.js";
-import { getContext } from "../../context.js";
-import { hasPermissionsToUseTool } from "../../permissions.js";
-import { query } from "../../query.js";
-import { formatDuration, formatNumber } from "../../utils/format.js";
-import {
-  getMessagesPath,
-  getNextAvailableLogSidechainNumber,
-  overwriteLog,
-  logError
-} from "../../utils/log.js";
-import {
-  createAssistantMessage,
-  createUserMessage,
-  getLastAssistantMessageId,
-  INTERRUPT_MESSAGE,
-  normalizeMessages
-} from "../../utils/messages.js";
-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 { execSync } from "child_process";
-import {
-  pushAgentContext,
-  popAgentContext,
-  cleanupAgentStreamingState
-} from "../../utils/streamingState.js";
-import {
-  validateAgentPermission,
-  MODE_CONFIGS
-} from "../../types/PermissionMode.js";
-import { executeAgentHooks, createHookContext } from "../../utils/agentHookExecutor.js";
-import {
-  loadAgentMemory,
-  saveAgentMemory,
-  formatMemoryForPrompt
-} from "../../utils/agentMemory.js";
-import { getSkill, loadSkillContent } from "../../utils/skillLoader.js";
-import { getCwd } from "../../utils/state.js";
-import { getHookManager } from "../../utils/hookManager.js";
-import { substituteVariables } from "../../utils/stringSubstitution.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"),
-  model_name: z.string().optional().describe(
-    "Optional: Specific model name to use for this task. If not provided, uses the default task model pointer."
-  ),
-  model: z.enum(["sonnet", "opus", "haiku"]).optional().describe(
-    "Optional model hint for this agent. Maps to configured model pointers: sonnet\u2192main, opus\u2192reasoning, haiku\u2192quick. If not specified, uses the task model pointer. Prefer haiku for quick, straightforward tasks."
-  ),
-  subagent_type: z.string().optional().describe(
-    '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."
-  ),
-  max_turns: z.number().int().positive().optional().describe(
-    "Maximum number of agentic turns (API round-trips) before stopping. Used internally for warmup."
-  )
-  // run_in_background parameter removed - concurrent execution is automatic
-});
-const TaskTool = {
-  async prompt({ safeMode }) {
-    return await getPrompt(safeMode);
-  },
-  name: TOOL_NAME,
-  async description() {
-    const availableTypes = await getAvailableAgentTypes();
-    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,
-    model,
-    subagent_type,
-    resume,
-    max_turns
-  }, {
-    abortController,
-    options: { safeMode = false, forkNumber, messageLogName, verbose },
-    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;
-    let disallowedToolFilter = null;
-    let temperature = void 0;
-    let agentMaxThinkingTokens = void 0;
-    let effectivePermissionMode = "default";
-    let loadedAgentConfig = null;
-    if (agentType) {
-      const agentConfig = await getAgentByType(agentType);
-      if (!agentConfig) {
-        const availableTypes = await getAvailableAgentTypes();
-        const helpMessage = `Agent type '${agentType}' not found.
-
-Available agents:
-${availableTypes.map((t) => `  \u2022 ${t}`).join("\n")}
-
-Use /agents command to manage agent configurations.`;
-        yield {
-          type: "result",
-          data: [{ type: "text", text: helpMessage }],
-          resultForAssistant: helpMessage
-        };
-        hasYieldedResult = true;
-        return;
-      }
-      loadedAgentConfig = agentConfig;
-      if (agentConfig.systemPrompt) {
-        effectivePrompt = `${agentConfig.systemPrompt}
-
-${prompt}`;
-      }
-      if (!model_name && agentConfig.model_name) {
-        if (agentConfig.model_name !== "inherit") {
-          effectiveModel = agentConfig.model_name;
-        }
-      }
-      toolFilter = agentConfig.tools;
-      if (agentConfig.disallowedTools?.length) {
-        disallowedToolFilter = agentConfig.disallowedTools;
-      }
-      if (agentConfig.maxThinkingTokens) {
-        agentMaxThinkingTokens = agentConfig.maxThinkingTokens;
-      }
-      if (agentConfig.permissionMode) {
-        const sessionMode = safeMode ? "plan" : "default";
-        effectivePermissionMode = validateAgentPermission(
-          agentConfig.permissionMode,
-          sessionMode
-        );
-      }
-      if (agentConfig.memory) {
-        try {
-          const memoryContent = await loadAgentMemory(
-            agentConfig.agentType,
-            agentConfig.memory
-          );
-          if (memoryContent) {
-            effectivePrompt = formatMemoryForPrompt(memoryContent, agentConfig.agentType) + "\n" + effectivePrompt;
-          }
-        } catch (error) {
-          debugLogger.warn("TASK_AGENT_MEMORY_LOAD_FAILED", {
-            agentId,
-            agentType,
-            error: error instanceof Error ? error.message : String(error)
-          });
-        }
-      }
-      if (agentConfig.skills?.length) {
-        for (const skillName of agentConfig.skills) {
-          try {
-            const skill = getSkill(skillName);
-            if (skill) {
-              const skillContent = await loadSkillContent(skill);
-              const skillBaseDir = dirname(skill.filePath);
-              const resolvedContent = skillContent.replace(
-                /\{baseDir\}/g,
-                skillBaseDir
-              );
-              const substitutedContent = await substituteVariables(
-                resolvedContent,
-                "",
-                // No arguments for preloaded skills
-                {
-                  sessionId: agentId,
-                  cwd: process.cwd(),
-                  env: { BASE_DIR: skillBaseDir }
-                }
-              );
-              effectivePrompt += `
-
-<preloaded-skill name="${skillName}">
-${substitutedContent}
-</preloaded-skill>`;
-            }
-          } catch (error) {
-            debugLogger.warn("TASK_AGENT_SKILL_PRELOAD_FAILED", {
-              agentId,
-              skillName,
-              error: error instanceof Error ? error.message : String(error)
-            });
-          }
-        }
-      }
-      if (agentConfig.hooks?.onStart?.length) {
-        try {
-          const hookContext = createHookContext({
-            sessionId: agentId,
-            agentId,
-            agentType
-          });
-          const hookResult = await executeAgentHooks(
-            "onStart",
-            agentConfig,
-            hookContext
-          );
-          if (!hookResult.continue) {
-            yield {
-              type: "result",
-              data: [
-                {
-                  type: "text",
-                  text: `Agent ${agentType} blocked by onStart hook: ${hookResult.reason || "Hook requested stop"}`
-                }
-              ],
-              resultForAssistant: `Agent blocked by onStart hook: ${hookResult.reason}`
-            };
-            hasYieldedResult = true;
-            return;
-          }
-        } catch (error) {
-          debugLogger.warn("TASK_AGENT_ONSTART_HOOK_FAILED", {
-            agentId,
-            agentType,
-            error: error instanceof Error ? error.message : String(error)
-          });
-        }
-      }
-    }
-    if (model) {
-      const modelPointerMap = {
-        sonnet: "main",
-        // Use main model for standard tasks
-        opus: "reasoning",
-        // Use reasoning model for complex tasks
-        haiku: "quick"
-        // Use quick model for fast tasks
-      };
-      const pointerType = modelPointerMap[model] || "task";
-      const modelManager = getModelManager();
-      const resolvedModelName = modelManager.getModelName(pointerType);
-      if (resolvedModelName) {
-        effectiveModel = resolvedModelName;
-      }
-    }
-    let worktreePath = null;
-    if (loadedAgentConfig?.isolation === "worktree") {
-      try {
-        const tmpDir = `/tmp/minto-worktree-${agentId}`;
-        execSync(`git worktree add "${tmpDir}" HEAD`, {
-          cwd: getCwd(),
-          stdio: "pipe"
-        });
-        worktreePath = tmpDir;
-        effectivePrompt = `[Working in isolated git worktree: ${tmpDir}]
-
-${effectivePrompt}`;
-        debugLogger.info("TASK_AGENT_WORKTREE_CREATED", {
-          agentId,
-          worktreePath
-        });
-      } catch (err) {
-        debugLogger.warn("TASK_AGENT_WORKTREE_FAILED", {
-          agentId,
-          error: err instanceof Error ? err.message : String(err)
-        });
-      }
-    }
-    const messages = resumedTranscript ? [...resumedTranscript.messages] : [createUserMessage(effectivePrompt)];
-    let tools = await getTaskTools(safeMode);
-    let allowedSubagentTypes = null;
-    if (toolFilter) {
-      const isAllArray = Array.isArray(toolFilter) && toolFilter.length === 1 && toolFilter[0] === "*";
-      if (toolFilter === "*" || isAllArray) {
-      } else if (Array.isArray(toolFilter)) {
-        const taskPatterns = toolFilter.filter((t) => t.startsWith("Task(") && t.endsWith(")")).map((t) => t.slice(5, -1));
-        if (taskPatterns.length > 0) {
-          allowedSubagentTypes = taskPatterns;
-        }
-        const baseToolNames = toolFilter.map((t) => t.startsWith("Task(") ? "Task" : t).filter((t, i, arr) => arr.indexOf(t) === i);
-        tools = tools.filter((tool) => baseToolNames.includes(tool.name));
-      }
-    }
-    if (disallowedToolFilter?.length) {
-      tools = tools.filter((tool) => !disallowedToolFilter.includes(tool.name));
-    }
-    if (effectivePermissionMode !== "default") {
-      const modeConfig = MODE_CONFIGS[effectivePermissionMode];
-      if (modeConfig && modeConfig.allowedTools[0] !== "*") {
-        tools = tools.filter(
-          (tool) => modeConfig.allowedTools.includes(tool.name)
-        );
-      }
-    }
-    const modelToUse = effectiveModel;
-    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}`),
-      normalizedMessages: normalizeMessages(messages),
-      tools
-    };
-    yield {
-      type: "progress",
-      content: createAssistantMessage(`Task: ${description}`),
-      normalizedMessages: normalizeMessages(messages),
-      tools
-    };
-    yield {
-      type: "progress",
-      content: createAssistantMessage(
-        `Prompt: ${prompt.length > 150 ? prompt.substring(0, 150) + "..." : prompt}`
-      ),
-      normalizedMessages: normalizeMessages(messages),
-      tools
-    };
-    const [taskPrompt, context, maxThinkingTokens] = await Promise.all([
-      getAgentPrompt(),
-      getContext(),
-      getMaxThinkingTokens(messages)
-    ]);
-    taskPrompt.push(
-      `
-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 = resumedTranscript?.toolUseCount || 0;
-    const getSidechainNumber = memoize(
-      () => getNextAvailableLogSidechainNumber(messageLogName, forkNumber)
-    );
-    const hookMgr = getHookManager();
-    if (hookMgr) {
-      hookMgr.executeSubagentStart(agentType, description).catch(
-        (err) => debugLogger.warn("SubagentStart hook failed", { error: err })
-      );
-    }
-    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 effectiveMaxThinkingTokens = agentMaxThinkingTokens ?? maxThinkingTokens;
-    const queryOptions = {
-      safeMode,
-      forkNumber,
-      messageLogName,
-      tools,
-      commands: [],
-      verbose,
-      maxThinkingTokens: effectiveMaxThinkingTokens,
-      model: modelToUse
-    };
-    if (temperature !== void 0) {
-      queryOptions["temperature"] = temperature;
-    }
-    pushAgentContext(agentId);
-    let turnCount = 0;
-    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
-        }
-      )) {
-        messages.push(message);
-        appendMessageToTranscript(agentId, message);
-        overwriteLog(
-          getMessagesPath(messageLogName, forkNumber, getSidechainNumber()),
-          messages.filter((_) => _.type !== "progress")
-        );
-        if (message.type !== "assistant") {
-          continue;
-        }
-        turnCount++;
-        if (max_turns && turnCount >= max_turns) {
-          debugLogger.info("TASK_AGENT_MAX_TURNS_REACHED", {
-            agentId,
-            turnCount,
-            max_turns
-          });
-          break;
-        }
-        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: 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");
-      }
-      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 });
-        if (hookMgr) {
-          hookMgr.executeSubagentStop(agentType, agentId).catch(
-            (err) => debugLogger.warn("SubagentStop hook failed", { error: err })
-          );
-        }
-        if (loadedAgentConfig?.hooks?.onComplete?.length) {
-          try {
-            const hookContext = createHookContext({
-              sessionId: agentId,
-              agentId,
-              agentType,
-              result: this.renderResultForAssistant(
-                lastMessage.message.content.filter((_) => _.type === "text")
-              )
-            });
-            await executeAgentHooks(
-              "onComplete",
-              loadedAgentConfig,
-              hookContext
-            );
-          } catch (hookError) {
-            debugLogger.warn("TASK_AGENT_ONCOMPLETE_HOOK_FAILED", {
-              agentId,
-              agentType,
-              error: hookError instanceof Error ? hookError.message : String(hookError)
-            });
-          }
-        }
-        if (loadedAgentConfig?.memory) {
-          try {
-            const finalResponse = lastMessage.message.content.filter((_) => _.type === "text").map((_) => _.text).join("\n");
-            if (finalResponse.trim()) {
-              await saveAgentMemory(
-                agentType,
-                loadedAgentConfig.memory,
-                finalResponse
-              );
-            }
-          } catch (memoryError) {
-            debugLogger.warn("TASK_AGENT_MEMORY_SAVE_FAILED", {
-              agentId,
-              agentType,
-              error: memoryError instanceof Error ? memoryError.message : String(memoryError)
-            });
-          }
-        }
-        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: "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
-        });
-        if (loadedAgentConfig?.hooks?.onError?.length) {
-          try {
-            const hookContext = createHookContext({
-              sessionId: agentId,
-              agentId,
-              agentType,
-              error: error instanceof Error ? error : new Error(String(error))
-            });
-            await executeAgentHooks("onError", loadedAgentConfig, hookContext);
-          } catch (hookError) {
-            debugLogger.warn("TASK_AGENT_ONERROR_HOOK_FAILED", {
-              agentId,
-              agentType,
-              error: hookError instanceof Error ? hookError.message : String(hookError)
-            });
-          }
-        }
-        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 {
-      if (worktreePath) {
-        try {
-          execSync(`git worktree remove "${worktreePath}" --force`, {
-            cwd: getCwd(),
-            stdio: "pipe"
-          });
-          debugLogger.info("TASK_AGENT_WORKTREE_REMOVED", {
-            agentId,
-            worktreePath
-          });
-        } catch {
-          debugLogger.warn("TASK_AGENT_WORKTREE_CLEANUP_FAILED", {
-            agentId,
-            worktreePath
-          });
-        }
-      }
-      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]`
-        };
-      }
-    }
-  },
-  isReadOnly() {
-    return true;
-  },
-  isConcurrencySafe() {
-    return true;
-  },
-  async validateInput(input, context) {
-    if (!input.description || typeof input.description !== "string") {
-      return {
-        result: false,
-        message: "Description is required and must be a string"
-      };
-    }
-    if (!input.prompt || typeof input.prompt !== "string") {
-      return {
-        result: false,
-        message: "Prompt is required and must be a string"
-      };
-    }
-    if (input.model_name) {
-      const modelManager = getModelManager();
-      const availableModels = modelManager.getAllAvailableModelNames();
-      if (!availableModels.includes(input.model_name)) {
-        return {
-          result: false,
-          message: `Model '${input.model_name}' does not exist. Available models: ${availableModels.join(", ")}`,
-          meta: {
-            model_name: input.model_name,
-            availableModels
-          }
-        };
-      }
-    }
-    if (input.subagent_type) {
-      const availableTypes = await getAvailableAgentTypes();
-      if (!availableTypes.includes(input.subagent_type)) {
-        return {
-          result: false,
-          message: `Agent type '${input.subagent_type}' does not exist. Available types: ${availableTypes.join(", ")}`,
-          meta: {
-            subagent_type: input.subagent_type,
-            availableTypes
-          }
-        };
-      }
-    }
-    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() {
-    return true;
-  },
-  userFacingName(input) {
-    const agentType = input?.subagent_type || "general-purpose";
-    return `agent-${agentType}`;
-  },
-  needsPermissions() {
-    return false;
-  },
-  renderResultForAssistant(data) {
-    return data.map((block) => block.type === "text" ? block.text : "").join("\n");
-  },
-  renderToolUseMessage({ description, prompt, model_name, subagent_type }, { verbose }) {
-    if (!description || !prompt) return null;
-    const modelManager = getModelManager();
-    const defaultTaskModel = modelManager.getModelName("task");
-    const actualModel = model_name || defaultTaskModel;
-    const agentType = subagent_type || "general-purpose";
-    const promptPreview = prompt.length > 80 ? prompt.substring(0, 80) + "..." : prompt;
-    const theme = getTheme();
-    if (verbose) {
-      return /* @__PURE__ */ React.createElement(Box, { flexDirection: "column" }, /* @__PURE__ */ React.createElement(Text, null, "[", agentType, "] ", actualModel, ": ", description), /* @__PURE__ */ React.createElement(
-        Box,
-        {
-          paddingLeft: 2,
-          borderLeftStyle: "single",
-          borderLeftColor: theme.secondaryBorder
-        },
-        /* @__PURE__ */ React.createElement(Text, { color: theme.secondaryText }, promptPreview)
-      ));
-    }
-    return `[${agentType}] ${actualModel}: ${description}`;
-  },
-  renderToolUseRejectedMessage() {
-    return /* @__PURE__ */ React.createElement(FallbackToolUseRejectedMessage, null);
-  },
-  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.success }, "Done"));
-    }
-    if (Array.isArray(content)) {
-      const textBlocks = content.filter(
-        (block) => block && block.type === "text"
-      );
-      const totalLength = textBlocks.reduce(
-        (sum, block) => sum + (block.text?.length || 0),
-        0
-      );
-      const isInterrupted = content.some(
-        (block) => block && block.type === "text" && block.text === INTERRUPT_MESSAGE
-      );
-      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"));
-      }
-      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.success }, "Done"));
-  }
-};
-export {
-  TaskTool
-};
-//# sourceMappingURL=TaskTool.js.map