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

reasoning_deployment_service/cli_editor/api_client.py

@@ -30,6 +30,27 @@ EXCLUDES = [
 
 
 class ApiClient:
+    def get_authorization_info(self, auth_id: str) -> dict:
+        """Get details for a specific authorization by ID."""
+        if not self.is_live:
+            # Return mock info for testing
+            return {
+                "id": auth_id,
+                "scopes": [
+                    "https://www.googleapis.com/auth/cloud-platform",
+                    "https://www.googleapis.com/auth/userinfo.email"
+                ],
+                "status": "mock"
+            }
+        headers = {
+            "Authorization": f"Bearer {self._access_token()}",
+            "Content-Type": "application/json",
+            "X-Goog-User-Project": self.project_id,
+        }
+        url = f"https://discoveryengine.googleapis.com/v1alpha/projects/{self.project_id}/locations/global/authorizations/{auth_id}"
+        r = self._http.get(url, headers=headers, timeout=60)
+        r.raise_for_status()
+        return r.json()
     """
     Single responsibility: hold configuration & credentials and expose API calls.
     This class has both 'live' and 'mock' modes; the public surface is identical.
@@ -559,6 +580,63 @@ class ApiClient:
         else:
             return ("failed", f"{r.status_code} {r.text}")
 
+    def get_authorization_info(self, auth_id: str) -> Dict[str, Any]:
+        """Get details for a specific authorization by ID."""
+        if not self.is_live:
+            # Return mock info for testing
+            return {
+                "id": auth_id,
+                "scopes": [
+                    "https://www.googleapis.com/auth/cloud-platform",
+                    "https://www.googleapis.com/auth/userinfo.email"
+                ],
+                "status": "mock"
+            }
+        headers = {
+            "Authorization": f"Bearer {self._access_token()}",
+            "Content-Type": "application/json",
+            "X-Goog-User-Project": self.project_id,
+        }
+        url = f"{BASE_URL}/projects/{self.project_id}/locations/global/authorizations/{auth_id}"
+        r = self._http.get(url, headers=headers, timeout=60)
+        r.raise_for_status()
+        return r.json()
+
+    def update_authorization_scopes(self, auth_id: str, scopes: list) -> Dict[str, Any]:
+        """Patch the scopes for a specific authorization by ID, updating the authorizationUri as well."""
+        if not self.is_live:
+            return {
+                "id": auth_id,
+                "scopes": scopes,
+                "status": "mock-patched"
+            }
+        headers = {
+            "Authorization": f"Bearer {self._access_token()}",
+            "Content-Type": "application/json",
+            "X-Goog-User-Project": self.project_number,
+        }
+        url = f"{BASE_URL}/projects/{self.project_number}/locations/global/authorizations/{auth_id}?update_mask=server_side_oauth2.authorization_uri"
+        scopes_str = "%20".join(scopes)
+        authorization_uri = (
+            "https://accounts.google.com/o/oauth2/auth"
+            "?response_type=code"
+            f"&client_id={self.oauth_client_id or 'your-client-id'}"
+            f"&scope={scopes_str}"
+            "&access_type=offline&prompt=consent"
+        )
+
+        payload = {
+            "serverSideOauth2": {
+                "authorizationUri": authorization_uri
+            }
+        }
+        r = self._http.patch(url, headers=headers, json=payload, timeout=60)
+        print(r.status_code)
+        print(r.text)
+        print(r.json())
+        r.raise_for_status()
+        return r.json()
+
     def _ensure_authorization(self, auth_name: str) -> Tuple[bool, str]:
         if not self.is_live:
             time.sleep(0.02)
@@ -663,4 +741,60 @@ class ApiClient:
         }
         self._profile["agent_space_agent_id"] = full
         self._save_profile()
-        return ("created", "Deployed", item)
+        return ("created", "Deployed", item)
+
+    def remove_authorization_from_agent(self, agent_id: str) -> Dict[str, Any]:
+        """Remove all authorizations from an agent by PATCHing with an empty authorizations list."""
+        if not self.is_live:
+            return {
+                "id": agent_id,
+                "authorizations": [],
+                "status": "mock-removed"
+            }
+        headers = {
+            "Authorization": f"Bearer {self._access_token()}",
+            "Content-Type": "application/json",
+            "X-Goog-User-Project": self.project_id,
+        }
+        url = f"{BASE_URL}/projects/{self.project_id}/locations/global/assistants/default_assistant/agents/{agent_id}"
+        payload = {"authorizations": []}
+        r = self._http.patch(url, headers=headers, json=payload, timeout=60)
+        r.raise_for_status()
+        return r.json()
+
+    def drop_agent_authorizations(self, agent_id: str) -> Dict[str, Any]:
+        """Drop all authorizations for an agent space agent by PATCHing with all attributes except authorizations (fully omitted)."""
+        if not self.is_live:
+            return {
+                "id": agent_id,
+                "authorizations": [],
+                "status": "mock-dropped"
+            }
+        headers = {
+            "Authorization": f"Bearer {self._access_token()}",
+            "Content-Type": "application/json",
+            "X-Goog-User-Project": self.project_id,
+        }
+        url = (f"{BASE_URL}/projects/{self.project_id}/locations/global/collections/default_collection/"
+               f"engines/{self.engine_name}/assistants/default_assistant/agents/{agent_id}")
+        # GET the current agent definition
+        get_resp = self._http.get(url, headers=headers, timeout=60)
+        get_resp.raise_for_status()
+        agent_data = get_resp.json()
+        # Build PATCH payload: copy all attributes except authorizations
+        patch_payload = {}
+        for key in ["displayName", "description"]:
+            if key in agent_data:
+                patch_payload[key] = agent_data[key]
+        adk_def = agent_data.get("adkAgentDefinition", {})
+        patch_adk_def = {}
+        # Copy all adkAgentDefinition fields except 'authorizations'
+        for k, v in adk_def.items():
+            if k != "authorizations":
+                patch_adk_def[k] = v
+        if patch_adk_def:
+            patch_payload["adk_agent_definition"] = patch_adk_def
+        # PATCH with the new payload
+        patch_resp = self._http.patch(url, headers=headers, json=patch_payload, timeout=60)
+        patch_resp.raise_for_status()
+        return patch_resp.json()

reasoning_deployment_service/cli_editor/cli_runner.py

@@ -43,6 +43,14 @@ class CLIRunner:
         subparsers.add_parser("list-authorizations", help="List all authorizations in the project")
         delete_auth_parser = subparsers.add_parser("delete-authorization", help="Delete an authorization by list position")
         delete_auth_parser.add_argument("position", help="Position number from the list (e.g., 1, 2, 3...)")
+        # New commands
+        get_auth_info_parser = subparsers.add_parser("get-authorization-info", help="Get details for a specific authorization")
+        get_auth_info_parser.add_argument("auth_id", help="Authorization ID")
+        update_auth_scopes_parser = subparsers.add_parser("update-authorization-scopes", help="Update scopes for a specific authorization")
+        update_auth_scopes_parser.add_argument("auth_id", help="Authorization ID")
+        update_auth_scopes_parser.add_argument("scopes", help="Comma-separated list of scopes")
+        drop_agent_auth_parser = subparsers.add_parser("drop-agent-authorizations", help="Drop all authorizations for an agent space agent")
+        drop_agent_auth_parser.add_argument("agent_id", help="Agent ID")
 
     def run(self):
         # Load environment variables from .env.agent file (same as GUI editor)
@@ -113,12 +121,20 @@ class CLIRunner:
                     self._list_authorizations()
                 elif args.command == "delete-authorization":
                     self._delete_authorization(args.position)
+                elif args.command == "get-authorization-info":
+                    self._get_authorization_info(args.auth_id)
+                elif args.command == "update-authorization-scopes":
+                    scopes = [s.strip() for s in args.scopes.split(",") if s.strip()]
+                    self._update_authorization_scopes(args.auth_id, scopes)
+                elif args.command == "drop-agent-authorizations":
+                    self._drop_agent_authorizations(args.agent_id)
                 else:
                     self.parser.print_help()
             except SystemExit:
                 # Catch argparse's SystemExit to prevent CLI from closing
                 print("Invalid command. Please try again.")
             except Exception as e:
+                raise
                 print(f"An error occurred: {e}")
         print("\nAvailable commands:")
         print("  list-engines            List all reasoning engines in the project")
@@ -339,5 +355,35 @@ class CLIRunner:
         except Exception as e:
             print(f"❌ Error deleting authorization: {e}")
 
+    def _get_authorization_info(self, auth_id):
+        """Get details for a specific authorization."""
+        print(f"🔍 Getting info for authorization: {auth_id}")
+        try:
+            info = self.api_client.get_authorization_info(auth_id)
+            from pprint import pprint
+            pprint(info)
+        except Exception as e:
+            print(f"❌ Error getting authorization info: {e}")
+
+    def _update_authorization_scopes(self, auth_id, scopes):
+        """Update scopes for a specific authorization."""
+        print(f"🔧 Updating scopes for authorization: {auth_id}")
+        print(f"New scopcdscsdes: {scopes}")
+
+        result = self.api_client.update_authorization_scopes(auth_id, scopes)
+        from pprint import pprint
+        pprint(result)
+
+    def _drop_agent_authorizations(self, agent_id):
+        """Drop all authorizations for an agent space agent."""
+        print(f"🗑️ Dropping all authorizations for agent: {agent_id}")
+        try:
+            result = self.api_client.drop_agent_authorizations(agent_id)
+            from pprint import pprint
+            pprint(result)
+        except Exception as e:
+            raise
+            print(f"❌ Error dropping agent authorizations: {e}")
+
 if __name__ == "__main__":
     CLIRunner().run()

reasoning_deployment_service/gui_editor/agent_checkbox_list.py

@@ -0,0 +1,48 @@
+"""
+Scrollable agent list with checkboxes for mass selection and actions.
+"""
+import tkinter as tk
+from tkinter import ttk, messagebox
+
+class AgentCheckboxList(tk.Frame):
+    def __init__(self, master, agents, on_mass_action):
+        super().__init__(master)
+        self.agents = agents
+        self.on_mass_action = on_mass_action
+        self.vars = {}
+        self._setup_ui()
+
+    def _setup_ui(self):
+        canvas = tk.Canvas(self)
+        scrollbar = ttk.Scrollbar(self, orient="vertical", command=canvas.yview)
+        self.scrollable_frame = tk.Frame(canvas)
+
+        self.scrollable_frame.bind(
+            "<Configure>",
+            lambda e: canvas.configure(scrollregion=canvas.bbox("all"))
+        )
+
+        canvas.create_window((0, 0), window=self.scrollable_frame, anchor="nw")
+        canvas.configure(yscrollcommand=scrollbar.set, height=300)
+
+        canvas.pack(side="left", fill="both", expand=True)
+        scrollbar.pack(side="right", fill="y")
+
+        for agent in self.agents:
+            var = tk.BooleanVar()
+            self.vars[agent["id"]] = var
+            cb = tk.Checkbutton(self.scrollable_frame, text=f"{agent.get('display_name', agent['id'])}", variable=var)
+            cb.pack(anchor="w", padx=4, pady=2)
+
+        self.action_btn = ttk.Button(self, text="Drop Authorizations for Checked Agents", command=self._do_mass_action)
+        self.action_btn.pack(fill="x", pady=8)
+
+    def get_checked_agent_ids(self):
+        return [aid for aid, var in self.vars.items() if var.get()]
+
+    def _do_mass_action(self):
+        checked = self.get_checked_agent_ids()
+        if not checked:
+            messagebox.showinfo("No agents selected", "Please check agents to drop authorizations.")
+            return
+        self.on_mass_action(checked)

reasoning_deployment_service/gui_editor/src/core/api_client.py

@@ -25,6 +25,94 @@ EXCLUDES = [
 
 
 class ApiClient:
+    def drop_agent_authorizations(self, agent_id: str) -> dict:
+        """Drop all authorizations for an agent space agent by PATCHing with all attributes except authorizations (fully omitted)."""
+        if not self.is_live:
+            return {
+                "id": agent_id,
+                "authorizations": [],
+                "status": "mock-dropped"
+            }
+        headers = {
+            "Authorization": f"Bearer {self._access_token()}",
+            "Content-Type": "application/json",
+            "X-Goog-User-Project": self.project_id,
+        }
+        url = (f"{BASE_URL}/projects/{self.project_id}/locations/global/collections/default_collection/"
+               f"engines/{self.engine_name}/assistants/default_assistant/agents/{agent_id}")
+        # GET the current agent definition
+        get_resp = self._http.get(url, headers=headers, timeout=60)
+        get_resp.raise_for_status()
+        agent_data = get_resp.json()
+        # Build PATCH payload: copy all attributes except authorizations
+        patch_payload = {}
+        for key in ["displayName", "description"]:
+            if key in agent_data:
+                patch_payload[key] = agent_data[key]
+        adk_def = agent_data.get("adkAgentDefinition", {})
+        patch_adk_def = {}
+        # Copy all adkAgentDefinition fields except 'authorizations'
+        for k, v in adk_def.items():
+            if k != "authorizations":
+                patch_adk_def[k] = v
+        if patch_adk_def:
+            patch_payload["adk_agent_definition"] = patch_adk_def
+        # PATCH with the new payload
+        patch_resp = self._http.patch(url, headers=headers, json=patch_payload, timeout=60)
+        patch_resp.raise_for_status()
+        return patch_resp.json()
+    def update_authorization_scopes(self, auth_id: str, scopes: list, oauth_client_id: str) -> dict:
+        """Patch the scopes for a specific authorization by ID, updating the authorizationUri as well."""
+        if not self.is_live:
+            return {
+                "id": auth_id,
+                "scopes": scopes,
+                "status": "mock-patched"
+            }
+        import requests
+        scopes_str = " ".join(scopes)
+        authorization_uri = (
+            "https://accounts.google.com/o/oauth2/auth"
+            "?response_type=code"
+            f"&client_id={oauth_client_id}"
+            f"&scope={scopes_str}"
+            "&access_type=offline&prompt=consent"
+        )
+        payload = {
+            "serverSideOauth2": {
+                "authorizationUri": authorization_uri
+            }
+        }
+        url = f"{BASE_URL}/projects/{self.project_id}/locations/global/authorizations/{auth_id}?update_mask=server_side_oauth2.authorization_uri"
+        headers = {
+            "Authorization": f"Bearer {self._access_token()}",
+            "Content-Type": "application/json",
+            "X-Goog-User-Project": self.project_id,
+        }
+        r = self._http.patch(url, headers=headers, json=payload, timeout=60)
+        r.raise_for_status()
+        return r.json()
+    def get_authorization_info(self, auth_id: str) -> dict:
+        """Get details for a specific authorization by ID."""
+        if not self.is_live:
+            # Return mock info for testing
+            return {
+                "id": auth_id,
+                "scopes": [
+                    "https://www.googleapis.com/auth/cloud-platform",
+                    "https://www.googleapis.com/auth/userinfo.email"
+                ],
+                "status": "mock"
+            }
+        headers = {
+            "Authorization": f"Bearer {self._access_token()}",
+            "Content-Type": "application/json",
+            "X-Goog-User-Project": self.project_id,
+        }
+        url = f"{BASE_URL}/projects/{self.project_id}/locations/global/authorizations/{auth_id}"
+        r = self._http.get(url, headers=headers, timeout=60)
+        r.raise_for_status()
+        return r.json()
     """
     Single responsibility: hold configuration & credentials and expose API calls.
     This class has both 'live' and 'mock' modes; the public surface is identical.

reasoning_deployment_service/gui_editor/src/ui/agent_space_view.py

@@ -6,6 +6,7 @@ from typing import Callable
 
 from ..core.api_client import ApiClient
 from .ui_components import async_operation, StatusButton, AgentDetailsDialog, LoadingDialog
+from reasoning_deployment_service.gui_editor.agent_checkbox_list import AgentCheckboxList
 
 
 class AgentSpaceView(ttk.Frame):
@@ -34,6 +35,9 @@ class AgentSpaceView(ttk.Frame):
         self.delete_btn = StatusButton(btns, text="Delete Selected", command=self.delete_selected)
         self.delete_btn.pack(side="left", padx=8)
 
+        self.drop_auth_btn = StatusButton(btns, text="Drop Authorizations (Selected)", command=self.drop_selected_authorizations)
+        self.drop_auth_btn.pack(side="left", padx=8)
+
         self.details_btn = StatusButton(btns, text="More Agent Details", command=self.show_agent_details)
         self.details_btn.pack(side="left", padx=8)
         
@@ -80,6 +84,10 @@ class AgentSpaceView(ttk.Frame):
         self._cached_selection = None
         self._selection_is_dirty = True
         
+        # Checkbox agent list (initially empty, filled on refresh)
+        self.checkbox_list_frame = ttk.LabelFrame(self, text="Mass Select Agents (Checkboxes)")
+        self.checkbox_list_frame.pack(fill="x", padx=10, pady=8)
+        self.agent_checkbox_list = None
         # Initialize button states without triggering immediate API calls
         self._update_button_states()
 
@@ -106,29 +114,66 @@ class AgentSpaceView(ttk.Frame):
 
     def _update_button_states(self):
         """Update button states based on current conditions - IMMEDIATE, no timers."""
-        # Refresh button - always enabled if authenticated (use cached state)
         is_auth = self._get_cached_auth_state()
         self.refresh_btn.set_enabled(
             is_auth,
             "Authentication required" if not is_auth else ""
         )
-        
-        # Get selection once and cache it
         selection = self._get_selection()
         has_selection = bool(selection)
         single_selection = len(selection) == 1
-        
-        # Delete button - enabled only if agents are selected
         self.delete_btn.set_enabled(
             has_selection,
             "Select agents to delete" if not has_selection else ""
         )
-        
-        # Details button - enabled only if a single agent is selected
+        self.drop_auth_btn.set_enabled(
+            has_selection,
+            "Select agents to drop authorizations" if not has_selection else ""
+        )
         self.details_btn.set_enabled(
             single_selection,
             "Select a single agent to view details" if not single_selection else ""
         )
+    def drop_selected_authorizations(self):
+        """Drop authorizations for selected agents."""
+        selection = self._get_selection()
+        if not selection:
+            messagebox.showinfo("No selection", "Select agents to drop authorizations.")
+            return
+        count = len(selection)
+        if not messagebox.askyesno("Confirm", f"Drop authorizations for {count} agent{'s' if count != 1 else ''}?"):
+            return
+        agent_ids = []
+        for item in selection:
+            values = self.tree.item(item, "values")
+            if len(values) >= 1:
+                agent_ids.append(values[0])
+        self.status.set(f"Dropping authorizations for {count} agent{'s' if count != 1 else ''}...")
+        def callback(results):
+            if isinstance(results, Exception):
+                self.status.set(f"Error: {results}")
+                self.log(f"❌ Error dropping authorizations: {results}")
+                return
+            ok = [k for k, v in results.items() if isinstance(v, dict)]
+            bad = {k: v for k, v in results.items() if not isinstance(v, dict)}
+            if ok:
+                self.log(f"✅ Dropped authorizations for {len(ok)} agent(s): {', '.join(ok[:10])}{'…' if len(ok) > 10 else ''}")
+            for k, v in list(bad.items())[:10]:
+                self.log(f"⚠️ {k}: {v}")
+            if len(bad) > 10:
+                self.log(f"…and {len(bad)-10} more failures")
+            self.status.set(f"Done. Dropped authorizations for {len(ok)} agent(s).")
+            self._update_button_states()
+            self.refresh()
+        def mass_drop():
+            results = {}
+            for agent_id in agent_ids:
+                try:
+                    results[agent_id] = self.api.drop_agent_authorizations(agent_id)
+                except Exception as e:
+                    results[agent_id] = str(e)
+            return results
+        async_operation(mass_drop, callback=callback, ui_widget=self)
 
     def _on_selection_change(self, event=None):
         """Handle tree selection changes - IMMEDIATE update, no debouncing."""
@@ -158,7 +203,54 @@ class AgentSpaceView(ttk.Frame):
             count = len(rows)
             self.status.set(f"Loaded {count} agent{'s' if count != 1 else ''}.")
             self.log(f"✅ Loaded {count} agent space agent{'s' if count != 1 else ''}. Data keys: {len(self._agents_data)}")
+            # Update checkbox list
+            self._update_checkbox_list(list(self._agents_data.values()))
+            self._update_button_states()
+
+    def _update_checkbox_list(self, agents):
+        # Remove previous checkbox list if present
+        if self.agent_checkbox_list:
+            self.agent_checkbox_list.destroy()
+        self.agent_checkbox_list = AgentCheckboxList(
+            self.checkbox_list_frame,
+            agents,
+            self._mass_drop_authorizations_from_checkboxes
+        )
+        self.agent_checkbox_list.pack(fill="x", padx=4, pady=4)
+
+    def _mass_drop_authorizations_from_checkboxes(self, agent_ids):
+        if not agent_ids:
+            messagebox.showinfo("No agents selected", "Please check agents to drop authorizations.")
+            return
+        count = len(agent_ids)
+        if not messagebox.askyesno("Confirm", f"Drop authorizations for {count} agent{'s' if count != 1 else ''}?"):
+            return
+        self.status.set(f"Dropping authorizations for {count} agent{'s' if count != 1 else ''}...")
+        def callback(results):
+            if isinstance(results, Exception):
+                self.status.set(f"Error: {results}")
+                self.log(f"❌ Error dropping authorizations: {results}")
+                return
+            ok = [k for k, v in results.items() if isinstance(v, dict)]
+            bad = {k: v for k, v in results.items() if not isinstance(v, dict)}
+            if ok:
+                self.log(f"✅ Dropped authorizations for {len(ok)} agent(s): {', '.join(ok[:10])}{'…' if len(ok) > 10 else ''}")
+            for k, v in list(bad.items())[:10]:
+                self.log(f"⚠️ {k}: {v}")
+            if len(bad) > 10:
+                self.log(f"…and {len(bad)-10} more failures")
+            self.status.set(f"Done. Dropped authorizations for {len(ok)} agent(s).")
             self._update_button_states()
+            self.refresh()
+        def mass_drop():
+            results = {}
+            for agent_id in agent_ids:
+                try:
+                    results[agent_id] = self.api.drop_agent_authorizations(agent_id)
+                except Exception as e:
+                    results[agent_id] = str(e)
+            return results
+        async_operation(mass_drop, callback=callback, ui_widget=self)
 
     def refresh(self):
         """Refresh the agent list from the API."""