reasoning-deployment-service 0.4.0__tar.gz → 0.4.1__tar.gz

{reasoning_deployment_service-0.4.0 → reasoning_deployment_service-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reasoning-deployment-service
-Version: 0.4.0
+Version: 0.4.1
 Summary: Deployment helper for Vertex AI Reasoning Engines & Agent Spaces
 Author-email: Sergio Estrada <sergio.estrada@accenture.com>
 License: Apache-2.0

{reasoning_deployment_service-0.4.0 → reasoning_deployment_service-0.4.1}/pyproject.toml

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

{reasoning_deployment_service-0.4.0 → reasoning_deployment_service-0.4.1}/reasoning_deployment_service/reasoning_deployment_service.py

@@ -767,7 +767,6 @@ class ReasoningEngineDeploymentService:
         
         return matches[0]
 
-
     def one_github_deployment_to_go(self):
         """
         CI-friendly deploy:
@@ -777,8 +776,17 @@ class ReasoningEngineDeploymentService:
         """
         self.info("Starting GitHub deployment...")
 
+        # Config snapshot
+        self.info(
+            f"[CFG] project_id={self._project_id} project_number={self._project_number} "
+            f"location={self._project_location} engine_name={self._reasoning_engine_name} "
+            f"agent_space_engine={self._agent_space_engine} auth_id={self._authorization_id} "
+            f"scopes={self._required_scopes} staging_bucket={self._staging_bucket}"
+        )
+
         # Ensure Vertex SDK calls have context for list/update
         self._cicd_deploy = True
+        self.info(f"[INIT] vertexai.init(project={self._project_id}, location={self._project_location}, staging_bucket={self._staging_bucket})")
         vertexai.init(
             project=self._project_id,
             location=self._project_location,
@@ -788,44 +796,64 @@ class ReasoningEngineDeploymentService:
         # -----------------------------
         # 1) Reasoning Engine (create or update)
         # -----------------------------
+        self.info(f"[ENGINE] Resolving by display_name={self._reasoning_engine_name}")
         engine_rn = self.find_engine_by_name(self._reasoning_engine_name)
+        self.info(f"[ENGINE] find_engine_by_name -> {engine_rn}")
+
         if not engine_rn:
-            self.info(f"Engine '{self._reasoning_engine_name}' not found. Creating...")
+            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)
+            rec_after_create = self._read_engine_deployment_record()
+            self.info(f"[ENGINE] record after create -> {json.dumps(rec_after_create, indent=2)}")
+            engine_rn = rec_after_create.get("reasoning_engine_id") or self.find_engine_by_name(self._reasoning_engine_name)
+            self.info(f"[ENGINE] post-create resolution -> {engine_rn}")
             if not engine_rn:
-                self.error("Engine creation did not yield a resource name.")
+                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.info(f"[ENGINE] '{self._reasoning_engine_name}' exists. Updating...")
             self.update_reasoning_engine(engine_rn)
 
+        self.info(f"[ENGINE] final engine_rn={engine_rn}")
+
         # -----------------------------
         # 2) Authorization (create if missing; update scopes if changed)
         # -----------------------------
+        auth_full_name = None
         if self._authorization_id:
             want_scopes = set(self._required_scopes or [])
+            self.info(f"[AUTH] id={self._authorization_id} want_scopes={sorted(want_scopes)}")
             auth_full_name = self.find_authorization_by_id(self._authorization_id)
+            self.info(f"[AUTH] find_authorization_by_id -> {auth_full_name}")
 
             if not auth_full_name:
-                self.info(f"Authorization '{self._authorization_id}' not found. Creating...")
+                self.info(f"[AUTH] '{self._authorization_id}' not found. Creating...")
                 ok = self._create_authorization()
-                if not ok:
-                    self.error("Authorization creation failed.")
-                    raise RuntimeError("Authorization creation failed.")
+                self.info(f"[AUTH] _create_authorization -> {ok}")
                 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.")
+                self.info(f"[AUTH] post-create resolve -> {auth_full_name}")
+                if not ok or not auth_full_name:
+                    self.error("[AUTH] Creation failed or did not resolve.")
+                    raise RuntimeError("Authorization creation failed.")
             else:
                 # Compare scopes; patch if different
-                r = self._http.get(f"{DISCOVERY_ENGINE_URL}/{auth_full_name}",
-                                headers=self._get_headers(), timeout=60)
+                auth_url = f"{DISCOVERY_ENGINE_URL}/{auth_full_name}"
+                hdrs = self._get_headers().copy()
+                if "Authorization" in hdrs:
+                    hdrs["Authorization"] = "Bearer ***"
+                self.info(f"[AUTH] GET {auth_url} headers={json.dumps(hdrs)}")
+                r = self._http.get(auth_url, headers=self._get_headers(), timeout=60)
+                self.info(f"[AUTH] GET status={r.status_code} ct={r.headers.get('content-type','')}")
+                try:
+                    self.info(f"[AUTH] GET body={json.dumps(r.json(), indent=2)[:4000]}")
+                except Exception:
+                    self.info(f"[AUTH] GET text={(r.text or '')[:1000]}")
                 r.raise_for_status()
+
                 data = r.json() or {}
                 existing_uri = (((data.get("serverSideOauth2") or {}).get("authorizationUri")) or "")
+                self.info(f"[AUTH] existing authorizationUri={existing_uri!r}")
+
                 existing_scopes = set()
                 if existing_uri:
                     parsed = urlparse(existing_uri)
@@ -833,53 +861,95 @@ class ReasoningEngineDeploymentService:
                     scope_str = (qs.get("scope", [""])[0] or "")
                     existing_scopes = set(scope_str.split())
 
+                self.info(
+                    f"[AUTH] scopes existing={sorted(existing_scopes)} want={sorted(want_scopes)} "
+                    f"missing={sorted(want_scopes - existing_scopes)} extra={sorted(existing_scopes - want_scopes)}"
+                )
+
                 if existing_scopes != want_scopes:
-                    self.info("Authorization scopes changed. Patching authorization...")
+                    self.info("[AUTH] 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,
+                            "clientSecret": "***" if self._oauth_client_secret else None,
                             "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)
+                    # remove None to keep payload clean
+                    if patch_payload["serverSideOauth2"]["clientSecret"] is None:
+                        patch_payload["serverSideOauth2"].pop("clientSecret", None)
+
+                    hdrs2 = self._get_headers().copy()
+                    if "Authorization" in hdrs2:
+                        hdrs2["Authorization"] = "Bearer ***"
+                    self.info(f"[AUTH] PATCH {auth_url} headers={json.dumps(hdrs2)} payload={json.dumps(patch_payload, indent=2)}")
+                    pr = self._http.patch(auth_url, headers=self._get_headers(), json=patch_payload, timeout=60)
+                    self.info(f"[AUTH] PATCH status={pr.status_code} ct={pr.headers.get('content-type','')}")
+                    try:
+                        self.info(f"[AUTH] PATCH body={json.dumps(pr.json(), indent=2)[:4000]}")
+                    except Exception:
+                        self.info(f"[AUTH] PATCH text={(pr.text or '')[:1000]}")
                     pr.raise_for_status()
-                    self.info("Authorization updated.")
+                    self.info("[AUTH] Authorization updated.")
                 else:
-                    self.info("Authorization scopes unchanged; no update needed.")
+                    self.info("[AUTH] Scopes unchanged; no update needed.")
         else:
-            self.info("No authorization_id configured; skipping authorization step.")
+            self.info("[AUTH] No authorization_id configured; skipping authorization step.")
 
         # -----------------------------
         # 3) Agent Space Agent (create or update by displayName under engine)
         # -----------------------------
+        self.info(f"[AGENT] Resolving by display_name={self._agent_space_name}")
         existing_agent = self.find_agent_space_agents_by_display(self._agent_space_name)
+        self.info(f"[AGENT] find_agent_space_agents_by_display -> {json.dumps(existing_agent, indent=2)}")
+
         headers, payload = self._get_agent_space_payload(engine_rn)
+        headers_log = headers.copy()
+        if "Authorization" in headers_log:
+            headers_log["Authorization"] = "Bearer ***"
+        self.info(f"[AGENT] request headers={json.dumps(headers_log)}")
+        self.info(f"[AGENT] payload={json.dumps(payload, indent=2)}")
 
         if not existing_agent:
-            self.info(f"Agent Space agent '{self._agent_space_name}' not found. Creating...")
+            self.info(f"[AGENT] '{self._agent_space_name}' not found. Creating...")
             create_url = self._get_agent_space_agent_url_new()
+            self.info(f"[AGENT] POST {create_url}")
             cr = self._http.post(create_url, headers=headers, json=payload, timeout=90)
+            self.info(f"[AGENT] POST status={cr.status_code} ct={cr.headers.get('content-type','')}")
+            try:
+                self.info(f"[AGENT] POST body={json.dumps(cr.json(), indent=2)[:4000]}")
+            except Exception:
+                self.info(f"[AGENT] POST text={(cr.text or '')[:1000]}")
             if cr.status_code >= 400:
-                # File-only details already handled elsewhere; surface concise error here
-                self.error(f"Agent creation failed [{cr.status_code}].")
+                self.error(f"[AGENT] Creation failed [{cr.status_code}].")
                 cr.raise_for_status()
-            agent_name = (cr.json() or {}).get("name")
+
+            try:
+                j = cr.json() or {}
+            except Exception:
+                j = {}
+            agent_name = j.get("name")
+            self.info(f"[AGENT] create response name={agent_name}")
             if agent_name:
                 self._write_engine_deployment({"agent_space_id": agent_name})
-                self.info(f"Agent Space agent created: {agent_name}")
+                self.info(f"[AGENT] Created: {agent_name}")
             else:
-                self.warning("Agent created but response missing name. Verify in console.")
+                self.warning("[AGENT] Created but response missing name. Verify in console.")
         else:
-            self.info(f"Agent Space agent '{self._agent_space_name}' exists. Updating...")
+            self.info(f"[AGENT] '{self._agent_space_name}' exists. Updating...")
             patch_url = f"{DISCOVERY_ENGINE_URL}/{existing_agent['full_name']}"
+            self.info(f"[AGENT] PATCH {patch_url}")
             ur = self._http.patch(patch_url, headers=headers, json=payload, timeout=90)
+            self.info(f"[AGENT] PATCH status={ur.status_code} ct={ur.headers.get('content-type','')}")
+            try:
+                self.info(f"[AGENT] PATCH body={json.dumps(ur.json(), indent=2)[:4000]}")
+            except Exception:
+                self.info(f"[AGENT] PATCH text={(ur.text or '')[:1000]}")
             if ur.status_code >= 400:
-                self.error(f"Agent update failed [{ur.status_code}].")
+                self.error(f"[AGENT] Update failed [{ur.status_code}].")
                 ur.raise_for_status()
-            self.info("Agent Space agent updated.")
+            self.info("[AGENT] Agent Space agent updated.")
 
         self.info("GitHub deployment completed successfully.")

{reasoning_deployment_service-0.4.0 → reasoning_deployment_service-0.4.1}/reasoning_deployment_service.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reasoning-deployment-service
-Version: 0.4.0
+Version: 0.4.1
 Summary: Deployment helper for Vertex AI Reasoning Engines & Agent Spaces
 Author-email: Sergio Estrada <sergio.estrada@accenture.com>
 License: Apache-2.0