reasoning-deployment-service 0.2.9__tar.gz → 0.3.2__tar.gz

{reasoning_deployment_service-0.2.9 → reasoning_deployment_service-0.3.2}/PKG-INFO

@@ -1,10 +1,13 @@
 Metadata-Version: 2.4
 Name: reasoning-deployment-service
-Version: 0.2.9
+Version: 0.3.2
 Summary: Deployment helper for Vertex AI Reasoning Engines & Agent Spaces
 Author: AxG-AI-Exchange-GenAI-Initiative
 Author-email: Sergio Estrada <sergio.estrada@accenture.com>
 License: Apache-2.0
+Project-URL: Homepage, https://github.com/AxG-AI-Exchange-GenAI-Initiative/AIXAgentDeploymentService
+Project-URL: Repository, https://github.com/AxG-AI-Exchange-GenAI-Initiative/AIXAgentDeploymentService
+Project-URL: Issues, https://github.com/AxG-AI-Exchange-GenAI-Initiative/AIXAgentDeploymentService/issues
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 Requires-Dist: requests>=2.28
@@ -13,10 +16,15 @@ Requires-Dist: google-auth>=2.20
 Requires-Dist: google-cloud-storage>=2.16
 Requires-Dist: keyring>=24.0
 Requires-Dist: keyrings.google-artifactregistry-auth>=1.1
+Requires-Dist: google-cloud-aiplatform>=1.50.0
+Requires-Dist: protobuf<7.0.0,>=4.21
+Requires-Dist: click>=8.0
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: build; extra == "dev"
 Requires-Dist: twine; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
 Dynamic: author
 Dynamic: requires-python
 

reasoning_deployment_service-0.3.2/pyproject.toml

@@ -0,0 +1,48 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "reasoning-deployment-service"
+version = "0.3.2"
+description = "Deployment helper for Vertex AI Reasoning Engines & Agent Spaces"
+readme = "README.md"
+license = { text = "Apache-2.0" }
+requires-python = ">=3.9"
+
+authors = [
+  { name = "Sergio Estrada", email = "sergio.estrada@accenture.com" }
+]
+
+dependencies = [
+  "requests>=2.28",
+  "python-dotenv>=1.0",
+  "google-auth>=2.20",
+  "google-cloud-storage>=2.16",
+  "keyring>=24.0",
+  "keyrings.google-artifactregistry-auth>=1.1",
+  "google-cloud-aiplatform>=1.50.0",         # Vertex AI SDK
+  "protobuf>=4.21,<7.0.0",                   # pinned for compat
+  "click>=8.0"                               # nice for CLI menus if you expand later
+]
+
+[project.optional-dependencies]
+dev = [
+  "pytest",
+  "build",
+  "twine",
+  "black",
+  "ruff"
+]
+
+[project.urls]
+Homepage = "https://github.com/AxG-AI-Exchange-GenAI-Initiative/AIXAgentDeploymentService"
+Repository = "https://github.com/AxG-AI-Exchange-GenAI-Initiative/AIXAgentDeploymentService"
+Issues = "https://github.com/AxG-AI-Exchange-GenAI-Initiative/AIXAgentDeploymentService/issues"
+
+[project.scripts]
+reasoning-deploy = "reasoning_deployment_service.runner:Runner.run"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["reasoning_deployment_service*"]

reasoning_deployment_service-0.3.2/reasoning_deployment_service/__init__.py

@@ -0,0 +1,25 @@
+# Initialize the reasoning_deployment_service package
+
+from .reasoning_deployment_service import ReasoningEngineDeploymentService
+
+# Import submodules for optional use
+try:
+    from . import cli_editor
+    from . import gui_editor
+    CLI_AVAILABLE = True
+    GUI_AVAILABLE = True
+except ImportError as e:
+    print(f"Warning: Some optional components not available: {e}")
+    CLI_AVAILABLE = False
+    GUI_AVAILABLE = False
+
+# Make main classes available for direct import
+__all__ = [
+    'ReasoningEngineDeploymentService',
+]
+
+# Add optional components if available
+if CLI_AVAILABLE:
+    __all__.append('cli_editor')
+if GUI_AVAILABLE:
+    __all__.append('gui_editor')

reasoning_deployment_service-0.3.2/reasoning_deployment_service/gui_editor/requirements_minimal.txt

@@ -0,0 +1,54 @@
+# Bare minimum requirements for Agent Space Deployment Service
+# Core functionality dependencies only
+
+# Google Cloud & Vertex AI (CORE REQUIREMENT)
+google-cloud-aiplatform==1.108.0
+vertexai==1.43.0
+google-auth==2.40.3
+google-auth-oauthlib==1.2.2
+google-api-python-client==2.178.0
+
+# Environment management (CORE REQUIREMENT)
+python-dotenv==1.1.1
+
+# HTTP requests (CORE REQUIREMENT)
+requests==2.32.4
+
+# Google Cloud dependencies (CORE REQUIREMENT)
+google-api-core==2.25.1
+googleapis-common-protos==1.70.0
+grpcio==1.74.0
+protobuf==6.31.1
+
+# Authentication dependencies (CORE REQUIREMENT)  
+google-auth-httplib2==0.2.0
+cachetools==5.5.2
+pyasn1==0.6.1
+pyasn1_modules==0.4.2
+rsa==4.9.1
+
+# Core Python utilities (CORE REQUIREMENT)
+certifi==2025.8.3
+urllib3==2.5.0
+six==1.17.0
+
+# OPTIONAL: For enhanced functionality
+# Uncomment if you need these features:
+
+# For MCP server support:
+# mcp==1.12.4
+
+# For FastAPI endpoints (if you plan to add web interface):
+# fastapi==0.116.1
+# uvicorn==0.35.0
+# pydantic==2.11.7
+
+# For document processing in agents:
+# PyPDF2==3.0.1
+# python-docx==1.2.0
+
+# For web scraping/HTTP in agents:
+# httpx==0.28.1
+
+# For YAML configuration:
+# PyYAML==6.0.2

reasoning_deployment_service-0.3.2/reasoning_deployment_service/gui_editor/run_program.sh

@@ -0,0 +1,55 @@
+#!/usr/bin/env bash
+set -e
+
+VENV_DIR=".venv"
+
+# Detect Python executable
+if command -v python3 &>/dev/null; then
+    PYTHON=python3
+elif command -v python &>/dev/null; then
+    PYTHON=python
+else
+    echo "❌ Python is not installed. Please install Python 3.9+."
+    exit 1
+fi
+
+# Create venv if missing
+if [ ! -d "$VENV_DIR" ]; then
+    echo "🔧 Creating virtual environment..."
+    $PYTHON -m venv "$VENV_DIR"
+fi
+
+# Activate venv (POSIX)
+if [ -f "$VENV_DIR/bin/activate" ]; then
+    source "$VENV_DIR/bin/activate"
+# Activate venv (Windows Git Bash or Cygwin)
+elif [ -f "$VENV_DIR/Scripts/activate" ]; then
+    source "$VENV_DIR/Scripts/activate"
+else
+    echo "❌ Could not find venv activation script."
+    exit 1
+fi
+
+# Install Tkinter if on Linux
+if [[ "$OSTYPE" == "linux-gnu"* ]]; then
+    echo "🖼  Installing Tkinter for Linux..."
+    if command -v apt-get &>/dev/null; then
+        sudo apt-get update && sudo apt-get install -y python3-tk
+    elif command -v dnf &>/dev/null; then
+        sudo dnf install -y python3-tkinter
+    elif command -v pacman &>/dev/null; then
+        sudo pacman -S --noconfirm tk
+    else
+        echo "⚠️ Could not determine package manager. Install python3-tk manually."
+    fi
+fi
+
+# Install dependencies
+echo "📦 Installing dependencies..."
+pip3 install --upgrade pip
+# Install the reasoning deployment service with GUI extras
+pip3 install "reasoning-deployment-service[gui]"
+
+# Run your app
+echo "🚀 Starting app..."
+$PYTHON main.py

reasoning_deployment_service-0.3.2/reasoning_deployment_service/reasoning_deployment_service.py

@@ -0,0 +1,687 @@
+import json, os, subprocess, yaml, sys
+import urllib.parse, vertexai, google.auth
+import requests as _requests
+from typing import Tuple
+from pathlib import Path
+from dotenv import load_dotenv
+from vertexai import agent_engines
+from google.adk.agents import BaseAgent
+from google.auth.transport.requests import Request as GoogleAuthRequest
+from google.api_core.exceptions import NotFound
+import logging
+from datetime import datetime
+
+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()
+        load_dotenv(dotenv_path=".env.agent", override=True)
+
+        self.root_agent = root_agent
+        self.deployment_env = deployment_environment
+        self.attempt_to_use_existing_auth = False
+        
+        self._staging_bucket = None
+        self._project_id = None
+        self._project_number = None
+        self._project_location = None
+        self._oauth_client_id = None
+        self._oauth_client_secret = None
+        self._agent_space_engine = None
+
+
+        self._load_agent_definition()
+        self._load_deployment_environment_variables(deployment_environment=deployment_environment)
+        self._check_requirements_file_present()
+         
+        self._http = _requests.Session()
+        self._http.headers.update({"Content-Type": "application/json"})
+        self.authenticate()
+
+    def _setup_logging(self):
+        os.makedirs("logs", exist_ok=True)
+        
+        # Setup logger
+        self.logger = logging.getLogger("ReasoningEngineDeployment")
+        self.logger.setLevel(logging.DEBUG)
+        self.logger.propagate = False  
+
+        if not self.logger.handlers:
+            self.log_filename = f"logs/deployment_{datetime.now().strftime('%Y%m%d_%H%M%S')}.log"
+            file_handler = logging.FileHandler(self.log_filename)
+            file_handler.setLevel(logging.DEBUG)
+            
+            console_handler = logging.StreamHandler()
+            console_handler.setLevel(logging.INFO)
+            
+            file_formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+            file_handler.setFormatter(file_formatter)
+            
+            console_formatter = logging.Formatter('%(message)s')
+            console_handler.setFormatter(console_formatter)
+            
+            self.logger.addHandler(file_handler)
+            self.logger.addHandler(console_handler)
+        
+        logging.getLogger('google').setLevel(logging.ERROR)
+        logging.getLogger('urllib3').setLevel(logging.ERROR)
+        logging.getLogger('requests').setLevel(logging.ERROR)
+
+    def _log_record_file(self, level="ERROR"):
+        """Log the current deployment record file contents to file only."""
+        try:
+            record = self._read_engine_deployment_record()
+            if record:
+                record_str = json.dumps(record, indent=2)
+                # Write directly to the same log file without terminal output
+                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 - {level} - Current deployment record:\n{record_str}\n")
+        except Exception as e:
+            self.logger.error(f"Failed to read deployment record: {e}")
+
+    def error(self, message: str):
+        self.logger.error(f"[DEPLOYMENT SERVICE: CRITICAL FAILURE]: {message}")
+        self._log_record_file("ERROR")
+
+    def warning(self, message: str):
+        self.logger.warning(f"[DEPLOYMENT SERVICE: WARNING]: {message}")
+
+    def info(self, message: str):
+        self.logger.info(f"[DEPLOYMENT SERVICE: INFO]: {message}")
+
+    def _check_required_files_exist(self):
+        end_run = False
+        if not os.path.exists(".env.agent"):
+            self.warning("Creating .env.agent file ... done")
+            self._generate_env_agent()
+            end_run = True
+        
+        if not os.path.exists("aix_agent.yaml"):
+            self._generate_example_yaml_config()
+            self.warning("Creating aix_agent.yaml file ... done")
+            end_run = True
+
+        self.warning("Please fill in the required values in the generated files and re-run the deployment.")
+
+        if end_run:
+            sys.exit(1)
+
+    def _access_token(self) -> str:
+        """Live: fetch ADC access token; raises if not available."""
+        creds, _ = google.auth.default(scopes=["https://www.googleapis.com/auth/cloud-platform"])
+
+        if not creds.valid or (creds.expired and creds.refresh_token):
+            creds.refresh(GoogleAuthRequest())
+        return creds.token
+
+    def authenticate(self) -> bool:
+        try:
+            _ = self._access_token()
+            return True
+        except Exception:
+            pass
+
+        try:
+            subprocess.run(["gcloud", "--version"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, check=True)
+        except Exception:
+            raise RuntimeError("'gcloud' not found on PATH. Install Google Cloud SDK.")
+
+        proc = subprocess.run(
+            ["gcloud", "auth", "application-default", "login"],
+            stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True
+        )
+        if proc.returncode != 0:
+            raise RuntimeError(f"ADC auth failed:\n{proc.stdout}")
+
+        _ = self._access_token()
+        return True
+
+    def _get_deployment_record_path(self):
+        return Path("deployments") / f"{self.deployment_env}_{self._reasoning_engine_name}.json"
+
+    def _read_engine_deployment_record(self) -> dict:
+        file_path = self._get_deployment_record_path()
+        if os.path.exists(file_path):
+            with open(file_path, "r") as f:
+                return json.load(f) or {}
+        return {}
+
+    def _write_engine_deployment(self, json_payload: dict):
+        if not os.path.exists("deployments"):
+            self.info(f"Creating deployments directory")
+            os.makedirs("deployments")
+
+        file_path = self._get_deployment_record_path()
+        read_engine_deployment = self._read_engine_deployment_record()
+
+        if read_engine_deployment:
+            read_engine_deployment.update(json_payload)
+
+            with open(file_path, "w") as f:
+                json.dump(read_engine_deployment, f, sort_keys=False)
+
+                self.info(f"Successfully wrote entry {json_payload} to {file_path}")
+            return
+        
+        with open(file_path, "w") as f:
+            self.info(f"Successfully created {file_path}")
+            json.dump(json_payload, f, sort_keys=False)
+            self.info(f"Successfully wrote entry {json_payload} to {file_path}")
+
+    def _generate_env_agent(self, path: str | Path = ".env.agent", overwrite: bool = False) -> Path:
+        """
+        Generate a .env.agent template file with all deployment profile
+        and app environment variables, left empty for later filling.
+        """
+        path = Path(path)
+        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=
+
+    REASONING_DEPLOYMENT_VERSION=0.2.4
+    #===================== **** DEPLOYMENT PROFILE **** =====================
+
+
+    #===================== **** YOUR APP ENV VARIABLES **** =====================
+    DEVELOPER=
+    #===================== **** YOUR APP ENV VARIABLES **** =====================
+    """
+
+        path.write_text(template.strip() + "\n")
+        
+        # Also update .gitignore to include logs
+        self._update_gitignore()
+        
+        return path
+
+    def _update_gitignore(self):
+        """Add common ignore patterns to .gitignore."""
+        gitignore_path = Path(".gitignore")
+        patterns_to_add = [
+            "logs/",
+            "deployments/", 
+            ".env.agent",
+            "__pycache__/",
+            "*.pyc",
+            ".venv/",
+            "deploy_env/"
+        ]
+        
+        existing_patterns = set()
+        if gitignore_path.exists():
+            existing_patterns = set(gitignore_path.read_text().splitlines())
+        
+        new_patterns = [p for p in patterns_to_add if p not in existing_patterns]
+        
+        if new_patterns:
+            with open(gitignore_path, "a") as f:
+                if existing_patterns:  # Add newline if file has content
+                    f.write("\n")
+                f.write("# Added by ReasoningEngineDeploymentService\n")
+                for pattern in new_patterns:
+                    f.write(f"{pattern}\n")
+
+    def _generate_example_yaml_config(self, path: str | Path = "aix_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:
+            raise FileExistsError(f"{path} already exists. Pass overwrite=True to replace it.")
+
+        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",
+                },
+                "agent_folder": "your_agent_folder",
+                "auth": {
+                    "oauth_authorization_id": "test_auth_three",
+                },
+                "environment_variables": [
+                    "DEVELOPER",
+                ],
+            }
+        }
+
+        path.write_text(yaml.safe_dump(config, sort_keys=False))
+        return path
+ 
+    def _load_agent_definition(self):
+        try:
+            with open("aix_agent.yaml", "r") as f:
+                config = yaml.safe_load(f)
+        except FileNotFoundError:
+            self._generate_example_yaml_config()
+            self.error("Could not locate a valid aix_agent.yaml file. Generating example file in your directory.")
+            sys.exit(1)
+
+        try:
+            config = config['defaults']
+            scopes = config['scopes']
+            metadata = config['metadata']
+            agent_folder = config['agent_folder']
+            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
+            self._agent_folder = agent_folder
+            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 []
+        except KeyError as e:
+             raise RuntimeError(f"Missing required key in aix_agent.yaml: {e}")
+        
+    def _load_deployment_environment_variables(self, deployment_environment: str):
+        required_vars = ['PROJECT_ID', 'PROJECT_NUMBER', 'PROJECT_LOCATION', 'STAGING_BUCKET', 'AGENT_SPACE_ENGINE']
+        
+        for var in required_vars:
+            env_var = f"{deployment_environment}_{var}"
+            if env_var not in os.environ or not os.getenv(env_var):
+                raise RuntimeError(f"Missing required environment variable: {env_var}.")
+            
+            setattr(self, f"_{var.lower()}", os.getenv(env_var))
+
+        if self._authorization_id:
+            required_auth_vars = ['OAUTH_CLIENT_ID', 'OAUTH_CLIENT_SECRET']
+
+            for var in required_auth_vars:
+                env_var = f"{deployment_environment}_{var}"
+                if env_var not in os.environ or not os.getenv(env_var):
+                    raise RuntimeError(f"Missing required environment variable: {env_var}")
+
+                setattr(self, f"_{var.lower()}", os.getenv(env_var))
+
+    def _check_requirements_file_present(self):
+        if not os.path.exists("requirements.txt"):
+            raise RuntimeError("Missing requirements.txt file")
+        
+    def _load_requirements(self):
+        with open("requirements.txt", "r") as f:
+            return [line.strip() for line in f if line.strip()]
+
+    def create_reasoning_engine(self):
+        vertexai.init(
+            project=self._project_id,
+            location=self._project_location,
+            staging_bucket=self._staging_bucket,
+        )
+
+        creation = agent_engines.create(
+            self.root_agent,
+            display_name=self._reasoning_engine_name,
+            description=self._reasoning_engine_description,
+            requirements=self._load_requirements(),
+            env_vars=self._environment_variables,
+            extra_packages=[f"./{self._agent_folder}"]
+        )
+
+        if creation:
+            self.info(f"Reasoning engine created successfully: {creation.resource_name}")
+
+        json_payload = {"reasoning_engine_id": creation.resource_name}
+        self._write_engine_deployment(json_payload)
+
+    def update_reasoning_engine(self, reasoning_engine_id):
+        vertexai.init(
+            project=self._project_id,
+            location=self._project_location,
+            staging_bucket=self._staging_bucket,
+        )
+
+        try:
+            updating = agent_engines.update(
+                resource_name=reasoning_engine_id,
+                agent_engine=self.root_agent,
+                display_name=self._reasoning_engine_name,
+                description=self._reasoning_engine_description,
+                requirements=self._load_requirements(),
+                env_vars=self._environment_variables,
+                extra_packages=[f"./{self._agent_folder}"]
+            )
+        except NotFound as e:
+            self.error(f"Reasoning engine {reasoning_engine_id} not found. Cannot update.")
+            self.error(f"Please inspect using CLI, GUI or GCP Interface to identify root cause.")
+            self.error(f"Deleting deployment record {self._get_deployment_record_path()} to allow re-creation.")
+            self.error(f"System reported: {e}")
+            os.remove(self._get_deployment_record_path())
+            sys.exit(1)
+            
+
+        if updating:
+            self.info(f"Reasoning engine updated successfully: {updating.resource_name}")
+
+        self._write_engine_deployment({'reasoning_engine_id': updating.resource_name})
+
+    def _get_agent_space_payload(self, reasoning_engine: str) -> Tuple[dict, dict]:
+        headers = {
+            "Authorization": f"Bearer {self._access_token()}",
+            "Content-Type": "application/json",
+            "X-Goog-User-Project": self._project_number,
+        }
+        payload = {
+            "displayName": self._agent_space_name,
+            "description": self._agent_space_description,
+            "adk_agent_definition": {
+                "tool_settings": {"tool_description": self._agent_space_tool_description},
+                "provisioned_reasoning_engine": {"reasoning_engine": reasoning_engine},
+            },
+        }
+
+        if self._authorization_id:
+            payload["adk_agent_definition"]["authorizations"] = [
+                f"projects/{self._project_number}/locations/global/authorizations/{self._authorization_id}"
+            ]
+
+        return headers, payload
+    
+    def _get_agent_space_agent_url_new(self):
+        return (f"{DISCOVERY_ENGINE_URL}/projects/{self._project_number}/locations/global/collections/default_collection/"
+               f"engines/{self._agent_space_engine}/assistants/default_assistant/agents")
+
+    def _deploy_to_agent_space(self):
+        get_reasoning_engine = self._read_engine_deployment_record()
+
+        if not get_reasoning_engine or not get_reasoning_engine.get("reasoning_engine_id"):
+            return ("failed", "Reasoning engine required before deploy", None)
+        
+        if get_reasoning_engine.get("agent_space_id"):
+            self.warning("Agent space already exists; skipping creation.")
+            
+            return
+
+        headers, payload = self._get_agent_space_payload(get_reasoning_engine["reasoning_engine_id"])
+        url = self._get_agent_space_agent_url_new()
+        r = self._http.post(url, headers=headers, json=payload, timeout=90)
+
+        if r.status_code < 400:
+            self.info("Agent space deployed successfully.")
+            if self.attempt_to_use_existing_auth:
+                self.warning("Using existing authorization.")
+                self._write_engine_deployment({"authorization_id": self._authorization_id, 'scopes': self._required_scopes})
+            self._write_engine_deployment({"agent_space_id": r.json().get("name")})
+        else:
+            # 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 - Agent space deployment failed with status {r.status_code} {r.reason}\n")
+                f.write(f"{timestamp} - ReasoningEngineDeployment - ERROR - URL: {r.url}\n")
+                f.write(f"{timestamp} - ReasoningEngineDeployment - ERROR - Response: {r.text}\n")
+                if r.headers.get('content-type', '').startswith('application/json'):
+                    try:
+                        error_json = r.json()
+                        f.write(f"{timestamp} - ReasoningEngineDeployment - ERROR - Error details: {json.dumps(error_json, indent=2)}\n")
+                    except:
+                        pass
+            
+            # Terminal message - simple
+            self.error("Agent space deployment failed")
+            # This will also log the record file
+
+    def _update_in_agent_space(self):
+        get_reasoning_engine = self._read_engine_deployment_record()
+
+        if not get_reasoning_engine or not get_reasoning_engine.get("reasoning_engine_id"):
+            return ("failed", "Reasoning engine required before update", None)
+        
+        if not get_reasoning_engine.get("agent_space_id"):
+            self.warning("No agent space to update; skipping.")
+            return
+
+        headers, payload = self._get_agent_space_payload(get_reasoning_engine["reasoning_engine_id"])
+        url = f'{DISCOVERY_ENGINE_URL}/' + get_reasoning_engine.get("agent_space_id")
+        r = self._http.patch(url, headers=headers, json=payload, timeout=90)
+
+        if r.status_code < 400:
+            if self.attempt_to_use_existing_auth:
+                self.info("Using existing authorization.")
+                self._write_engine_deployment({"authorization_id": self._authorization_id, 'scopes': self._required_scopes})
+            self.info("Agent space updated successfully.")
+            return True
+        else:
+            # 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 update agent space with status {r.status_code} {r.reason}\n")
+                f.write(f"{timestamp} - ReasoningEngineDeployment - ERROR - URL: {r.url}\n")
+                f.write(f"{timestamp} - ReasoningEngineDeployment - ERROR - Response: {r.text}\n")
+                if r.headers.get('content-type', '').startswith('application/json'):
+                    try:
+                        error_json = r.json()
+                        f.write(f"{timestamp} - ReasoningEngineDeployment - ERROR - Error details: {json.dumps(error_json, indent=2)}\n")
+                    except:
+                        pass
+            
+            # Terminal message - simple
+            self.error("Failed to update agent space")
+            # This will also log the record file
+            return False
+
+    def _build_authorization_uri(self, client_id: str, scopes: list[str]) -> str:
+        base = "https://accounts.google.com/o/oauth2/auth"
+        query = {
+            "response_type": "code",
+            "client_id": client_id,
+            "scope": " ".join(scopes),
+            "access_type": "offline",
+            "prompt": "consent",
+        }
+        return f"{base}?{urllib.parse.urlencode(query)}"
+
+    def _create_authorization(self) -> dict:
+        read_authorizations = self._read_engine_deployment_record()
+
+        if not self._authorization_id:
+            self.warning("No authorization ID provided; skipping authorization creation.")
+
+            return
+
+        if read_authorizations and (read_authorizations.get("authorization_id") and read_authorizations.get("authorization_id") == self._authorization_id):
+            self.warning("Authorization already exists; skipping creation.")
+
+            return
+        
+        discovery_engine_url = "https://discoveryengine.googleapis.com/v1alpha"
+        headers = {
+            "Authorization": f"Bearer {self._access_token()}",
+            "Content-Type": "application/json",
+            "X-Goog-User-Project": self._project_number,
+        }
+
+        client_id = self._oauth_client_id or "your-client-id"
+        client_secret = self._oauth_client_secret or "your-client-secret"
+
+        payload = {
+            "name": f"projects/{self._project_number}/locations/global/authorizations/{self._authorization_id}",
+            "serverSideOauth2": {
+                "clientId": client_id,
+                "clientSecret": client_secret,
+                "authorizationUri": self._build_authorization_uri(client_id, self._required_scopes),
+                "tokenUri": "https://oauth2.googleapis.com/token",
+            },
+        }
+
+        url = (
+            f"{discovery_engine_url}/projects/{self._project_id}/locations/global/authorizations"
+            f"?authorizationId={self._authorization_id}"
+        )
+
+        r = self._http.post(url, headers=headers, json=payload, timeout=60)
+
+        if r.status_code < 400:
+            payload = {"authorization_id": self._authorization_id, 'scopes': self._required_scopes}
+            self._write_engine_deployment(payload)
+            return True
+        
+        if r.status_code == 409:
+            self.warning("Authorization conflict detected; attempting to use existing authorization.")
+            self.logger.debug(f"Conflict response: {r.text}")
+            self.attempt_to_use_existing_auth = True
+        elif r.status_code >= 400:
+            # 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 - Authorization creation failed with status {r.status_code} {r.reason}\n")
+                f.write(f"{timestamp} - ReasoningEngineDeployment - ERROR - URL: {r.url}\n")
+                f.write(f"{timestamp} - ReasoningEngineDeployment - ERROR - Response: {r.text}\n")
+                if r.headers.get('content-type', '').startswith('application/json'):
+                    try:
+                        error_json = r.json()
+                        f.write(f"{timestamp} - ReasoningEngineDeployment - ERROR - Error details: {json.dumps(error_json, indent=2)}\n")
+                    except:
+                        pass
+            
+            # Terminal message - simple
+            self.error("Authorization creation failed")
+            # This will also log the record file
+
+
+    def _drop_authorization(self) -> bool:
+        temp_auth = self._authorization_id
+        self._authorization_id = None
+        self._update_in_agent_space()
+        self._authorization_id = temp_auth
+
+        read_record = self._read_engine_deployment_record()
+        read_record.pop("authorization_id", None)
+
+        file_path = self._get_deployment_record_path()
+
+        with open(file_path, "w") as f:
+            json.dump(read_record, f, sort_keys=False, indent=2)
+
+        self.info("Authorization dropped successfully")
+
+        return True
+    
+    def _delete_authorization(self):
+        if not self._authorization_id:
+            self.warning("No authorization ID provided; skipping deletion.")
+            return
+
+        discovery_engine_url = "https://discoveryengine.googleapis.com/v1alpha"
+        headers = {
+            "Authorization": f"Bearer {self._access_token()}",
+            "Content-Type": "application/json",
+            "X-Goog-User-Project": self._project_number,
+        }
+
+        url = (
+            f"{discovery_engine_url}/projects/{self._project_id}/locations/global/authorizations"
+            f"?authorizationId={self._authorization_id}"
+        )
+
+        r = self._http.delete(url, headers=headers, timeout=60)
+
+        if r.status_code < 400:
+            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")
+            f.write(f"{timestamp} - ReasoningEngineDeployment - ERROR - URL: {r.url}\n")
+            f.write(f"{timestamp} - ReasoningEngineDeployment - ERROR - Response: {r.text}\n")
+            if r.headers.get('content-type', '').startswith('application/json'):
+                try:
+                    error_json = r.json()
+                    f.write(f"{timestamp} - ReasoningEngineDeployment - ERROR - Error details: {json.dumps(error_json, indent=2)}\n")
+                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):
+        read_engine = self._read_engine_deployment_record()
+
+    
+        if not skip_engine_step:
+            if read_engine and read_engine.get("reasoning_engine_id"):
+                self.info("Updating reasoning engine ... ")
+                self.update_reasoning_engine(read_engine["reasoning_engine_id"])
+                self.info("Done!")
+            else:
+                self.create_reasoning_engine()
+        else:
+            if not read_engine or not read_engine.get("reasoning_engine_id"):
+                self.warning("Skipping reasoning engine step, but no existing engine found in record.")
+                self.warning("Please ensure the reasoning engine exists before proceeding. Ending Agent Space update attempt")
+
+                sys.exit(1)
+
+        needs_auth_reset = False
+
+        if not read_engine or read_engine.get("authorization_id") != self._authorization_id:
+            self.warning("Detected change in authorization ID")
+            needs_auth_reset = True
+
+        elif read_engine and read_engine.get("scopes") != self._required_scopes:
+            self.warning("Detected change in authorization scopes")
+            needs_auth_reset = True
+
+        if needs_auth_reset:
+            self.info("Resetting authorization...")
+            self._drop_authorization()
+            self._create_authorization()
+
+        if not read_engine or (read_engine and not read_engine.get("agent_space_id")):
+            self.info("Creating agent space ... ")
+            self._deploy_to_agent_space()
+        else:
+            self._update_in_agent_space()

reasoning_deployment_service-0.3.2/reasoning_deployment_service/runner.py

@@ -0,0 +1,122 @@
+import os
+import sys
+import subprocess
+from pathlib import Path
+from dotenv import load_dotenv
+import argparse
+
+from reasoning_deployment_service import (
+    ReasoningEngineDeploymentService,
+)
+from reasoning_deployment_service.gui_editor import GUIEditor
+from reasoning_deployment_service.cli_editor import CLIRunner
+
+
+class Runner:
+    @staticmethod
+    def run():
+        parser = argparse.ArgumentParser(description="Reasoning Engine Deployment Runner")
+        parser.add_argument(
+            "--mode",
+            choices=["create", "auth", "cli", "gui", "populate_files"],
+            required=False,
+            help="Operation mode to run",
+        )
+        args = parser.parse_args()
+
+        # --- Ensure .gitignore covers junk ---
+        Runner._ensure_gitignore()
+
+        # --- Ensure your_agent_import.py exists ---
+        if not Path("your_agent_import.py").exists():
+            Runner._create_agent_import()
+
+        # --- Always ensure venv exists & is up to date ---
+        venv_python = Runner._ensure_venv()
+
+        # --- Install dependencies into venv ---
+        Runner._install_deps(venv_python)
+
+        # --- If no config files, restrict menu ---
+        if not Path(".env.agent").exists() or not Path("aix_agent.yaml").exists():
+            print("Missing .env.agent or aix_agent.yaml.")
+            print("Options:\n 5) Generate placeholder config\n q) Quit")
+            choice = input("Enter choice: ").strip()
+            if choice == "5":
+                subprocess.check_call([venv_python, "deploy.py", "--mode", "populate_files"])
+            else:
+                sys.exit(0)
+            return
+
+        # --- Dispatch based on mode or menu ---
+        if args.mode:
+            Runner._dispatch(args.mode, venv_python)
+        else:
+            Runner._menu(venv_python)
+
+    # ------------------ HELPERS ------------------
+
+    @staticmethod
+    def _ensure_gitignore():
+        gi = Path(".gitignore")
+        if not gi.exists():
+            gi.write_text("# Generated by Runner\n")
+        patterns = [".venv", ".venv_deploy", "venv", "__pycache__", "deploy_env", "your_agent_import.py"]
+        content = gi.read_text().splitlines()
+        for p in patterns:
+            if p not in content:
+                with gi.open("a") as f:
+                    f.write(f"{p}\n")
+
+    @staticmethod
+    def _create_agent_import():
+        agent_dir = input("Enter the directory where your root_agent (agent.py) lives: ").strip()
+        if not Path(agent_dir, "agent.py").exists():
+            print(f"Error: {agent_dir}/agent.py not found")
+            sys.exit(1)
+        import_path = agent_dir.replace("/", ".") + ".agent"
+        Path("your_agent_import.py").write_text(f"from {import_path} import root_agent\n")
+        print(f"Created your_agent_import.py pointing to {agent_dir}/agent.py")
+
+    @staticmethod
+    def _ensure_venv():
+        venv_dir = Path("deploy_env")
+        if not venv_dir.exists():
+            subprocess.check_call([sys.executable, "-m", "venv", str(venv_dir)])
+            print("Created venv at ./deploy_env")
+        return str(venv_dir / "bin" / "python")
+
+    @staticmethod
+    def _install_deps(venv_python):
+        subprocess.check_call([venv_python, "-m", "pip", "install", "--upgrade", "pip"])
+        subprocess.check_call([venv_python, "-m", "pip", "install", "keyring", "keyrings.google-artifactregistry-auth"])
+        # Install reasoning-deployment-service itself (current package)
+        subprocess.check_call([venv_python, "-m", "pip", "install", "reasoning-deployment-service"])
+
+        if Path("requirements.txt").exists():
+            subprocess.check_call([venv_python, "-m", "pip", "install", "-r", "requirements.txt"])
+
+    @staticmethod
+    def _dispatch(mode, venv_python):
+        from your_agent_import import root_agent
+        svc = ReasoningEngineDeploymentService(root_agent, deployment_environment="DEV")
+
+        if mode == "create":
+            svc.one_deployment_with_everything_on_it()
+        elif mode == "auth":
+            svc.one_deployment_with_everything_on_it(skip_engine_step=True)
+        elif mode == "cli":
+            CLIRunner().run()
+        elif mode == "gui":
+            GUIEditor().run()
+        elif mode == "populate_files":
+            svc._check_required_files_exist()
+
+    @staticmethod
+    def _menu(venv_python):
+        print("Choose an operation:\n1) Create/Update\n2) Auth only\n3) CLI\n4) GUI\nq) Quit")
+        choice = input("Enter choice: ").strip()
+        mapping = {"1": "create", "2": "auth", "3": "cli", "4": "gui"}
+        if choice.lower() == "q":
+            sys.exit(0)
+        Runner._dispatch(mapping.get(choice, ""), venv_python)

{reasoning_deployment_service-0.2.9/reasoning_deployment_service → reasoning_deployment_service-0.3.2}/reasoning_deployment_service.egg-info/PKG-INFO

@@ -1,10 +1,13 @@
 Metadata-Version: 2.4
 Name: reasoning-deployment-service
-Version: 0.2.9
+Version: 0.3.2
 Summary: Deployment helper for Vertex AI Reasoning Engines & Agent Spaces
 Author: AxG-AI-Exchange-GenAI-Initiative
 Author-email: Sergio Estrada <sergio.estrada@accenture.com>
 License: Apache-2.0
+Project-URL: Homepage, https://github.com/AxG-AI-Exchange-GenAI-Initiative/AIXAgentDeploymentService
+Project-URL: Repository, https://github.com/AxG-AI-Exchange-GenAI-Initiative/AIXAgentDeploymentService
+Project-URL: Issues, https://github.com/AxG-AI-Exchange-GenAI-Initiative/AIXAgentDeploymentService/issues
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 Requires-Dist: requests>=2.28
@@ -13,10 +16,15 @@ Requires-Dist: google-auth>=2.20
 Requires-Dist: google-cloud-storage>=2.16
 Requires-Dist: keyring>=24.0
 Requires-Dist: keyrings.google-artifactregistry-auth>=1.1
+Requires-Dist: google-cloud-aiplatform>=1.50.0
+Requires-Dist: protobuf<7.0.0,>=4.21
+Requires-Dist: click>=8.0
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: build; extra == "dev"
 Requires-Dist: twine; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
 Dynamic: author
 Dynamic: requires-python
 

{reasoning_deployment_service-0.2.9/reasoning_deployment_service → reasoning_deployment_service-0.3.2}/reasoning_deployment_service.egg-info/SOURCES.txt

@@ -1,6 +1,15 @@
 README.md
 pyproject.toml
 setup.py
+reasoning_deployment_service/__init__.py
+reasoning_deployment_service/reasoning_deployment_service.py
+reasoning_deployment_service/runner.py
+reasoning_deployment_service.egg-info/PKG-INFO
+reasoning_deployment_service.egg-info/SOURCES.txt
+reasoning_deployment_service.egg-info/dependency_links.txt
+reasoning_deployment_service.egg-info/entry_points.txt
+reasoning_deployment_service.egg-info/requires.txt
+reasoning_deployment_service.egg-info/top_level.txt
 reasoning_deployment_service/cli_editor/__init__.py
 reasoning_deployment_service/cli_editor/api_client.py
 reasoning_deployment_service/cli_editor/cli_runner.py
@@ -9,6 +18,8 @@ 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/main.py
+reasoning_deployment_service/gui_editor/requirements_minimal.txt
+reasoning_deployment_service/gui_editor/run_program.sh
 reasoning_deployment_service/gui_editor/src/__init__.py
 reasoning_deployment_service/gui_editor/src/core/__init__.py
 reasoning_deployment_service/gui_editor/src/core/api_client.py
@@ -20,9 +31,4 @@ reasoning_deployment_service/gui_editor/src/ui/agent_space_view.py
 reasoning_deployment_service/gui_editor/src/ui/authorization_view.py
 reasoning_deployment_service/gui_editor/src/ui/reasoning_engine_view.py
 reasoning_deployment_service/gui_editor/src/ui/reasoning_engines_view.py
-reasoning_deployment_service/gui_editor/src/ui/ui_components.py
-reasoning_deployment_service/reasoning_deployment_service.egg-info/PKG-INFO
-reasoning_deployment_service/reasoning_deployment_service.egg-info/SOURCES.txt
-reasoning_deployment_service/reasoning_deployment_service.egg-info/dependency_links.txt
-reasoning_deployment_service/reasoning_deployment_service.egg-info/requires.txt
-reasoning_deployment_service/reasoning_deployment_service.egg-info/top_level.txt
+reasoning_deployment_service/gui_editor/src/ui/ui_components.py

reasoning_deployment_service-0.3.2/reasoning_deployment_service.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+reasoning-deploy = reasoning_deployment_service.runner:Runner.run

{reasoning_deployment_service-0.2.9/reasoning_deployment_service → reasoning_deployment_service-0.3.2}/reasoning_deployment_service.egg-info/requires.txt

@@ -4,8 +4,13 @@ google-auth>=2.20
 google-cloud-storage>=2.16
 keyring>=24.0
 keyrings.google-artifactregistry-auth>=1.1
+google-cloud-aiplatform>=1.50.0
+protobuf<7.0.0,>=4.21
+click>=8.0
 
 [dev]
 pytest
 build
 twine
+black
+ruff

reasoning_deployment_service-0.3.2/reasoning_deployment_service.egg-info/top_level.txt

@@ -0,0 +1 @@
+reasoning_deployment_service

reasoning_deployment_service-0.2.9/pyproject.toml

@@ -1,36 +0,0 @@
-[build-system]
-requires = ["setuptools>=61.0", "wheel"]
-build-backend = "setuptools.build_meta"
-
-[project]
-name = "reasoning-deployment-service"
-version = "0.2.9"
-description = "Deployment helper for Vertex AI Reasoning Engines & Agent Spaces"
-readme = "README.md"
-license = { text = "Apache-2.0" }
-requires-python = ">=3.9"
-
-authors = [
-  { name = "Sergio Estrada", email = "sergio.estrada@accenture.com" }
-]
-
-dependencies = [
-  "requests>=2.28",
-  "python-dotenv>=1.0",
-  "google-auth>=2.20",
-  "google-cloud-storage>=2.16",
-  "keyring>=24.0",
-  "keyrings.google-artifactregistry-auth>=1.1"
-]
-
-[project.optional-dependencies]
-dev = [
-  "pytest",
-  "build",
-  "twine",
-]
-
-[project.urls]
-
-[tool.setuptools.packages.find]
-where = ["reasoning_deployment_service"]

reasoning_deployment_service-0.2.9/reasoning_deployment_service/reasoning_deployment_service.egg-info/top_level.txt

@@ -1,2 +0,0 @@
-cli_editor
-gui_editor