reasoning-deployment-service 0.6.0__tar.gz → 0.7.0__tar.gz

{reasoning_deployment_service-0.6.0 → reasoning_deployment_service-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reasoning-deployment-service
-Version: 0.6.0
+Version: 0.7.0
 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.0 → reasoning_deployment_service-0.7.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "reasoning-deployment-service"
-version = "0.6.0"
+version = "0.7.0"
 description = "Deployment helper for Vertex AI Reasoning Engines & Agent Spaces"
 readme = "README.md"
 license = { text = "Apache-2.0" }

{reasoning_deployment_service-0.6.0 → reasoning_deployment_service-0.7.0}/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-0.6.0 → reasoning_deployment_service-0.7.0}/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-0.6.0 → reasoning_deployment_service-0.7.0}/reasoning_deployment_service/reasoning_deployment_service.py

@@ -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,25 @@ class ReasoningEngineDeploymentService:
     def info(self, message: str):
         self.logger.info(f"[DEPLOYMENT SERVICE: INFO]: {message}")
 
+    def _generate_authorization_id(self) -> str:
+        get_deployment_environment = os.getenv('AGENT_DEPLOYMENT_PIPELINE_ID', "LOCAL_RUN")
+
+        return f"{get_deployment_environment}-{self._reasoning_engine_name}-{self._agent_space_engine}-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 {})
+        runtime_vars.update({'AUTHORIZATION_ID': self._generate_authorization_id()})
+
+        self._authorization_id = runtime_vars.get('AUTHORIZATION_ID')
+        self._environment_variables = runtime_vars
+
     def _check_required_files_exist(self):
         end_run = False
         if not os.path.exists(".env.agent"):
@@ -185,33 +205,12 @@ 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")
         
@@ -250,13 +249,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 +256,28 @@ 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",
+                "deployment_service": "0.6.2",
+                "reasoning_engine": {
+                    "name": "reasoning-engine-dev",
+                    "description": "A reasoning engine for development"
                 },
-                "auth": {
-                    "oauth_authorization_id": "test_auth_three",
+                "gemini_enterprise": {
+                    "target_deployment_engine_id": "",
+                    "name": "Agent Name Here",
+                    "description": "Agent description here",
+                    "tool_description": "Tool description here",
                 },
-                "environment_variables": [
-                    "DEVELOPER",
-                ],
+                "authorization": {
+                    "enabled": True,
+                    "scopes": [
+                        "https://www.googleapis.com/auth/cloud-platform",
+                        "https://www.googleapis.com/auth/userinfo.email"
+                        ]
+                },
+                "import_from_dot_env_by_name": ["TEST_ENV_VAR"],
+                "runtime_variable_definitions":{
+                    "EXAMPLE_VAR": "An example environment variable for the agent runtime"
+                }
             }
         }
 
@@ -298,26 +295,34 @@ 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
+            deployment_service_version = config.get('deployment_service')
+
+            if deployment_service_version >= 0.7:
+                raise RuntimeError(f"Unsupported deployment_service version: {deployment_service_version}. Expected minimum '0.7'")
+            
+            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')
+
+            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')
+
+            self._target_deployment_engine_id = gemini_enterprise_engine_id
+            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)
         except KeyError as e:
              raise RuntimeError(f"Missing required key in agent.yaml: {e}")
         
@@ -331,7 +336,7 @@ class ReasoningEngineDeploymentService:
             
             setattr(self, f"_{var.lower()}", os.getenv(env_var))
 
-        if self._authorization_id:
+        if self._use_authorization:
             required_auth_vars = ['OAUTH_CLIENT_ID', 'OAUTH_CLIENT_SECRET']
 
             for var in required_auth_vars:
@@ -723,8 +728,12 @@ class ReasoningEngineDeploymentService:
         
         self.info(r.json())
         self.info(r.text)
-        
-        r.raise_for_status()
+
+        if r.status_code == 403:
+            self.warning("Access denied")
+            return None
+        else:
+            r.raise_for_status()
         
         return r.json().get("name", name)
 
@@ -851,8 +860,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} "
@@ -860,7 +867,6 @@ 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
         self.info(f"[INIT] vertexai.init(project={self._project_id}, location={self._project_location}, staging_bucket={self._staging_bucket})")
         vertexai.init(
@@ -869,9 +875,6 @@ 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}")
@@ -893,9 +896,6 @@ class ReasoningEngineDeploymentService:
 
         self.info(f"[ENGINE] final engine_rn={engine_rn}")
 
-        # -----------------------------
-        # 2) Authorization (create if missing; update scopes if changed)
-        # -----------------------------
         auth_full_name = None
         if self._authorization_id:
             want_scopes = set(self._required_scopes or [])
@@ -913,7 +913,6 @@ class ReasoningEngineDeploymentService:
                     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:
@@ -952,15 +951,11 @@ class ReasoningEngineDeploymentService:
         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}")
@@ -976,7 +971,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"],

{reasoning_deployment_service-0.6.0 → reasoning_deployment_service-0.7.0}/reasoning_deployment_service.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reasoning-deployment-service
-Version: 0.6.0
+Version: 0.7.0
 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.0 → reasoning_deployment_service-0.7.0}/reasoning_deployment_service.egg-info/SOURCES.txt

@@ -14,7 +14,6 @@ reasoning_deployment_service/cli_editor/api_client.py
 reasoning_deployment_service/cli_editor/cli_runner.py
 reasoning_deployment_service/cli_editor/config.py
 reasoning_deployment_service/cli_editor/google_deps.py
-reasoning_deployment_service/cli_editor/reasoning_engine_creator.py
 reasoning_deployment_service/gui_editor/__init__.py
 reasoning_deployment_service/gui_editor/agent_checkbox_list.py
 reasoning_deployment_service/gui_editor/main.py

reasoning_deployment_service-0.6.0/reasoning_deployment_service/gui_editor/src/core/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)