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

gui_agents/grpc_app.py

@@ -29,6 +29,7 @@ import platform
 from concurrent import futures
 import grpc
 import uuid
+import datetime
 
 from lybic import LybicClient, LybicAuth, Sandbox
 import gui_agents.cli_app as app
@@ -44,12 +45,13 @@ class AgentServicer(agent_pb2_grpc.AgentServicer):
     Implements the Agent gRPC service.
     """
 
-    def __init__(self, max_concurrent_task_num = 1):
+    def __init__(self, max_concurrent_task_num: int = 1, log_dir: str = "runtime"):
         """
         Initialize the AgentServicer with concurrency and runtime state.
         
         Parameters:
             max_concurrent_task_num (int): Maximum number of agent tasks allowed to run concurrently; defaults to 1.
+            log_dir (str): Directory for logging and task-related files.
         """
         self.lybic_auth: LybicAuth | None = None
         self.max_concurrent_task_num = max_concurrent_task_num
@@ -58,6 +60,7 @@ class AgentServicer(agent_pb2_grpc.AgentServicer):
         self.task_lock = asyncio.Lock()
         self.lybic_client: LybicClient | None = None
         self.sandbox: Sandbox | None = None
+        self.log_dir = log_dir
 
     async def GetAgentTaskStream(self, request, context):
         """
@@ -110,6 +113,42 @@ class AgentServicer(agent_pb2_grpc.AgentServicer):
             domain=platform.node(),
         )
 
+    async def _setup_task_state(self, task_id: str) -> Registry:
+        """Setup global state and registry 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.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)
+
+        # 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"),
+            search_query_path=str(state_dir / "search_query.json"),
+            completed_subtasks_path=str(state_dir / "completed_subtasks.json"),
+            failed_subtasks_path=str(state_dir / "failed_subtasks.json"),
+            remaining_subtasks_path=str(state_dir / "remaining_subtasks.json"),
+            termination_flag_path=str(state_dir / "termination_flag.json"),
+            running_state_path=str(state_dir / "running_state.json"),
+            display_info_path=str(timestamp_dir / "display.json"),
+            agent_log_path=str(timestamp_dir / "agent_log.json")
+        )
+
+        # Register in task-specific registry using instance method
+        registry_key = "GlobalStateStore"
+        task_registry.register_instance(registry_key, global_state)
+
+        logger.info(f"Created task-specific registry for task {task_id}")
+
+        return task_registry
+
     async def _run_task(self, task_id: str, backend_kwargs):
         """
         Run the lifecycle of a single agent task: mark it running, execute the agent, record final state, emit stream messages, and unregister the task.
@@ -136,23 +175,29 @@ class AgentServicer(agent_pb2_grpc.AgentServicer):
             # Send message through stream manager
             await stream_manager.add_message(task_id, "starting", "Task starting")
 
-            # Set task_id for the agent to enable streaming from within the agent
+            # Create task-specific registry
+            task_registry = await self._setup_task_state(task_id)
+
+            # Set task_id for the agent. This is needed so that agent.reset() can find the right components.
             if hasattr(agent, 'set_task_id'):
                 agent.set_task_id(task_id)
 
             hwi = HardwareInterface(backend='lybic', **backend_kwargs)
 
+            # We need to set the registry for the main thread context before reset
+            Registry.set_task_registry(task_id, task_registry)
             agent.reset()
+            Registry.remove_task_registry(task_id) # Clean up main thread's local
 
-            # Run the blocking function in a separate thread to avoid blocking the event loop
-            mode: InstanceMode | None = backend_kwargs["mode"]
+            # Run the blocking function in a separate thread, passing the context
+            mode: InstanceMode | None = backend_kwargs.get("mode")
             if mode and mode == InstanceMode.NORMAL:
-                await asyncio.to_thread(app.run_agent_normal,agent, query, hwi, steps, False)
+                await asyncio.to_thread(app.run_agent_normal, agent, query, hwi, steps, False, task_id=task_id, task_registry=task_registry)
             else:
-                await asyncio.to_thread(app.run_agent_fast, agent, query, hwi, steps, False)
+                await asyncio.to_thread(app.run_agent_fast, agent, query, hwi, steps, False, task_id=task_id, task_registry=task_registry)
 
-            global_state: GlobalState = Registry.get("GlobalStateStore")  # type: ignore
-            final_state = global_state.get_running_state()
+            # The final state is now determined inside the thread. We'll assume success if no exception.
+            final_state = "completed"
 
             async with self.task_lock:
                 self.tasks[task_id]["final_state"] = final_state
@@ -171,6 +216,7 @@ class AgentServicer(agent_pb2_grpc.AgentServicer):
             await stream_manager.add_message(task_id, "error", f"An error occurred: {e}")
         finally:
             logger.info(f"Task {task_id} processing finished.")
+            # Registry cleanup is now handled within the worker thread
             await stream_manager.unregister_task(task_id)
 
     async def _make_backend_kwargs(self, request):
@@ -213,23 +259,30 @@ class AgentServicer(agent_pb2_grpc.AgentServicer):
 
         platform_str = platform.system()
         sid = ''
+        sandbox_pb = None
+
         if backend == 'lybic':
             if request.HasField("sandbox"):
                 shape = request.sandbox.shapeName
                 sid = request.sandbox.id
                 if sid:
                     logger.info(f"Using existing sandbox with id: {sid}")
+                    sandbox_pb = await self._get_sandbox_pb(sid) # if not exist raise NotFound
+                    platform_str = sandbox_pb.os
                 else:
-                    sid, platform_str = await self._create_sandbox(shape)
+                    sandbox_pb = await self._create_sandbox(shape)
+                    sid, platform_str = sandbox_pb.id, sandbox_pb.os
 
                 if request.sandbox.os != agent_pb2.SandboxOS.OSUNDEFINED:
                     platform_str = platform_map.get(request.sandbox.os, platform.system())
             else:
-                sid, platform_str = await self._create_sandbox(shape)
-
+                sandbox_pb = await self._create_sandbox(shape)
+                sid, platform_str = sandbox_pb.id, sandbox_pb.os
         else:
-            platform_str = platform_map.get(request.sandbox.os, platform.system())
+            if request.HasField("sandbox") and request.sandbox.os != agent_pb2.SandboxOS.OSUNDEFINED:
+                platform_str = platform_map.get(request.sandbox.os, platform.system())
 
+        backend_kwargs["sandbox"] = sandbox_pb
         backend_kwargs["platform"] = platform_str
         backend_kwargs["precreate_sid"] = sid
 
@@ -250,12 +303,6 @@ class AgentServicer(agent_pb2_grpc.AgentServicer):
         return backend_kwargs
 
     async def _make_agent(self,request):
-        # todo: add max_steps support
-        # max_steps = 50
-        # if request.HasField("runningConfig") and request.runningConfig.steps:
-        #     max_steps = request.runningConfig.steps
-
-        # Dynamically build tools_dict based on global config
         """
         Builds and returns an AgentS2 configured for the incoming request by applying model and provider overrides to the tool configurations.
         
@@ -345,7 +392,6 @@ class AgentServicer(agent_pb2_grpc.AgentServicer):
             tools_config=tools_config,
         )
 
-
     async def RunAgentInstruction(self, request, context):
         """
         Stream task progress for a newly created instruction-run agent while managing task lifecycle and concurrency.
@@ -390,8 +436,13 @@ class AgentServicer(agent_pb2_grpc.AgentServicer):
                 "query": request.instruction,
                 "agent": agent,
                 "max_steps": max_steps,
+                "sandbox": backend_kwargs["sandbox"],
             }
 
+            # This property is used to pass sandbox information.
+            # It has now completed its mission and needs to be deleted, otherwise other backends may crash.
+            del backend_kwargs["sandbox"]
+
             task_future = asyncio.create_task(self._run_task(task_id, backend_kwargs))
             self.tasks[task_id]["future"] = task_future
         try:
@@ -449,6 +500,7 @@ class AgentServicer(agent_pb2_grpc.AgentServicer):
                 "query": request.instruction,
                 "agent": agent,
                 "max_steps": max_steps,
+                "sandbox": backend_kwargs["sandbox"],
             }
 
             # Start the task in background
@@ -510,7 +562,7 @@ class AgentServicer(agent_pb2_grpc.AgentServicer):
             status=task_status,
             message=message,
             result=result,
-            sandbox=task_info["request"].sandbox
+            sandbox=task_info["sandbox"]
         )
 
     def _mask_config_secrets(self, config: CommonConfig) -> CommonConfig:
@@ -700,7 +752,7 @@ class AgentServicer(agent_pb2_grpc.AgentServicer):
         logger.info(f"Global embedding LLM config updated to: {request.llmConfig.modelName}")
         return request.llmConfig
 
-    async def _create_sandbox(self,shape:str):
+    async def _create_sandbox(self,shape:str)->agent_pb2.Sandbox:
         """
         Create a sandbox with the given shape via the Lybic service and return its identifier and operating system.
         
@@ -721,7 +773,49 @@ class AgentServicer(agent_pb2_grpc.AgentServicer):
             self.sandbox = Sandbox(self.lybic_client)
         result = await self.sandbox.create(shape=shape)
         sandbox = await self.sandbox.get(result.id)
-        return sandbox.sandbox.id, sandbox.sandbox.shape.os
+
+        return agent_pb2.Sandbox(
+            id=sandbox.sandbox.id,
+            os=sandbox.sandbox.shape.os.upper(),
+            shapeName=sandbox.sandbox.shapeName,
+            hardwareAcceleratedEncoding=sandbox.sandbox.shape.hardwareAcceleratedEncoding,
+            virtualization=sandbox.sandbox.shape.virtualization,
+            architecture=sandbox.sandbox.shape.architecture,
+        )
+
+    async def _get_sandbox_pb(self, sid: str) -> agent_pb2.Sandbox:
+        """
+        Retrieves sandbox details for a given sandbox ID and returns them as a protobuf message.
+        """
+        if not self.lybic_auth:
+            raise ValueError("Lybic client not initialized. Please call SetGlobalCommonConfig before")
+
+        if not self.lybic_client:
+            await self._new_lybic_client()
+        if not self.sandbox:
+            self.sandbox = Sandbox(self.lybic_client)
+        
+        sandbox_details = await self.sandbox.get(sid)
+
+        os_raw = getattr(sandbox_details.sandbox.shape, "os", "") or ""
+        os_upper = str(os_raw).upper()
+        if "WIN" in os_upper:
+            os_enum = agent_pb2.SandboxOS.WINDOWS
+        elif "LINUX" in os_upper or "UBUNTU" in os_upper:
+            os_enum = agent_pb2.SandboxOS.LINUX
+        elif "ANDROID" in os_upper:
+            os_enum = agent_pb2.SandboxOS.ANDROID
+        else:
+            os_enum = agent_pb2.SandboxOS.OSUNDEFINED
+
+        return agent_pb2.Sandbox(
+            id=sandbox_details.sandbox.id,
+            os=os_enum,
+            shapeName=sandbox_details.sandbox.shapeName,
+            hardwareAcceleratedEncoding=sandbox_details.sandbox.shape.hardwareAcceleratedEncoding,
+            virtualization=sandbox_details.sandbox.shape.virtualization,
+            architecture=sandbox_details.sandbox.shape.architecture,
+        )
 
 async def serve():
     """
@@ -735,8 +829,8 @@ async def serve():
     """
     port = os.environ.get("GRPC_PORT", 50051)
     max_workers = int(os.environ.get("GRPC_MAX_WORKER_THREADS", 100))
-    # task_num = int(os.environ.get("TASK_MAX_TASKS", 5))
-    servicer = AgentServicer(max_concurrent_task_num=1)
+    task_num = int(os.environ.get("TASK_MAX_TASKS", 5))
+    servicer = AgentServicer(max_concurrent_task_num=task_num, log_dir=app.log_dir)
     server = grpc.aio.server(futures.ThreadPoolExecutor(max_workers))
     agent_pb2_grpc.add_AgentServicer_to_server(servicer, server)
     server.add_insecure_port(f'[::]:{port}')
@@ -752,32 +846,6 @@ def main():
     has_display, pyautogui_available, _ = app.check_display_environment()
     compatible_backends, incompatible_backends = app.get_compatible_backends(has_display, pyautogui_available)
     app.validate_backend_compatibility('lybic', compatible_backends, incompatible_backends)
-    timestamp_dir = os.path.join(app.log_dir, app.datetime_str)
-    cache_dir = os.path.join(timestamp_dir, "cache", "screens")
-    state_dir = os.path.join(timestamp_dir, "state")
-
-    os.makedirs(cache_dir, exist_ok=True)
-    os.makedirs(state_dir, exist_ok=True)
-
-    Registry.register(
-        "GlobalStateStore",
-        GlobalState(
-            screenshot_dir=cache_dir,
-            tu_path=os.path.join(state_dir, "tu.json"),
-            search_query_path=os.path.join(state_dir, "search_query.json"),
-            completed_subtasks_path=os.path.join(state_dir,
-                                                 "completed_subtasks.json"),
-            failed_subtasks_path=os.path.join(state_dir,
-                                              "failed_subtasks.json"),
-            remaining_subtasks_path=os.path.join(state_dir,
-                                                 "remaining_subtasks.json"),
-            termination_flag_path=os.path.join(state_dir,
-                                               "termination_flag.json"),
-            running_state_path=os.path.join(state_dir, "running_state.json"),
-            display_info_path=os.path.join(timestamp_dir, "display.json"),
-            agent_log_path=os.path.join(timestamp_dir, "agent_log.json")
-        )
-    )
     asyncio.run(serve())
 
 if __name__ == '__main__':

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.4.0.dist-info}/METADATA

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: lybic-guiagents
-Version: 0.3.0
+Version: 0.4.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