reasoning-deployment-service 0.3.5__py3-none-any.whl → 0.3.7__py3-none-any.whl

reasoning_deployment_service/gui_editor/src/ui/authorization_view.py

@@ -16,28 +16,44 @@ class AuthorizationView(ttk.Frame):
         self.api = api
         self.log = log
         self._auth_auto_loaded = False  # Track if authorizations have been auto-loaded
-        
         # Cache authentication state to avoid repeated API calls
         self._cached_auth_state = None
         self._last_auth_check = 0
         self._auth_cache_duration = 30  # 30 seconds
-        
         self._setup_ui()
 
     def _setup_ui(self):
         # Control buttons
         btns = ttk.Frame(self)
         btns.pack(fill="x", pady=(6, 4))
-        
+
         self.refresh_btn = StatusButton(btns, text="Refresh Authorizations", command=self.refresh)
         self.refresh_btn.pack(side="left", padx=4)
-        
+
         self.delete_btn = StatusButton(btns, text="Delete Selected", command=self.delete_selected)
         self.delete_btn.pack(side="left", padx=8)
-        
+
         self.status = tk.StringVar(value="Ready.")
         ttk.Label(btns, textvariable=self.status).pack(side="right")
 
+        # Update scopes UI
+        scopes_frame = ttk.LabelFrame(self, text="Update Authorization Scopes")
+        scopes_frame.pack(fill="x", padx=4, pady=4)
+        ttk.Label(scopes_frame, text="Authorization ID:").grid(row=0, column=0, sticky="w")
+        self.auth_id_entry = ttk.Entry(scopes_frame, width=30)
+        self.auth_id_entry.grid(row=0, column=1, sticky="w")
+        ttk.Label(scopes_frame, text="Scopes:").grid(row=1, column=0, sticky="nw")
+        self.scopes_var_list = []
+        self.scopes_check_frame = ttk.Frame(scopes_frame)
+        self.scopes_check_frame.grid(row=1, column=1, sticky="nw")
+        self.add_scope_btn = ttk.Button(scopes_frame, text="Add Scope", command=self._add_scope_dialog)
+        self.add_scope_btn.grid(row=2, column=1, sticky="w", pady=(2,0))
+        ttk.Label(scopes_frame, text="OAuth Client ID:").grid(row=2, column=0, sticky="w")
+        self.client_id_entry = ttk.Entry(scopes_frame, width=40)
+        self.client_id_entry.grid(row=2, column=1, sticky="w")
+        self.update_scopes_btn = ttk.Button(scopes_frame, text="Update Scopes", command=self.update_scopes)
+        self.update_scopes_btn.grid(row=3, column=0, columnspan=2, pady=4)
+
         # Info label
         info_frame = ttk.Frame(self)
         info_frame.pack(fill="x", padx=4, pady=4)
@@ -49,40 +65,94 @@ class AuthorizationView(ttk.Frame):
         wrap.pack(fill="both", expand=True)
         cols = ("id", "name")
         self.tree = ttk.Treeview(wrap, columns=cols, show="headings", selectmode="extended")
-        
+
         for c, t, w in [
             ("id", "Authorization ID", 300),
             ("name", "Full Resource Name", 600),
         ]:
             self.tree.heading(c, text=t)
             self.tree.column(c, width=w, anchor="w")
-        
+
         self.tree.pack(side="left", fill="both", expand=True)
         vsb = ttk.Scrollbar(wrap, orient="vertical", command=self.tree.yview)
         self.tree.configure(yscroll=vsb.set)
         vsb.pack(side="right", fill="y")
-        
+
         # Event bindings
         self.tree.bind("<<TreeviewSelect>>", self._on_selection_change)
         self.tree.bind("<Button-3>", self._popup)
-        
+
         # Context menu
         self.menu = tk.Menu(self, tearoff=0)
         self.menu.add_command(label="Delete", command=self.delete_selected)
-        
+
         # Debouncing for button updates
         self._update_timer = None
-        
+
         # Store full authorization data
         self._authorizations_data = {}
-        
+
         # Cache selection state to avoid redundant tree.selection() calls
         self._cached_selection = None
         self._selection_is_dirty = True
-        
+
         # Initialize button states without immediate API calls
         self._update_button_states()
 
+    def update_scopes(self):
+        """Update scopes for the given authorization."""
+        auth_id = self.auth_id_entry.get().strip()
+        scopes = [var.get().strip() for var, cb_var in self.scopes_var_list if cb_var.get() and var.get().strip()]
+        client_id = self.client_id_entry.get().strip()
+        if not auth_id or not scopes or not client_id:
+            messagebox.showwarning("Missing info", "Please fill all fields.")
+            return
+        self.status.set(f"Updating scopes for {auth_id}...")
+        def callback(result):
+            if isinstance(result, Exception):
+                self.status.set(f"Error: {result}")
+                self.log(f"❌ Error updating scopes: {result}")
+                return
+            self.status.set(f"Scopes updated for {auth_id}.")
+            self.log(f"✅ Scopes updated for {auth_id}: {result}")
+        async_operation(lambda: self.api.update_authorization_scopes(auth_id, scopes, client_id), callback=callback, ui_widget=self)
+
+    def _add_scope_dialog(self):
+        dialog = tk.Toplevel(self)
+        dialog.title("Add Scope")
+        ttk.Label(dialog, text="Enter new scope:").pack(padx=8, pady=8)
+        entry = ttk.Entry(dialog, width=50)
+        entry.pack(padx=8, pady=(0,8))
+        def on_add():
+            scope = entry.get().strip()
+            if scope:
+                self._add_scope_checkbox(scope, checked=True)
+            dialog.destroy()
+        ttk.Button(dialog, text="Add", command=on_add).pack(pady=(0,8))
+        entry.focus_set()
+        dialog.transient(self)
+        dialog.grab_set()
+        self.wait_window(dialog)
+
+    def _add_scope_checkbox(self, scope, checked=False):
+        var = tk.StringVar(value=scope)
+        cb_var = tk.BooleanVar(value=checked)
+        frame = ttk.Frame(self.scopes_check_frame)
+        cb = ttk.Checkbutton(frame, text=scope, variable=cb_var)
+        cb.pack(side="left")
+        del_btn = ttk.Button(frame, text="✕", width=2, command=lambda: self._remove_scope_checkbox(frame, var, cb_var))
+        del_btn.pack(side="left", padx=(4,0))
+        frame.pack(anchor="w", pady=1)
+        self.scopes_var_list.append((var, cb_var))
+        # Update checkbutton text if scope changes
+        def update_text(*_):
+            cb.config(text=var.get())
+        var.trace_add('write', update_text)
+
+    def _remove_scope_checkbox(self, frame, var, cb_var):
+        frame.destroy()
+        self.scopes_var_list = [(v, c) for v, c in self.scopes_var_list if v != var]
+
     def _get_cached_auth_state(self) -> bool:
         """Get authentication state with local caching to reduce API calls."""
         now = time.time()
@@ -127,6 +197,50 @@ class AuthorizationView(ttk.Frame):
         # Immediate update - no timers or delays
         self._update_button_states()
 
+        # Auto-populate update scopes fields if a single authorization is selected
+        sel = self._get_selection()
+        if len(sel) == 1:
+            item_id = sel[0]
+            auth_data = self._authorizations_data.get(item_id)
+            if auth_data:
+                self.auth_id_entry.delete(0, tk.END)
+                self.auth_id_entry.insert(0, auth_data.get("id", ""))
+                # Try to fetch scopes and client id from API if possible
+                try:
+                    info = self.api.get_authorization_info(auth_data.get("id", ""))
+                    import pprint
+                    print("[DEBUG] get_authorization_info response:")
+                    pprint.pprint(info)
+                    scopes = []
+                    sso = info.get("serverSideOauth2", {})
+                    # Prefer parsing scopes from authorizationUri if present
+                    if "authorizationUri" in sso and isinstance(sso["authorizationUri"], str):
+                        import urllib.parse
+                        parsed = urllib.parse.parse_qs(urllib.parse.urlparse(sso["authorizationUri"]).query)
+                        scope_str = parsed.get("scope", [""])[0]
+                        if scope_str:
+                            # Split scopes by space, comma, or plus, and decode each
+                            import re
+                            raw_scopes = re.split(r"[ ,+]+", scope_str)
+                            scopes = [urllib.parse.unquote_plus(s) for s in raw_scopes if s.strip()]
+                    # Fallback to scopes field if present
+                    if not scopes and "scopes" in info:
+                        scopes = info["scopes"]
+                    # Clear previous checkboxes
+                    for child in self.scopes_check_frame.winfo_children():
+                        child.destroy()
+                    self.scopes_var_list.clear()
+                    # Add one checkbox per parsed scope
+                    for scope in scopes:
+                        self._add_scope_checkbox(scope, checked=True)
+                    client_id = sso.get("clientId", "")
+                    if client_id:
+                        self.client_id_entry.delete(0, tk.END)
+                        self.client_id_entry.insert(0, client_id)
+                except Exception as e:
+                    print(f"[ERROR] Exception in _on_selection_change: {e}")
+                    pass
+
     def refresh(self):
         """Refresh the list of authorizations."""
         # Update button states immediately on click

reasoning_deployment_service/reasoning_deployment_service.py

@@ -1,15 +1,17 @@
 import json, os, subprocess, yaml, sys
 import urllib.parse, vertexai, google.auth
 import requests as _requests
-from typing import Tuple
+from typing import Dict, Optional, Tuple
 from pathlib import Path
 from dotenv import load_dotenv
 from vertexai import agent_engines
+from vertexai.agent_engines import AgentEngine
 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
+from urllib.parse import urlparse, parse_qs
 
 DISCOVERY_ENGINE_URL = "https://discoveryengine.googleapis.com/v1alpha"
 
@@ -101,9 +103,9 @@ class ReasoningEngineDeploymentService:
             self._generate_env_agent()
             end_run = True
         
-        if not os.path.exists("aix_agent.yaml"):
+        if not os.path.exists("agent.yaml"):
             self._generate_example_yaml_config()
-            self.warning("Creating aix_agent.yaml file ... done")
+            self.warning("Creating agent.yaml file ... done")
             end_run = True
 
         self.warning("Please fill in the required values in the generated files and re-run the deployment.")
@@ -246,7 +248,7 @@ class ReasoningEngineDeploymentService:
                 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:
+    def _generate_example_yaml_config(self, path: str | Path = "agent.yaml", overwrite: bool = False) -> Path:
         """
         Create an example YAML config matching the requested schema.
 
@@ -289,11 +291,11 @@ class ReasoningEngineDeploymentService:
  
     def _load_agent_definition(self):
         try:
-            with open("aix_agent.yaml", "r") as f:
+            with open("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.")
+            self.error("Could not locate a valid agent.yaml file. Generating example file in your directory.")
             sys.exit(1)
 
         try:
@@ -320,7 +322,7 @@ class ReasoningEngineDeploymentService:
             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}")
+             raise RuntimeError(f"Missing required key in 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']
@@ -684,4 +686,202 @@ class ReasoningEngineDeploymentService:
             self.info("Creating agent space ... ")
             self._deploy_to_agent_space()
         else:
-            self._update_in_agent_space()
+            self._update_in_agent_space()
+
+
+    def _ensure_vertex_inited(self):
+        """Initialize Vertex AI once and reuse to avoid repeated heavy init calls."""
+        if not self._vertex_inited:
+            vertexai.init()
+            self._vertex_inited = True
+        
+    
+    def find_engine_by_name(self, engine_name: str) -> Optional[str]:
+        engines = list(agent_engines.list(filter=f'display_name="{engine_name}"'))
+        if not engines:
+            return None
+        if len(engines) > 1:
+            raise RuntimeError(f"Multiple engines found with display_name='{engine_name}'. Use unique names/labels.")
+        eng = engines[0]
+        if not isinstance(eng, AgentEngine) or not hasattr(eng, "resource_name"):
+            raise RuntimeError("Unexpected engine object; missing AgentEngine/resource_name.")
+        return eng.resource_name
+
+        
+    def _get_headers(self) -> dict:
+        return {
+            "Authorization": f"Bearer {self._access_token()}",
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+            "X-Goog-User-Project": str(self._project_number),
+        }
+    
+    def find_authorization_by_id(self, authorization_id: str) -> Optional[str]:
+        name = f"projects/{self._project_id}/locations/global/authorizations/{authorization_id}"
+        url = f"{DISCOVERY_ENGINE_URL}/{name}"
+        r = self._http.get(url, headers=self._get_headers(), timeout=60)
+
+        if r.status_code == 404:
+            return None
+        
+        r.raise_for_status()
+        
+        return r.json().get("name", name)
+
+    def find_agent_space_agents_by_display(self, display_name: str) -> Optional[dict]:
+        base = (
+            f"{DISCOVERY_ENGINE_URL}/projects/{self._project_id}/locations/global/"
+            f"collections/default_collection/engines/{self._agent_space_engine}/"
+            f"assistants/default_assistant/agents"
+        )
+
+        headers = self._get_headers()
+        page = None
+        matches =[]
+
+        while True:
+            url = base + (f"?pageToken={page}" if page else "")
+            r = self._http.get(url, headers=headers, timeout=60)
+            r.raise_for_status()
+            data = r.json()
+
+            for a in data.get("agents", []):
+                if a.get("displayName") != display_name:
+                    continue
+                full = a.get("name", "")
+                matches.append({
+                    "id": full.split("/")[-1] if full else "",
+                    "display_name": a.get("displayName", ""),
+                    "full_name": full,
+                    "labels": a.get("labels", {}),
+                })
+
+            page = data.get("nextPageToken")
+            if not page:
+                break
+
+        if not matches:
+            return None
+        if len(matches) > 1:
+            raise RuntimeError(
+                f"Found {len(matches)} agents with displayName='{display_name}'. "
+                "Provide an ID or labels (e.g., env/app/agent) to disambiguate."
+            )
+        
+        return matches[0]
+
+
+    def one_github_deployment_to_go(self):
+        """
+        CI-friendly deploy:
+        - Engine: create or update by display_name.
+        - Authorization: create if missing; patch if scopes changed.
+        - Agent Space: create if missing; patch if found (by displayName under engine).
+        """
+        self.info("Starting GitHub deployment...")
+
+        # Ensure Vertex SDK calls have context for list/update
+        vertexai.init(
+            project=self._project_id,
+            location=self._project_location,
+            staging_bucket=self._staging_bucket,
+        )
+
+        # -----------------------------
+        # 1) Reasoning Engine (create or update)
+        # -----------------------------
+        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)
+            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:
+            want_scopes = set(self._required_scopes or [])
+            auth_full_name = self.find_authorization_by_id(self._authorization_id)
+
+            if not auth_full_name:
+                self.info(f"Authorization '{self._authorization_id}' not found. Creating...")
+                ok = self._create_authorization()
+                if not ok:
+                    self.error("Authorization creation failed.")
+                    raise RuntimeError("Authorization creation failed.")
+                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.")
+        else:
+            self.info("No authorization_id configured; skipping authorization step.")
+
+        # -----------------------------
+        # 3) Agent Space Agent (create or update by displayName under engine)
+        # -----------------------------
+        existing_agent = self.find_agent_space_agents_by_display(self._agent_space_name)
+        headers, payload = self._get_agent_space_payload(engine_rn)
+
+        if not existing_agent:
+            self.info(f"Agent Space agent '{self._agent_space_name}' not found. Creating...")
+            create_url = self._get_agent_space_agent_url_new()
+            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()
+            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}")
+            else:
+                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("GitHub deployment completed successfully.")

reasoning_deployment_service/runner.py

@@ -29,8 +29,8 @@ class Runner:
         root_agent = Runner._load_agent(args.agent_path)
 
         # --- Require config files ---
-        if not Path(".env.agent").exists() or not Path("aix_agent.yaml").exists():
-            print("Missing .env.agent or aix_agent.yaml.")
+        if not Path(".env.agent").exists() or not Path("agent.yaml").exists():
+            print("Missing .env.agent or agent.yaml.")
             print("Options:\n 5) Generate placeholder config\n q) Quit")
             choice = input("Enter choice: ").strip()
             if choice == "5":
@@ -132,6 +132,8 @@ class Runner:
             GUIEditor().run()
         elif mode == "populate_files":
             svc._check_required_files_exist()
+        elif mode == "github_deployment":
+            svc.one_github_deployment_to_go()
 
     @staticmethod
     def _menu(root_agent):