feat(core): add previous task infos for SOP extraction (#33)

* fix(core): set true at the end of space agent

* feat(core): add previous task context to sop agent

* fix(core): sop with condidtion

* prompt(core): use sop agent

* prompt: update task tracking

* feat(core): update learning status api

* test: update learning status

Author: gusye1234

src/server/core/acontext_core/llm/agent/space_construct.py

@@ -10,6 +10,7 @@
 from ...schema.utils import asUUID
 from ..prompt.space_construct import SpaceConstructPrompt
 from ..tool.space_tools import SPACE_TOOLS, SpaceCtx
+from ..tool.space_lib.insert_candidate_data_as_content import set_space_digests
 
 
 async def build_space_ctx(
@@ -76,12 +77,13 @@ async def space_construct_agent_curd(
         }
         for sop_data in sop_datas
     ]
+    candidate_data_section = pack_candidate_data_list(candidate_data_list)
+    LOG.info(f"Candidate Data Section: {candidate_data_section}")
+
     _messages = [
         {
             "role": "user",
-            "content": SpaceConstructPrompt.pack_task_input(
-                pack_candidate_data_list(candidate_data_list)
-            ),
+            "content": SpaceConstructPrompt.pack_task_input(candidate_data_section),
         }
     ]
     just_finish = False
@@ -143,4 +145,16 @@ async def space_construct_agent_curd(
             LOG.info("finish tool called, exit the loop")
             break
         already_iterations += 1
+
+    async with DB_CLIENT.get_session_context() as db_session:
+        USE_CTX = await build_space_ctx(
+            db_session,
+            project_id,
+            space_id,
+            task_ids,
+            candidate_data_list,
+            before_use_ctx=USE_CTX,
+        )
+        for d_i in USE_CTX.already_inserted_candidate_data:
+            await set_space_digests(USE_CTX, d_i)
     return Result.resolve(None)

src/server/core/acontext_core/llm/agent/task.py

@@ -134,7 +134,6 @@ async def task_agent_curd(
 
     LOG.info(f"Task Section: {task_section}")
     LOG.info(f"Previous Progress Section: {previous_progress_section}")
-    LOG.info(f"Current Messages Section: {current_messages_section}")
 
     json_tools = [tool.model_dump() for tool in TaskPrompt.tool_schema()]
     already_iterations = 0

src/server/core/acontext_core/llm/agent/task_sop.py

@@ -1,4 +1,4 @@
-from typing import Optional
+from typing import Optional, List
 from ...env import LOG, bound_logging_vars
 from ...schema.result import Result
 from ...schema.utils import asUUID
@@ -25,21 +25,45 @@ def pack_task_data(
     )
 
 
+def pack_one_task_progress_context(task: TaskSchema) -> str:
+    progresses = task.data.progresses or []
+    progress_context = "\n".join([f"- {p}" for p in progresses])
+    return f"""<task id={task.order}>
+Description: {task.data.task_description}
+Progresses:
+{progress_context}
+</task>
+"""
+
+
+def pack_previous_task_context(
+    previous_tasks: List[TaskSchema], current_task: TaskSchema
+) -> str:
+    prev_tasks = "\n".join(
+        [pack_one_task_progress_context(task) for task in previous_tasks]
+    )
+    return f"""{prev_tasks}
+You're looking at task {current_task.order}.
+"""
+
+
 @track_process
 async def sop_agent_curd(
     project_id: asUUID,
     space_id: asUUID,
     current_task: TaskSchema,
+    previous_tasks: List[TaskSchema],
     message_blobs: list[MessageBlob],
     max_iterations=3,
     project_config: Optional[ProjectConfig] = None,
 ):
-
     task_desc, user_perferences, raw_messages = pack_task_data(
         current_task, message_blobs
     )
+    previous_task_context = pack_previous_task_context(previous_tasks, current_task)
 
-    LOG.info(f"Task SOP before: {task_desc}, {user_perferences}, {raw_messages}")
+    LOG.info(f"Task SOP Input: {task_desc}, {user_perferences}")
+    LOG.info(f"Previous Task Context: {previous_task_context}")
 
     # Build customization from project config
     customization = None
@@ -55,7 +79,7 @@ async def sop_agent_curd(
         {
             "role": "user",
             "content": TaskSOPPrompt.pack_task_input(
-                task_desc, user_perferences, raw_messages
+                previous_task_context, task_desc, user_perferences, raw_messages
             ),
         }
     ]

src/server/core/acontext_core/llm/prompt/task.py

@@ -49,12 +49,11 @@ def system_prompt(cls) -> str:
 - If user mentioned any preference on this task, extract in the clean format 'user expects/wants...' in 'user_preference_and_infos' field.
 - If user mentioned any infos(address, email,... etc) so that the task can be completed, extract it and fill it in 'user_preference_and_infos' field.
 
-## Append with Progress
-- Give a brief progress of the task when appending messages
-- Concise and short. only state what the current state.
+## Summary the Task State and Append to Progress
+- Give a concise current state of the task when appending messages
 - Narrate progress in the first person as the agent.
 - Facts over General. Don't say "I encountered many errors", say "I encountered python syntax and rust compiling error."
-- Actual State over Reference. Don't say 'I open the target websit', say "I navigate to https://github.com/trending".
+- Actual Value over Generic. Don't say 'I open the target websit', say "I navigate to https://github.com/trending". Use actual website url, DB table... when possible.
 
 ## Update Task Status 
 - `pending`: For tasks not yet started
@@ -79,14 +78,14 @@ def system_prompt(cls) -> str:
 2. Does the user report that any task failed and need to re-run?
 3. How existing tasks are related to current conversation? 
 4. Any new task should be created?
-5. Which Messages are contributed to planning? Not the execution.
+5. Which Messages are contributed to planning?
 6. Which Messages are contributed to which task? What the progress of the messages brough to the task?
 7. Any user preferences and personal infos in Current Message section related to complete which tasks?
-8. Any progress should be appended with actual states?
+8. What's the actual value for state should be appended to progress?
 9. Which task's status need to be updated?
 10. Briefly describe your tool-call actions to correctly manage the tasks.
 
-Call 'finish' tool if you have finish your jobs.
+Before call 'finish' tool to quit, report your thinking again to make sure every action is covered, if not, continue to perform your job then 'finish'
 """
 
     @classmethod

src/server/core/acontext_core/llm/prompt/task_sop.py

@@ -19,11 +19,10 @@ def system_prompt(
             Complete system prompt string
         """
         # Build base scoring rules
-        base_scoring_section = """### Task Complexity Scoring
-(c.1) If there're errors because of the wrong tool parameter passing and it can be avoided, + 1 point
+        base_scoring_section = """(c.1) If there're errors because of the wrong tool parameter passing and it can be avoided, + 1 point
 (c.2) If there're back-and-forth retries (not errors) because agent has a wrong strategy, + 1 point.
 (c.3) If agent done something wrong decision before, then user offers some feedbacks/preferences to correct the agent's wrong decision, + 2 points
-(c.4) User explicitly emphasized saving this workflow or experience, + 5 points"""
+(c.4) User explicitly emphasized to remember during the task, + 2 points"""
 
         # Append custom scoring rules if provided
         if customization and customization.custom_scoring_rules:
@@ -41,37 +40,50 @@ def system_prompt(
         return f"""You're a Tool-calling SOP Agent that analyzes user-agent working history and generates reusable tool-calling SOPs.
 
 ## Core Responsibilities
-- Understand task and user preferences
+- Understand task conditions and user preferences
 - Give the task's complexity a score. 
 - Skip easy task's tool_sop, or abstract a template SOP from complex task.
+
+## Task Complexity Scoring
 {base_scoring_section}
 If a task's complexity score is < 2, then skip the task because it's too easy, and you should submit a empty SOP with `is_easy_task` set to True.
 else, set `is_easy_task` to False.
 
-### Tool-calling SOP Abstraction
+## Tool-calling SOP Abstraction
 If the task is not an easy task, abstract a template SOP from complex task for a certain scenario, using 'submit_sop' tool:
 - When generate `tool_sops`, use the exact tool_name from <agent_action>, and keep the most necessary and generalizable arguments in 'action'.
     - `tool_sops` can be an empty list if the task itself is a easy task.
 - If this task involves the same workflow repeated with different inputs, only retain the most concise SOP from a single iteration.
-#### Templatized Tool Action 
+### Templatized Tool Action 
 - Template SOP must be the shortest possible too-calls to achieve the goal, remove all the redundancies.
 - Template tool sops: remove those parameters that may vary in different user input in tool 'action', only keep the parameters that are critical to the sop case.
 For example, if the sop is 'star a github repo', 
 then the detailed repo url should be removed because next time user may input a new repo url.
 But use `click` tool to click a 'Star' button, this can keep in action because the 'Star' button is a universal step and unrelated to the user's input.
-#### Preferences
-- remove those preferences or infos that are may vary in different user input.
+### Preferences
+- remove those preferences or infos that are may vary in the future input.
+- keep those preferences and infos that are critical to the future SOP execution.
+
+## Find the conditions of the Current Task
+- Current Task is only possible when bounded to certain conditions. For example:
+    - the sop is about starring a repo, the inferred conditions is agent is on github.com so that agent can star a repo, the use_when should be 'star a repo on github.com', not 'star a repo'.
+    - the sop is about querying by certain year, the inferred conditions is in private_lung_cancer table so that SQL query is only valid, the use_when should be 'query private_lung_cancer table by certain year', not 'query by certain year'.
+- You must infer the conditions of the current task from the previous tasks context and working history.
+- Conditions must be concrete: 'on github.com' is better than 'on code website', 'on private_lung_cancer MySQL table' is better than 'on a cancer table'.
+- You must include the conditions in the SOP's `use_when` field: 'star a repo on github.com', 'query private_lung_cancer table by certain year'.
 
 ## Input Format
+### Previous Task Context
+This section contains the previous tasks progresses. 
+Make sure your understand the state of the current task (e.g. which website the agent is on, which db table the agent is querying, etc.)
 ### Task Description
 What the task is and its purpose.
 ### User Preferences and Infos
-User preferences and personal infos for this task.
+User preferences and personal infos extracted from this task.
 ### Raw Working History
 Format:
 ```
 <user>(text) ...
-<agent>(text) ...
 <agent>(tool-call) 'tool_name': '...', 'arguments': '...'
 <agent>(tool-result) 'tool_name': '...', 'result': '...'
 ```
@@ -81,21 +93,28 @@ def system_prompt(
 ## Report before Submit
 You must report your thinkings (using extrmaly brief wordings) first using the 'report_thinking' tool:
 1. What's tools have been used?
-2. Give your judgement on {rule_indices_str} and for each term, what's the scores?, then sum them and score the task complexity.
-3. If it's an easy task, confirm you will set `is_easy_task` to True and only submit the `use_when` and `preferences` field and an empty `tool_sops list
-4. How to reduce the tool-calls to build a shortest path to achieve the goal?
-5. Which parameters/values are related to the future user input and should be removed in 'action' and 'preferences'?
-6. Which parameters/values are necessary to make sure the SOP will have no more unexpected errors and back-and-forth retries?
-7. In which general scenarios should we use this SOP? (3~5 words for `use_when`)
-8. Any user preferences can help this general scenarios? (short sentenqces for `preferences`) If not, 'preferences' field should be empty string
+2. Infer the necessary conditions for the Current Task can happened.
+3. Give your judgement on {rule_indices_str} and for each term, what's the scores?, then sum them and score the task complexity.
+4. If it's an easy task, confirm you will set `is_easy_task` to True and only submit and with an empty `tool_sops list
+5. How to reduce the tool-calls to build a shortest path to achieve the goal?
+6. Which parameters/values are related to the future user input and should be removed in 'action' and 'preferences'?
+7. Which parameters/values are necessary to make sure the SOP will have no more unexpected errors and back-and-forth retries?
+8. When and with which condidtions should we apply this SOP? (for `use_when`)?
+9. Any user preferences to keep for future SOP execution? (for `preferences`) If not, 'preferences' field should be empty string
 Then decide if you should submit the SOP.
 """
 
     @classmethod
     def pack_task_input(
-        cls, task_description: str, user_preferences: str, history_messages: str
+        cls,
+        previous_task_context: str,
+        task_description: str,
+        user_preferences: str,
+        history_messages: str,
     ) -> str:
-        return f"""### Task Description
+        return f"""### Previous Task Context
+{previous_task_context}
+### Current Task Description
 {task_description}
 ### User Preferences and Infos
 {user_preferences}

src/server/core/acontext_core/llm/tool/space_lib/insert_candidate_data_as_content.py

@@ -48,7 +48,6 @@ async def _insert_data_handler(
     )
     if not r.ok():
         return Result.resolve(f"Failed to insert candidate data: {r.error}")
-    await set_space_digests(ctx, candidate_index)
     return Result.resolve(
         f"Inserted candidate data {candidate_index} to page {page_path} after block index {after_block_index}"
     )

src/server/core/acontext_core/schema/config.py

@@ -16,10 +16,11 @@ class ProjectConfig(BaseModel):
     project_session_message_buffer_max_turns: int = 16
     project_session_message_buffer_max_overflow: int = 16
     project_session_message_buffer_ttl_seconds: int = 8  # 4 seconds
-    default_task_agent_max_iterations: int = 4
+    default_task_agent_max_iterations: int = 6
     default_task_agent_previous_progress_num: int = 6
     default_sop_agent_max_iterations: int = 4
     default_space_construct_agent_max_iterations: int = 16
+    default_space_construct_agent_previous_tasks_limit: int = 5
 
     # SOP Agent Customization (extensible for future features)
     sop_agent_custom_scoring_rules: List[CustomScoringRule] = []

src/server/core/acontext_core/schema/mq/sop.py

@@ -1,7 +1,6 @@
 from pydantic import BaseModel
 from ..utils import asUUID
 from ..block.sop_block import SOPData
-from typing import Dict, Any
 
 
 class SOPComplete(BaseModel):

src/server/core/acontext_core/service/controller/space_sop.py

@@ -16,7 +16,6 @@ async def process_sop_complete(
     Process SOP completion and trigger construct agent
     """
     LOG.info(f"Processing SOP completion for task {task_id}")
-
     # Call construct agent
     construct_result = await SC.space_construct_agent_curd(
         project_id,

src/server/core/acontext_core/service/controller/space_task.py

@@ -7,6 +7,7 @@
 from ...env import LOG
 from ...schema.config import ProjectConfig
 from ...schema.session.task import TaskSchema
+from ..data import task as TD
 
 
 async def process_space_task(
@@ -31,10 +32,22 @@ async def process_space_task(
             MessageBlob(message_id=m.id, role=m.role, parts=m.parts, task_id=m.task_id)
             for m in messages
         ]
-    r = await TSOP.sop_agent_curd(
+    async with DB_CLIENT.get_session_context() as db_session:
+        r = await TD.fetch_previous_tasks_without_message_ids(
+            db_session,
+            task.session_id,
+            st_order=task.order,
+            limit=project_config.default_space_construct_agent_previous_tasks_limit,
+        )
+        if not r.ok():
+            return
+        PREVIOUS_TASKS = r.data
+
+    await TSOP.sop_agent_curd(
         project_id,
         space_id,
         task,
+        PREVIOUS_TASKS,
         messages_data,
         max_iterations=project_config.default_sop_agent_max_iterations,
         project_config=project_config,