lybic-guiagents 0.4.0__tar.gz → 0.5.0__tar.gz

{lybic_guiagents-0.4.0/lybic_guiagents.egg-info → lybic_guiagents-0.5.0}/PKG-INFO

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

{lybic_guiagents-0.4.0 → lybic_guiagents-0.5.0}/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.4.0"
+__version__ = "0.5.0"
 
 # Primary exports (what users should typically use)
 __all__ = [

{lybic_guiagents-0.4.0 → lybic_guiagents-0.5.0}/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,
@@ -253,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 = {
@@ -280,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
@@ -434,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
@@ -854,18 +882,27 @@ class AgentSFast(UIAgent):
     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

{lybic_guiagents-0.4.0 → lybic_guiagents-0.5.0}/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 {

{lybic_guiagents-0.4.0 → lybic_guiagents-0.5.0}/gui_agents/agents/grounding.py

@@ -101,6 +101,11 @@ class Grounding(ACI):
         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 = (

{lybic_guiagents-0.4.0 → lybic_guiagents-0.5.0}/gui_agents/agents/manager.py

@@ -576,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()
 

{lybic_guiagents-0.4.0 → lybic_guiagents-0.5.0}/gui_agents/agents/worker.py

@@ -178,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.
@@ -188,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.
@@ -196,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()
 

{lybic_guiagents-0.4.0 → lybic_guiagents-0.5.0}/gui_agents/cli_app.py

@@ -275,7 +275,7 @@ def run_agent_normal(agent, instruction: str, hwi_para: HardwareInterface, max_s
     """
     if task_registry:
         Registry.set_task_registry(task_id, task_registry)
-    
+
     try:
         import time
         obs = {}
@@ -297,6 +297,11 @@ def run_agent_normal(agent, instruction: str, hwi_para: HardwareInterface, max_s
                     break
                 time.sleep(0.5)
 
+            # Check for cancellation
+            if global_state.is_cancelled():
+                logger.info("Agent execution cancelled by user request")
+                return
+
             screenshot: Image.Image = hwi.dispatch(Screenshot())  # type: ignore
             global_state.set_screenshot(
                 scale_screenshot_dimensions(screenshot, hwi_para))  # type: ignore
@@ -393,7 +398,7 @@ def run_agent_normal(agent, instruction: str, hwi_para: HardwareInterface, max_s
         global_state.log_operation(module="other",
                                 operation="total_execution_time",
                                 data={"duration": total_duration})
-        
+
         # Auto-analyze execution statistics after task completion
         timestamp_dir = os.path.join(log_dir, datetime_str)
         auto_analyze_execution(timestamp_dir)
@@ -409,7 +414,7 @@ def run_agent_fast(agent,
                    enable_takeover: bool = False, task_id: str | None = None, task_registry: Registry | None = None):
     if task_registry:
         Registry.set_task_registry(task_id, task_registry)
-    
+
     try:
         import time
         obs = {}
@@ -428,6 +433,10 @@ def run_agent_fast(agent,
                     logger.info("[Fast Mode] Agent execution resumed by user")
                     break
                 time.sleep(0.5)
+            # Check for cancellation
+            if global_state.is_cancelled():
+                logger.info("[Fast Mode] Agent execution cancelled by user request")
+                return
 
             screenshot: Image.Image = hwi.dispatch(Screenshot())  # type: ignore
             global_state.set_screenshot(
@@ -519,7 +528,7 @@ def run_agent_fast(agent,
         global_state.log_operation(module="other",
                                 operation="total_execution_time_fast",
                                 data={"duration": total_duration})
-        
+
         # Auto-analyze execution statistics after task completion
         timestamp_dir = os.path.join(log_dir, datetime_str)
         auto_analyze_execution(timestamp_dir)

{lybic_guiagents-0.4.0 → lybic_guiagents-0.5.0}/gui_agents/grpc_app.py

@@ -53,13 +53,10 @@ class AgentServicer(agent_pb2_grpc.AgentServicer):
             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
         self.tasks = {}
         self.global_common_config = agent_pb2.CommonConfig(id="global")
         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):
@@ -113,7 +110,7 @@ class AgentServicer(agent_pb2_grpc.AgentServicer):
             domain=platform.node(),
         )
 
-    async def _setup_task_state(self, task_id: str) -> Registry:
+    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")
@@ -152,15 +149,16 @@ class AgentServicer(agent_pb2_grpc.AgentServicer):
     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.
-        
+
         Parameters:
         	task_id (str): Identifier of the task to run.
         	backend_kwargs (dict): Backend configuration passed to the HardwareInterface (e.g., platform, org/api fields, sandbox id).
-        
+
         Notes:
         	- Updates the task entry in self.tasks (status and final_state).
         	- Emits task lifecycle messages via stream_manager and unregisters the task when finished.
         	- Exceptions are caught, the task status is set to "error", and an error message is emitted.
+        	- Supports task cancellation via asyncio.CancelledError.
         """
         async with self.task_lock:
             self.tasks[task_id]["status"] = "running"
@@ -176,7 +174,7 @@ class AgentServicer(agent_pb2_grpc.AgentServicer):
             await stream_manager.add_message(task_id, "starting", "Task starting")
 
             # Create task-specific registry
-            task_registry = await self._setup_task_state(task_id)
+            task_registry = 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'):
@@ -209,6 +207,11 @@ class AgentServicer(agent_pb2_grpc.AgentServicer):
                 status = final_state if final_state else 'unknown'
                 await stream_manager.add_message(task_id, "finished", f"Task finished with status: {status}")
 
+        except asyncio.CancelledError:
+            logger.info(f"Task {task_id} was cancelled")
+            async with self.task_lock:
+                self.tasks[task_id]["status"] = "cancelled"
+            await stream_manager.add_message(task_id, "cancelled", "Task was cancelled by user request")
         except Exception as e:
             logger.exception(f"Error during task execution for {task_id}: {e}")
             async with self.task_lock:
@@ -236,7 +239,6 @@ class AgentServicer(agent_pb2_grpc.AgentServicer):
                 - "endpoint": Lybic API endpoint.
         
         Side effects:
-            - May initialize or replace self.lybic_auth from request.runningConfig.authorizationInfo.
             - May call self._create_sandbox(...) to create or retrieve a sandbox and determine the platform.
         """
         backend_kwargs = {}
@@ -249,12 +251,6 @@ class AgentServicer(agent_pb2_grpc.AgentServicer):
         if request.HasField("runningConfig"):
             if request.runningConfig.backend:
                 backend = request.runningConfig.backend
-            if request.runningConfig.HasField("authorizationInfo"):
-                self.lybic_auth = LybicAuth(
-                    org_id=request.runningConfig.authorizationInfo.orgID,
-                    api_key=request.runningConfig.authorizationInfo.apiKey,
-                    endpoint=request.runningConfig.authorizationInfo.apiEndpoint or "https://api.lybic.cn/"
-                )
             backend_kwargs["mode"] = request.runningConfig.mode
 
         platform_str = platform.system()
@@ -262,22 +258,34 @@ class AgentServicer(agent_pb2_grpc.AgentServicer):
         sandbox_pb = None
 
         if backend == 'lybic':
+            auth_info = (request.runningConfig.authorizationInfo
+                         if request.HasField("runningConfig") and request.runningConfig.HasField("authorizationInfo")
+                         else self.global_common_config.authorizationInfo)
+            if not auth_info or not auth_info.orgID or not auth_info.apiKey:
+                raise ValueError("Lybic backend requires valid authorization (orgID and apiKey)")
+
+            lybic_auth = LybicAuth(
+                org_id=auth_info.orgID,
+                api_key=auth_info.apiKey,
+                endpoint=auth_info.apiEndpoint or "https://api.lybic.cn/"
+            )
+
             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
+                    sandbox_pb = await self._get_sandbox_pb(sid, lybic_auth)  # if not exist raise NotFound
+                    platform_str = platform_map.get(sandbox_pb.os, platform.system())
                 else:
-                    sandbox_pb = await self._create_sandbox(shape)
-                    sid, platform_str = sandbox_pb.id, sandbox_pb.os
+                    sandbox_pb = await self._create_sandbox(shape, lybic_auth)
+                    sid, platform_str = sandbox_pb.id, platform_map.get(sandbox_pb.os, platform.system())
 
                 if request.sandbox.os != agent_pb2.SandboxOS.OSUNDEFINED:
                     platform_str = platform_map.get(request.sandbox.os, platform.system())
             else:
-                sandbox_pb = await self._create_sandbox(shape)
-                sid, platform_str = sandbox_pb.id, sandbox_pb.os
+                sandbox_pb = await self._create_sandbox(shape, lybic_auth)
+                sid, platform_str = sandbox_pb.id, platform_map.get(sandbox_pb.os, platform.system())
         else:
             if request.HasField("sandbox") and request.sandbox.os != agent_pb2.SandboxOS.OSUNDEFINED:
                 platform_str = platform_map.get(request.sandbox.os, platform.system())
@@ -457,6 +465,16 @@ class AgentServicer(agent_pb2_grpc.AgentServicer):
             logger.info(f"RunAgentInstruction stream for {task_id} cancelled by client.")
             if task_future:
                 task_future.cancel()
+                # Set cancellation flag in global state for agents to check
+                try:
+                    global_state: GlobalState = Registry.get_from_context("GlobalStateStore", task_id)
+                    if global_state:
+                        global_state.set_running_state("cancelled")
+                        logger.info(f"Set running state to 'cancelled' for task {task_id} due to client disconnect.")
+                    else:
+                        logger.warning(f"Could not find GlobalState for task {task_id} to set cancellation flag on client disconnect.")
+                except Exception as e:
+                    logger.error(f"Error setting cancellation flag for task {task_id} on client disconnect: {e}")
         except Exception as e:
             logger.exception(f"Error in RunAgentInstruction stream for task {task_id}")
             context.set_code(grpc.StatusCode.INTERNAL)
@@ -502,6 +520,9 @@ class AgentServicer(agent_pb2_grpc.AgentServicer):
                 "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"]
 
             # Start the task in background
             task_future = asyncio.create_task(self._run_task(task_id, backend_kwargs))
@@ -542,6 +563,7 @@ class AgentServicer(agent_pb2_grpc.AgentServicer):
             "running": agent_pb2.TaskStatus.RUNNING,
             "fulfilled": agent_pb2.TaskStatus.SUCCESS,
             "rejected": agent_pb2.TaskStatus.FAILURE,
+            "cancelled": agent_pb2.TaskStatus.CANCELLED,
         }
 
         if status == "finished":
@@ -552,6 +574,10 @@ class AgentServicer(agent_pb2_grpc.AgentServicer):
             task_status = agent_pb2.TaskStatus.FAILURE
             message = "Task failed with an exception."
             result = ""
+        elif status == "cancelled":
+            task_status = agent_pb2.TaskStatus.CANCELLED
+            message = "Task was cancelled by user request."
+            result = ""
         else:  # pending or running
             task_status = status_map.get(status, agent_pb2.TaskStatus.TASKSTATUSUNDEFINED)
             message = "Task is running."
@@ -565,6 +591,82 @@ class AgentServicer(agent_pb2_grpc.AgentServicer):
             sandbox=task_info["sandbox"]
         )
 
+    async def CancelTask(self, request, context):
+        """
+        Cancel a running task by its taskId.
+
+        If the task exists and is running, it will be cancelled and a success response is returned.
+        If the task is not found or already completed, an appropriate response is returned.
+
+        Parameters:
+            request: CancelTaskRequest containing the taskId to cancel
+            context: gRPC context for setting status codes and details
+
+        Returns:
+            CancelTaskResponse: Response containing taskId, success status, and message
+        """
+        task_id = request.taskId
+        logger.info(f"Received CancelTask request for taskId: {task_id}")
+
+        async with self.task_lock:
+            task_info = self.tasks.get(task_id)
+
+        if not task_info:
+            return agent_pb2.CancelTaskResponse(
+                taskId=task_id,
+                success=False,
+                message=f"Task with ID {task_id} not found."
+            )
+
+        status = task_info["status"]
+        task_future = task_info.get("future")
+
+        # Check if task can be cancelled
+        if status in ["finished", "error"]:
+            return agent_pb2.CancelTaskResponse(
+                taskId=task_id,
+                success=False,
+                message=f"Task {task_id} is already {status} and cannot be cancelled."
+            )
+        elif status == "cancelled":
+            return agent_pb2.CancelTaskResponse(
+                taskId=task_id,
+                success=True,
+                message=f"Task {task_id} was already cancelled."
+            )
+        elif status in ["pending", "running"] and task_future:
+            try:
+                # Cancel the task future
+                task_future.cancel()
+                task_info["status"] = "cancelled"
+
+                # Set cancellation flag in global state for agents to check
+                global_state: GlobalState = Registry.get_from_context("GlobalStateStore", task_id)  # type: ignore
+                global_state.set_running_state("cancelled")
+
+                # Send cancellation message through stream manager
+                await stream_manager.add_message(task_id, "cancelled", "Task was cancelled by user request")
+
+                logger.info(f"Task {task_id} successfully cancelled")
+                return agent_pb2.CancelTaskResponse(
+                    taskId=task_id,
+                    success=True,
+                    message=f"Task {task_id} has been successfully cancelled."
+                )
+            except Exception as e:
+                logger.error(f"Failed to cancel task {task_id}: {e}")
+                return agent_pb2.CancelTaskResponse(
+                    taskId=task_id,
+                    success=False,
+                    message=f"Failed to cancel task {task_id}: {e}"
+                )
+        else:
+            return agent_pb2.CancelTaskResponse(
+                taskId=task_id,
+                success=False,
+                message=f"Task {task_id} is in state '{status}' and cannot be cancelled."
+            )
+
     def _mask_config_secrets(self, config: CommonConfig) -> CommonConfig:
         """
         Return a deep copy of a CommonConfig with sensitive API keys replaced by "********".
@@ -667,20 +769,17 @@ class AgentServicer(agent_pb2_grpc.AgentServicer):
         context.set_details(f"Config for task {request.id} not found.")
         return agent_pb2.CommonConfig()
 
-    async def _new_lybic_client(self):
+    def _new_lybic_client(self, lybic_auth: LybicAuth) -> LybicClient:
         """
-        Create and store a new LybicClient using the servicer's current LybicAuth.
-        
-        This replaces the servicer's `lybic_client` attribute with a newly constructed
-        LybicClient initialized from `self.lybic_auth`.
+        Create and return a new LybicClient.
         """
-        self.lybic_client = LybicClient(self.lybic_auth)
+        return LybicClient(lybic_auth)
 
     async def SetGlobalCommonConfig(self, request, context):
         """
-        Set the server's global common configuration and initialize Lybic authorization if provided.
+        Set the server's global common configuration.
         
-        Sets request.commonConfig.id to "global" and stores it as the servicer's global_common_config. If the provided config contains authorizationInfo, initializes or updates self.lybic_auth with the org ID, API key, and API endpoint (defaulting to "https://api.lybic.cn/" when endpoint is empty).
+        Sets request.commonConfig.id to "global" and stores it as the servicer's global_common_config.
         
         Parameters:
             request: gRPC request containing `commonConfig` to apply.
@@ -688,17 +787,14 @@ class AgentServicer(agent_pb2_grpc.AgentServicer):
         Returns:
             agent_pb2.SetCommonConfigResponse: Response with `success=True` and the configuration `id`.
         """
+        if os.environ.get("ALLOW_SET_GLOBAL_CONFIG", "0")=="0":
+            context.set_code(grpc.StatusCode.PERMISSION_DENIED)
+            context.set_details("Permission denied.")
+            return agent_pb2.SetCommonConfigResponse()
         logger.info("Setting new global common config.")
         request.commonConfig.id = "global"
         self.global_common_config = request.commonConfig
 
-        if self.global_common_config.HasField("authorizationInfo"):  # lybic
-            self.lybic_auth = LybicAuth(
-                org_id=self.global_common_config.authorizationInfo.orgID,
-                api_key=self.global_common_config.authorizationInfo.apiKey,
-                endpoint=self.global_common_config.authorizationInfo.apiEndpoint or "https://api.lybic.cn/"
-            )
-
         return agent_pb2.SetCommonConfigResponse(success=True, id=self.global_common_config.id)
 
     async def SetGlobalCommonLLMConfig(self, request, context):
@@ -710,6 +806,10 @@ class AgentServicer(agent_pb2_grpc.AgentServicer):
         Returns:
             llmConfig: The `LLMConfig` message that was stored in the global configuration.
         """
+        if os.environ.get("ALLOW_SET_GLOBAL_CONFIG", "0")=="0":
+            context.set_code(grpc.StatusCode.PERMISSION_DENIED)
+            context.set_details("Permission denied.")
+            return agent_pb2.LLMConfig()
         if not self.global_common_config.HasField("stageModelConfig"):
             self.global_common_config.stageModelConfig.SetInParent()
         self.global_common_config.stageModelConfig.actionGeneratorModel.CopyFrom(request.llmConfig)
@@ -730,6 +830,10 @@ class AgentServicer(agent_pb2_grpc.AgentServicer):
         Returns:
         	LLMConfig: The `llmConfig` that was applied.
         """
+        if os.environ.get("ALLOW_SET_GLOBAL_CONFIG", "0")=="0":
+            context.set_code(grpc.StatusCode.PERMISSION_DENIED)
+            context.set_details("Permission denied.")
+            return agent_pb2.LLMConfig()
         if not self.global_common_config.HasField("stageModelConfig"):
             self.global_common_config.stageModelConfig.SetInParent()
         self.global_common_config.stageModelConfig.groundingModel.CopyFrom(request.llmConfig)
@@ -746,58 +850,48 @@ class AgentServicer(agent_pb2_grpc.AgentServicer):
         Returns:
             The `llmConfig` that was set as the global embedding model.
         """
+        if os.environ.get("ALLOW_SET_GLOBAL_CONFIG", "0")=="0":
+            context.set_code(grpc.StatusCode.PERMISSION_DENIED)
+            context.set_details("Permission denied.")
+            return agent_pb2.LLMConfig()
         if not self.global_common_config.HasField("stageModelConfig"):
             self.global_common_config.stageModelConfig.SetInParent()
         self.global_common_config.stageModelConfig.embeddingModel.CopyFrom(request.llmConfig)
         logger.info(f"Global embedding LLM config updated to: {request.llmConfig.modelName}")
         return request.llmConfig
 
-    async def _create_sandbox(self,shape:str)->agent_pb2.Sandbox:
+    async def _create_sandbox(self, shape: str, lybic_auth: LybicAuth) -> agent_pb2.Sandbox:
         """
         Create a sandbox with the given shape via the Lybic service and return its identifier and operating system.
-        
+
         Parameters:
             shape (str): The sandbox shape to create (provider-specific size/OS configuration).
-        
+            lybic_auth (LybicAuth): The authentication object for Lybic.
+
         Returns:
-            tuple: A pair (sandbox_id, platform_os) where `sandbox_id` is the created sandbox identifier and `platform_os` is the sandbox operating system string.
-        
-        Raises:
-            Exception: If Lybic authorization is not initialized (call SetGlobalCommonConfig first).
+            agent_pb2.Sandbox: A protobuf message containing sandbox details.
         """
-        if not self.lybic_auth:
-            raise Exception("Lybic client not initialized. Please call SetGlobalCommonConfig before")
-
-        await self._new_lybic_client()
-        if not self.sandbox:
-            self.sandbox = Sandbox(self.lybic_client)
-        result = await self.sandbox.create(shape=shape)
-        sandbox = await self.sandbox.get(result.id)
+        lybic_client = self._new_lybic_client(lybic_auth)
+        sandbox_service = Sandbox(lybic_client)
+        result = await sandbox_service.create(shape=shape)
+        sandbox = await sandbox_service.get(result.id)
+        await lybic_client.close()
 
         return agent_pb2.Sandbox(
             id=sandbox.sandbox.id,
-            os=sandbox.sandbox.shape.os.upper(),
+            os=self._lybic_sandbox_os_to_pb_enum(sandbox.sandbox.shape),
             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:
+    @staticmethod
+    def _lybic_sandbox_os_to_pb_enum(os) -> agent_pb2.SandboxOS:
         """
-        Retrieves sandbox details for a given sandbox ID and returns them as a protobuf message.
+        Converts a sandbox OS string to an enum value.
         """
-        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_raw = getattr(os, "os", "") or ""
         os_upper = str(os_raw).upper()
         if "WIN" in os_upper:
             os_enum = agent_pb2.SandboxOS.WINDOWS
@@ -807,10 +901,23 @@ class AgentServicer(agent_pb2_grpc.AgentServicer):
             os_enum = agent_pb2.SandboxOS.ANDROID
         else:
             os_enum = agent_pb2.SandboxOS.OSUNDEFINED
+        return os_enum
+
+    async def _get_sandbox_pb(self, sid: str, lybic_auth: LybicAuth) -> agent_pb2.Sandbox:
+        """
+        Retrieves sandbox details for a given sandbox ID and returns them as a protobuf message.
+        """
+        if not lybic_auth:
+            raise ValueError("Lybic client not initialized. Please call SetGlobalCommonConfig before")
+
+        lybic_client = self._new_lybic_client(lybic_auth)
+        sandbox_service = Sandbox(lybic_client)
+        sandbox_details = await sandbox_service.get(sid)
+        await lybic_client.close()
 
         return agent_pb2.Sandbox(
             id=sandbox_details.sandbox.id,
-            os=os_enum,
+            os=self._lybic_sandbox_os_to_pb_enum(sandbox_details.sandbox.shape),
             shapeName=sandbox_details.sandbox.shapeName,
             hardwareAcceleratedEncoding=sandbox_details.sandbox.shape.hardwareAcceleratedEncoding,
             virtualization=sandbox_details.sandbox.shape.virtualization,

{lybic_guiagents-0.4.0 → lybic_guiagents-0.5.0}/gui_agents/store/registry.py

@@ -127,4 +127,4 @@ class Registry:
                     pass  # Fall back to global registry
 
         # Fall back to global registry for CLI mode or if not in task registry
-        return cls.get(name)
+        return cls.get(name)

{lybic_guiagents-0.4.0 → lybic_guiagents-0.5.0/lybic_guiagents.egg-info}/PKG-INFO

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

{lybic_guiagents-0.4.0 → lybic_guiagents-0.5.0}/pyproject.toml

@@ -3,7 +3,7 @@ requires = ["setuptools >= 77.0.3"]
 build-backend = "setuptools.build_meta"
 [project]
 name = "lybic-guiagents"
-version = "0.4.0"
+version = "0.5.0"
 authors = [
   { name="Lybic Development Team", email="lybic@tingyutech.com" },
 ]