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

gui_agents/service/agent_service.py

@@ -92,29 +92,41 @@ class AgentService:
         
         return logger
     
-    def _get_or_create_agent(self, mode: str, **kwargs) -> Union[AgentS2, AgentSFast]:
+    def _get_or_create_agent(self, mode: str, task_id: Optional[str] = None, **kwargs) -> Union[AgentS2, AgentSFast]:
         """Get or create agent instance based on mode"""
-        cache_key = f"{mode}_{hash(str(sorted(kwargs.items())))}"
-        
+        # Include task_id in cache key for task isolation when task_id is provided
+        if task_id:
+            cache_key = f"{mode}_{task_id}_{hash(str(sorted(kwargs.items())))}"
+        else:
+            cache_key = f"{mode}_{hash(str(sorted(kwargs.items())))}"
+
         if cache_key not in self._agents:
             agent_kwargs = {
                 'platform': kwargs.get('platform', self.config.default_platform),
                 'enable_takeover': kwargs.get('enable_takeover', self.config.enable_takeover),
                 'enable_search': kwargs.get('enable_search', self.config.enable_search),
             }
-            
+
             if mode == AgentMode.FAST.value:
                 self._agents[cache_key] = AgentSFast(**agent_kwargs)
             else:
                 self._agents[cache_key] = AgentS2(**agent_kwargs)
-            
+
             self.logger.debug(f"Created new agent: {mode} with kwargs: {agent_kwargs}")
-        
-        return self._agents[cache_key]
+
+        # Set task_id on the agent for task-specific operations
+        agent = self._agents[cache_key]
+        if task_id and hasattr(agent, 'set_task_id'):
+            agent.set_task_id(task_id)
+
+        return agent
     
-    def _get_or_create_hwi(self, backend: str, **kwargs) -> HardwareInterface:
+    def _get_or_create_hwi(self, backend: str, task_id: Optional[str] = None, **kwargs) -> HardwareInterface:
         """Get or create hardware interface instance"""
-        cache_key = f"{backend}_{hash(str(sorted(kwargs.items())))}"
+        if task_id:
+            cache_key = f"{backend}_{task_id}_{hash(str(sorted(kwargs.items())))}"
+        else:
+            cache_key = f"{backend}_{hash(str(sorted(kwargs.items())))}"
         
         if cache_key not in self._hwi_instances:
             # Get backend-specific config
@@ -134,17 +146,20 @@ class AgentService:
         return self._hwi_instances[cache_key]
     
     def _setup_global_state(self, task_id: str) -> str:
-        """Setup global state for task execution"""
+        """Setup global state for task execution with task isolation"""
         # Create timestamp-based directory structure like cli_app.py
         datetime_str = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
-        timestamp_dir = Path(self.config.log_dir) / datetime_str
+        timestamp_dir = Path(self.config.log_dir) / f"{datetime_str}_{task_id[:8]}"  # Include task_id prefix
         cache_dir = timestamp_dir / "cache" / "screens"
         state_dir = timestamp_dir / "state"
-        
+
         cache_dir.mkdir(parents=True, exist_ok=True)
         state_dir.mkdir(parents=True, exist_ok=True)
-        
-        # Register global state for this task
+
+        # Create task-specific registry
+        task_registry = Registry()
+
+        # Register global state for this task in task-specific registry
         global_state = GlobalState(
             screenshot_dir=str(cache_dir),
             tu_path=str(state_dir / "tu.json"),
@@ -157,11 +172,16 @@ class AgentService:
             display_info_path=str(timestamp_dir / "display.json"),
             agent_log_path=str(timestamp_dir / "agent_log.json")
         )
-        
-        # Use task-specific registry key to avoid conflicts
+
+        # Register in task-specific registry using instance method
         registry_key = "GlobalStateStore"
-        Registry.register(registry_key, global_state)
-        
+        task_registry.register_instance(registry_key, global_state)
+
+        # Set task registry in thread-local storage
+        Registry.set_task_registry(task_id, task_registry)
+
+        self.logger.info(f"Setup task-specific registry for task {task_id}")
+
         return str(timestamp_dir)
     
     def _execute_task_internal(self, request: TaskRequest, task_result: TaskResult) -> TaskResult:
@@ -173,19 +193,21 @@ class AgentService:
             # Setup global state
             task_dir = self._setup_global_state(task_result.task_id)
             
-            # Create agent and hardware interface
+            # Create agent and hardware interface with task_id
             agent = self._get_or_create_agent(
                 request.mode,
+                task_id=task_result.task_id,
                 platform=self.config.default_platform,
                 enable_takeover=request.enable_takeover,
                 enable_search=request.enable_search
             )
-            
+
             hwi = self._get_or_create_hwi(
                 request.backend,
+                task_id=task_result.task_id,
                 **(request.config or {})
             )
-            
+
             # Reset agent state
             agent.reset()
             
@@ -259,22 +281,17 @@ class AgentService:
             task_result.mark_failed(error_msg)
             
         finally:
-            # Cleanup global state registry
-            registry_key = f"GlobalStateStore"
-            try:
-                # Registry doesn't have unregister method, we'll use clear or manual removal
-                if hasattr(Registry, '_services') and registry_key in Registry._services:
-                    del Registry._services[registry_key]
-            except:
-                pass
+            # Cleanup task-specific registry
+            Registry.remove_task_registry(task_result.task_id)
+            self.logger.info(f"Cleaned up task-specific registry for task {task_result.task_id}")
         
         return task_result
     
-    def _run_agent_normal_internal(self, agent, instruction: str, hwi, max_steps: int, 
+    def _run_agent_normal_internal(self, agent, instruction: str, hwi, max_steps: int,
                                  enable_takeover: bool, task_id: str):
         """Run agent in normal mode (adapted from cli_app.py)"""
         # This is a simplified version - you may want to adapt the full logic from cli_app.py
-        global_state: GlobalState = Registry.get(f"GlobalStateStore")  # type: ignore
+        global_state: GlobalState = Registry.get_from_context("GlobalStateStore", task_id)  # type: ignore
         global_state.set_Tu(instruction)
         global_state.set_running_state("running")
         
@@ -316,10 +333,10 @@ class AgentService:
             hwi.dispatchDict(code[0])
             time.sleep(1.0)
     
-    def _run_agent_fast_internal(self, agent, instruction: str, hwi, max_steps: int, 
-                               enable_takeover: bool, task_id: str):
+    def _run_agent_fast_internal(self, agent, instruction: str, hwi, max_steps: int,
+                              enable_takeover: bool, task_id: str):
         """Run agent in fast mode (adapted from cli_app.py)"""
-        global_state: GlobalState = Registry.get(f"GlobalStateStore")  # type: ignore
+        global_state: GlobalState = Registry.get_from_context("GlobalStateStore", task_id)  # type: ignore
         global_state.set_Tu(instruction)
         global_state.set_running_state("running")
         

gui_agents/store/registry.py

@@ -4,19 +4,127 @@
 # from gui_agents.store.registry import Registry
 # GlobalStateStore = Registry.get("GlobalStateStore")
 
+import threading
+from typing import Optional, ClassVar
+
+
 class Registry:
-    _services: dict[str, object] = {}
+    """
+    Registry class that supports both global singleton and task-specific instances.
+    It uses a process-wide dictionary for task registries to ensure visibility
+    across threads, making it compatible with asyncio.to_thread.
+    """
+    # For global singletons (backward compatibility)
+    _global_services: ClassVar[dict[str, object]] = {}
+    _global_lock: ClassVar[threading.RLock] = threading.RLock()
+
+    # Process-wide storage for task-specific registries, protected by a lock
+    _task_registries: ClassVar[dict[str, 'Registry']] = {}
+    _task_registries_lock: ClassVar[threading.RLock] = threading.RLock()
+
+    # Thread-local storage can be used as a cache for faster access
+    _thread_local: ClassVar[threading.local] = threading.local()
+
+    def __init__(self):
+        """Create a new registry instance (for a specific task)."""
+        self._services: dict[str, object] = {}
+        self._lock = threading.RLock()
 
+    # ========== Instance methods (for a single registry) ==========
+    def register_instance(self, name: str, obj: object):
+        """Register an object in this registry instance."""
+        with self._lock:
+            self._services[name] = obj
+
+    def get_instance(self, name: str) -> object:
+        """Get an object from this registry instance."""
+        with self._lock:
+            if name not in self._services:
+                raise KeyError(f"{name!r} not registered in this Registry instance")
+            return self._services[name]
+
+    def clear_instance(self):
+        """Clear all objects in this registry instance."""
+        with self._lock:
+            self._services.clear()
+
+    # ========== Class methods for global registry (backward compatibility) ==========
     @classmethod
     def register(cls, name: str, obj: object):
-        cls._services[name] = obj
+        """Register an object in the global registry."""
+        with cls._global_lock:
+            cls._global_services[name] = obj
 
     @classmethod
     def get(cls, name: str) -> object:
-        if name not in cls._services:
-            raise KeyError(f"{name!r} not registered in Registry")
-        return cls._services[name]
+        """Get an object from the global registry."""
+        with cls._global_lock:
+            if name not in cls._global_services:
+                raise KeyError(f"{name!r} not registered in global Registry")
+            return cls._global_services[name]
 
     @classmethod
     def clear(cls):
-        cls._services.clear()
+        """Clear all objects in the global registry."""
+        with cls._global_lock:
+            cls._global_services.clear()
+
+    # ========== Task-specific registry management (Process-wide) ==========
+    @classmethod
+    def set_task_registry(cls, task_id: str, registry: 'Registry'):
+        """Set a task-specific registry, making it visible process-wide."""
+        with cls._task_registries_lock:
+            cls._task_registries[task_id] = registry
+        
+        # Also set it in thread-local for faster access within the current thread
+        if not hasattr(cls._thread_local, 'task_cache'):
+            cls._thread_local.task_cache = {}
+        cls._thread_local.task_cache[task_id] = registry
+
+    @classmethod
+    def get_task_registry(cls, task_id: str) -> Optional['Registry']:
+        """Get a task-specific registry, checking thread-local cache first."""
+        # Check thread-local cache first for performance
+        if hasattr(cls._thread_local, 'task_cache'):
+            cached_registry = cls._thread_local.task_cache.get(task_id)
+            if cached_registry:
+                return cached_registry
+
+        # If not in cache, check the process-wide dictionary
+        with cls._task_registries_lock:
+            registry = cls._task_registries.get(task_id)
+            if registry:
+                # Populate cache for subsequent calls in the same thread
+                if not hasattr(cls._thread_local, 'task_cache'):
+                    cls._thread_local.task_cache = {}
+                cls._thread_local.task_cache[task_id] = registry
+            return registry
+
+    @classmethod
+    def remove_task_registry(cls, task_id: str):
+        """Remove a task-specific registry from process-wide and thread-local storage."""
+        # Remove from the main process-wide storage
+        with cls._task_registries_lock:
+            cls._task_registries.pop(task_id, None)
+        
+        # Remove from the current thread's local cache, if it exists
+        if hasattr(cls._thread_local, 'task_cache'):
+            cls._thread_local.task_cache.pop(task_id, None)
+
+    @classmethod
+    def get_from_context(cls, name: str, task_id: Optional[str] = None) -> object:
+        """
+        Get an object, trying task-specific registry first, then global registry.
+        This is now thread-safe across different threads for the same task_id.
+        """
+        # Try task-specific registry first
+        if task_id:
+            task_registry = cls.get_task_registry(task_id)
+            if task_registry:
+                try:
+                    return task_registry.get_instance(name)
+                except KeyError:
+                    pass  # Fall back to global registry
+
+        # Fall back to global registry for CLI mode or if not in task registry
+        return cls.get(name)

{lybic_guiagents-0.3.0.dist-info → lybic_guiagents-0.5.0.dist-info}/METADATA

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: lybic-guiagents
-Version: 0.3.0
+Version: 0.5.0
 Summary: An open-source agentic framework that enables AI to use computers like humans and can provide a multi-agent runtime environment as an infrastructure capability
 Author: Lybic Development Team
 Author-email: Lybic Development Team <lybic@tingyutech.com>
 License-Expression: Apache-2.0
 Classifier: Programming Language :: Python :: 3
-Requires-Python: >=3.12, <3.14
+Requires-Python: >=3.12, <3.15
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: dotenv
@@ -281,11 +281,11 @@ powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/0.8.5/install.ps
 # testing uv installation, version should be 0.8.5
 uv --version
 
-# 2. Install the python 3.12
-uv python install 3.12.11
+# 2. Install the python 3.14
+uv python install 3.14
 
 # 3. Create a virtual environment
-uv venv -p 3.12.11
+uv venv -p 3.14
 
 # 4. Activate the virtual environment
 # macOS and Linux
@@ -525,7 +525,7 @@ USE_PRECREATE_VM=Ubuntu
 **Problem**: `ModuleNotFoundError` or package import errors.
 
 **Solution**:
-- Ensure you're using Python 3.12.11 as specified
+- Ensure you're using Python >= 3.12
 - Activate the virtual environment:
   ```bash
   # macOS/Linux

{lybic_guiagents-0.3.0.dist-info → lybic_guiagents-0.5.0.dist-info}/RECORD

@@ -51,19 +51,19 @@ desktop_env/providers/virtualbox/provider.py,sha256=kSWLSddLpn8IfeyAPyMEy_p5SOap
 desktop_env/providers/vmware/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 desktop_env/providers/vmware/manager.py,sha256=pFqJwF6BAijmD-LbSei68-DU7ILCTONRj7e0At5iKIg,18893
 desktop_env/providers/vmware/provider.py,sha256=88ERND67KQIxG74b10sAXJ04o5FhNpx0d9pRTi8bHrA,4080
-gui_agents/__init__.py,sha256=LxPoaPPm9tX6rxyl9WOlaMkcN3RtmQJeZ9u7SRc3T_U,1603
-gui_agents/cli_app.py,sha256=Zwf8H9gl31Q-IwKFMKzDTudsCOtmDK7VVIVSFqIAPh8,30289
-gui_agents/grpc_app.py,sha256=j_TPshxIzIA1PMbkBKH_7VfTjbg4hLquGGMjB0dmEec,37088
+gui_agents/__init__.py,sha256=L0zKeoSF5AKiLUun6ykq7ZtF4RMh2qNqF6c-lcW3buM,1603
+gui_agents/cli_app.py,sha256=r2xXTl3DFhxaWgZ5VqOA8orVGVaUXvkv83UPkCwB9PY,32004
+gui_agents/grpc_app.py,sha256=y9IZUcinkU0W7wg44eOH2CAj0ivqqobJVtKSnQO5pPc,45349
 gui_agents/agents/Action.py,sha256=aEqkrNtb5TWn5i5nkMBWTN56_9tbfRPEGw2SgkFYKeY,6197
 gui_agents/agents/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-gui_agents/agents/agent_s.py,sha256=VwrkISbQcKGp9joDTb4BW2MDK810WfUFZSmpZJjaeEc,45795
-gui_agents/agents/global_state.py,sha256=BS6tUeK9Z3CdUIeU0gcEjzVnc_s7naeKQsCoIQLp23g,22314
-gui_agents/agents/grounding.py,sha256=bOy9V19Z_SO-hbUqg5h6Ru7E4k9YDGiXsQ_RArGuolg,25262
+gui_agents/agents/agent_s.py,sha256=TTCLhcHakO83zawc18DdEpGSHOb9QbfBA7eL_CTWc2Y,48512
+gui_agents/agents/global_state.py,sha256=MdHJUOUr0ISOVu4bTrG9qJB14Vvq9lkbYsT-_JV4szY,22774
+gui_agents/agents/grounding.py,sha256=NtyH1X6c9SYnnEgLhbHCWFxMLgPZoYFqsmrHvjSkMKM,26173
 gui_agents/agents/hardware_interface.py,sha256=32auvpVwJ-DimTTCDguM49DEBR4JeFCeHx41Bgv3Svg,5332
-gui_agents/agents/manager.py,sha256=44E5fTELymcSMBBUUzG7y2ntcT-DL5yA0OoZnTIq2v8,28861
+gui_agents/agents/manager.py,sha256=HGfl8aa7NNjBffQN-WYeMAH2IQUC-VCagT56auV_r2Y,29487
 gui_agents/agents/stream_manager.py,sha256=FxkM5GtTI4mFRd5rmuvoLSaC2NINVsSfhhREw3VlmUA,6704
 gui_agents/agents/translator.py,sha256=WwWY1ffs2OQuh65DSVjWpfpettJVdmmCI-w92K0JeHg,5171
-gui_agents/agents/worker.py,sha256=OTvrnnV_b28DmmIp3E9s8hZ6o3LlWcsV19FLSddTl08,17962
+gui_agents/agents/worker.py,sha256=iX4vQK19x7w9k-hLEFvvgrecybXSCtOf17NMOrhn3uA,18735
 gui_agents/agents/Backend/ADBBackend.py,sha256=J8WeFFLEPh05FmFKuGz72wgcKdKQT9kLUCHyEb8mRkk,2151
 gui_agents/agents/Backend/Backend.py,sha256=Aou3gBfur0AqL_bMn9FFeLTBM4CfL5aiIRivjqaB6zk,978
 gui_agents/agents/Backend/LybicBackend.py,sha256=mDjvP3Rx1cjuWkFN0X9QiWWeqBnfepUHGwDIsCmI_As,14069
@@ -79,12 +79,12 @@ gui_agents/prompts/prompts.py,sha256=w9ZP4FhuBDzWP7J0Urn69woLhas9AIWTtNfC1tys59c
 gui_agents/proto/__init__.py,sha256=_PORrnlylDiijb0s_soqgb1REm1eqXOtSmo0Oah4KRM,85
 gui_agents/proto/pb/__init__.py,sha256=UbJYRSLmdZrc2F6ou4dkvgGb4Y0YDObcwftmJCE3fC0,96
 gui_agents/service/__init__.py,sha256=5WsJ0Mx3e5BAP9qQMhoVimhOgTIndGeVcasGNoo1s-c,518
-gui_agents/service/agent_service.py,sha256=ZAPQjO76GRP7P0n_prU76NK5d7fzHk1pqLJ7a9rHt-Q,20969
+gui_agents/service/agent_service.py,sha256=5Tuz0JotHWPHNx5mnE1KciKH8IVlnKgoV44Fk_KRCDk,21774
 gui_agents/service/api_models.py,sha256=06iFyaV6ttROsNiS2GnAAaB4kR1XNpSRuUHD2W60L8o,3949
 gui_agents/service/config.py,sha256=WODT8RpaMFQ_oSshfDWsq_M8inPMHTlWYjoFoRpn6FY,8595
 gui_agents/service/exceptions.py,sha256=Tk3U4eycX-wuAqR0B-TthBESKyu8KuwH5Ksng0v4juo,831
 gui_agents/store/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-gui_agents/store/registry.py,sha256=KWySYUlRA5SGubqqCgOu5Lk7PvBIQQ4cEZmHoNwKzVQ,615
+gui_agents/store/registry.py,sha256=hJj4ECEnoQQ7IGONeshdI2lEc4Z30QTN-X_gjAs_dXY,5358
 gui_agents/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 gui_agents/tools/model.md,sha256=xeEuG3sBFu5j614V6alVk7l7JZmEewLniEg1hh7qA6Y,5553
 gui_agents/tools/tools.py,sha256=mPWed16cbGvje49M405qi0WVHh1qNxQkW5ojLz9Ac9Y,30785
@@ -101,9 +101,9 @@ gui_agents/utils/common_utils.py,sha256=lfWg7SrGfEnu9ZS9AWP3GKhbeTbaSZ6F9oh6U_qC
 gui_agents/utils/display_viewer.py,sha256=hL6Pf-wpoQrrYeOi6eaGnCorkAvGWNzkLIuM9yIudnk,8731
 gui_agents/utils/embedding_manager.py,sha256=7QFITe9l0z8OKHT-yqx-BGwVMj4BRL2iJ13PgJ2-Yak,2117
 gui_agents/utils/image_axis_utils.py,sha256=z21cVAE2ZOK1DR7wK10JHg8aZapkX2oGI6D93pKZEao,878
-lybic_guiagents-0.3.0.dist-info/licenses/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
-lybic_guiagents-0.3.0.dist-info/METADATA,sha256=zr3-McA1IPjk5fcm-fvkoX0U1GpPdovCJ7BHQwZb98Y,23821
-lybic_guiagents-0.3.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-lybic_guiagents-0.3.0.dist-info/entry_points.txt,sha256=n8OTYmXL0QPhSFUz-StUmhf0cpdL7Qcaeg5BWe7MiL4,106
-lybic_guiagents-0.3.0.dist-info/top_level.txt,sha256=NFP1jNNbbEGUexavwh7g0z_23hahrdgEV_9AjdynSw0,23
-lybic_guiagents-0.3.0.dist-info/RECORD,,
+lybic_guiagents-0.5.0.dist-info/licenses/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
+lybic_guiagents-0.5.0.dist-info/METADATA,sha256=dVElMdXMT0ldPLSUUY6Y_RLHG8UpNq3yF6KhC3hJF5M,23802
+lybic_guiagents-0.5.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lybic_guiagents-0.5.0.dist-info/entry_points.txt,sha256=n8OTYmXL0QPhSFUz-StUmhf0cpdL7Qcaeg5BWe7MiL4,106
+lybic_guiagents-0.5.0.dist-info/top_level.txt,sha256=NFP1jNNbbEGUexavwh7g0z_23hahrdgEV_9AjdynSw0,23
+lybic_guiagents-0.5.0.dist-info/RECORD,,