reasoning-deployment-service 0.4.0__py3-none-any.whl → 0.8.3__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()
@@ -39,6 +39,7 @@ class ReasoningEngineDeploymentService:
 
         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 +98,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 +217,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 +259,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 +266,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 +304,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 +346,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 +359,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 +437,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 +543,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 +626,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 +642,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 +669,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):
@@ -721,7 +748,14 @@ class ReasoningEngineDeploymentService:
         if r.status_code == 404:
             return None
         
-        r.raise_for_status()
+        self.info(r.json())
+        self.info(r.text)
+
+        if r.status_code == 403:
+            self.warning("Access denied")
+            return None
+        else:
+            r.raise_for_status()
         
         return r.json().get("name", name)
 
@@ -766,9 +800,121 @@ class ReasoningEngineDeploymentService:
             )
         
         return matches[0]
+    
+    def patch_agent_space_metadata_and_auth(
+        self,
+        agent_id: str,
+        new_display_name: Optional[str] = None,
+        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
+        (reasoningEngine, authorizations) for an existing Agent Space agent.
+        Preserves all other required adkAgentDefinition fields.
+        """
+        url = (
+            f"{DISCOVERY_ENGINE_URL}/projects/{self._project_id}/locations/global/"
+            f"collections/default_collection/engines/{self._agent_space_engine}/"
+            f"assistants/default_assistant/agents/{agent_id}"
+        )
 
+        agent_updates_body = {
+            "displayName": new_display_name,
+            "description": new_description,
+            "adk_agent_definition": {
+                "tool_settings": {
+                    "tool_description": new_description
+                },
+                "provisioned_reasoning_engine":{
+                    "reasoning_engine": new_reasoning_engine
+                }, 
+                "authorizations": new_authorizations
+            }
+        }
+
+        if icon_uri:
+            agent_updates_body["icon"] = {"uri": icon_uri}
+
+        self.info(agent_updates_body)
 
-    def one_github_deployment_to_go(self):
+        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", 'icon.uri']
+        params = {"update_mask": ",".join(update_mask)}
+        resp = self._http.patch(url, headers=headers, params=params, json=agent_updates_body, timeout=60)
+
+        return resp.json()
+
+    
+    def one_githhub_deployment_to_go_with_skip(self):
+        return self.one_github_deployment_to_go(skip_engine=True)
+
+    def update_authorization_scopes(self, auth_id: str, scopes: list, oauth_client_id: str) -> dict:
+        """Patch the scopes for a specific authorization by ID, updating the authorizationUri as well."""
+        scopes_str = " ".join(scopes)
+        authorization_uri = (
+            "https://accounts.google.com/o/oauth2/auth"
+            "?response_type=code"
+            f"&client_id={oauth_client_id}"
+            f"&scope={scopes_str}"
+            "&access_type=offline&prompt=consent"
+        )
+        payload = {
+            "serverSideOauth2": {
+                "authorizationUri": authorization_uri
+            }
+        }
+        url = f"{DISCOVERY_ENGINE_URL}/projects/{self._project_id}/locations/global/authorizations/{auth_id}?update_mask=server_side_oauth2.authorization_uri"
+        headers = {
+            "Authorization": f"Bearer {self._access_token()}",
+            "Content-Type": "application/json",
+            "X-Goog-User-Project": self._project_number,
+        }
+        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):
         """
         CI-friendly deploy:
         - Engine: create or update by display_name.
@@ -776,110 +922,110 @@ class ReasoningEngineDeploymentService:
         - Agent Space: create if missing; patch if found (by displayName under engine).
         """
         self.info("Starting GitHub deployment...")
+        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} "
+            f"agent_space_engine={self._agent_space_engine} auth_id={self._authorization_id} "
+            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,
             location=self._project_location,
             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)
-        if not engine_rn:
-            self.info(f"Engine '{self._reasoning_engine_name}' not found. Creating...")
-            self.create_reasoning_engine()
-            # read back the created id (or re-resolve by name as fallback)
-            engine_rn = self._read_engine_deployment_record().get("reasoning_engine_id") or \
-                        self.find_engine_by_name(self._reasoning_engine_name)
+        self.info(f"[ENGINE] find_engine_by_name -> {engine_rn}")
+
+        if not skip_engine and not self._reasoning_engine_bypass:
             if not engine_rn:
-                self.error("Engine creation did not yield a resource name.")
-                raise RuntimeError("Engine creation failed.")
-        else:
-            self.info(f"Engine '{self._reasoning_engine_name}' exists. Updating...")
-            self.update_reasoning_engine(engine_rn)
+                self.info(f"[ENGINE] '{self._reasoning_engine_name}' not found. Creating...")
+                self.create_reasoning_engine()
+                rec_after_create = self._read_engine_deployment_record()
+                self.info(f"[ENGINE] record after create -> {json.dumps(rec_after_create, indent=2)}")
+                engine_rn = rec_after_create.get("reasoning_engine_id") or self.find_engine_by_name(self._reasoning_engine_name)
+                self.info(f"[ENGINE] post-create resolution -> {engine_rn}")
+                if not engine_rn:
+                    self.error("[ENGINE] Creation did not yield a resource name.")
+                    raise RuntimeError("Engine creation failed.")
+            else:
+                self.info(f"[ENGINE] '{self._reasoning_engine_name}' exists. Updating...")
+                self.update_reasoning_engine(engine_rn)
 
-        # -----------------------------
-        # 2) Authorization (create if missing; update scopes if changed)
-        # -----------------------------
-        if self._authorization_id:
+        self.info(f"[ENGINE] final engine_rn={engine_rn}")
+
+        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 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"Authorization '{self._authorization_id}' not found. Creating...")
+                self.info(f"[AUTH] '{self._authorization_id}' not found. Creating...")
                 ok = self._create_authorization()
-                if not ok:
-                    self.error("Authorization creation failed.")
-                    raise RuntimeError("Authorization creation failed.")
+                self.info(f"[AUTH] _create_authorization -> {ok}")
                 auth_full_name = self.find_authorization_by_id(self._authorization_id)
-                if not auth_full_name:
-                    self.error("Authorization creation did not resolve to a resource.")
-                    raise RuntimeError("Authorization creation failed to resolve.")
-            else:
-                # Compare scopes; patch if different
-                r = self._http.get(f"{DISCOVERY_ENGINE_URL}/{auth_full_name}",
-                                headers=self._get_headers(), timeout=60)
-                r.raise_for_status()
-                data = r.json() or {}
-                existing_uri = (((data.get("serverSideOauth2") or {}).get("authorizationUri")) or "")
-                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())
-
-                if existing_scopes != want_scopes:
-                    self.info("Authorization scopes changed. Patching authorization...")
-                    new_auth_uri = self._build_authorization_uri(self._oauth_client_id, list(want_scopes))
-                    patch_payload = {
-                        "serverSideOauth2": {
-                            "clientId": self._oauth_client_id,
-                            "clientSecret": self._oauth_client_secret,
-                            "authorizationUri": new_auth_uri,
-                            "tokenUri": "https://oauth2.googleapis.com/token",
-                        }
-                    }
-                    pr = self._http.patch(f"{DISCOVERY_ENGINE_URL}/{auth_full_name}",
-                                        headers=self._get_headers(), json=patch_payload, timeout=60)
-                    pr.raise_for_status()
-                    self.info("Authorization updated.")
-                else:
-                    self.info("Authorization scopes unchanged; no update needed.")
+                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:
-            self.info("No authorization_id configured; skipping authorization step.")
+            self.info("[AUTH] No authorization_id configured; skipping authorization step.")
 
-        # -----------------------------
-        # 3) Agent Space Agent (create or update by displayName under engine)
-        # -----------------------------
+        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)
-        headers, payload = self._get_agent_space_payload(engine_rn)
+        self.info(f"[AGENT] find_agent_space_agents_by_display -> {json.dumps(existing_agent, indent=2)}")
 
         if not existing_agent:
-            self.info(f"Agent Space agent '{self._agent_space_name}' not found. Creating...")
+            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}")
             cr = self._http.post(create_url, headers=headers, json=payload, timeout=90)
-            if cr.status_code >= 400:
-                # File-only details already handled elsewhere; surface concise error here
-                self.error(f"Agent creation failed [{cr.status_code}].")
-                cr.raise_for_status()
+            self.info(f"[AGENT] POST status={cr.status_code}")
+            self.info(f"[AGENT] POST ct={cr.headers.get('content-type','')}")
+            self.info(f"[AGENT] POST body={(cr.text or '')[:4000]}")
+            cr.raise_for_status()
             agent_name = (cr.json() or {}).get("name")
             if agent_name:
                 self._write_engine_deployment({"agent_space_id": agent_name})
-                self.info(f"Agent Space agent created: {agent_name}")
+                self.info(f"[AGENT] Created: {agent_name}")
             else:
-                self.warning("Agent created but response missing name. Verify in console.")
+                self.warning("[AGENT] Created but response missing name. Verify in console.")
         else:
-            self.info(f"Agent Space agent '{self._agent_space_name}' exists. Updating...")
-            patch_url = f"{DISCOVERY_ENGINE_URL}/{existing_agent['full_name']}"
-            ur = self._http.patch(patch_url, headers=headers, json=payload, timeout=90)
-            if ur.status_code >= 400:
-                self.error(f"Agent update failed [{ur.status_code}].")
-                ur.raise_for_status()
-            self.info("Agent Space agent updated.")
+            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"],
+                new_display_name=self._agent_space_name,
+                new_description=self._agent_space_description,
+                new_reasoning_engine=engine_rn,
+                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

@@ -13,7 +13,7 @@ class Runner:
         parser = argparse.ArgumentParser(description="Reasoning Engine Deployment Runner")
         parser.add_argument(
             "--mode",
-            choices=["create", "auth", "cli", "gui", "populate_files", "github_deployment"],
+            choices=["create", "auth", "cli", "gui", "populate_files", "github_deployment", "github_deployment_without_engine"],
             help="Operation mode to run",
         )
         parser.add_argument(
@@ -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
@@ -133,12 +133,14 @@ class Runner:
             svc._check_required_files_exist()
         elif mode == "github_deployment":
             svc.one_github_deployment_to_go()
+        elif mode == "github_deployment_without_engine":
+            svc.one_githhub_deployment_to_go_with_skip()
 
     @staticmethod
     def _menu(root_agent):
         print("Choose an operation:\n1) Create/Update\n2) Auth only\n3) CLI\n4) GUI\nq) Quit")
         choice = input("Enter choice: ").strip().lower()
-        mapping = {"1": "create", "2": "auth", "3": "cli", "4": "gui", "5": "github_deployment"}
+        mapping = {"1": "create", "2": "auth", "3": "cli", "4": "gui", "5": "github_deployment", "6": "github_deployment_without_engine"}
         if choice == "q":
             sys.exit(0)
         Runner._dispatch(mapping.get(choice, ""), root_agent)

{reasoning_deployment_service-0.4.0.dist-info → reasoning_deployment_service-0.8.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reasoning-deployment-service
-Version: 0.4.0
+Version: 0.8.3
 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.4.0.dist-info → reasoning_deployment_service-0.8.3.dist-info}/RECORD

@@ -1,12 +1,11 @@
 reasoning_deployment_service/__init__.py,sha256=xDuKt9gGviQiTV6vXBdkBvygnlAOIrwnUjVaMGZy0L4,670
-reasoning_deployment_service/reasoning_deployment_service.py,sha256=7slzcV6wKunE4Kj3dV1Fyap5D6uf1O0C-e1uhinOVSk,38211
-reasoning_deployment_service/runner.py,sha256=Y_SPGp26eoXRr8Ql6ugRF7jNYq3OwaytFIivuym6ICA,5428
+reasoning_deployment_service/reasoning_deployment_service.py,sha256=8CLjzDYFKAwKr6Avd97YlJ1b43T8_Oa3Pqi0Xfim5C8,45298
+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.4.0.dist-info/METADATA,sha256=dwROlsOFaaHXoFeA82APxw0ZunSfFiVAYYROMqXMJWQ,5302
-reasoning_deployment_service-0.4.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-reasoning_deployment_service-0.4.0.dist-info/entry_points.txt,sha256=onGKjR5ONTtRv3aqEtK863iw9Ty1kLcjfZlsplkRZrA,84
-reasoning_deployment_service-0.4.0.dist-info/top_level.txt,sha256=GKuQS1xHUYLZbatw9DmcYdBxxLhWhhGkV4FmFxgKdp0,29
-reasoning_deployment_service-0.4.0.dist-info/RECORD,,
+reasoning_deployment_service-0.8.3.dist-info/METADATA,sha256=hNyOtztxXHUY45RW7jQFn_n_apls8D61leAm-88wCJ0,5302
+reasoning_deployment_service-0.8.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+reasoning_deployment_service-0.8.3.dist-info/entry_points.txt,sha256=onGKjR5ONTtRv3aqEtK863iw9Ty1kLcjfZlsplkRZrA,84
+reasoning_deployment_service-0.8.3.dist-info/top_level.txt,sha256=GKuQS1xHUYLZbatw9DmcYdBxxLhWhhGkV4FmFxgKdp0,29
+reasoning_deployment_service-0.8.3.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)