reasoning-deployment-service 0.3.4__py3-none-any.whl → 0.3.6__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."""

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/runner.py

@@ -1,6 +1,7 @@
-import sys
+import sys, os
 import argparse
 from pathlib import Path
+from dotenv import load_dotenv
 from reasoning_deployment_service import ReasoningEngineDeploymentService
 from reasoning_deployment_service.gui_editor import GUIEditor
 from reasoning_deployment_service.cli_editor import CLIRunner
@@ -27,7 +28,7 @@ class Runner:
         # --- Load root_agent dynamically ---
         root_agent = Runner._load_agent(args.agent_path)
 
-        # --- Check env config ---
+        # --- Require config files ---
         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")
@@ -37,6 +38,11 @@ class Runner:
                 svc._check_required_files_exist()
             sys.exit(0)
 
+        # --- Sanity check env vars ---
+        if not Runner._check_proper_configuration():
+            print("Error: Missing required environment variables in .env.agent")
+            sys.exit(1)
+
         # --- Run mode or menu ---
         if args.mode:
             Runner._dispatch(args.mode, root_agent)
@@ -61,11 +67,12 @@ class Runner:
 
     @staticmethod
     def _load_agent(agent_path_arg: str):
-        """Load root_agent either from --agent-path or your_agent_import.py."""
+        """Load root_agent either from --agent-path or your_agent_import.py, bootstrapping if needed."""
         sys.path.insert(0, str(Path.cwd()))  # ensure project root on sys.path
+        import importlib
 
+        # Case 1: explicit --agent-path (power user / devs only)
         if agent_path_arg:
-            import importlib
             if ":" in agent_path_arg:
                 module_path, attr = agent_path_arg.split(":")
             else:
@@ -73,12 +80,43 @@ class Runner:
             module = importlib.import_module(module_path)
             return getattr(module, attr)
 
-        if Path("your_agent_import.py").exists():
+        # Case 2: shim already exists
+        shim = Path("your_agent_import.py")
+        if shim.exists():
             from your_agent_import import root_agent
             return root_agent
 
-        print("Error: No agent path provided and your_agent_import.py not found.")
-        sys.exit(1)
+        # Case 3: bootstrap (first run)
+        print("No agent path configured. Let's set it up once.")
+        agent_dir = input("Enter the directory where your root_agent (agent.py) lives: ").strip()
+        agent_dir = agent_dir.rstrip("/")
+
+        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"
+        shim.write_text(f"from {import_path} import root_agent\n")
+        print(f"Created {shim} pointing to {agent_dir}/agent.py")
+
+        from your_agent_import import root_agent
+        return root_agent
+
+
+    @staticmethod
+    def _check_proper_configuration():
+        """Ensure required environment variables are set in .env.agent."""
+        required_vars = ['PROJECT_ID', 'PROJECT_NUMBER', 'PROJECT_LOCATION', 'AGENT_SPACE_ENGINE']
+        load_dotenv(dotenv_path=".env.agent")
+
+        ok = True
+        for var in required_vars:
+            dev_var = f"DEV_{var}"
+            prod_var = f"PROD_{var}"
+            if not (Path(".env.agent").exists() and (os.getenv(dev_var) or os.getenv(prod_var))):
+                print(f"Missing: {dev_var} or {prod_var}")
+                ok = False
+        return ok
 
     @staticmethod
     def _dispatch(mode, root_agent):

reasoning_deployment_service-0.3.6.dist-info/METADATA

@@ -0,0 +1,211 @@
+Metadata-Version: 2.4
+Name: reasoning-deployment-service
+Version: 0.3.6
+Summary: Deployment helper for Vertex AI Reasoning Engines & Agent Spaces
+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.9
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.28
+Requires-Dist: python-dotenv>=1.0
+Requires-Dist: google-auth>=2.20
+Requires-Dist: google-cloud-storage>=2.16
+Requires-Dist: google-cloud-aiplatform[adk,agent-engines]>=1.88.0
+Requires-Dist: protobuf<7.0.0,>=4.21
+Requires-Dist: keyring>=24.0
+Requires-Dist: keyrings.google-artifactregistry-auth>=1.1
+Requires-Dist: PyYAML>=6.0
+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"
+
+# Reasoning Deployment Service
+
+Helper package for deploying Vertex AI Reasoning Engines and Agent Spaces
+
+---
+
+## 📦 Installation
+
+Install the package directly from PyPI (version 0.3.5):
+
+```bash
+pip install reasoning-deployment-service==0.3.5
+```
+
+---
+
+## 🚀 First Run
+
+Run the CLI tool with no arguments:
+
+```bash
+reasoning-deploy
+```
+
+### What happens
+
+- You will see a list of available modes:
+
+```
+Choose an operation:
+1) Create/Update
+2) Auth only
+3) CLI
+4) GUI
+q) Quit
+```
+
+- If required files are missing, usage will be limited until you bootstrap the project
+- The tool will guide you to create the starter files:
+  - `your_agent_import.py` (shim pointing to your agent folder)
+  - `.env.agent` (environment and project settings)
+  - `aix_agent.yaml` (agent engine and space definition)
+
+Once these are in place, all modes will be fully available
+
+⚠️ Important: You must be running inside the same virtual environment where you installed reasoning-deployment-service
+
+---
+
+## ⚙️ Required Project Structure
+
+Your project must have the following at minimum:
+
+```
+my_project/
+├── requirements.txt       # pinned dependencies
+├── .env.agent             # environment and project config
+├── aix_agent.yaml         # engine and agent space definition
+├── my_agent/              # your agent folder
+│   └── agent.py           # defines root_agent
+```
+
+---
+
+### ✅ requirements.txt
+
+This file must be in your project root and contain all dependencies
+
+Example:
+
+```text
+google-adk==1.0.0
+google-cloud-aiplatform[adk,agent_engines]>=1.88.0
+google-generativeai>=0.7.0
+pydantic>=2.0.0
+python-dotenv>=1.0.0
+python-docx>=1.1.0
+google-api-python-client>=2.100.0
+google-auth>=2.25.0
+google-auth-httplib2>=0.2.0
+google-auth-oauthlib>=1.2.0
+absl-py>=2.0.0
+PyPDF2>=3.0.0
+deprecated>=1.2.14
+reasoning-deployment-service==0.3.5
+```
+
+Install with:
+
+```bash
+pip install -r requirements.txt
+```
+
+---
+
+### ✅ my_agent/agent.py
+
+Inside your agent folder (for example `my_agent`) you must define a variable called `root_agent`
+
+Example:
+
+```python
+from google.adk.agents import LlmAgent
+
+root_agent = LlmAgent(
+    name="my_agent",
+    model="gemini-2.5-flash",
+    description="My reasoning agent",
+    instruction="You do not do a whole lot yet"
+)
+```
+
+This `root_agent` instance is what gets deployed  
+It can be an `LlmAgent`, `Agent`, or any derived class
+
+---
+
+### ✅ .env.agent
+
+Environment specific config for DEV and PROD
+
+Example:
+
+```env
+DEV_PROJECT_ID=your-dev-project-id
+DEV_PROJECT_NUMBER=123456789012
+DEV_PROJECT_LOCATION=us-central1
+DEV_STAGING_BUCKET=gs://your-dev-staging-bucket
+DEV_AGENT_SPACE_ENGINE=your-dev-agentspace-engine
+DEV_OAUTH_CLIENT_ID=your-dev-oauth-client-id.apps.googleusercontent.com
+DEV_OAUTH_CLIENT_SECRET=your-dev-oauth-client-secret
+
+PROD_PROJECT_ID=
+PROD_PROJECT_NUMBER=
+PROD_PROJECT_LOCATION=
+PROD_STAGING_BUCKET=
+PROD_AGENT_SPACE_ENGINE=
+PROD_OAUTH_CLIENT_ID=
+PROD_OAUTH_CLIENT_SECRET=
+
+REASONING_DEPLOYMENT_VERSION=0.3.5
+
+DEVELOPER=your.name
+```
+
+---
+
+### ✅ aix_agent.yaml
+
+Example starter file:
+
+```yaml
+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: My Engine
+    agent_space_name: My Agent Space
+    agent_space_description: Example Agent Space
+    agent_space_tool_description: Example Tool
+  agent_folder: my_agent
+  auth:
+    oauth_authorization_id: test_auth
+  environment_variables:
+    - DEVELOPER
+```
+
+---
+
+## 🛠 Potential Issues
+
+- If you cannot run `reasoning-deploy`, try deleting your venv and making a new one
+- If you see a message saying you can only install on user site-packages, you will most likely need a fresh venv and new requirements install
+- Always ensure you are running `reasoning-deploy` inside the venv where it was installed
+
+---
+
+## ⚠️ Experimental Notice
+
+This tool is still experimental  
+If it takes longer than 20 to 30 minutes to set up, please go back to what already works for you and send logs and feedback to the development team

{reasoning_deployment_service-0.3.4.dist-info → reasoning_deployment_service-0.3.6.dist-info}/RECORD

@@ -1,28 +1,29 @@
 reasoning_deployment_service/__init__.py,sha256=xDuKt9gGviQiTV6vXBdkBvygnlAOIrwnUjVaMGZy0L4,670
 reasoning_deployment_service/reasoning_deployment_service.py,sha256=0QHU2IqqojwFI2wPJ0izrskiHiwBfxdBEB9I_YxYbSA,29133
-reasoning_deployment_service/runner.py,sha256=Vv8LYj4E8TQ0vmXoQXpe4Sm0Og-C1OD6JSFd6i6JWkk,3874
+reasoning_deployment_service/runner.py,sha256=e2Uu4DdRWuCHQI4H1x8Q6s1eMbBNoWFkBTnAaspK1tk,5413
 reasoning_deployment_service/cli_editor/__init__.py,sha256=bN8NPkw8riB92pj2lAwJZuEMOQIO_RRuge0ehnJTW1I,118
-reasoning_deployment_service/cli_editor/api_client.py,sha256=PUXPWUslFOksKMrcKjJSK_gVJkTI0bO_bqtCEYeM85g,27897
-reasoning_deployment_service/cli_editor/cli_runner.py,sha256=w8jv2ep6TiYfpc_KnlvDOJ9hsCSuZcix4Rv4GQcZO4g,15729
+reasoning_deployment_service/cli_editor/api_client.py,sha256=Kzx5iYp0MmowggrSmPLE7I2kt1-8xvdGBAgde9a1gCY,33681
+reasoning_deployment_service/cli_editor/cli_runner.py,sha256=1KkHtgAhVZ7VHQj7o76JibLHnr7NMUB-tieDX_KrAcY,18239
 reasoning_deployment_service/cli_editor/config.py,sha256=lZ8Ng007NVdN1n5spJ0OFC72TOPFWKvPRxa9eKE-FDY,3573
 reasoning_deployment_service/cli_editor/google_deps.py,sha256=PhGwdKEC96GdlFHkQrtSJrg_-w1JoUPes3zvaz22rd0,771
 reasoning_deployment_service/cli_editor/reasoning_engine_creator.py,sha256=6QC8Y9yZAT8SYNkT_R00g_SSOYuwEkIxAN9lBG3br2k,19564
 reasoning_deployment_service/gui_editor/__init__.py,sha256=e5e88iNTk1GC243DRsQFi5E7PqMaT2SXmqOez9FbYzo,128
+reasoning_deployment_service/gui_editor/agent_checkbox_list.py,sha256=ElxFqSgT3iUqDv2U9eR4eV-MfLUHqOXbDz6DqEEevOk,1783
 reasoning_deployment_service/gui_editor/main.py,sha256=4UzgGUga_xIYIWRVo-80PzhJ1Dlou8PaUXoRiLcLhp8,10914
 reasoning_deployment_service/gui_editor/src/__init__.py,sha256=q4YBECQGHtHV_TF4MyL36ElWe6tdVgmoNchN1lQU7z4,25
 reasoning_deployment_service/gui_editor/src/core/__init__.py,sha256=kH-6PxUQ-uVn79ihXN3eLyv_oFhReVsVz-f-kEK_qUo,46
-reasoning_deployment_service/gui_editor/src/core/api_client.py,sha256=rGyFKRyBY_MjRsnWxVI1IX1WAYTEfM1V5X3l1iR8GaI,26845
+reasoning_deployment_service/gui_editor/src/core/api_client.py,sha256=-AWhwKxTUM_-s5gOyTECDzEBakJSj3ik4DwXbNL4bDM,30772
 reasoning_deployment_service/gui_editor/src/core/config.py,sha256=nQT7biTArZl4zsbSZuSD_G7CU7xTJ1bZ4VPfQkxbpX4,1817
 reasoning_deployment_service/gui_editor/src/core/google_deps.py,sha256=7mMSqtvclJewEBeb-0MevZ7FE0ZEOGHyXh5V73bhpRk,495
 reasoning_deployment_service/gui_editor/src/core/reasoning_engine_creator.py,sha256=6QC8Y9yZAT8SYNkT_R00g_SSOYuwEkIxAN9lBG3br2k,19564
 reasoning_deployment_service/gui_editor/src/ui/__init__.py,sha256=262ZiXO6Luk8vZnhCIoYxOtGiny0bXK-BTKjxUNBx-w,43
-reasoning_deployment_service/gui_editor/src/ui/agent_space_view.py,sha256=TV2f0_pkw5JCQRWjVPuS-iW92toW41kPJk-pR1C0oqQ,12471
-reasoning_deployment_service/gui_editor/src/ui/authorization_view.py,sha256=uiyN411qYe7V2pnPRNdvxRkOifI-aXFI6j2De2RZp1M,10956
+reasoning_deployment_service/gui_editor/src/ui/agent_space_view.py,sha256=UTUMRFEzpUuRONl3K7bsCPRjZ_hiVE1s9fTsIHTZtSs,17130
+reasoning_deployment_service/gui_editor/src/ui/authorization_view.py,sha256=BoNcGRFZ-Rb2pnOAAZxraP7yDdbwMJNvIrBrjMc_hbw,16970
 reasoning_deployment_service/gui_editor/src/ui/reasoning_engine_view.py,sha256=tCvSPEf4dW0NRdAqfs3yT5Pa873gYeLzCMMIt2r2T4o,14644
 reasoning_deployment_service/gui_editor/src/ui/reasoning_engines_view.py,sha256=IRjFlBbY98usAZa0roOonjvWQOsF6NBW4bBg_k8KnKI,7860
 reasoning_deployment_service/gui_editor/src/ui/ui_components.py,sha256=HdQHy-oSZ3GobQ3FNdH7y_w3ANbFiuf2rMoflAmff0A,55366
-reasoning_deployment_service-0.3.4.dist-info/METADATA,sha256=SGmPBaX-F-ReutdQgR8vi4fdLKjI9W-r6O2nDrQpTbU,4991
-reasoning_deployment_service-0.3.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-reasoning_deployment_service-0.3.4.dist-info/entry_points.txt,sha256=onGKjR5ONTtRv3aqEtK863iw9Ty1kLcjfZlsplkRZrA,84
-reasoning_deployment_service-0.3.4.dist-info/top_level.txt,sha256=GKuQS1xHUYLZbatw9DmcYdBxxLhWhhGkV4FmFxgKdp0,29
-reasoning_deployment_service-0.3.4.dist-info/RECORD,,
+reasoning_deployment_service-0.3.6.dist-info/METADATA,sha256=yn2cDwndN4bqUfVOt_kixzD3LvUD5z0XslS5-gtu7GY,5314
+reasoning_deployment_service-0.3.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+reasoning_deployment_service-0.3.6.dist-info/entry_points.txt,sha256=onGKjR5ONTtRv3aqEtK863iw9Ty1kLcjfZlsplkRZrA,84
+reasoning_deployment_service-0.3.6.dist-info/top_level.txt,sha256=GKuQS1xHUYLZbatw9DmcYdBxxLhWhhGkV4FmFxgKdp0,29
+reasoning_deployment_service-0.3.6.dist-info/RECORD,,

reasoning_deployment_service-0.3.4.dist-info/METADATA

@@ -1,183 +0,0 @@
-Metadata-Version: 2.4
-Name: reasoning-deployment-service
-Version: 0.3.4
-Summary: Deployment helper for Vertex AI Reasoning Engines & Agent Spaces
-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.9
-Description-Content-Type: text/markdown
-Requires-Dist: requests>=2.28
-Requires-Dist: python-dotenv>=1.0
-Requires-Dist: google-auth>=2.20
-Requires-Dist: google-cloud-storage>=2.16
-Requires-Dist: google-cloud-aiplatform[adk,agent-engines]>=1.88.0
-Requires-Dist: protobuf<7.0.0,>=4.21
-Requires-Dist: keyring>=24.0
-Requires-Dist: keyrings.google-artifactregistry-auth>=1.1
-Requires-Dist: PyYAML>=6.0
-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"
-
-# Reasoning Deployment Service
-
-A comprehensive service for deploying reasoning agents with CLI and GUI editors.
-
-## Installation
-
-### Basic Installation (Core deployment service only)
-
-```bash
-pip install reasoning-deployment-service
-```
-
-### Installation with GUI Editor
-
-```bash
-pip install "reasoning-deployment-service[gui]"
-```
-
-### Installation with CLI Editor
-
-```bash
-pip install "reasoning-deployment-service[cli]"
-```
-
-### Full Installation (Everything)
-
-```bash
-pip install "reasoning-deployment-service[full]"
-```
-
-## Quick Start
-
-### Using the Deploy Script (Recommended)
-
-The easiest way to get started is using the provided deploy script:
-
-```bash
-# Download and run the deploy script
-curl -O https://raw.githubusercontent.com/your-org/AIXAgentDeploymentService/main/deploy.sh
-chmod +x deploy.sh
-./deploy.sh
-```
-
-The deploy script will:
-
-- Set up a virtual environment
-- Install all necessary dependencies
-- Create a `deploy.py` file configured for your agent
-- Run the deployment
-
-## Manual Usage
-
-### Core Deployment Service
-
-The main deployment service for reasoning engines:
-
-```python
-from reasoning_deployment_service import ReasoningEngineDeploymentService
-from google.adk.agents import BaseAgent
-
-# Your agent implementation
-class MyAgent(BaseAgent):
-    # ... your agent implementation
-
-# Deploy using the service
-agent = MyAgent()
-deployment_service = ReasoningEngineDeploymentService(
-    root_agent=agent,
-    deployment_environment="DEV"  # or "PROD"
-)
-
-# Deploy everything
-deployment_service.one_deployment_with_everything_on_it()
-```
-
-### CLI Editor (Optional)
-
-For command-line management of reasoning engines and agent spaces:
-
-```python
-from reasoning_deployment_service.cli_editor import CLIRunner
-
-# Start the CLI interface
-cli = CLIRunner()
-cli.run()
-```
-
-### GUI Editor (Optional)
-
-For graphical management interface:
-
-```python
-from reasoning_deployment_service.gui_editor import GUIEditor
-
-# Start the GUI application
-app = GUIEditor()
-app.mainloop()
-```
-
-## Configuration
-
-Create a `.env` file with your deployment environment variables:
-
-```bash
-# Development Profile
-DEV_PROJECT_ID=your-project-id
-DEV_PROJECT_NUMBER=your-project-number
-DEV_PROJECT_LOCATION=us-central1
-DEV_STAGING_BUCKET=gs://your-staging-bucket
-DEV_AGENT_SPACE_ENGINE=your-agent-space-engine
-DEV_OAUTH_CLIENT_ID=your-oauth-client-id
-DEV_OAUTH_CLIENT_SECRET=your-oauth-client-secret
-
-# Production Profile
-PROD_PROJECT_ID=your-prod-project-id
-PROD_PROJECT_NUMBER=your-prod-project-number
-# ... etc
-```
-
-Create an `aix_agent.yaml` file with your agent metadata:
-
-```yaml
-defaults:
-  scopes:
-    - "https://www.googleapis.com/auth/cloud-platform"
-  metadata:
-    reasoning_engine_name: "my-reasoning-engine"
-    reasoning_engine_description: "My custom reasoning engine"
-    agent_space_name: "my-agent-space"
-    agent_space_description: "My agent space"
-    agent_space_tool_description: "Tool description"
-  auth:
-    oauth_authorization_id: "my-auth-id"
-  environment_variables:
-    - "CUSTOM_VAR=value"
-```
-
-## Dependency Management
-
-Dependencies are now centrally managed in `setup.py`:
-
-- **Core dependencies**: Installed automatically with the base package
-- **GUI dependencies**: Install with `[gui]` extra for tkinter-based interface
-- **CLI dependencies**: Install with `[cli]` extra (currently no additional deps)
-- **Full dependencies**: Install with `[full]` extra for complete functionality
-
-## Modular Usage
-
-Each component can be used independently:
-
-- **Core Service**: Just use `ReasoningEngineDeploymentService` for programmatic deployment
-- **CLI Editor**: Add `cli_editor` for command-line management
-- **GUI Editor**: Add `gui_editor` for graphical interface
-
-The package is designed so users can import only what they need and instantiate the components they want to use.