xpander-sdk 2.0.166__tar.gz → 2.0.168__tar.gz

{xpander_sdk-2.0.166 → xpander_sdk-2.0.168}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xpander-sdk
-Version: 2.0.166
+Version: 2.0.168
 Summary: xpander.ai Backend-as-a-service for AI Agents - SDK
 Home-page: https://www.xpander.ai
 Author: xpanderAI

{xpander_sdk-2.0.166 → xpander_sdk-2.0.168}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r", encoding="utf-8") as fh:
 
 setup(
     name="xpander-sdk",
-    version="2.0.166",
+    version="2.0.168",
     author="xpanderAI",
     author_email="dev@xpander.ai",
     description="xpander.ai Backend-as-a-service for AI Agents - SDK",

xpander_sdk-2.0.168/src/xpander_sdk/models/compactization.py

@@ -0,0 +1,101 @@
+from typing import List
+
+from pydantic import Field
+from xpander_sdk.models.deep_planning import DeepPlanningItem
+from xpander_sdk.models.shared import XPanderSharedModel
+from xpander_sdk.modules.agents.models.agent import AgentInstructions
+from xpander_sdk.modules.tasks.models.task import AgentExecutionInput
+
+
+class TaskCompactizationInput(XPanderSharedModel):
+    user_input: AgentExecutionInput = Field(
+        ...,
+        description=(
+            "Original user input that initiated the task, including text, optional file URLs, "
+            "and optional user details."
+        ),
+    )
+    agent_instructions: AgentInstructions = Field(
+        ...,
+        description="Agent instructions (role, goals, and general guidance) that were active during execution."
+    )
+    task_context_and_messages: str = Field(
+        ...,
+        description=(
+            "Complete execution context including message history, tool calls, and session state. "
+            "This contains all information about what was attempted and what was achieved."
+        )
+    )
+    uncompleted_tasks: List["DeepPlanningItem"] = Field(
+        default_factory=list,
+        description=(
+            "List of planned tasks that remain incomplete. Each task has an id, title, and completed status. "
+            "ALL of these tasks MUST be completed and marked as completed=true in the continuation."
+        )
+    )
+
+class TaskCompactizationOutput(XPanderSharedModel):
+    new_task_prompt: str = Field(
+        ...,
+        min_length=1,
+        description=(
+            "A continuation prompt that seamlessly continues the running execution. "
+            "This is NOT a new task - it's the next message in an ongoing conversation. "
+            "The prompt must:\n"
+            "1. Resume from where the execution left off (do NOT repeat completed work)\n"
+            "2. Focus on completing ALL remaining uncompleted tasks\n"
+            "3. Include specific instructions to mark each task as completed after finishing it\n"
+            "4. Be written as if you're continuing mid-conversation, not starting fresh\n"
+            "5. Reference the current state and what still needs to be done\n"
+            "Example: 'Continuing from where we left off, we still need to complete tasks X, Y, and Z. "
+            "Let's proceed with task X first, then mark it complete using the appropriate tool.'"
+        ),
+    )
+
+    task_context: str = Field(
+        ...,
+        min_length=1,
+        description=(
+            "Comprehensive context for continuing the execution. This context will be injected "
+            "into the agent's system prompt to maintain execution continuity.\n\n"
+            "REQUIRED FORMAT (use these exact headings, in this order):\n"
+            "1) ORIGINAL USER REQUEST\n"
+            "- Verbatim user_input text and any file references.\n\n"
+            "2) AGENT INSTRUCTIONS IN EFFECT\n"
+            "- General description from agent instructions.\n"
+            "- Role instructions (bullet list).\n"
+            "- Goals (bullet list).\n"
+            "- Any constraints or special requirements.\n\n"
+            "3) EXECUTION SUMMARY\n"
+            "- What actions were taken (facts only, no speculation).\n"
+            "- What outputs were produced (facts only).\n\n"
+            "4) CURRENT STATE AND ARTIFACTS\n"
+            "- All created artifacts with their identifiers, paths, URLs, or references.\n"
+            "- Current state of variables, decisions, configurations, and assumptions.\n"
+            "- Active session or database state if relevant.\n\n"
+            "5) MESSAGES AND KEY EVIDENCE\n"
+            "- Compact chronological summary of the conversation flow.\n"
+            "- Up to 5 verbatim quotes (max 25 words each) capturing critical details.\n\n"
+            "6) TOOL CALLS AND OBSERVATIONS\n"
+            "- For each tool call: tool name/id, purpose, key inputs, key outputs, errors.\n"
+            "- Include plan tool calls (create/get/complete) if they occurred.\n"
+            "- If no tools used: 'No tool calls were made.'\n\n"
+            "7) COMPLETED VS UNCOMPLETED TASKS\n"
+            "- Completed: List with task IDs and titles that are done.\n"
+            "- Uncompleted: List each task ID, title, and specific reason it's incomplete.\n"
+            "- CRITICAL: All uncompleted tasks MUST be finished in the continuation.\n\n"
+            "8) OPEN QUESTIONS AND UNKNOWNS\n"
+            "- Missing information needed to complete remaining tasks.\n"
+            "- Blockers or dependencies preventing progress.\n"
+            "- If none: 'No open questions.'\n\n"
+            "9) NEXT ACTIONS TO COMPLETE ALL TASKS\n"
+            "- Ordered list of specific actions to complete each uncompleted task.\n"
+            "- Each action should reference the task ID it completes.\n"
+            "- Final action must be to mark all tasks as completed using the plan tools.\n\n"
+            "ACCURACY REQUIREMENTS:\n"
+            "- Do NOT invent details. Use 'Unknown' if information is missing.\n"
+            "- Preserve exact names, IDs, numbers, file paths, and user wording.\n"
+            "- Task completion status must match reality - no implied completion.\n"
+            "- Focus on actionable, specific continuation steps.\n"
+        ),
+    )

{xpander_sdk-2.0.166 → xpander_sdk-2.0.168}/src/xpander_sdk/models/frameworks.py

@@ -30,7 +30,7 @@ class AgnoSettings(BaseModel):
         session_storage (Optional[bool]): If True, enables session-level storage. Default is True.
         user_memories (Optional[bool]): If True, enables memory of user interactions. Default is True.
         session_summaries (Optional[bool]): If True, enables generation of session summaries. Default is False.
-        num_history_runs (Optional[int]): Number of historical runs to retain or consider. Default is 3.
+        num_history_runs (Optional[int]): Number of historical runs to retain or consider. Default is 10.
         tool_call_limit (Optional[int]): Max tool calls per run.
         coordinate_mode (Optional[bool]): If True, The agent will be loaded as a Team. Default is False.
         pii_detection_enabled (Optional[bool]): If True, enables PII detection guardrail on agent input. Default is False.
@@ -50,7 +50,7 @@ class AgnoSettings(BaseModel):
     agentic_culture: Optional[bool] = False
     
     session_summaries: Optional[bool] = False
-    num_history_runs: Optional[int] = 3
+    num_history_runs: Optional[int] = 10
     max_tool_calls_from_history: Optional[int] = 0
     tool_call_limit: Optional[int] = None
     coordinate_mode: Optional[bool] = False

{xpander_sdk-2.0.166 → xpander_sdk-2.0.168}/src/xpander_sdk/modules/backend/frameworks/agno.py

@@ -219,6 +219,7 @@ async def build_agent_args(
 
 def _configure_deep_planning_guidance(args: Dict[str, Any], agent: Agent, task: Optional[Task]) -> None:
     if args and agent and task and agent.deep_planning and task.deep_planning.enabled == True:
+        task.reload() # reload the task - get latest version
         # add instructions guidance
         if not "instructions" in args:
             args["instructions"] = ""
@@ -227,23 +228,49 @@ def _configure_deep_planning_guidance(args: Dict[str, Any], agent: Agent, task:
             <important_planning_instructions>
             ## **Deep Planning Tools - Essential for Multi-Step Tasks**
 
+            **ABSOLUTE RULE - READ THIS FIRST**:
+            
+            IF YOU ARE ABOUT TO WRITE A QUESTION TO THE USER, STOP AND CHECK:
+            - Did I call xpstart_execution_plan? 
+              - YES → Use xpask_for_information tool (DO NOT write the question in your response)
+              - NO → You can ask directly
+            
+            SIMPLE RULE:
+            - BEFORE calling xpstart_execution_plan: You CAN ask questions directly in your response
+            - AFTER calling xpstart_execution_plan: You are FORBIDDEN from writing questions - use xpask_for_information tool
+            
+            Once execution has started, writing things like "Before I proceed, I need to know..." or "I need clarification on..."
+            or "Please choose one of the following..." in your response text is STRICTLY PROHIBITED and will cause execution failures.
+            
+            MANDATORY CHECK BEFORE ASKING: Have I started the plan? YES = use tool | NO = can ask directly
+
             When handling complex tasks with multiple steps, use these planning tools to track progress systematically.
 
             ### **Core Workflow**
-            1. **CREATE** plan at the start (`xpcreate-agent-plan`)
-            2. **START** plan execution (`xpstart-execution-plan`) - MANDATORY to enable enforcement
-            3. **CHECK** plan before each action (`xpget-agent-plan`)
-            4. **COMPLETE** task immediately after finishing it (`xpcomplete-agent-plan-item`)
-            5. **ASK** user for info if needed (`xpask-for-information`)
-            6. Repeat steps 3-5 until all tasks are done
+            1. **CREATE** plan at the start (`xpcreate_agent_plan`)
+            2. **START** plan execution (`xpstart_execution_plan`) - MANDATORY to enable enforcement
+            3. **CHECK** plan before each action (`xpget_agent_plan`)
+            4. **DO THE WORK** for one task
+            5. **COMPLETE** task IMMEDIATELY - call `xpcomplete_agent_plan_item` RIGHT AFTER finishing work (DO NOT DELAY!)
+            6. **ASK** user for info if needed (`xpask_for_information`) - MANDATORY if you need input or want to pause
+            7. Repeat steps 3-6 until all tasks are done
+            
+            **CRITICAL RULES - ABSOLUTE REQUIREMENTS**: 
+            - Mark each task complete THE MOMENT you finish it - not later, not at the end, RIGHT AWAY!
+            - **CHECK BEFORE ASKING**: Did you call xpstart_execution_plan?
+              - If YES: Use xpask_for_information tool ONLY (never write questions in response)
+              - If NO: Can ask directly
+            - **AFTER plan starts: Writing questions in your response is FORBIDDEN** - violates execution protocol
+            - If you called xpstart_execution_plan and then write "I need clarification" or "Before I proceed" or "Please choose", you are VIOLATING THE PROTOCOL
+            - AFTER xpstart_execution_plan: The ONLY way to ask users questions is through `xpask_for_information` tool - ZERO EXCEPTIONS!
 
             ---
 
             ### **Tool Reference**
 
-            #### **1. xpcreate-agent-plan** - Create Initial Plan
+            #### **1. xpcreate_agent_plan** - Create Initial Plan
             **When to use**: At the very start of any multi-step task, ONLY if no plan exists yet
-            **Note**: After creating a plan, you MUST call `xpstart-execution-plan` to begin enforcement
+            **Note**: After creating a plan, you MUST call `xpstart_execution_plan` to begin enforcement
 
             **How to use**:
             - Pass an array of task objects (NOT strings)
@@ -269,7 +296,7 @@ def _configure_deep_planning_guidance(args: Dict[str, Any], agent: Agent, task:
 
             ---
 
-            #### **2. xpget-agent-plan** - View Current Plan
+            #### **2. xpget_agent_plan** - View Current Plan
             **When to use**: Before deciding what to do next; to check progress
 
             **Returns**: 
@@ -280,8 +307,8 @@ def _configure_deep_planning_guidance(args: Dict[str, Any], agent: Agent, task:
 
             ---
 
-            #### **3. xpcomplete-agent-plan-item** - Mark Task Complete
-            **When to use**: **IMMEDIATELY** after finishing each task (NOT before!)
+            #### **3. xpcomplete_agent_plan_item** - Mark Task Complete
+            **When to use**: **IMMEDIATELY** after finishing each task (NOT before, NOT later, RIGHT NOW!)
 
             **How to use**:
             ```json
@@ -291,14 +318,19 @@ def _configure_deep_planning_guidance(args: Dict[str, Any], agent: Agent, task:
             }
             }
             ```
-            **CRITICAL**: 
-            - Only mark complete AFTER work is actually done
-            - This is MANDATORY for progress tracking
-            - Get the task ID from `xpget-agent-plan` results
+            **🚨 CRITICAL - NON-NEGOTIABLE RULES**: 
+            - Call THIS TOOL the INSTANT you finish a task
+            - DO NOT wait to mark multiple tasks at once
+            - DO NOT postpone marking completion
+            - DO NOT be lazy - mark it complete RIGHT AFTER the work is done
+            - This is MANDATORY for progress tracking and continuation
+            - If you finish a task and don't mark it complete immediately, you are doing it WRONG
+            
+            **Pattern**: Finish work → IMMEDIATELY call xpcomplete_agent_plan_item → Move to next task
 
             ---
 
-            #### **4. xpadd-new-agent-plan-item** - Add Discovered Task
+            #### **4. xpadd_new_agent_plan_item** - Add Discovered Task
             **When to use**: When you discover additional work needed during execution
 
             **How to use**:
@@ -312,7 +344,7 @@ def _configure_deep_planning_guidance(args: Dict[str, Any], agent: Agent, task:
             ```
             ---
 
-            #### **5. xpupdate-agent-plan-item** - Modify Existing Task
+            #### **5. xpupdate_agent_plan_item** - Modify Existing Task
             **When to use**: When task details change or need clarification
 
             **How to use**:
@@ -329,7 +361,7 @@ def _configure_deep_planning_guidance(args: Dict[str, Any], agent: Agent, task:
 
             ---
 
-            #### **6. xpdelete-agent-plan-item** - Remove Task
+            #### **6. xpdelete_agent_plan_item** - Remove Task
             **When to use**: When a task becomes unnecessary or redundant
 
             **How to use**:
@@ -342,8 +374,8 @@ def _configure_deep_planning_guidance(args: Dict[str, Any], agent: Agent, task:
             ```
             ---
 
-            #### **7. xpstart-execution-plan** - Start Plan Execution
-            **When to use**: Immediately after creating a plan with `xpcreate-agent-plan`
+            #### **7. xpstart_execution_plan** - Start Plan Execution
+            **When to use**: Immediately after creating a plan with `xpcreate_agent_plan`
             **CRITICAL**: Must be called to enable enforcement mode before executing tasks
 
             **How to use**:
@@ -361,9 +393,19 @@ def _configure_deep_planning_guidance(args: Dict[str, Any], agent: Agent, task:
 
             ---
 
-            #### **8. xpask-for-information** - Ask User a Question
-            **When to use**: When you need information from the user during plan execution
+            #### **8. xpask_for_information** - Ask User a Question
+            **When to use**: **MANDATORY AFTER PLAN STARTS** when you need ANY of the following:
+            - Information from the user
+            - Clarification on requirements
+            - Approval before proceeding
+            - To pause execution for user input
+            
             **PREREQUISITE**: Plan must be started (running) first
+            
+            **CRITICAL RULE**: Once the plan has started, if you need user input or want to pause, you MUST use this tool.
+            DO NOT just respond with questions in your regular output after plan starts - that breaks execution flow!
+            
+            **NOTE**: BEFORE starting the plan (before xpstart_execution_plan), you CAN ask questions directly if needed.
 
             **How to use**:
             ```json
@@ -375,10 +417,13 @@ def _configure_deep_planning_guidance(args: Dict[str, Any], agent: Agent, task:
             ```
 
             **What it does**:
-            - Sets `question_raised` flag to true
-            - Prints the question for the user
-            - Keeps enforcement active (does NOT pause execution)
-            - Returns waiting status
+            - Properly pauses plan enforcement and sets `question_raised` flag
+            - Delivers question to the user through the correct channel
+            - Manages execution state for proper continuation
+            - Allows resuming execution after user responds
+            
+            **Why this matters**: Using this tool ensures execution can be properly continued with full context.
+            Just responding with a question will NOT pause execution correctly!
 
             ---
 
@@ -386,19 +431,27 @@ def _configure_deep_planning_guidance(args: Dict[str, Any], agent: Agent, task:
 
             ✅ **DO:**
             - Create comprehensive plans with ALL necessary steps
-            - **START** the plan with `xpstart-execution-plan` after creating it
+            - **START** the plan with `xpstart_execution_plan` after creating it
             - Use descriptive, actionable task titles
             - Check plan before each action to stay oriented
-            - Mark tasks complete immediately after finishing them
-            - Ask for user information when needed with `xpask-for-information`
+            - **Mark tasks complete THE INSTANT you finish them - NO DELAYS, NO EXCEPTIONS**
+            - **ALWAYS use `xpask_for_information` when you need user input or want to pause**
             - Call plan tools **sequentially** (one at a time, never in parallel)
+            - Follow the pattern: DO WORK → MARK COMPLETE → NEXT TASK
 
-            ❌ **DON'T:**
+            ❌ **DON'T - THESE ARE FORBIDDEN:**
             - Mark tasks complete before they're actually done
+            - **Be lazy and wait to mark tasks complete later** (FORBIDDEN!)
+            - **Batch mark multiple tasks at the end** (WRONG! Mark each immediately!)
+            - **AFTER plan starts: NEVER write questions in your response text** ("Before I proceed...", "I need clarification...", etc.)
+            - **AFTER plan starts: NEVER respond with questions - ONLY use xpask_for_information tool** (ABSOLUTE RULE!)
             - Pass plain string arrays - must be objects with `title` field
             - Call plan tools in parallel with each other
             - Skip checking the plan between major steps
-            - Forget to mark completed tasks
+            - Postpone marking completion "until later" - there is no later, only NOW
+            
+            **REMEMBER**: Once execution started, any text like "I need to know", "Before I proceed", "I need clarification" means you MUST call xpask_for_information instead!
+            **EXCEPTION**: Before starting the plan, you CAN ask questions directly if needed for planning.
 
             ---
 
@@ -407,7 +460,7 @@ def _configure_deep_planning_guidance(args: Dict[str, Any], agent: Agent, task:
             ```
             1. User: "Build a REST API for user management"
 
-            2. Call: xpcreate-agent-plan
+            2. Call: xpcreate_agent_plan
             tasks: [
                 {"title": "Design user schema"},
                 {"title": "Create database migration"},
@@ -416,27 +469,52 @@ def _configure_deep_planning_guidance(args: Dict[str, Any], agent: Agent, task:
                 {"title": "Write integration tests"}
             ]
 
-            3. Call: xpstart-execution-plan
+            3. Call: xpstart_execution_plan
             → Plan now started, enforcement enabled (if enforce=true)
 
-            4. Call: xpget-agent-plan
+            4. Call: xpget_agent_plan
             → See: Task 1 (ID: abc-123) - Design user schema - Not complete
 
-            5. [Realize need user input] Call: xpask-for-information
+            5. [Realize need user input] Call: xpask_for_information
             question: "Which database should we use - PostgreSQL or MySQL?"
             → question_raised=true, waiting for response
 
-            6. [After user responds, do the work: Design schema]
+            6. [After user responds, DO THE WORK: Design schema]
 
-            7. Call: xpcomplete-agent-plan-item
+            7. ⚠️ IMMEDIATELY Call: xpcomplete_agent_plan_item
             id: "abc-123"
+            → MARKED COMPLETE RIGHT AFTER FINISHING - NOT DELAYED!
+
+            8. Call: xpget_agent_plan
+            → See: Task 1 ✓ complete, Task 2 (ID: def-456) - Create database migration - Not complete
+
+            9. [DO THE WORK: Create migration file]
 
-            8. Call: xpget-agent-plan
-            → See: Task 1 ✓ complete, Task 2 next...
+            10. ⚠️ IMMEDIATELY Call: xpcomplete_agent_plan_item
+            id: "def-456"
+            → MARKED COMPLETE RIGHT AWAY!
 
-            9. [Continue through remaining tasks]
+            11. [Continue this pattern: GET PLAN → DO WORK → MARK COMPLETE IMMEDIATELY → REPEAT]
+            ```
+            
+            ### **WRONG WAY - ANTI-PATTERN (DO NOT DO THIS)**
+            
+            ```
+            ❌ WRONG:
+            1. Call: xpcreate_agent_plan
+            2. Call: xpstart_execution_plan  ← PLAN IS NOW STARTED!
+            3. Respond: "Before I proceed, I need clarification on..."  ← WRONG! FORBIDDEN!
+            
+            ✅ CORRECT:
+            1. Call: xpcreate_agent_plan
+            2. Call: xpstart_execution_plan  ← PLAN IS NOW STARTED!
+            3. Call: xpask_for_information with question  ← CORRECT! Use the tool!
             ```
-            **Remember**: The plan is your roadmap. Check it often, update it as needed, and always mark tasks complete when done!
+            
+            **KEY POINT**: Once you call `xpstart_execution_plan`, the execution mode changes.
+            You CANNOT write questions in your response anymore. You MUST use the tool.
+            
+            **Golden Rule**: FINISH TASK → MARK COMPLETE INSTANTLY → MOVE TO NEXT TASK. No delays, no batching, no "I'll do it later"!
             </important_planning_instructions>
         """
         

{xpander_sdk-2.0.166 → xpander_sdk-2.0.168}/src/xpander_sdk/modules/events/events_module.py

@@ -358,12 +358,12 @@ class Events(ModuleBase):
             plan_following_status = await task.aget_plan_following_status()
             if not plan_following_status.can_finish:
                 # Check if we've exceeded max retries
-                if retry_count >= 2:  # 0, 1, 2 = 3 total attempts
+                if retry_count >= 50:  # 0, 1, 2 = 50 total attempts
                     logger.warning(f"Failed to complete plan after {retry_count + 1} attempts. Remaining incomplete tasks.")
                     return
                 
                 # Recursively call with incremented retry count
-                logger.info(f"Plan not complete, retrying (attempt {retry_count + 2}/3)")
+                logger.info(f"Plan not complete, retrying (attempt {retry_count + 2})")
                 await self.handle_task_execution_request(
                     agent_worker,
                     task,

{xpander_sdk-2.0.166 → xpander_sdk-2.0.168}/src/xpander_sdk/modules/tasks/sub_modules/task.py

@@ -43,7 +43,7 @@ from httpx import HTTPStatusError
 import httpx
 import json
 from httpx_sse import aconnect_sse
-from pydantic import Field, computed_field
+from pydantic import Field
 
 from xpander_sdk.consts.api_routes import APIRoute
 from xpander_sdk.core.xpander_api_client import APIClient
@@ -337,10 +337,13 @@ class Task(XPanderSharedModel):
         """
         return run_sync(self.aset_status(status=status, result=result))
 
-    async def asave(self):
+    async def asave(self, with_deep_plan_update: Optional[bool] = False):
         """
         Asynchronously saves the current task state to the backend.
 
+        Args:
+            with_deep_plan_update (Optional[bool]): should update deep plan as well? default false.
+        
         Raises:
             ModuleException: Error related to HTTP requests or task saving.
 
@@ -349,10 +352,15 @@ class Task(XPanderSharedModel):
         """
         client = APIClient(configuration=self.configuration)
         try:
+            exclude = {"configuration"}
+            
+            if not with_deep_plan_update:
+                exclude.add("deep_planning")
+                
             response = await client.make_request(
                 path=APIRoute.UpdateTask.format(task_id=self.id),
                 method="PATCH",
-                payload=self.model_dump_safe(exclude={"configuration","deep_planning"}),
+                payload=self.model_dump_safe(exclude=exclude),
             )
             updated_task = Task(**response, configuration=self.configuration)
             for field, value in updated_task.__dict__.items():
@@ -362,16 +370,19 @@ class Task(XPanderSharedModel):
         except Exception as e:
             raise ModuleException(500, f"Failed to save task: {str(e)}")
 
-    def save(self):
+    def save(self, with_deep_plan_update: Optional[bool] = False):
         """
         Saves the current task state synchronously.
 
         This function wraps the asynchronous asave method.
+        
+        Args:
+            with_deep_plan_update (Optional[bool]): should update deep plan as well? default false.
 
         Example:
             >>> task.save()
         """
-        return run_sync(self.asave())
+        return run_sync(self.asave(with_deep_plan_update=with_deep_plan_update))
 
     async def astop(self):
         """
@@ -540,16 +551,20 @@ class Task(XPanderSharedModel):
             for f in readable_files:
                 message += f"\n{json.dumps(f)}"
 
-        if self.deep_planning and self.deep_planning.enabled == True:
+        if self.deep_planning and self.deep_planning.enabled == True and self.deep_planning.started:
             self.reload()
-            uncompleted_tasks = [task for task in self.deep_planning.tasks if not task.completed]
-            if len(uncompleted_tasks) != 0:
-                message = "\n".join([
-                    "Task not finished, uncompleted tasks detected:",
-                    f"Uncompleted tasks: {[task.model_dump_json() for task in uncompleted_tasks]}",
-                    "You must complete tasks if fulfilled",
-                    f"User's original request: \"{message}\""
-                ])
+            if not self.deep_planning.question_raised:
+                uncompleted_tasks = [task for task in self.deep_planning.tasks if not task.completed]
+                if len(uncompleted_tasks) != 0: # make a retry with compactization
+                    from xpander_sdk.utils.agents.compactization_agent import run_task_compactization
+                    compactization_result = run_task_compactization(message=message, task=self, uncompleted_tasks=uncompleted_tasks)
+                    if isinstance(compactization_result, str):
+                        message = compactization_result
+                    else:
+                        message = f"<user_input>{compactization_result.new_task_prompt}</user_input><task_context>{compactization_result.task_context}</task_context>"
+            else:
+                self.deep_planning.question_raised = False # reset question raised indicator
+                self.save(with_deep_plan_update=True)
         
         return message
 
@@ -785,9 +800,8 @@ class Task(XPanderSharedModel):
             ...     print(f"Remaining tasks: {len(status.uncompleted_tasks)}")
         """
         try:
-            return PlanFollowingStatus(can_finish=True) # TODO: complete
+            await self.areload()
             if self.deep_planning and self.deep_planning.enabled and self.deep_planning.started and self.deep_planning.enforce:
-                await self.areload()
                 
                 # allow early exit to ask question
                 if self.deep_planning.question_raised:

xpander_sdk-2.0.168/src/xpander_sdk/utils/agents/compactization_agent.py

@@ -0,0 +1,189 @@
+from typing import TYPE_CHECKING, List, Union
+from agno.agent import Agent as AgnoAgent
+from loguru import logger
+import json
+from xpander_sdk.models.compactization import TaskCompactizationOutput, TaskCompactizationInput
+from xpander_sdk.models.deep_planning import DeepPlanningItem
+from xpander_sdk.models.frameworks import Framework
+from xpander_sdk.models.shared import Tokens
+from xpander_sdk.modules.agents.agents_module import Agents
+from xpander_sdk.modules.backend.backend_module import Backend
+
+if TYPE_CHECKING:
+    from xpander_sdk.modules.tasks.sub_modules.task import Task
+
+def run_task_compactization(message: str, task: "Task", uncompleted_tasks: List[DeepPlanningItem]) -> Union[str, TaskCompactizationOutput]:
+    try:
+        # get agent to identify framework
+        agent = Agents(configuration=task.configuration).get(agent_id=task.agent_id,version=task.agent_version)
+        
+        # non agno, let the same agent handle it
+        if agent.framework != Framework.Agno:
+            return "\n".join([
+                "Task not finished, uncompleted tasks detected:",
+                f"Uncompleted tasks: {[task.model_dump_json() for task in uncompleted_tasks]}",
+                "You must complete tasks if fulfilled",
+                f"User's original request: \"{message}\""
+            ])
+        
+        # load backend args for consistency of model provider and settings
+        agno_args = Backend(configuration=agent.configuration).get_args(agent_id=agent.id, agent_version=agent.version, task=task)
+        
+        if agent.model_provider == "openai":
+            agno_args["model"].id = "gpt-5-mini"
+        
+        # create compacitzation agent
+        compactization_agent = AgnoAgent(
+            output_schema=TaskCompactizationOutput,
+            name="Task Compactization Agent",
+            model=agno_args.get("model"),
+            description="""
+                You analyze a running agent execution that has uncompleted tasks and produce a seamless continuation package.
+                
+                Your output enables the execution to resume exactly where it left off and complete ALL remaining tasks.
+                
+                You produce:
+                1. A continuation prompt that picks up mid-execution (NOT a new task start)
+                2. Comprehensive context that preserves all critical state, decisions, and artifacts
+                
+                CRITICAL: ALL uncompleted tasks provided to you MUST be addressed and marked as completed in your continuation plan.
+            """,
+            role="""
+                You are a **Task Compactization Agent** specialized in maintaining execution continuity.
+                
+                Your mission: Convert a partially-executed agent run into a precise continuation package that allows the execution 
+                to resume seamlessly and complete ALL uncompleted tasks without repetition or confusion.
+                
+                You are NOT starting a new task - you are continuing a running process that was interrupted.
+                The next agent run will receive your continuation prompt as the next message in an ongoing conversation.
+            """,
+            instructions="""
+            ## Core Principles
+            
+            * **This is a CONTINUATION, not a restart.** The next prompt continues an active execution mid-conversation.
+            * **ALL uncompleted tasks MUST be completed.** Your continuation plan must ensure every uncompleted task gets done and marked complete.
+            * **Stay factual.** Do not invent details. Use "Unknown" for missing information and list it under open questions.
+            * **Preserve exact state.** Keep precise names, IDs, numbers, file paths, tool outputs, and user wording unchanged.
+            * **Track completion accurately.** Never imply completion. Clearly distinguish what IS done from what REMAINS to be done.
+            
+            ## What You Must Capture
+            
+            * **Tool call history.** For each tool: name/id, purpose, inputs (high-level), outputs (high-level), errors. Include plan tools (xpcreate_agent_plan, xpcomplete_agent_plan_item, etc.).
+            * **Artifacts and state.** All created files, IDs, URLs, variables, decisions, and configurations.
+            * **What worked / what didn't.** Successes, failures, blockers, missing info, wrong assumptions.
+            * **Task completion status.** For each uncompleted task: exact ID, title, and specific reason it's incomplete.
+            * **PROTOCOL VIOLATIONS.** Check if agent asked questions in response text AFTER calling xpstart_execution_plan (violates protocol).
+            
+            ## Detecting Protocol Violations
+            
+            If the agent's last message contains questions to the user AFTER the plan was started (after xpstart_execution_plan was called):
+            - This is a PROTOCOL VIOLATION
+            - The agent should have used xpask_for_information tool instead
+            
+            When violation is detected, you MUST make it SUPER CLEAR in BOTH output fields:
+            
+            **In `new_task_prompt`:**
+            - START with: "CRITICAL PROTOCOL VIOLATION DETECTED: You asked questions directly after starting the plan."
+            - Explicitly state: "You MUST use xpask_for_information tool to ask questions once plan is running."
+            - Include: "NEVER write questions in your response text after calling xpstart_execution_plan."
+            - Then provide the continuation instructions
+            
+            **In `task_context`:**
+            - Add a dedicated section at the TOP before section 1: "**PROTOCOL VIOLATION DETECTED**"
+            - State clearly: "Agent asked questions in response text after calling xpstart_execution_plan. This violates execution protocol."
+            - Remind: "Rule: After xpstart_execution_plan is called, questions MUST be asked using xpask_for_information tool, NOT written in response text."
+            
+            Signs of protocol violation in messages:
+            - Phrases like "Before I proceed", "I need clarification", "Please choose", "Which option"
+            - Questions written in response text after xpstart_execution_plan was called
+            
+            ## Continuation Prompt Requirements
+            
+            Your `new_task_prompt` must:
+            1. **IF protocol violation detected:** START with "CRITICAL PROTOCOL VIOLATION DETECTED" warning (see above)
+            2. Resume where execution stopped ("Continuing from where we left off...")
+            3. NOT repeat completed work
+            4. List ALL uncompleted tasks by ID and title
+            5. Provide step-by-step actions to complete each task
+            6. Explicitly instruct to mark each task complete using xpcomplete_agent_plan_item after finishing it
+            7. Sound like the next message in an ongoing conversation, not a new task
+            8. **IF protocol violation:** Emphasize the requirement to use xpask_for_information tool for any questions
+            
+            ## Task Context Requirements
+            
+            Your `task_context` must:
+            1. **IF protocol violation detected:** Add "PROTOCOL VIOLATION DETECTED" section at the TOP before section 1
+            2. Follow the exact 9-heading structure specified in the output schema (or 10 if violation detected)
+            3. Be deterministic and parseable by downstream systems
+            4. Focus on actionable continuation steps in section 9 (NEXT ACTIONS)
+            5. Include task IDs for all uncompleted tasks
+            6. Emphasize that ALL tasks must be completed and marked complete
+            
+            ## Critical Rules
+            
+            ❌ **NEVER:**
+            - Suggest restarting or creating a new plan
+            - Mark tasks as complete that aren't actually done
+            - Invent details or speculate
+            - Write a "fresh start" prompt
+            
+            ✅ **ALWAYS:**
+            - Write continuation prompts that resume mid-execution
+            - Include all uncompleted task IDs and titles
+            - Provide specific actions to complete each task
+            - Instruct to mark tasks complete using the plan tools
+            - Preserve exact state, IDs, names, and wording
+            - **Check for protocol violations** and correct them in your continuation prompt
+            - If agent asked questions in text after plan started, instruct to use xpask_for_information tool instead
+            """,
+            expected_output="""
+            Return a JSON object with exactly these two fields:
+
+            - new_task_prompt (string): A continuation message that resumes the running execution mid-conversation.
+              IF PROTOCOL VIOLATION DETECTED (agent asked questions after xpstart_execution_plan):
+                - START WITH: "CRITICAL PROTOCOL VIOLATION DETECTED: You asked questions directly after starting the plan. You MUST use xpask_for_information tool to ask questions once plan is running. NEVER write questions in your response text after calling xpstart_execution_plan."
+              Then: (1) list ALL uncompleted tasks with their IDs and titles, (2) give step-by-step actions to finish each,
+              (3) explicitly instruct to mark each task complete using xpcomplete_agent_plan_item after finishing it, and
+              (4) read like the next message in an ongoing conversation (NOT a fresh start).
+
+            - task_context (string): Comprehensive context for continuation.
+              IF PROTOCOL VIOLATION DETECTED:
+                - Add section at TOP: "**PROTOCOL VIOLATION DETECTED**\nAgent asked questions in response text after calling xpstart_execution_plan. This violates execution protocol. Rule: After xpstart_execution_plan is called, questions MUST be asked using xpask_for_information tool, NOT written in response text.\n\n"
+              Then follow the EXACT 9-section structure defined in TaskCompactizationOutput.task_context.
+              Must be deterministic, actionable, and focused on completing ALL remaining tasks and marking them as completed.
+
+            Important:
+            - Do NOT invent details; write 'Unknown' when information is missing.
+            - Preserve exact IDs, names, file paths, numbers, and user phrasing.
+            - Final actions must include marking each remaining task as completed with the plan tools.
+            - IF protocol violation: Make it SUPER CLEAR in both fields that tool must be used for questions.
+            """
+        )
+        
+        session = agent.get_session(session_id=task.id)
+        
+        # run compactization
+        run_result = compactization_agent.run(
+            input=TaskCompactizationInput(
+                user_input=task.input,
+                agent_instructions=agent.instructions,
+                task_context_and_messages=json.dumps({"messages": [message.model_dump() for message in session.get_messages() if message.role != "system"]}),
+                uncompleted_tasks=uncompleted_tasks
+            )
+        )
+        
+        # reset old session
+        agent.delete_session(session_id=task.id)
+        
+        # report LLM Metrics
+        task.tokens = Tokens(
+            completion_tokens=run_result.metrics.output_tokens,
+            prompt_tokens=run_result.metrics.input_tokens
+        )
+        
+        task.report_metrics(configuration=task.configuration)
+        
+        return run_result.content
+    except Exception as e:
+        logger.warning(f"Failed to run task compactization - {str(e)}")
+        return message

{xpander_sdk-2.0.166 → xpander_sdk-2.0.168}/src/xpander_sdk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xpander-sdk
-Version: 2.0.166
+Version: 2.0.168
 Summary: xpander.ai Backend-as-a-service for AI Agents - SDK
 Home-page: https://www.xpander.ai
 Author: xpanderAI

{xpander_sdk-2.0.166 → xpander_sdk-2.0.168}/src/xpander_sdk.egg-info/SOURCES.txt

@@ -18,6 +18,7 @@ src/xpander_sdk/exceptions/__init__.py
 src/xpander_sdk/exceptions/module_exception.py
 src/xpander_sdk/models/__init__.py
 src/xpander_sdk/models/activity.py
+src/xpander_sdk/models/compactization.py
 src/xpander_sdk/models/configuration.py
 src/xpander_sdk/models/deep_planning.py
 src/xpander_sdk/models/events.py
@@ -88,6 +89,8 @@ src/xpander_sdk/utils/__init__.py
 src/xpander_sdk/utils/env.py
 src/xpander_sdk/utils/event_loop.py
 src/xpander_sdk/utils/tools.py
+src/xpander_sdk/utils/agents/__init__.py
+src/xpander_sdk/utils/agents/compactization_agent.py
 tests/test_agents_module.py
 tests/test_api_client.py
 tests/test_backend_module.py