lybic-guiagents 0.3.0__py3-none-any.whl → 0.5.0__py3-none-any.whl

gui_agents/__init__.py

@@ -37,7 +37,7 @@ from .agents.hardware_interface import HardwareInterface
 from .store.registry import Registry
 from .agents.global_state import GlobalState
 
-__version__ = "0.3.0"
+__version__ = "0.5.0"
 
 # Primary exports (what users should typically use)
 __all__ = [

gui_agents/agents/agent_s.py

@@ -1,4 +1,3 @@
-import asyncio
 import json
 import logging
 import os
@@ -13,7 +12,6 @@ from gui_agents.utils.common_utils import Node
 from gui_agents.agents.global_state import GlobalState
 from gui_agents.store.registry import Registry
 from gui_agents.utils.common_utils import (
-    # call_llm_safe,
     parse_single_code_from_string,
     sanitize_code,
     extract_first_agent_function,
@@ -172,8 +170,6 @@ class AgentS2(UIAgent):
         else:
             print(f"Found local knowledge base path: {kb_platform_path}")
 
-        self.reset()
-
     def reset(self) -> None:
         """
         Reinitialize core components and reset the agent's runtime state.
@@ -219,12 +215,18 @@ class AgentS2(UIAgent):
         self.subtasks: List[Node] = []
         self.search_query: str = ""
         self.subtask_status: str = "Start"
-        self.global_state: GlobalState = Registry.get("GlobalStateStore") # type: ignore
+        # Use task-specific registry if task_id is available, otherwise fall back to global registry
+        if self.task_id:
+            self.global_state: GlobalState = Registry.get_from_context("GlobalStateStore", self.task_id) # type: ignore
+        else:
+            self.global_state: GlobalState = Registry.get("GlobalStateStore") # type: ignore
 
         # Pass task_id to components
-        if self.task_id:
-            self.manager.task_id = self.task_id
-            self.worker.task_id = self.task_id
+        self.manager.set_task_id(self.task_id)
+        self.worker.set_task_id(self.task_id)
+        # Grounding doesn't have task_id in normal mode, but we set it if available
+        if hasattr(self, 'grounding') and hasattr(self.grounding, 'set_task_id'):
+            self.grounding.set_task_id(self.task_id)
 
     def set_task_id(self, task_id: str) -> None:
         """
@@ -236,9 +238,9 @@ class AgentS2(UIAgent):
         self.task_id = task_id
         # Also set task_id for components if they exist
         if hasattr(self, 'manager') and self.manager:
-            self.manager.task_id = task_id
+            self.manager.set_task_id(task_id)
         if hasattr(self, 'worker') and self.worker:
-            self.worker.task_id = task_id
+            self.worker.set_task_id(task_id)
 
     def reset_executor_state(self) -> None:
         """Reset executor and step counter"""
@@ -249,17 +251,28 @@ class AgentS2(UIAgent):
         # Initialize the three info dictionaries
         """
         Produce the next executor actions and diagnostic information for the current task step.
-        
+
         This method coordinates planning, subtask selection, action generation, grounding (code extraction and execution), and status updates. It may trigger replanning, advance to the next subtask, mark subtasks as completed or failed, and emit stream messages and logs. The returned info merges planner, executor, and evaluator metadata and includes current subtask details.
-        
+
         Parameters:
             instruction (str): The user or system instruction describing the task to accomplish; forwarded to the manager/worker as the task utterance.
             observation (Dict): Current environment observation/state used for grounding and coordinate assignment.
-        
+
         Returns:
             info (Dict): A merged dictionary containing planner_info, executor_info, evaluator_info and the keys `subtask`, `subtask_info`, and `subtask_status`.
             actions (List[Dict]): List of action dictionaries produced for execution (may include actions with type "DONE", failure indicators, or other executor-generated actions).
         """
+        # Check for cancellation before starting prediction
+        if self.global_state.is_cancelled():
+            logger.info("AgentS2 prediction cancelled by user request")
+            return {
+                "subtask": "cancelled",
+                "subtask_info": "",
+                "subtask_status": "cancelled",
+                "reflection": "Task was cancelled",
+                "executor_plan": "agent.done()"
+            }, ["done"]
+
         planner_info = {}
         executor_info = {}
         evaluator_info = {
@@ -276,6 +289,16 @@ class AgentS2(UIAgent):
 
         # If the DONE response by the executor is for a subtask, then the agent should continue with the next subtask without sending the action to the environment
         while not self.should_send_action:
+            # Check for cancellation in each iteration
+            if self.global_state.is_cancelled():
+                logger.info("AgentS2 prediction loop cancelled by user request")
+                return {
+                    "subtask": "cancelled",
+                    "subtask_info": "",
+                    "subtask_status": "cancelled",
+                    "reflection": "Task was cancelled",
+                    "executor_plan": "agent.done()"
+                }, [{"type": "DONE"}]
             time.sleep(5.0)
             self.subtask_status = "In"
             # Always time get_action_queue, even if not called
@@ -430,6 +453,15 @@ class AgentS2(UIAgent):
                     }
                 )
             except Exception as e:
+                if self.global_state.is_cancelled():
+                    logger.info("Cancelled during grounding; stopping without action")
+                    return {
+                        "subtask": "cancelled",
+                        "subtask_info": "",
+                        "subtask_status": "cancelled",
+                        "reflection": "Task was cancelled",
+                        "executor_plan": "agent.done()"
+                    }, [{"type": "DONE"}]
                 logger.error("Error in parsing plan code: %s", e)
                 plan_code = "agent.wait(1.0)"
                 agent: Grounding = self.grounding # this agent will be used in next code
@@ -733,8 +765,6 @@ class AgentSFast(UIAgent):
         else:
             print(f"Found local knowledge base path: {kb_platform_path}")
 
-        self.reset()
-
     def reset(self) -> None:
         """
         Reinitialize the fast-agent components and reset internal runtime state.
@@ -816,19 +846,25 @@ class AgentSFast(UIAgent):
         # Reset state variables
         self.step_count: int = 0
         self.turn_count: int = 0
-        self.global_state: GlobalState = Registry.get("GlobalStateStore") # type: ignore
+        # Use task-specific registry if task_id is available, otherwise fall back to global registry
+        if self.task_id:
+            self.global_state: GlobalState = Registry.get_from_context("GlobalStateStore", self.task_id) # type: ignore
+        else:
+            self.global_state: GlobalState = Registry.get("GlobalStateStore") # type: ignore
         self.latest_action = None
 
-        # Pass task_id to tools if available
-        if self.task_id:
-            self.fast_action_generator.task_id = self.task_id
-            if self.enable_reflection and hasattr(self, 'reflection_agent'):
-                self.reflection_agent.task_id = self.task_id
+        # Pass task_id to tools and components if available
+        self.fast_action_generator.task_id = self.task_id
+        if self.enable_reflection and hasattr(self, 'reflection_agent'):
+            self.reflection_agent.task_id = self.task_id
+        # Set task_id for grounding component
+        if hasattr(self, 'grounding') and hasattr(self.grounding, 'set_task_id'):
+            self.grounding.set_task_id(self.task_id)
 
     def set_task_id(self, task_id: str) -> None:
         """
         Store the task identifier on the agent and propagate it to subcomponents that use it.
-        
+
         Parameters:
             task_id (str): Identifier for the active task; assigned to this agent and, if present, to
                 `fast_action_generator` and `reflection_agent`.
@@ -839,22 +875,34 @@ class AgentSFast(UIAgent):
             self.fast_action_generator.task_id = task_id
         if hasattr(self, 'reflection_agent') and self.reflection_agent:
             self.reflection_agent.task_id = task_id
+        # Set task_id for grounding component
+        if hasattr(self, 'grounding') and hasattr(self.grounding, 'set_task_id'):
+            self.grounding.set_task_id(task_id)
 
     def predict(self, instruction: str, observation: Dict) -> Tuple[Dict, List[str]]:
         """
         Generate the next executor plan and corresponding actions using the configured fast action generator.
-        
+
         Parameters:
         	instruction (str): Natural language task description.
         	observation (Dict): Current UI state; must include a "screenshot" entry with the screen image.
-        
+
         Returns:
         	executor_info (dict): Contains at least the keys `executor_plan` (raw plan text), `reflection` (reflection text or empty string), and `plan_code` (the latest extracted/used action code).
         	actions (List[dict]): List of action dictionaries produced by grounding execution; typically a single action dict describing the operation to perform.
         """
+        # Check for cancellation before starting prediction
+        if self.global_state.is_cancelled():
+            logger.info("AgentSFast prediction cancelled by user request")
+            return {
+                "executor_plan": "agent.done()",
+                "reflection": "Task was cancelled",
+                "plan_code": "agent.done()"
+            }, [{"type": "DONE"}]
+
         import time
         predict_start_time = time.time()
-        
+
         fast_action_start_time = time.time()
 
         reflection = None

gui_agents/agents/global_state.py

@@ -467,7 +467,9 @@ class GlobalState:
             return "stopped"
 
     def set_running_state(self, state: str) -> None:
-        assert state in {"running", "stopped"}
+        if state not in {"running", "stopped", "cancelled"}:
+            raise ValueError(f"Invalid running state: {state}")
+
         tmp = self.running_state_path.with_suffix(".tmp")
         try:
             with locked(tmp, "w") as f:
@@ -486,6 +488,16 @@ class GlobalState:
                     pass
             raise
 
+    def is_cancelled(self) -> bool:
+        """Check if the current execution has been cancelled"""
+        try:
+            with locked(self.running_state_path, "r") as f:
+                data = safe_json_load(f)
+            return data == "cancelled"
+        except Exception as e:
+            logger.warning(f"Failed to check cancellation state: {e}")
+            return False
+
     # ---------- High-level Wrappers ----------
     def get_obs_for_manager(self):
         return {

gui_agents/agents/grounding.py

@@ -92,10 +92,20 @@ class Grounding(ACI):
         self.text_span_agent = Tools()
         _register(self.text_span_agent, "text_span")
 
-        self.global_state: GlobalState = Registry.get(
-            "GlobalStateStore")  # type: ignore
+        # GlobalState will be initialized when task_id is set
+        self.global_state: GlobalState = None  # type: ignore
+
+    def set_task_id(self, task_id: str) -> None:
+        """Set the task identifier and update global state reference"""
+        # Update global state reference with task-specific registry
+        self.global_state = Registry.get_from_context("GlobalStateStore", task_id)  # type: ignore
 
     def generate_coords(self, ref_expr: str, obs: Dict) -> List[int]:
+        # Check for cancellation before starting coordinate generation
+        if self.global_state.is_cancelled():
+            logger.info("Grounding coordinate generation cancelled by user request")
+            raise RuntimeError("cancelled")  # Return default coordinates when cancelled
+
         grounding_start_time = time.time()
         self.grounding_model.tools["grounding"].llm_agent.reset()
         prompt = (
@@ -453,8 +463,13 @@ class FastGrounding(ACI):
         self.height = height
         self.grounding_width = grounding_width
         self.grounding_height = grounding_height
-        self.global_state: GlobalState = Registry.get(
-            "GlobalStateStore")  # type: ignore
+        # GlobalState will be initialized when task_id is set
+        self.global_state: GlobalState = None  # type: ignore
+
+    def set_task_id(self, task_id: str) -> None:
+        """Set the task identifier and update global state reference"""
+        # Update global state reference with task-specific registry
+        self.global_state = Registry.get_from_context("GlobalStateStore", task_id)  # type: ignore
 
     def reset_screen_size(self, width: int, height: int):
         self.width = width

gui_agents/agents/manager.py

@@ -102,7 +102,8 @@ class Manager:
             Tools_dict=KB_Tools_dict,
         )
 
-        self.global_state: GlobalState = Registry.get("GlobalStateStore") # type: ignore
+        # GlobalState will be initialized in reset() method when task_id is available
+        self.global_state: GlobalState = None  # type: ignore
 
         self.planner_history = []
 
@@ -118,6 +119,12 @@ class Manager:
 
         self.multi_round = multi_round
 
+    def set_task_id(self, task_id: str) -> None:
+        """Set the task identifier and update global state reference"""
+        self.task_id = task_id
+        # Update global state reference with task-specific registry
+        self.global_state = Registry.get_from_context("GlobalStateStore", task_id)  # type: ignore
+
     def _send_stream_message(self, task_id: str, stage: str, message: str) -> None:
         """
         Enqueue a stream message for the given task if a task ID is provided.
@@ -569,6 +576,11 @@ class Manager:
         """Generate the action list based on the instruction
         instruction:str: Instruction for the task
         """
+        # Check for cancellation before starting action queue generation
+        if self.global_state.is_cancelled():
+            logger.info("Manager action queue generation cancelled by user request")
+            return {"cancelled": True}, []
+
         import time
         action_queue_start = time.time()
 

gui_agents/agents/worker.py

@@ -67,8 +67,8 @@ class Worker:
 
         self.enable_reflection = enable_reflection
         self.use_subtask_experience = use_subtask_experience
-        self.global_state: GlobalState = Registry.get(
-            "GlobalStateStore")  # type: ignore
+        # GlobalState will be initialized in reset() method when task_id is available
+        self.global_state: GlobalState = None  # type: ignore
         self.reset()
 
     def reset(self):
@@ -159,6 +159,12 @@ class Worker:
         self.max_trajector_length = 8
         self.task_id = None  # Will be set by agent
 
+    def set_task_id(self, task_id: str) -> None:
+        """Set the task identifier and update global state reference"""
+        self.task_id = task_id
+        # Update global state reference with task-specific registry
+        self.global_state = Registry.get_from_context("GlobalStateStore", task_id)  # type: ignore
+
     def generate_next_action(
         self,
         Tu: str,
@@ -172,7 +178,7 @@ class Worker:
     ) -> Dict:
         """
         Generate the next executor action plan and related metadata for the current subtask given the observation and context.
-        
+
         Parameters:
             Tu (str): Full task description or task context.
             search_query (str): Search string used for retrieving episodic/subtask experience.
@@ -182,7 +188,7 @@ class Worker:
             done_task (List[Node]): List of completed task nodes.
             obs (Dict): Current observation dictionary; must include a "screenshot" key with the current screen image.
             running_state (str): Current executor running state (default "running").
-        
+
         Returns:
             Dict: Executor information containing:
                 - "current_subtask" (str): The provided subtask.
@@ -190,6 +196,16 @@ class Worker:
                 - "executor_plan" (str): The raw plan produced by the action generator.
                 - "reflection" (str|None): Reflection text produced by the trajectory reflector, or None if reflection is disabled.
         """
+        # Check for cancellation before starting action generation
+        if self.global_state.is_cancelled():
+            logger.info("Worker action generation cancelled by user request")
+            return {
+                "current_subtask": subtask,
+                "current_subtask_info": subtask_info,
+                "executor_plan": "agent.done()",
+                "reflection": "Task was cancelled"
+            }
+
         import time
         action_start = time.time()