Refactor the tunnel-related code to make the logic of the Agent sending messages to the Human more reasonable.

2023-11-08 22:13:18 -08:00
parent 7fd3749a40
commit de685da38b
15 changed files with 652 additions and 232 deletions
@@ -258,8 +258,16 @@ class LLMResult:
        r.state = llm_json.get("state")
        r.resp = llm_json.get("resp")

-        r.post_msgs = llm_json.get("post_msgs")
-        r.send_msgs = llm_json.get("send_msgs")
+        post_msgs = llm_json.get("post_msg")
+        r.post_msgs = []
+        if post_msgs:
+            for msg in post_msgs:
+                new_msg = AgentMsg()
+                target_id = msg.get("target")
+                msg_content = msg.get("content")
+                new_msg.set("",target_id,msg_content)
+                r.post_msgs.append(new_msg)
+                #new_msg.msg_type = AgentMsgType.TYPE_MSG

        r.calls = llm_json.get("calls")
        r.post_calls = llm_json.get("post_calls")
@@ -352,23 +360,44 @@ class LLMResult:

        return r   

-class AgentGoal:
-    def __init__(self) -> None:
-        self.description = None
-
-
 class AgentReport:
    def __init__(self):
        pass 

 class AgentTodoResult:
+    TODO_RESULT_CODE_OK = 0,
+    TODO_RESULT_CODE_LLM_ERROR = 1,
+    TODO_RESULT_CODE_EXEC_OP_ERROR = 2
+
+
    def __init__(self) -> None:
-        self.result_state = "error"
+        self.result_code = AgentTodoResult.TODO_RESULT_CODE_OK
+        self.result_str = None
+        self.error_str = None
+        self.op_list = None
+
+    def to_dict(self) -> dict:
+        result = {}
+        result["result_code"] = self.result_code
+        result["result_str"] = self.result_str
+        result["error_str"] = self.error_str
+        result["op_list"] = self.op_list
+        return result
        

 class AgentTodo:
+    TODO_STATE_WAIT_ASSIGN = "wait_assign"
+    TODO_STATE_INIT = "init"

+    TODO_STATE_PENDING = "pending"
+    TODO_STATE_WAITING_CHECK = "wait_check"
+    TODO_STATE_EXEC_FAILED = "exec_failed"
+    TDDO_STATE_CHECKFAILED = "check_failed"

+    TODO_STATE_CASNCEL = "cancel"
+    TODO_STATE_DONE = "done"
+    TODO_STATE_EXPIRED = "expired"
+    
    def __init__(self):
        self.todo_id = "todo#" + uuid.uuid4().hex
        self.title = None
@@ -376,20 +405,23 @@ class AgentTodo:
        self.todo_path = None # get parent todo,sub todo by path
        #self.parent = None
        self.create_time = time.time()
-        self.due_date = time.time() + 3600 * 24 * 2
-        self.state = "pending"
-
-        self.depend_todo_ids = []
-        self.sub_todos = {}
-
-        self.need_check = True
-        self.result : ComputeTaskResult = None
-        self.last_check_result = None

+        self.state = "wait_assign" 
        self.worker = None 
        self.checker = None 
        self.createor = None

+        self.need_check = True
+        self.due_date = time.time() + 3600 * 24 * 2
+        self.last_do_time = None
+        self.last_check_time = None
+        self.last_review_time = None
+
+        self.depend_todo_ids = []
+        self.sub_todos = {}
+
+        self.result : AgentTodoResult = None
+        self.last_check_result = None
        self.retry_count = 0
        self.raw_obj = None

@@ -400,14 +432,26 @@ class AgentTodo:
            todo.todo_id = json_obj.get("id")
        
        todo.title = json_obj.get("title")
+        todo.state = json_obj.get("state")
        create_time = json_obj.get("create_time")
        if create_time:
            todo.create_time = datetime.fromisoformat(create_time).timestamp()
+
        todo.detail = json_obj.get("detail")
        due_date = json_obj.get("due_date")
        if due_date:
            todo.due_date = datetime.fromisoformat(due_date).timestamp()
-        todo.todo_path = json_obj.get("todo_path")
+
+        last_do_time = json_obj.get("last_do_time")
+        if last_do_time:
+            todo.last_do_time = datetime.fromisoformat(last_do_time).timestamp()
+        last_check_time = json_obj.get("last_check_time")   
+        if last_check_time:
+            todo.last_check_time = datetime.fromisoformat(last_check_time).timestamp()
+        last_review_time = json_obj.get("last_review_time")
+        if last_review_time:
+            todo.last_review_time = datetime.fromisoformat(last_review_time).timestamp()
+
        todo.depend_todo_ids = json_obj.get("depend_todo_ids")
        todo.need_check = json_obj.get("need_check")
        #todo.result = json_obj.get("result")
@@ -423,14 +467,21 @@ class AgentTodo:
        return todo

    def to_dict(self) -> dict:
-        result = {}
+        if self.raw_obj:
+            result = self.raw_obj
+        else:
+            result = {}
+
        result["id"] = self.todo_id
-        result["todo_path"] = self.todo_path   
        #result["parent_id"] = self.parent_id
        result["title"] = self.title
+        result["state"] = self.state
        result["create_time"] = datetime.fromtimestamp(self.create_time).isoformat()
        result["detail"] = self.detail
        result["due_date"] = datetime.fromtimestamp(self.due_date).isoformat()
+        result["last_do_time"] = datetime.fromtimestamp(self.last_do_time).isoformat() if self.last_do_time else None
+        result["last_check_time"] = datetime.fromtimestamp(self.last_check_time).isoformat() if self.last_check_time else None
+        result["last_review_time"] = datetime.fromtimestamp(self.last_review_time).isoformat() if self.last_review_time else None
        result["depend_todo_ids"] = self.depend_todo_ids
        result["need_check"] = self.need_check
        result["worker"] = self.worker
@@ -439,19 +490,57 @@ class AgentTodo:
        result["retry_count"] = self.retry_count

        return result 
-    def can_do(self) -> bool:
-        for sub_todo in self.sub_todos.values():
-            if sub_todo.state:
-                if sub_todo.state != "done":
-                    return False
+    
+    def can_check(self)->bool:
+        if self.state != AgentTodo.TODO_STATE_WAITING_CHECK:
+            return False
        
        now = datetime.now().timestamp()
-        time_diff = now - self.due_date
-
-        if time_diff > 7*24*3600:
-            return False
+        if self.last_check_time:
+            time_diff = now - self.last_check_time
+            if time_diff < 60*15:
+                logger.info(f"todo {self.title} is already checked, ignore")
+                return False  
+            
        return True
    
+    def can_do(self) -> bool:
+        match self.state:
+            case AgentTodo.TODO_STATE_DONE:
+                logger.info(f"todo {self.title} is done, ignore")
+                return False
+            case AgentTodo.TODO_STATE_CASNCEL:
+                logger.info(f"todo {self.title} is cancel, ignore")
+                return False
+            case AgentTodo.TODO_STATE_EXPIRED:
+                logger.info(f"todo {self.title} is expired, ignore")
+                return False
+            case AgentTodo.TODO_STATE_EXEC_FAILED:
+                if self.retry_count > 3:
+                    logger.info(f"todo {self.title} retry count ({self.retry_count}) is too many, ignore")
+                    return False
+                    
+        now = datetime.now().timestamp()
+        time_diff = self.due_date - now 
+        if time_diff < 0:
+            logger.info(f"todo {self.title} is expired, ignore")
+            self.state = AgentTodo.TODO_STATE_EXPIRED
+            return False
+        
+        if time_diff > 7*24*3600:
+            logger.info(f"todo {self.title} is far before due date, ignore")
+            return False
+        
+        if self.last_do_time:
+            time_diff = now - self.last_do_time
+            if time_diff < 60*15:
+                logger.info(f"todo {self.title} is already do ignore")
+                return False     
+                
+        logger.info(f"todo {self.title} can do.")
+        return True
+        
+
 class AgentWorkLog:
    def __init__(self) -> None:
        pass