Function createTaskTerminateTool

src/node/services/tools/task_terminate.ts:79–177

(config: ToolConfiguration)

}

export const createTaskTerminateTool: ToolFactory = (config: ToolConfiguration) => {
  return tool({
    description: TOOL_DEFINITIONS.task_terminate.description,
    inputSchema: TOOL_DEFINITIONS.task_terminate.schema,
    execute: async (args): Promise<unknown> => {
      const workspaceId = requireWorkspaceId(config, "task_terminate");
      const taskService = requireTaskService(config, "task_terminate");

      const uniqueTaskIds = dedupeStrings(args.task_ids);

      const results = await Promise.all(
        uniqueTaskIds.map(async (taskId) => {
          if (isWorkflowRunTaskId(taskId)) {
            return await interruptWorkflowRun(config, workspaceId, taskId);
          }

          if (isWorkspaceTurnTaskId(taskId)) {
            const interruptResult = await taskService.interruptWorkspaceTurn(workspaceId, taskId);
            if (!interruptResult.success) {
              const msg = interruptResult.error;
              if (/not found/i.test(msg) || /scope/i.test(msg)) {
                return { status: "invalid_scope" as const, taskId };
              }
              return { status: "error" as const, taskId, error: msg };
            }
            return {
              status: "interrupted" as const,
              taskId,
              note: "Workspace turn interrupted. The full workspace is preserved for inspection and future prompts.",
            };
          }

          const maybeProcessId = fromBashTaskId(taskId);
          if (taskId.startsWith("bash:") && !maybeProcessId) {
            return { status: "error" as const, taskId, error: "Invalid bash taskId." };
          }

          if (maybeProcessId) {
            if (!config.backgroundProcessManager) {
              return {
                status: "error" as const,
                taskId,
                error: "Background process manager not available",
              };
            }

            const proc = await config.backgroundProcessManager.getProcess(maybeProcessId);
            if (!proc) {
              return { status: "not_found" as const, taskId };
            }

            const inScope =
              proc.workspaceId === workspaceId ||
              (await taskService.isDescendantAgentTask(workspaceId, proc.workspaceId));
            if (!inScope) {
              return { status: "invalid_scope" as const, taskId };
            }