reasoning-deployment-service 0.6.1__py3-none-any.whl → 0.8.4__py3-none-any.whl

reasoning_deployment_service/cli_editor/api_client.py

@@ -14,14 +14,11 @@ try:
         HAS_GOOGLE, google, GoogleAuthRequest, 
         vertexai, agent_engines
     )
-    from reasoning_engine_creator import ReasoningEngineCreator
 except ImportError as e:
     from .google_deps import (HAS_GOOGLE, google, GoogleAuthRequest, vertexai, agent_engines)
-    from .reasoning_engine_creator import ReasoningEngineCreator
 
 BASE_URL = "https://discoveryengine.googleapis.com/v1alpha"
 
-
 # --- helpers for clean packaging ---
 EXCLUDES = [
         ".env", ".env.*", ".git", "__pycache__", ".pytest_cache", ".mypy_cache",
@@ -501,17 +498,6 @@ class ApiClient:
                 if name in sys.modules:
                     del sys.modules[name]
 
-    def create_reasoning_engine_advanced(self, config: Dict[str, Any]) -> Tuple[str, str, Optional[str]]:
-        """Create a reasoning engine with advanced configuration options."""
-        creator = ReasoningEngineCreator(
-            project_id=self.project_id,
-            location=self.location,
-            staging_bucket=self.staging_bucket,
-            debug=self.debug,
-        )
-
-        return creator.create_advanced_engine(config)
-
     def delete_reasoning_engine(self) -> Tuple[str, str]:
         if not self._profile.get("name"):
             return ("not_found", "No engine")

reasoning_deployment_service/gui_editor/src/ui/reasoning_engine_view.py

@@ -290,40 +290,6 @@ class ReasoningEngineView(ttk.Frame):
             finally:
                 self.engines_menu.grab_release()
 
-    def _create_engine_advanced(self):
-        """Create a new reasoning engine with advanced configuration."""
-        if not self.api.is_authenticated:
-            self.log("❌ Authentication required")
-            return
-        
-        # Show advanced create engine dialog
-        dialog = CreateReasoningEngineAdvancedDialog(self.winfo_toplevel(), self.api)
-        self.wait_window(dialog)
-        
-        if not dialog.result:
-            return  # User cancelled
-        
-        config = dialog.result
-        self.log(f"⚙️ Creating advanced reasoning engine '{config['display_name']}'...")
-        # self.create_advanced_btn.set_enabled(False, "Creating...")
-        
-        def callback(res):
-            # self.create_advanced_btn.set_enabled(True)
-            if isinstance(res, Exception):
-                self.log(f"❌ {res}")
-                return
-            
-            status, msg, resource = res
-            self.log(f"{status.upper()}: {msg}")
-            if resource:
-                self.log(f"resource: {resource}")
-            
-            # Refresh engines list to show the new engine
-            self._refresh_engines()
-            self._update_button_states()
-        
-        async_operation(lambda: self.api.create_reasoning_engine_advanced(config), callback=callback, ui_widget=self)
-
     def update_api(self, api: ApiClient):
         """Update the API client reference."""
         self.api = api

reasoning_deployment_service/reasoning_deployment_service.py

@@ -1,4 +1,5 @@
 import json, os, subprocess, yaml, sys
+import uuid
 import urllib.parse, vertexai, google.auth
 import requests as _requests
 from typing import Dict, Optional, Tuple
@@ -17,7 +18,6 @@ DISCOVERY_ENGINE_URL = "https://discoveryengine.googleapis.com/v1alpha"
 
 class ReasoningEngineDeploymentService:
     def __init__(self, root_agent: BaseAgent, deployment_environment: str="DEV"):
-        # Setup logging
         self._setup_logging()
         
         self._check_required_files_exist()
@@ -35,10 +35,12 @@ class ReasoningEngineDeploymentService:
         self._oauth_client_id = None
         self._oauth_client_secret = None
         self._agent_space_engine = None
+        self._authorization_id = None
 
 
         self._load_agent_definition()
         self._load_deployment_environment_variables(deployment_environment=deployment_environment)
+        self._load_runtime_variables()
         self._check_requirements_file_present()
          
         self._http = _requests.Session()
@@ -97,6 +99,37 @@ class ReasoningEngineDeploymentService:
     def info(self, message: str):
         self.logger.info(f"[DEPLOYMENT SERVICE: INFO]: {message}")
 
+    def _generate_authorization_id(self) -> Optional[str]:
+        get_deployment_environment = os.getenv('AGENT_DEPLOYMENT_PIPELINE_ID', "LOCAL_RUN")
+
+        if self._authorization_override:
+            return self._authorization_override.lower()
+        
+        if not self._authorization_override:
+            return None
+
+        return f"{get_deployment_environment}-{self._reasoning_engine_name}-{str(uuid.uuid4())}-auth".lower()
+        
+    def _load_runtime_variables(self):
+        load_dotenv(dotenv_path=".env", override=True)
+        runtime_vars = {}
+
+        for key in self._specific_dot_env_variables:
+            if key in os.environ:
+                runtime_vars[key] = os.environ[key]
+        
+        runtime_vars.update(self._runtime_variable_definitions or {})
+        local_auth_id = self._generate_authorization_id()
+
+        if self._use_authorization and local_auth_id:
+            runtime_vars.update({'AUTHORIZATION_ID': local_auth_id})
+            self._authorization_id = local_auth_id
+        runtime_vars.update({f"DEPLOYED_PROJECT_NUMBER": self._project_number})
+        runtime_vars.update({f"DEPLOYED_PROJECT_ID": self._project_id})
+        runtime_vars.update({f"AGENT_DEPLOYMENT_PIPELINE_ID": self._deployed_environment})
+
+        self._environment_variables = runtime_vars
+
     def _check_required_files_exist(self):
         end_run = False
         if not os.path.exists(".env.agent"):
@@ -185,37 +218,14 @@ class ReasoningEngineDeploymentService:
         if path.exists() and not overwrite:
             raise FileExistsError(f"{path} already exists. Pass overwrite=True to replace it.")
 
-        template = """#===================== **** DEPLOYMENT PROFILE **** =====================
-    # Development Profile
-    DEV_PROJECT_ID=
-    DEV_PROJECT_NUMBER=
-    DEV_PROJECT_LOCATION=
-    DEV_STAGING_BUCKET=
-    DEV_AGENT_SPACE_ENGINE=
-    DEV_API_TOKEN=
-    DEV_OAUTH_CLIENT_ID=
-    DEV_OAUTH_CLIENT_SECRET=
-
-    # Production Profile
-    PROD_PROJECT_ID=
-    PROD_PROJECT_NUMBER=
-    PROD_PROJECT_LOCATION=
-    PROD_STAGING_BUCKET=
-    PROD_AGENT_SPACE_ENGINE=
-    PROD_API_TOKEN=
-    PROD_OAUTH_CLIENT_ID=
-    PROD_OAUTH_CLIENT_SECRET=
-    #===================== **** DEPLOYMENT PROFILE **** =====================
-
-
-    #===================== **** YOUR APP ENV VARIABLES **** =====================
-    DEVELOPER=dev
-    #===================== **** YOUR APP ENV VARIABLES **** =====================
-    """
+        template = """
+        DEV_PROJECT_ID=
+        DEV_PROJECT_NUMBER=
+        DEV_PROJECT_LOCATION=
+        DEV_OAUTH_CLIENT_ID=
+        DEV_OAUTH_CLIENT_SECRET="""
 
         path.write_text(template.strip() + "\n")
-        
-        # Also update .gitignore to include logs
         self._update_gitignore()
         
         return path
@@ -250,13 +260,6 @@ class ReasoningEngineDeploymentService:
     def _generate_example_yaml_config(self, path: str | Path = "agent.yaml", overwrite: bool = False) -> Path:
         """
         Create an example YAML config matching the requested schema.
-
-        Structure:
-        defaults:
-        scopes: [ ... ]
-        metadata: { ... }
-        auth: { ... }
-        environment_variables: [ ... ]
         """
         path = Path(path)
         if path.exists() and not overwrite:
@@ -264,23 +267,27 @@ class ReasoningEngineDeploymentService:
 
         config = {
             "defaults": {
-                "scopes": [
-                    "https://www.googleapis.com/auth/cloud-platform",
-                    "https://www.googleapis.com/auth/userinfo.email",
-                ],
-                "metadata": {
-                    "reasoning_engine_name": "reasoning-engine-dev",
-                    "reasoning_engine_description": "A reasoning engine for development",
-                    "agent_space_name": "Agent Space Dev Numba Three!",
-                    "agent_space_description": "Agent spece description, lets go",
-                    "agent_space_tool_description": "Agent space tool description",
+                "reasoning_engine": {
+                    "name": "reasoning-engine-dev",
+                    "description": "A reasoning engine for development"
+                },
+                "gemini_enterprise": {
+                    "target_deployment_engine_id": "your-gemini-enterprise-engine-id",
+                    "name": "Agent Name Here",
+                    "description": "Agent description here",
+                    "tool_description": "Tool description here",
                 },
-                "auth": {
-                    "oauth_authorization_id": "test_auth_three",
+                "authorization": {
+                    "enabled": True,
+                    "scopes": [
+                        "https://www.googleapis.com/auth/cloud-platform",
+                        "https://www.googleapis.com/auth/userinfo.email"
+                        ]
                 },
-                "environment_variables": [
-                    "DEVELOPER",
-                ],
+                "import_from_dot_env_by_name": ["TEST_ENV_VAR"],
+                "runtime_variable_definitions":{
+                    "EXAMPLE_VAR": "An example environment variable for the agent runtime"
+                }
             }
         }
 
@@ -298,31 +305,40 @@ class ReasoningEngineDeploymentService:
 
         try:
             config = config['defaults']
-            scopes = config['scopes']
-            metadata = config['metadata']
-            auth = config['auth']
-            environment_variables = config['environment_variables']
-
-            reasoning_engine_name = metadata['reasoning_engine_name']
-            reasoning_engine_description = metadata['reasoning_engine_description']
-            agent_space_name = metadata['agent_space_name']
-            agent_space_description = metadata['agent_space_description']
-            agent_space_tool_description = metadata["agent_space_tool_description"]
-
-            self._required_scopes = scopes
+            authorization = config['authorization']
+            gemini_enterprise = config['gemini_enterprise']
+            reasoning_engine = config['reasoning_engine']
+            self._specific_dot_env_variables = config.get('import_from_dot_env_by_name', [])
+            self._runtime_variable_definitions = config.get('runtime_variable_definitions', {})
+
+            reasoning_engine_name = reasoning_engine.get('name')
+            reasoning_engine_description = reasoning_engine.get('description')
+            reasoning_engine_bypass = reasoning_engine.get('skip_build', False)
+
+            gemini_enterprise_name = gemini_enterprise.get('name')
+            gemini_enterprise_description = gemini_enterprise.get('description')
+            gemini_enterprise_tool_description = gemini_enterprise.get('tool_description')
+            gemini_enterprise_engine_id = gemini_enterprise.get('target_deployment_engine_id')
+            gemini_enterprise_icon_uri = gemini_enterprise.get('icon_uri')
+
+
+            self._reasoning_engine_bypass = reasoning_engine_bypass
+            self._icon_uri = gemini_enterprise_icon_uri
+            self._agent_space_engine = gemini_enterprise_engine_id or os.getenv(f"{self.deployment_env}_AGENT_SPACE_ENGINE")
+            self._required_scopes = authorization.get('scopes', [])
             self._agent_folder = "agent"
             self._reasoning_engine_name = reasoning_engine_name
             self._reasoning_engine_description = reasoning_engine_description
-            self._agent_space_name = agent_space_name
-            self._agent_space_description = agent_space_description
-            self._agent_space_tool_description = agent_space_tool_description
-            self._authorization_id = auth.get("oauth_authorization_id", None)
-            self._environment_variables = environment_variables or []
+            self._agent_space_name = gemini_enterprise_name
+            self._agent_space_description = gemini_enterprise_description
+            self._agent_space_tool_description = gemini_enterprise_tool_description
+            self._use_authorization = authorization.get('enabled', False)
+            self._authorization_override = authorization.get('authorization_id_override', None)
         except KeyError as e:
-             raise RuntimeError(f"Missing required key in agent.yaml: {e}")
+             raise RuntimeError(f"Missing required key in agent.yaml: {e}. Your agent.yaml file is not valid for this deployment service version.")
         
     def _load_deployment_environment_variables(self, deployment_environment: str):
-        required_vars = ['PROJECT_ID', 'PROJECT_NUMBER', 'PROJECT_LOCATION', 'STAGING_BUCKET', 'AGENT_SPACE_ENGINE']
+        required_vars = ['PROJECT_ID', 'PROJECT_NUMBER', 'PROJECT_LOCATION', 'STAGING_BUCKET']
         
         for var in required_vars:
             env_var = f"{deployment_environment}_{var}"
@@ -331,7 +347,10 @@ class ReasoningEngineDeploymentService:
             
             setattr(self, f"_{var.lower()}", os.getenv(env_var))
 
-        if self._authorization_id:
+        if not self._agent_space_engine:
+            raise RuntimeError(f"Missing AGENT_SPACE_ENGINE for deployment environment {deployment_environment}.")
+
+        if self._use_authorization:
             required_auth_vars = ['OAUTH_CLIENT_ID', 'OAUTH_CLIENT_SECRET']
 
             for var in required_auth_vars:
@@ -341,6 +360,8 @@ class ReasoningEngineDeploymentService:
 
                 setattr(self, f"_{var.lower()}", os.getenv(env_var))
 
+        self._deployed_environment = os.getenv(f"AGENT_DEPLOYMENT_PIPELINE_ID", "unregistered_environment")
+
     def _check_requirements_file_present(self):
         if not os.path.exists("requirements.txt"):
             raise RuntimeError("Missing requirements.txt file")
@@ -417,7 +438,10 @@ class ReasoningEngineDeploymentService:
             },
         }
 
-        if self._authorization_id:
+        if self._icon_uri:
+            payload["icon"] = {"uri": self._icon_uri}
+
+        if self._use_authorization and self._authorization_id:
             payload["adk_agent_definition"]["authorizations"] = [
                 f"projects/{self._project_number}/locations/global/authorizations/{self._authorization_id}"
             ]
@@ -520,7 +544,7 @@ class ReasoningEngineDeploymentService:
     def _create_authorization(self) -> dict:
         read_authorizations = self._read_engine_deployment_record()
 
-        if not self._authorization_id:
+        if not self._authorization_id or not self._use_authorization:
             self.warning("No authorization ID provided; skipping authorization creation.")
 
             return
@@ -603,8 +627,10 @@ class ReasoningEngineDeploymentService:
 
         return True
     
-    def _delete_authorization(self):
-        if not self._authorization_id:
+    def _delete_authorization(self, drop_authorization_for_refresh: Optional[str] = None):
+        auth_to_drop = drop_authorization_for_refresh or self._authorization_id
+
+        if not auth_to_drop:
             self.warning("No authorization ID provided; skipping deletion.")
             return
 
@@ -617,18 +643,21 @@ class ReasoningEngineDeploymentService:
 
         url = (
             f"{discovery_engine_url}/projects/{self._project_id}/locations/global/authorizations"
-            f"?authorizationId={self._authorization_id}"
+            f"?authorizationId={auth_to_drop}"
         )
 
         r = self._http.delete(url, headers=headers, timeout=60)
 
         if r.status_code < 400:
+            if drop_authorization_for_refresh:
+                self.info(f"Authorization {drop_authorization_for_refresh} deleted successfully for refresh.")
+                return True
+            
             self.info("Authorization deleted successfully.")
             self._authorization_id = None
             self._update_in_agent_space()
             return True
 
-        # Log API failure details to file only
         with open(self.log_filename, 'a') as f:
             timestamp = datetime.now().strftime('%Y-%m-%d %H:%M:%S,%f')[:-3]
             f.write(f"{timestamp} - ReasoningEngineDeployment - ERROR - Failed to delete authorization with status {r.status_code} {r.reason}\n")
@@ -641,9 +670,8 @@ class ReasoningEngineDeploymentService:
                 except:
                     pass
         
-        # Terminal message - simple
+
         self.error("Failed to delete authorization")
-        # This will also log the record file
         return False
 
     def one_deployment_with_everything_on_it(self, skip_engine_step=False):
@@ -781,6 +809,7 @@ class ReasoningEngineDeploymentService:
         new_description: Optional[str] = None,
         new_reasoning_engine: Optional[str] = None,
         new_authorizations: Optional[list[str]] = None,
+        icon_uri: Optional[str] = None,
     ) -> dict:
         """
         Safely patch metadata (displayName, description) and linkage fields
@@ -807,12 +836,15 @@ class ReasoningEngineDeploymentService:
             }
         }
 
+        if icon_uri:
+            agent_updates_body["icon"] = {"uri": icon_uri}
+
         self.info(agent_updates_body)
 
         headers = self._get_headers()
 
         update_mask = ["displayName", "description", "adk_agent_definition.tool_settings.tool_description", 
-                       "adk_agent_definition.provisioned_reasoning_engine.reasoning_engine", "adk_agent_definition.authorizations"]
+                       "adk_agent_definition.provisioned_reasoning_engine.reasoning_engine", "adk_agent_definition.authorizations", 'icon.uri']
         params = {"update_mask": ",".join(update_mask)}
         resp = self._http.patch(url, headers=headers, params=params, json=agent_updates_body, timeout=60)
 
@@ -846,6 +878,42 @@ class ReasoningEngineDeploymentService:
         r = self._http.patch(url, headers=headers, json=payload, timeout=60)
         r.raise_for_status()
         return r.json()
+    
+    def detect_scope_change(self, auth_full_name, want_scopes) -> Optional[bool]:
+        auth_url = f"{DISCOVERY_ENGINE_URL}/{auth_full_name}"
+        hdrs = self._get_headers().copy()
+
+        if "Authorization" in hdrs:
+            hdrs["Authorization"] = "Bearer ***"
+        
+        self.info(f"[AUTH] GET {auth_url} headers={json.dumps(hdrs)}")
+        r = self._http.get(auth_url, headers=self._get_headers(), timeout=60)
+        self.info(f"[AUTH] GET status={r.status_code} ct={r.headers.get('content-type','')}")
+        
+        try:
+            self.info(f"[AUTH] GET body={json.dumps(r.json(), indent=2)[:4000]}")
+        except Exception:
+            self.info(f"[AUTH] GET text={(r.text or '')[:1000]}")
+        r.raise_for_status()
+
+        data = r.json() or {}
+        existing_uri = (((data.get("serverSideOauth2") or {}).get("authorizationUri")) or "")
+        self.info(f"[AUTH] existing authorizationUri={existing_uri!r}")
+        existing_scopes = set()
+        
+        if existing_uri:
+            parsed = urlparse(existing_uri)
+            qs = parse_qs(parsed.query)
+            scope_str = (qs.get("scope", [""])[0] or "")
+            existing_scopes = set(scope_str.split())
+
+        self.info(
+            f"[AUTH] scopes existing={sorted(existing_scopes)} want={sorted(want_scopes)} "
+            f"missing={sorted(want_scopes - existing_scopes)} extra={sorted(existing_scopes - want_scopes)}"
+        )
+
+        if existing_scopes != want_scopes:
+            return True
 
     def one_github_deployment_to_go(self, skip_engine=False):
         """
@@ -855,8 +923,6 @@ class ReasoningEngineDeploymentService:
         - Agent Space: create if missing; patch if found (by displayName under engine).
         """
         self.info("Starting GitHub deployment...")
-
-        # Config snapshot
         self.info(
             f"[CFG] project_id={self._project_id} project_number={self._project_number} "
             f"location={self._project_location} engine_name={self._reasoning_engine_name} "
@@ -864,8 +930,8 @@ class ReasoningEngineDeploymentService:
             f"scopes={self._required_scopes} staging_bucket={self._staging_bucket}"
         )
 
-        # Ensure Vertex SDK calls have context for list/update
         self._cicd_deploy = True
+        delete_old_authorization = False
         self.info(f"[INIT] vertexai.init(project={self._project_id}, location={self._project_location}, staging_bucket={self._staging_bucket})")
         vertexai.init(
             project=self._project_id,
@@ -873,14 +939,11 @@ class ReasoningEngineDeploymentService:
             staging_bucket=self._staging_bucket,
         )
 
-        # -----------------------------
-        # 1) Reasoning Engine (create or update)
-        # -----------------------------
         self.info(f"[ENGINE] Resolving by display_name={self._reasoning_engine_name}")
         engine_rn = self.find_engine_by_name(self._reasoning_engine_name)
         self.info(f"[ENGINE] find_engine_by_name -> {engine_rn}")
 
-        if not skip_engine:
+        if not skip_engine and not self._reasoning_engine_bypass:
             if not engine_rn:
                 self.info(f"[ENGINE] '{self._reasoning_engine_name}' not found. Creating...")
                 self.create_reasoning_engine()
@@ -897,74 +960,42 @@ class ReasoningEngineDeploymentService:
 
         self.info(f"[ENGINE] final engine_rn={engine_rn}")
 
-        # -----------------------------
-        # 2) Authorization (create if missing; update scopes if changed)
-        # -----------------------------
+        if not engine_rn:
+            self.error("[ENGINE] Reasoning engine required for Agent Space deployment.")
+            raise RuntimeError("Reasoning engine resolution failed.")
+
         auth_full_name = None
-        if self._authorization_id:
+        if self._authorization_id and self._use_authorization:
             want_scopes = set(self._required_scopes or [])
             self.info(f"[AUTH] id={self._authorization_id} want_scopes={sorted(want_scopes)}")
             auth_full_name = self.find_authorization_by_id(self._authorization_id)
             self.info(f"[AUTH] find_authorization_by_id -> {auth_full_name}")
 
+            if auth_full_name and self.detect_scope_change(auth_full_name, want_scopes):
+                self.info(f"[AUTH] Scopes changed; patching authorization {self._authorization_id}...")
+                delete_old_authorization = auth_full_name
+                self._authorization_id = self._generate_authorization_id()
+                auth_full_name = None
+
             if not auth_full_name:
                 self.info(f"[AUTH] '{self._authorization_id}' not found. Creating...")
                 ok = self._create_authorization()
                 self.info(f"[AUTH] _create_authorization -> {ok}")
                 auth_full_name = self.find_authorization_by_id(self._authorization_id)
                 self.info(f"[AUTH] post-create resolve -> {auth_full_name}")
+
                 if not ok or not auth_full_name:
                     self.error("[AUTH] Creation failed or did not resolve.")
+
                     raise RuntimeError("Authorization creation failed.")
-            else:
-                # Compare scopes; patch if different
-                auth_url = f"{DISCOVERY_ENGINE_URL}/{auth_full_name}"
-                hdrs = self._get_headers().copy()
-                if "Authorization" in hdrs:
-                    hdrs["Authorization"] = "Bearer ***"
-                self.info(f"[AUTH] GET {auth_url} headers={json.dumps(hdrs)}")
-                r = self._http.get(auth_url, headers=self._get_headers(), timeout=60)
-                self.info(f"[AUTH] GET status={r.status_code} ct={r.headers.get('content-type','')}")
-                try:
-                    self.info(f"[AUTH] GET body={json.dumps(r.json(), indent=2)[:4000]}")
-                except Exception:
-                    self.info(f"[AUTH] GET text={(r.text or '')[:1000]}")
-                r.raise_for_status()
-
-                data = r.json() or {}
-                existing_uri = (((data.get("serverSideOauth2") or {}).get("authorizationUri")) or "")
-                self.info(f"[AUTH] existing authorizationUri={existing_uri!r}")
-
-                existing_scopes = set()
-                if existing_uri:
-                    parsed = urlparse(existing_uri)
-                    qs = parse_qs(parsed.query)
-                    scope_str = (qs.get("scope", [""])[0] or "")
-                    existing_scopes = set(scope_str.split())
-
-                self.info(
-                    f"[AUTH] scopes existing={sorted(existing_scopes)} want={sorted(want_scopes)} "
-                    f"missing={sorted(want_scopes - existing_scopes)} extra={sorted(existing_scopes - want_scopes)}"
-                )
-
-                if existing_scopes != want_scopes:
-                    self.info("[AUTH] Scopes changed. Patching authorization...")
-                    self.update_authorization_scopes(self._authorization_id, list(want_scopes), self._oauth_client_id)
-                    self.info("[AUTH] Authorization updated.")
-                else:
-                    self.info("[AUTH] Scopes unchanged; no update needed.")
         else:
             self.info("[AUTH] No authorization_id configured; skipping authorization step.")
 
-        # -----------------------------
-        # 3) Agent Space Agent (create or update)
-        # -----------------------------
         self.info(f"[AGENT] Resolving by display_name={self._agent_space_name}")
         existing_agent = self.find_agent_space_agents_by_display(self._agent_space_name)
         self.info(f"[AGENT] find_agent_space_agents_by_display -> {json.dumps(existing_agent, indent=2)}")
 
         if not existing_agent:
-            # Fresh create
             headers, payload = self._get_agent_space_payload(engine_rn)
             create_url = self._get_agent_space_agent_url_new()
             self.info(f"[AGENT] POST {create_url}")
@@ -980,7 +1011,6 @@ class ReasoningEngineDeploymentService:
             else:
                 self.warning("[AGENT] Created but response missing name. Verify in console.")
         else:
-            # Safe patch using our new helper
             self.info(f"[AGENT] '{self._agent_space_name}' exists. Patching metadata and auth only...")
             patched = self.patch_agent_space_metadata_and_auth(
                 agent_id=existing_agent["id"],
@@ -990,7 +1020,13 @@ class ReasoningEngineDeploymentService:
                 new_authorizations=[
                     f"projects/{self._project_number}/locations/global/authorizations/{self._authorization_id}"
                 ] if self._authorization_id else None,
+                icon_uri=self._icon_uri,
             )
             self.info(f"[AGENT] PATCH result -> {json.dumps(patched, indent=2)[:2000]}")
 
+
+        if delete_old_authorization:
+            self.info(f"[AUTH] Deleting old authorization {delete_old_authorization}...")
+            self._delete_authorization(delete_old_authorization)
+
         self.info("GitHub deployment completed successfully.")

reasoning_deployment_service/runner.py

@@ -105,7 +105,7 @@ class Runner:
     @staticmethod
     def _check_proper_configuration():
         """Ensure required environment variables are set in .env.agent."""
-        required_vars = ['PROJECT_ID', 'PROJECT_NUMBER', 'PROJECT_LOCATION', 'AGENT_SPACE_ENGINE']
+        required_vars = ['PROJECT_ID', 'PROJECT_NUMBER', 'PROJECT_LOCATION']
         load_dotenv(dotenv_path=".env.agent")
 
         ok = True

{reasoning_deployment_service-0.6.1.dist-info → reasoning_deployment_service-0.8.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reasoning-deployment-service
-Version: 0.6.1
+Version: 0.8.4
 Summary: Deployment helper for Vertex AI Reasoning Engines & Agent Spaces
 Author-email: Sergio Estrada <sergio.estrada@accenture.com>
 License: Apache-2.0

{reasoning_deployment_service-0.6.1.dist-info → reasoning_deployment_service-0.8.4.dist-info}/RECORD

@@ -1,12 +1,11 @@
 reasoning_deployment_service/__init__.py,sha256=xDuKt9gGviQiTV6vXBdkBvygnlAOIrwnUjVaMGZy0L4,670
-reasoning_deployment_service/reasoning_deployment_service.py,sha256=s95nEM9HXRDKBv9Q4cC9CfyXBH8FUv_LW3YSa223FOs,43281
-reasoning_deployment_service/runner.py,sha256=qWN0t66lQ1G4ht48gIHSF2JvedcheHRu8PmUz5TaKTI,5619
+reasoning_deployment_service/reasoning_deployment_service.py,sha256=7hf5VYvAFuKXworJO_fVOLUU0v5LNJ40vRJJqdWpZaQ,45336
+reasoning_deployment_service/runner.py,sha256=A88IhRPPAWtqedWPWOVne3Lg16uXhXuqARKGD5ORsWc,5597
 reasoning_deployment_service/cli_editor/__init__.py,sha256=bN8NPkw8riB92pj2lAwJZuEMOQIO_RRuge0ehnJTW1I,118
-reasoning_deployment_service/cli_editor/api_client.py,sha256=Kzx5iYp0MmowggrSmPLE7I2kt1-8xvdGBAgde9a1gCY,33681
+reasoning_deployment_service/cli_editor/api_client.py,sha256=bcuV0kEHxyNobqJ1k2Iwp73EaFjuOWa4XJ77MRrWQr0,33106
 reasoning_deployment_service/cli_editor/cli_runner.py,sha256=1KkHtgAhVZ7VHQj7o76JibLHnr7NMUB-tieDX_KrAcY,18239
 reasoning_deployment_service/cli_editor/config.py,sha256=lZ8Ng007NVdN1n5spJ0OFC72TOPFWKvPRxa9eKE-FDY,3573
 reasoning_deployment_service/cli_editor/google_deps.py,sha256=PhGwdKEC96GdlFHkQrtSJrg_-w1JoUPes3zvaz22rd0,771
-reasoning_deployment_service/cli_editor/reasoning_engine_creator.py,sha256=6QC8Y9yZAT8SYNkT_R00g_SSOYuwEkIxAN9lBG3br2k,19564
 reasoning_deployment_service/gui_editor/__init__.py,sha256=e5e88iNTk1GC243DRsQFi5E7PqMaT2SXmqOez9FbYzo,128
 reasoning_deployment_service/gui_editor/agent_checkbox_list.py,sha256=ElxFqSgT3iUqDv2U9eR4eV-MfLUHqOXbDz6DqEEevOk,1783
 reasoning_deployment_service/gui_editor/main.py,sha256=4UzgGUga_xIYIWRVo-80PzhJ1Dlou8PaUXoRiLcLhp8,10914
@@ -19,11 +18,11 @@ reasoning_deployment_service/gui_editor/src/core/reasoning_engine_creator.py,sha
 reasoning_deployment_service/gui_editor/src/ui/__init__.py,sha256=262ZiXO6Luk8vZnhCIoYxOtGiny0bXK-BTKjxUNBx-w,43
 reasoning_deployment_service/gui_editor/src/ui/agent_space_view.py,sha256=UTUMRFEzpUuRONl3K7bsCPRjZ_hiVE1s9fTsIHTZtSs,17130
 reasoning_deployment_service/gui_editor/src/ui/authorization_view.py,sha256=BoNcGRFZ-Rb2pnOAAZxraP7yDdbwMJNvIrBrjMc_hbw,16970
-reasoning_deployment_service/gui_editor/src/ui/reasoning_engine_view.py,sha256=tCvSPEf4dW0NRdAqfs3yT5Pa873gYeLzCMMIt2r2T4o,14644
+reasoning_deployment_service/gui_editor/src/ui/reasoning_engine_view.py,sha256=T_kBop74wHv8W7tk9aY17ty44rLu8Dc-vRZdRvhmeH0,13317
 reasoning_deployment_service/gui_editor/src/ui/reasoning_engines_view.py,sha256=IRjFlBbY98usAZa0roOonjvWQOsF6NBW4bBg_k8KnKI,7860
 reasoning_deployment_service/gui_editor/src/ui/ui_components.py,sha256=HdQHy-oSZ3GobQ3FNdH7y_w3ANbFiuf2rMoflAmff0A,55366
-reasoning_deployment_service-0.6.1.dist-info/METADATA,sha256=lIVFjuF_XYh1cmyTanM4bms3EUXo0HzB_IW2EwjYj8c,5302
-reasoning_deployment_service-0.6.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-reasoning_deployment_service-0.6.1.dist-info/entry_points.txt,sha256=onGKjR5ONTtRv3aqEtK863iw9Ty1kLcjfZlsplkRZrA,84
-reasoning_deployment_service-0.6.1.dist-info/top_level.txt,sha256=GKuQS1xHUYLZbatw9DmcYdBxxLhWhhGkV4FmFxgKdp0,29
-reasoning_deployment_service-0.6.1.dist-info/RECORD,,
+reasoning_deployment_service-0.8.4.dist-info/METADATA,sha256=3ylGfj_4YjvBThijeiUh1EhS2dKqTF46h9xmsWDAA-o,5302
+reasoning_deployment_service-0.8.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+reasoning_deployment_service-0.8.4.dist-info/entry_points.txt,sha256=onGKjR5ONTtRv3aqEtK863iw9Ty1kLcjfZlsplkRZrA,84
+reasoning_deployment_service-0.8.4.dist-info/top_level.txt,sha256=GKuQS1xHUYLZbatw9DmcYdBxxLhWhhGkV4FmFxgKdp0,29
+reasoning_deployment_service-0.8.4.dist-info/RECORD,,

reasoning_deployment_service/cli_editor/reasoning_engine_creator.py

@@ -1,448 +0,0 @@
-"""Reasoning Engine creation with robust venv lifecycle and safe imports.
-
-This module provides a `ReasoningEngineCreator` that:
-- Creates an isolated virtual environment per engine build
-- Installs dependencies using the *venv's* interpreter (`python -m pip`)
-- Temporarily exposes the venv's site-packages to the current process for imports
-- Emulates activation for subprocesses via PATH/VIRTUAL_ENV
-- Stages a clean copy of the agent directory as an extra package
-- Cleans up the venv after completion
-
-Pass a config dict to `create_advanced_engine` with keys:
-- display_name (str)
-- description (str, optional)
-- enable_tracing (bool, optional)
-- requirements_source_type ("file" | "text")
-- requirements_file (str, optional when source_type == "file")
-- requirements_text (str, optional when source_type == "text")
-- agent_file_path (str, path to the python file exporting `root_agent`)
-- project_id, location, staging_bucket should be supplied to the constructor
-"""
-from __future__ import annotations
-
-import importlib
-import importlib.util
-import json
-import os
-import platform
-import shutil
-import subprocess
-import sys
-import tempfile
-import venv
-from datetime import datetime
-from pathlib import Path
-from typing import Any, Dict, List, Optional, Tuple
-
-from vertexai import init as vertexai_init
-from vertexai.preview.reasoning_engines import AdkApp
-from vertexai import agent_engines
-
-# --- helpers for clean packaging ---
-EXCLUDES = [
-    ".env",
-    ".env.*",
-    ".git",
-    "__pycache__",
-    ".pytest_cache",
-    ".mypy_cache",
-    ".DS_Store",
-    "*.pyc",
-    "*.pyo",
-    "*.pyd",
-    ".venv",
-    "venv",
-    "tests",
-    "docs",
-]
-
-
-class ReasoningEngineCreator:
-    """
-    Dedicated class for creating reasoning engines with advanced virtual environment management.
-    Handles all the complex logic for venv creation, dependency installation, and deployment.
-    """
-
-    def __init__(self, project_id: str, location: str, staging_bucket: str, debug: bool = False):
-        self.project_id = project_id
-        self.location = location
-        self.staging_bucket = staging_bucket
-        self.debug = debug
-
-        # Ensure staging bucket has gs:// prefix
-        if not self.staging_bucket.startswith("gs://"):
-            self.staging_bucket = f"gs://{self.staging_bucket}"
-
-    # ---------------- Vertex init ----------------
-    def _ensure_vertex_inited(self) -> None:
-        """Initialize Vertex AI once and reuse."""
-        if not getattr(self, "_vertex_inited", False):
-            vertexai_init(project=self.project_id, location=self.location, staging_bucket=self.staging_bucket)
-            self._vertex_inited = True
-
-    # ---------------- Virtual Environment Management ----------------
-    def _create_venv_name(self, engine_name: str) -> str:
-        """Generate a unique virtual environment name with timestamp."""
-        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-        # Clean engine name for filesystem safety
-        clean_name = "".join(c for c in engine_name if c.isalnum() or c in "_-").lower()
-        return f"venv_{timestamp}_{clean_name}"
-
-    def _deactivate_current_venv(self) -> bool:
-        """Deactivate any currently active virtual environment."""
-        if not os.environ.get("VIRTUAL_ENV"):
-            if self.debug:
-                print("📍 No virtual environment currently active.")
-            return True
-        if self.debug:
-            print(f"📍 Deactivating current virtual environment: {os.environ.get('VIRTUAL_ENV')}")
-        # No-op for current process; we'll spawn new processes with the target venv
-        return True
-
-    def _create_and_activate_venv(self, venv_name: str, project_dir: str) -> Tuple[bool, str, str]:
-        """
-        Create a new virtual environment.
-        Returns: (success, venv_path, python_executable)
-        """
-        try:
-            venv_base = os.path.join(os.path.expanduser("~"), ".agent_venvs")
-            os.makedirs(venv_base, exist_ok=True)
-            venv_path = os.path.join(venv_base, venv_name)
-
-            print(f"🔧 Creating virtual environment: {venv_path}")
-            venv.create(venv_path, with_pip=True, clear=True)
-
-            if platform.system() == "Windows":
-                python_exe = os.path.join(venv_path, "Scripts", "python.exe")
-            else:
-                python_exe = os.path.join(venv_path, "bin", "python")
-
-            if not os.path.exists(python_exe):
-                raise RuntimeError(f"Python executable not found at: {python_exe}")
-
-            print("✅ Virtual environment created successfully")
-            print(f"📍 Python executable: {python_exe}")
-            return True, venv_path, python_exe
-        except Exception as e:
-            print(f"❌ Failed to create virtual environment: {e}")
-            return False, "", ""
-
-    def _install_requirements_in_venv(self, python_exe: str, requirements: List[str]) -> bool:
-        """Install requirements in the specified virtual environment using interpreter-correct pip."""
-        if not requirements:
-            print("📍 No requirements to install.")
-            return True
-        try:
-            print(f"📦 Installing {len(requirements)} requirements...")
-            for req in requirements:
-                print(f"  📦 Installing: {req}")
-                cmd = [python_exe, "-m", "pip", "install", req]
-                result = subprocess.run(cmd, capture_output=True, text=True, timeout=300)
-                if result.returncode != 0:
-                    print(f"❌ Failed to install {req}\nSTDOUT:\n{result.stdout}\nSTDERR:\n{result.stderr}")
-                    return False
-            print("✅ All requirements installed successfully!")
-            return True
-        except subprocess.TimeoutExpired:
-            print("❌ Package installation timed out")
-            return False
-        except Exception as e:
-            print(f"❌ Error installing requirements: {e}")
-            return False
-
-    def _cleanup_venv(self, venv_path: str) -> bool:
-        """Remove the virtual environment directory."""
-        if not venv_path or not os.path.exists(venv_path):
-            if self.debug:
-                print("📍 Virtual environment path doesn't exist, nothing to clean up.")
-            return True
-        try:
-            print(f"🧹 Cleaning up virtual environment: {venv_path}")
-            shutil.rmtree(venv_path)
-            print("✅ Virtual environment cleaned up successfully!")
-            return True
-        except Exception as e:
-            print(f"⚠️ Warning: Failed to clean up virtual environment: {e}")
-            return False
-
-    def _add_venv_to_sys_path(self, python_exe: str) -> Optional[str]:
-        """Add the virtual environment's site-packages to sys.path for imports."""
-        try:
-            code = "import sysconfig, json; print(json.dumps(sysconfig.get_paths()))"
-            result = subprocess.check_output([python_exe, "-c", code], text=True)
-            paths = json.loads(result.strip())
-            site_pkgs = paths.get("purelib") or paths.get("platlib")
-            if site_pkgs and site_pkgs not in sys.path:
-                print(f"📍 Adding venv site-packages to sys.path: {site_pkgs}")
-                sys.path.insert(0, site_pkgs)
-                return site_pkgs
-            return site_pkgs
-        except Exception as e:
-            print(f"⚠️ Warning: Could not add venv to sys.path: {e}")
-            return None
-
-    def _remove_venv_from_sys_path(self, site_pkgs_path: Optional[str]) -> None:
-        """Remove the virtual environment's site-packages from sys.path."""
-        if site_pkgs_path and site_pkgs_path in sys.path:
-            sys.path.remove(site_pkgs_path)
-            print(f"📍 Removed venv site-packages from sys.path: {site_pkgs_path}")
-
-    def _push_venv_envvars(self, venv_path: str) -> None:
-        """Temporarily emulate activation for subprocesses/tools."""
-        self._old_env = {
-            "PATH": os.environ.get("PATH", ""),
-            "VIRTUAL_ENV": os.environ.get("VIRTUAL_ENV"),
-        }
-        bin_dir = os.path.join(venv_path, "Scripts" if platform.system() == "Windows" else "bin")
-        os.environ["VIRTUAL_ENV"] = venv_path
-        os.environ["PATH"] = bin_dir + os.pathsep + self._old_env["PATH"]
-
-    def _pop_venv_envvars(self) -> None:
-        if hasattr(self, "_old_env"):
-            os.environ["PATH"] = self._old_env["PATH"]
-            if self._old_env["VIRTUAL_ENV"] is None:
-                os.environ.pop("VIRTUAL_ENV", None)
-            else:
-                os.environ["VIRTUAL_ENV"] = self._old_env["VIRTUAL_ENV"]
-            del self._old_env
-
-    # ---------------- Validation ----------------
-    def _assert_no_google_shadow(self, agent_dir: str) -> None:
-        """Ensure no local package named 'google' shadows site-packages."""
-        local_google = os.path.join(agent_dir, "google")
-        if os.path.isdir(local_google) or os.path.isfile(local_google + ".py"):
-            raise RuntimeError(
-                f"Found local '{local_google}'. This will shadow 'google.adk'. "
-                "Rename/remove it or move agent code under a different package."
-            )
-
-    # ---------------- Agent Loading and Staging ----------------
-    def _stage_clean_copy(self, src_dir: str) -> str:
-        """Copy agent directory to temp dir, excluding dev files and secrets."""
-        src = Path(src_dir).resolve()
-        dst_root = Path(tempfile.mkdtemp(prefix="agent_stage_"))
-        dst = dst_root / src.name
-
-        if self.debug:
-            print("📦 Staging agent directory...")
-            print(f"📁 Source: {src}")
-            print(f"📁 Destination: {dst}")
-            print(f"🚫 Excluding: {EXCLUDES}")
-            if src.exists():
-                print("📋 Source contents:")
-                for item in sorted(src.iterdir()):
-                    print(f"  {'📁' if item.is_dir() else '📄'} {item.name}{'/' if item.is_dir() else ''}")
-
-        shutil.copytree(src, dst, ignore=shutil.ignore_patterns(*EXCLUDES), dirs_exist_ok=True)
-
-        if self.debug:
-            print("📋 Staged contents:")
-            for item in sorted(dst.iterdir()):
-                print(f"  {'📁' if item.is_dir() else '📄'} {item.name}{'/' if item.is_dir() else ''}")
-
-        # Clean up .env files
-        for p in dst.rglob(".env*"):
-            try:
-                p.unlink()
-                if self.debug:
-                    print(f"🗑️  Removed: {p}")
-            except Exception:
-                pass
-
-        if self.debug:
-            print(f"✅ Staging complete: {dst}")
-        return str(dst)
-
-    def _load_agent_from_file(self, agent_file_path: str):
-        """Load root_agent from a Python file, handling relative imports properly."""
-        agent_file = Path(agent_file_path).resolve()
-        if not agent_file.exists():
-            raise RuntimeError(f"Agent file not found: {agent_file}")
-
-        agent_dir = agent_file.parent
-        package_name = agent_dir.name
-        module_name = f"{package_name}.{agent_file.stem}"
-
-        parent_dir = str(agent_dir.parent)
-        agent_dir_str = str(agent_dir)
-
-        print(f"🤖 Loading {agent_file.stem} from: {agent_file}")
-        print(f"📁 Agent directory: {agent_dir}")
-        print(f"📦 Package name: {package_name}")
-        print(f"🔧 Module name: {module_name}")
-        if self.debug:
-            print(f"🛤️  Adding to sys.path: {parent_dir} (for package imports)")
-            print(f"🛤️  Adding to sys.path: {agent_dir_str} (for absolute imports like 'tools')")
-
-        # Add both parent directory and agent directory
-        paths_added: List[str] = []
-        if parent_dir not in sys.path:
-            sys.path.insert(0, parent_dir)
-            paths_added.append(parent_dir)
-        if agent_dir_str not in sys.path:
-            sys.path.insert(0, agent_dir_str)
-            paths_added.append(agent_dir_str)
-
-        try:
-            # Optionally create a package for proper relative import resolution
-            init_py = agent_dir / "__init__.py"
-            package_spec = importlib.util.spec_from_file_location(package_name, init_py if init_py.exists() else None)
-            if package_spec:
-                package_module = importlib.util.module_from_spec(package_spec)
-                sys.modules[package_name] = package_module
-                if package_spec.loader and init_py.exists():
-                    package_spec.loader.exec_module(package_module)
-
-            spec = importlib.util.spec_from_file_location(module_name, agent_file)
-            if spec is None or spec.loader is None:
-                raise RuntimeError(f"Could not load module spec from {agent_file}")
-
-            module = importlib.util.module_from_spec(spec)
-            module.__package__ = package_name  # help relative imports
-            sys.modules[module_name] = module
-            spec.loader.exec_module(module)
-
-            if not hasattr(module, "root_agent"):
-                raise RuntimeError(f"Module '{agent_file}' does not define `root_agent`.")
-            print(f"✅ Successfully loaded root_agent from {agent_file}")
-            return getattr(module, "root_agent")
-        except Exception as e:
-            print(f"❌ Failed to load agent: {e}")
-            raise RuntimeError(f"Failed to execute agent module {agent_file}: {e}") from e
-        finally:
-            for path in reversed(paths_added):
-                while path in sys.path:
-                    sys.path.remove(path)
-            # clean any submodules from this package
-            mods_to_remove = [name for name in list(sys.modules.keys()) if name.startswith(package_name)]
-            for name in mods_to_remove:
-                sys.modules.pop(name, None)
-
-    # ---------------- Utilities ----------------
-    @staticmethod
-    def _merge_requirements(baseline: List[str], user: List[str]) -> List[str]:
-        seen = set()
-        out: List[str] = []
-        for seq in (baseline, user):
-            for item in seq:
-                key = item.strip().lower()
-                if not key or key in seen:
-                    continue
-                seen.add(key)
-                out.append(item.strip())
-        return out
-
-    # ---------------- Main Creation Method ----------------
-    def create_advanced_engine(self, config: Dict[str, Any]) -> Tuple[str, str, Optional[str]]:
-        """Create a reasoning engine with advanced configuration options."""
-        print("🚀 Starting advanced reasoning engine creation...")
-        if self.debug:
-            print("📋 Configuration:")
-            try:
-                print(json.dumps(config, indent=2))
-            except Exception:
-                print(str(config))
-
-        try:
-            display_name = config["display_name"]
-            description = config.get("description", "")
-            enable_tracing = config.get("enable_tracing", True)
-
-            # Requirements
-            requirements: List[str] = []
-            if config["requirements_source_type"] == "file":
-                req_file = config.get("requirements_file")
-                if req_file and os.path.exists(req_file):
-                    with open(req_file, "r", encoding="utf-8") as f:
-                        requirements = [line.strip() for line in f if line.strip() and not line.strip().startswith("#")]
-            elif config["requirements_source_type"] == "text":
-                requirements_text = config.get("requirements_text", "").strip()
-                requirements = [line.strip() for line in requirements_text.splitlines() if line.strip() and not line.strip().startswith("#")]
-
-            # Ensure baseline ADK deps exist in the build venv (idempotent)
-            baseline = [
-                "google-adk>=1.0.0",
-                "google-cloud-aiplatform[agent_engines]>=1.93.0,<2.0.0",
-                "google-genai>=1.16.1,<2.0.0",
-            ]
-            requirements = self._merge_requirements(baseline, requirements)
-
-            # Paths
-            agent_file_path = config["agent_file_path"]
-            agent_dir = os.path.dirname(agent_file_path)
-
-            # venv lifecycle
-            print("🌐 Setting up isolated virtual environment...")
-            self._deactivate_current_venv()
-            venv_name = self._create_venv_name(display_name)
-            v_success, venv_path, python_exe = self._create_and_activate_venv(venv_name, agent_dir)
-            if not v_success:
-                raise RuntimeError("Failed to create virtual environment")
-
-            # installs
-            if requirements:
-                if not self._install_requirements_in_venv(python_exe, requirements):
-                    self._cleanup_venv(venv_path)
-                    raise RuntimeError("Failed to install requirements in virtual environment")
-
-            # make imports & subprocesses behave like activated
-            self._push_venv_envvars(venv_path)
-            venv_site_pkgs = self._add_venv_to_sys_path(python_exe)
-
-            try:
-                # quick guard against local google/ package
-                self._assert_no_google_shadow(agent_dir)
-
-                print("🔍 Checking agent directory structure...")
-                agent_path = Path(agent_dir)
-                tools_path = agent_path / "tools"
-                if tools_path.exists() and self.debug:
-                    tool_files = [p.name for p in tools_path.glob("*.py")]
-                    print(f"✅ Found tools directory with files: {tool_files}")
-                elif not tools_path.exists():
-                    print(f"❌ WARNING: tools directory not found at {tools_path}")
-
-                staged_dir = self._stage_clean_copy(agent_dir)
-                staged_tools = Path(staged_dir) / "tools"
-                if not staged_tools.exists():
-                    print("❌ ERROR: Tools directory missing from staged copy!")
-                    raise RuntimeError("Tools directory was not properly staged")
-
-                # load agent
-                print(f"🤖 Loading root_agent from: {agent_file_path}")
-                root_agent = self._load_agent_from_file(agent_file_path)
-
-                # vertex init + create
-                self._ensure_vertex_inited()
-                print("🚀 Creating reasoning engine with venv dependencies…")
-                app = AdkApp(agent=root_agent, enable_tracing=enable_tracing)
-                remote = agent_engines.create(
-                    app,
-                    display_name=display_name,
-                    description=description,
-                    requirements=requirements,
-                    extra_packages=[staged_dir],
-                )
-
-                print("✅ Engine creation successful!")
-                return (
-                    "created",
-                    f"Advanced engine '{display_name}' created successfully",
-                    remote.resource_name,
-                )
-
-            except Exception as e:
-                print(f"❌ Deployment failed: {e}")
-                raise
-            finally:
-                # undo import/env tweaks, then remove the venv
-                if venv_site_pkgs:
-                    self._remove_venv_from_sys_path(venv_site_pkgs)
-                self._pop_venv_envvars()
-                print("🧹 Cleaning up virtual environment...")
-                self._cleanup_venv(venv_path)
-
-        except Exception as e:
-            import traceback
-            traceback.print_exc()
-            return ("failed", f"Creation failed: {str(e)}", None)