pyxecm 3.6.0__tar.gz → 3.6.2__tar.gz

{pyxecm-3.6.0 → pyxecm-3.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: pyxecm
-Version: 3.6.0
+Version: 3.6.2
 Summary: A Python library to interact with Opentext Content Management Rest API
 Project-URL: Homepage, https://github.com/opentext/pyxecm
 Author-email: Kai Gatzweiler <kgatzweiler@opentext.com>, "Dr. Marc Diefenbruch" <mdiefenb@opentext.com>

{pyxecm-3.6.0 → pyxecm-3.6.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pyxecm"
-version = "3.6.0"
+version = "3.6.2"
 description = 'A Python library to interact with Opentext Content Management Rest API'
 keywords = [
   'opentext',

{pyxecm-3.6.0 → pyxecm-3.6.2}/src/pyxecm/otca.py

@@ -122,18 +122,22 @@ class OTCA:
         # Stats endpoint:
         otca_config["usageStatsUrl"] = base_url + "/v1/usage-stats"
 
+        # Tools Url
+        tools_url = base_url + "/v1/tools"
+        otca_config["toolsUrl"] = tools_url
+
         # MCP Client endpoints:
-        otca_config["mcpClientServersUrl"] = base_url + "/mcp-client/servers"
-        otca_config["mcpClientToolsUrl"] = base_url + "/mcp-client/tools"
-        otca_config["mcpClientToolsRefreshUrl"] = base_url + "/mcp-client/tools/refresh"
-        otca_config["mcpClientHealthUrl"] = base_url + "/mcp-client/health"
+        mcp_client_url = base_url + "/mcp-client"
+        otca_config["mcpClientServersUrl"] = mcp_client_url + "/servers"
+        otca_config["mcpClientToolsUrl"] = mcp_client_url + "/tools"
+        otca_config["mcpClientToolsRefreshUrl"] = otca_config["mcpClientToolsUrl"] + "/refresh"
+        otca_config["mcpClientToolsSyncUrl"] = otca_config["mcpClientToolsUrl"] + "/sync"
+        otca_config["mcpClientHealthUrl"] = mcp_client_url + "/health"
 
         # MCP Server endpoints:
-        otca_config["mcpServerAllToolsUrl"] = base_url + "/mcp-server/list/alltools"
-        otca_config["mcpServerRegisterToolsUrl"] = base_url + "/mcp-server/register/tools"
-        otca_config["mcpServerToolsUrl"] = base_url + "/mcp-server/list/tools"
-        otca_config["mcpServerDeleteToolsUrl"] = base_url + "/mcp-server/tools"
-        otca_config["mcpServerHealthUrl"] = base_url + "/mcp-server/health"
+        mcp_server_url = base_url + "/mcp-server"
+        otca_config["mcpServerToolsUrl"] = mcp_server_url + "/tools"
+        otca_config["mcpServerHealthUrl"] = mcp_server_url + "/health"
 
         otca_config["contentSystem"] = self.get_content_system()
         otca_config["clientId"] = client_id
@@ -1268,6 +1272,27 @@ class OTCA:
 
     # end method definition
 
+    def get_tools(self) -> list | None:
+        """List all tools available from remote MCP servers.
+
+        Returns:
+            list | None:
+                List of available MCP tools or None in case of an error.
+
+        """
+
+        request_url = self.config()["toolsUrl"]
+        request_header = self.request_header(service_type="user")
+
+        return self.do_request(
+            url=request_url,
+            method="GET",
+            headers=request_header,
+            failure_message="Canbnot get list of tools",
+        )
+
+    # end method definition
+
     # --- MCP Client Methods ---
 
     def create_mcp_server(self, server_config: dict) -> dict | None:
@@ -1410,6 +1435,29 @@ class OTCA:
             list | None:
                 List of available MCP tools or None in case of an error.
 
+        Example:
+        [
+            {
+                'id': 2,
+                'key': 'ALLOWED_MCP_TOOLS',
+                'value': [
+                    {
+                        'name': 'current_time',
+                        'description': 'Use this to get the current date and time, return it as a string.'
+                    },
+                    {
+                        'name': 'otcm_recman_agent',
+                        'description': "Invoke Records Management agent and its related tools."
+                    },
+                    {
+                        'name': 'otcm_workspace_agent',
+                        'description': "Invoke the workspace operations agent for OpenText Content Management.'
+                    }
+                ],
+                'subscription_id': None
+            }
+        ]
+
         """
 
         request_url = self.config()["mcpClientToolsUrl"]
@@ -1476,7 +1524,7 @@ class OTCA:
 
         """
 
-        request_url = self.config()["mcpServerAllToolsUrl"]
+        request_url = self.config()["mcpServerToolsUrl"]
         request_header = self.request_header(service_type="user")
 
         return self.do_request(
@@ -1501,7 +1549,7 @@ class OTCA:
 
         """
 
-        request_url = self.config()["mcpServerRegisterToolsUrl"]
+        request_url = self.config()["mcpServerToolsUrl"]
         request_header = self.request_header(service_type="user")
 
         return self.do_request(
@@ -1548,7 +1596,7 @@ class OTCA:
 
         """
 
-        request_url = self.config()["mcpServerDeleteToolsUrl"]
+        request_url = self.config()["mcpServerToolsUrl"]
         request_header = self.request_header(service_type="user")
 
         return self.do_request(

{pyxecm-3.6.0 → pyxecm-3.6.2}/src/pyxecm/otcs.py

@@ -27519,7 +27519,13 @@ class OTCS:
                     workspace_id,
                 )
                 return None
-        template_names = [item.text for item in root.findall("startup/processing/templates/template")]
+        template_names = [
+            item.text for item in root.findall("startup/processing/templates/template") if item is not None
+        ]
+        # below for scenarios where they only configure one template for testing
+        if not template_names:
+            # A single template appears only in startup/processing/template instead
+            template_names = [item.text for item in root.findall("startup/processing/template") if item is not None]
 
         return template_names
 
@@ -28189,55 +28195,25 @@ class OTCS:
             if not forms or not isinstance(forms[0], dict):
                 continue
 
+            form_data = forms[0].get("data", {})
+            if not isinstance(form_data, dict):
+                form_data = {}
+
             # we take the priority form the form data if
             # the baseline follow-up does not have a priority set.
-            form_data = forms[0].get("data", {})
             if "priority" not in followup and "priority" in form_data:
                 followup["priority"] = form_data.get("priority")
 
+            # The escalation, activation and schedule details are not part of the reminder
+            # itself - they only live in the view form. We just hang the raw sections the
+            # caller asked for into the followup dictionary. _extract_reminder_payload()
+            # unpacks them into the flat reminder fields further down:
             if escalation:
-                escalation_alert = form_data.get("escalation_alert", {}) if isinstance(form_data, dict) else {}
-                send_in = escalation_alert.get("send_in", {}) if isinstance(escalation_alert, dict) else {}
-                send_to = escalation_alert.get("send_to", []) if isinstance(escalation_alert, dict) else []
-
-                if isinstance(escalation_alert, dict) and "escalation_enabled" in escalation_alert:
-                    followup["escalation_enabled"] = escalation_alert.get("escalation_enabled")
-                if isinstance(send_in, dict) and "escalation_period" in send_in:
-                    followup["escalation_period"] = send_in.get("escalation_period")
-                if isinstance(send_in, dict) and "escalation_when" in send_in:
-                    followup["escalation_when"] = send_in.get("escalation_when")
-                if isinstance(send_to, list) and send_to:
-                    # send_to is a plain list of member IDs; expand each one to the same
-                    # {id, name, type, type_name, [node_id]} shape as the assignees list:
-                    escalation_recipients = []
-                    for recipient_id in send_to:
-                        recipient_entry = {"id": recipient_id}
-                        recipient_member = self.get_member(
-                            member_id=recipient_id, fields="properties{name,type,type_name,node_id}"
-                        )
-                        if recipient_member:
-                            for recipient_field in ("name", "type", "type_name", "node_id"):
-                                recipient_value = self.get_result_value(
-                                    response=recipient_member, key=recipient_field, show_error=False
-                                )
-                                if recipient_value is not None:
-                                    recipient_entry[recipient_field] = recipient_value
-                        escalation_recipients.append(recipient_entry)
-                    followup["escalation_recipient_list"] = escalation_recipients
-            # end if escalation:
-
+                followup["escalation_alert"] = form_data.get("escalation_alert", {})
             if activation:
-                activation_data = form_data.get("activation_alert", {}) if isinstance(form_data, dict) else {}
-                send_in = activation_data.get("send_in", {}) if isinstance(activation_data, dict) else {}
-                if isinstance(send_in, dict) and "activation_period" in send_in:
-                    followup["activation_period"] = send_in.get("activation_period")
-                if isinstance(send_in, dict) and "activation_unit" in send_in:
-                    followup["activation_unit"] = send_in.get("activation_unit")
-
-            if schedule:
-                schedule_data = form_data.get("schedule", {}) if isinstance(form_data, dict) else {}
-                if schedule_data:
-                    followup["schedule"] = schedule_data
+                followup["activation_alert"] = form_data.get("activation_alert", {})
+            if schedule and form_data.get("schedule"):
+                followup["schedule"] = form_data["schedule"]
         # end for loop to enrich reminders with view form information
 
         # Normalize the numeric values of the REST API response to their readable form.
@@ -28466,58 +28442,24 @@ class OTCS:
             return self._extract_reminder_payload(reminder=response)
 
         form_data = forms[0].get("data", {})
+        if not isinstance(form_data, dict):
+            form_data = {}
 
         # we take the priority from the form data if
         # the baseline follow-up does not have a priority set.
         if "priority" not in followup and "priority" in form_data:
             followup["priority"] = form_data.get("priority")
 
+        # The escalation, activation and schedule details are not part of the reminder itself -
+        # they only live in the view form. We just hang the raw sections the caller asked for
+        # into the followup dictionary. _extract_reminder_payload() below unpacks them into the
+        # flat reminder fields and normalizes their values:
         if escalation:
-            escalation_alert = form_data.get("escalation_alert", {}) if isinstance(form_data, dict) else {}
-            send_in = escalation_alert.get("send_in", {}) if isinstance(escalation_alert, dict) else {}
-            send_to = escalation_alert.get("send_to", {}) if isinstance(escalation_alert, dict) else []
-
-            # The fields 'escalation_enabled', 'escalation_period', and 'escalation_when' may only be aviable
-            # if the reminder is in 'open' state. If it is already in 'active' or 'completed' state, these
-            # fields may not be available.
-            if isinstance(escalation_alert, dict) and "escalation_enabled" in escalation_alert:
-                followup["escalation_enabled"] = escalation_alert.get("escalation_enabled")
-            if isinstance(send_in, dict) and "escalation_period" in send_in:
-                followup["escalation_period"] = send_in.get("escalation_period")
-            if isinstance(send_in, dict) and "escalation_when" in send_in:
-                followup["escalation_when"] = send_in.get("escalation_when")
-
-            if isinstance(send_to, list) and send_to:
-                # send_to is a plain list of member IDs; expand each one to the same
-                # {id, name, type, type_name, [node_id]} shape as the assignees list:
-                escalation_recipients = []
-                for escalation_recipient_id in send_to:
-                    escalation_recipient_entry = {"id": escalation_recipient_id}
-                    escalation_recipient_member = self.get_member(
-                        member_id=escalation_recipient_id, fields="properties{name_formatted,type,type_name,node_id}"
-                    )
-                    if escalation_recipient_member:
-                        for escalation_recipient_field in ("name_formatted", "type", "type_name", "node_id"):
-                            escalation_recipient_value = self.get_result_value(
-                                response=escalation_recipient_member, key=escalation_recipient_field, show_error=False
-                            )
-                            if escalation_recipient_value is not None:
-                                if escalation_recipient_field == "name_formatted":
-                                    escalation_recipient_field = "name"
-                                escalation_recipient_entry[escalation_recipient_field] = escalation_recipient_value
-                    escalation_recipients.append(escalation_recipient_entry)
-                followup["escalation_recipient_list"] = escalation_recipients
+            followup["escalation_alert"] = form_data.get("escalation_alert", {})
         if activation:
-            activation_data = form_data.get("activation_alert", {}) if isinstance(form_data, dict) else {}
-            send_in = activation_data.get("send_in", {}) if isinstance(activation_data, dict) else {}
-            if isinstance(send_in, dict) and "activation_period" in send_in:
-                followup["activation_period"] = send_in.get("activation_period")
-            if isinstance(send_in, dict) and "activation_unit" in send_in:
-                followup["activation_unit"] = send_in.get("activation_unit")
-        if schedule:
-            schedule_data = form_data.get("schedule", {}) if isinstance(form_data, dict) else {}
-            if schedule_data:
-                followup["schedule"] = schedule_data
+            followup["activation_alert"] = form_data.get("activation_alert", {})
+        if schedule and form_data.get("schedule"):
+            followup["schedule"] = form_data["schedule"]
 
         # Normalize the numeric values of the REST API response to their readable form.
         # This happens last, so that the values added from the view form above are covered as well:
@@ -29093,6 +29035,16 @@ class OTCS:
             escalation_when -1 -> "after"
             activation_unit  1 -> "day"
 
+        In addition, this method unpacks the raw sections of the reminder view form that
+        ``get_reminder()`` and ``get_reminders()`` hang into the reminder: "escalation_alert"
+        becomes ``escalation_enabled``, ``escalation_period``, ``escalation_when``,
+        ``escalation_unit`` and ``escalation_recipient_list`` (each recipient expanded via
+        ``get_member()``), and "activation_alert" becomes ``activation_period``,
+        ``activation_unit`` and ``activation_when``. The raw sections are removed afterwards.
+        Depending on the state of the reminder, OTCS delivers these settings either as
+        discrete fields (state "open") or as readable text in "activationAlert1" /
+        "activationAlert2" (states "active" and "in progress") - both forms are handled.
+
         NOTE: Values that are only delivered by the reminder view form (priority, escalation,
         activation and the relative due date) are only present if ``get_reminder()`` or
         ``get_reminders()`` were called with ``escalation=True``, ``activation=True`` or
@@ -29100,6 +29052,9 @@ class OTCS:
         encoding is kept as it is and reported with a warning - this method never
         guesses and never removes information.
 
+        NOTE: Expanding the escalation recipients issues one ``get_member()`` request per
+        recipient.
+
         Args:
             reminder (dict | None):
                 A reminder as returned by ``get_reminder()``, a single entry as yielded by
@@ -29148,10 +29103,99 @@ class OTCS:
                 return
             data[field] = names[value]
 
+        # get_reminder() and get_reminders() hang the raw "escalation_alert" and
+        # "activation_alert" sections of the reminder view form into the followup dictionary -
+        # but only if the caller asked for them. They are unpacked into the flat reminder
+        # fields here and dropped afterwards, so that callers only ever see the flat fields.
+        # The numeric values they carry are normalized by the map_value() calls below:
+        escalation_alert = followup.pop("escalation_alert", None)
+        if isinstance(escalation_alert, dict):
+            send_in = escalation_alert.get("send_in", {})
+            if not isinstance(send_in, dict):
+                send_in = {}
+            send_to = escalation_alert.get("send_to", [])
+
+            # The fields 'escalation_enabled', 'escalation_period', and 'escalation_when' may only
+            # be available if the reminder is in 'open' state. If it is already in 'active' or
+            # 'in progress' state, OTCS reports them as readable text in 'activationAlert1' and
+            # 'activationAlert2' instead:
+            if "escalation_enabled" in escalation_alert:
+                followup["escalation_enabled"] = escalation_alert.get("escalation_enabled")
+            else:
+                followup["escalation_enabled"] = "activationAlert1" in send_in
+
+            if "escalation_period" in send_in:
+                followup["escalation_period"] = send_in.get("escalation_period")
+            elif "activationAlert1" in send_in:
+                followup["escalation_period"] = int(send_in.get("activationAlert1", "0").split(" ", 1)[0])
+
+            if "escalation_when" in send_in:
+                followup["escalation_when"] = send_in.get("escalation_when")
+            elif "activationAlert2" in send_in:
+                followup["escalation_when"] = self.REMINDER_ESCALATION_WHEN_MAP.get(
+                    "after" if "after" in send_in.get("activationAlert2", "") else "before",
+                )
+
+            for unit in self.REMINDER_UNIT_MAP:
+                if unit in send_in.get("activationAlert1", ""):
+                    followup["escalation_unit"] = self.REMINDER_UNIT_MAP[unit]
+                    break
+
+            if isinstance(send_to, list) and send_to:
+                # send_to is a plain list of member IDs; expand each one to the same
+                # {id, name, type, type_name, [node_id]} shape as the assignees list:
+                escalation_recipients = []
+                for recipient_id in send_to:
+                    recipient_entry = {"id": recipient_id}
+                    recipient_member = self.get_member(
+                        member_id=recipient_id,
+                        fields="properties{name_formatted,type,type_name,node_id}",
+                    )
+                    if recipient_member:
+                        for recipient_field in ("name_formatted", "type", "type_name", "node_id"):
+                            recipient_value = self.get_result_value(
+                                response=recipient_member, key=recipient_field, show_error=False
+                            )
+                            if recipient_value is not None:
+                                # the members REST API calls the name "name_formatted":
+                                key = "name" if recipient_field == "name_formatted" else recipient_field
+                                recipient_entry[key] = recipient_value
+                    escalation_recipients.append(recipient_entry)
+                followup["escalation_recipient_list"] = escalation_recipients
+            # end if isinstance(send_to, list) and send_to
+        # end if isinstance(escalation_alert, dict)
+
+        activation_alert = followup.pop("activation_alert", None)
+        if isinstance(activation_alert, dict):
+            send_in = activation_alert.get("send_in", {})
+            if not isinstance(send_in, dict):
+                send_in = {}
+
+            if "activation_period" in send_in:
+                followup["activation_period"] = send_in.get("activation_period")
+            elif "activationAlert1" in send_in:
+                followup["activation_period"] = int(send_in.get("activationAlert1", "0").split(" ", 1)[0])
+
+            if "activation_unit" in send_in:
+                followup["activation_unit"] = send_in.get("activation_unit")
+            else:
+                for unit in self.REMINDER_UNIT_MAP:
+                    if unit in send_in.get("activationAlert1", ""):
+                        followup["activation_unit"] = self.REMINDER_UNIT_MAP[unit]
+                        break
+
+            if "activationAlert2" in send_in:
+                followup["activation_when"] = self.REMINDER_ESCALATION_WHEN_MAP.get(
+                    "after" if "after" in send_in.get("activationAlert2", "") else "before",
+                )
+        # end if isinstance(activation_alert, dict)
+
         map_value(followup, "status", self.REMINDER_STATUS_NAMES)
         map_value(followup, "priority", self.REMINDER_PRIORITY_NAMES)
         map_value(followup, "rule", self.REMINDER_RULE_NAMES)
         map_value(followup, "escalation_when", self.REMINDER_ESCALATION_WHEN_NAMES)
+        map_value(followup, "escalation_unit", self.REMINDER_UNIT_NAMES)
+        map_value(followup, "activation_when", self.REMINDER_ESCALATION_WHEN_NAMES)
         map_value(followup, "activation_unit", self.REMINDER_UNIT_NAMES)
 
         # The unit of a relative due date lives in the schedule delivered by the view form:
@@ -29160,6 +29204,20 @@ class OTCS:
             due_in = schedule.get("due_in")
             if isinstance(due_in, dict):
                 map_value(due_in, "due_in_unit", self.REMINDER_UNIT_NAMES)
+            seq_repeat = schedule.get("seq_repeat")
+            if seq_repeat:
+                if "Every day" in seq_repeat:
+                    schedule["repeat_on"] = OTCS.REMINDER_SEQUENCE_MAP.get("daily")
+                if "Every 2 weeks" in seq_repeat:
+                    schedule["repeat_on"] = OTCS.REMINDER_SEQUENCE_MAP.get("bi-weekly")
+                elif "Every 2 months" in seq_repeat:
+                    schedule["repeat_on"] = OTCS.REMINDER_SEQUENCE_MAP.get("every 2 months")
+                elif "every 3 months" in seq_repeat:
+                    schedule["repeat_on"] = OTCS.REMINDER_SEQUENCE_MAP.get("quarterly")
+                elif "every 6 months" in seq_repeat:
+                    schedule["repeat_on"] = OTCS.REMINDER_SEQUENCE_MAP.get("semi-annually")
+                elif "Every year" in seq_repeat:
+                    schedule["repeat_on"] = OTCS.REMINDER_SEQUENCE_MAP.get("yearly")
 
         # OTCS reports this flag as 0 / 1 while the reminder methods take a boolean:
         if isinstance(followup.get("activation_by_day"), int):

{pyxecm-3.6.0 → pyxecm-3.6.2}/src/pyxecm_customizer/payload.py

@@ -608,6 +608,7 @@ class Payload:
         self._embeddings = self.get_payload_section("embeddings")
         self._nifi_flows = self.get_payload_section("nifi")
         self._aviator_mcp_servers = self.get_payload_section("aviatorMcpServers")
+        self._aviator_mcp_tools = self.get_payload_section("aviatorMcpTools")
 
         return self._payload
 
@@ -2951,6 +2952,14 @@ class Payload:
                             self.logger.warning(
                                 "aviatorMcpServers in payload but Content Aviator (OTCA) is not configured! MCP servers will not be processed.",
                             )
+                    case "aviatorMcpTools":
+                        if self._otca and isinstance(self._otca, OTCA):
+                            self._log_header_callback("Process Aviator MCP Tools")
+                            self.process_mcp_tools()
+                        else:
+                            self.logger.warning(
+                                "aviatorMcpTools in payload but Content Aviator (OTCA) is not configured! MCP tools will not be processed.",
+                            )
                     case _:
                         self.logger.error(
                             "Illegal payload section name -> '%s' in payloadSections!",
@@ -32224,3 +32233,137 @@ class Payload:
         return success
 
     # end method definition
+
+    @tracer.start_as_current_span(attributes=OTEL_TRACING_ATTRIBUTES, name="process_mcp_tools")
+    def process_mcp_tools(self, section_name: str = "aviatorMcpTools") -> bool:
+        """Register Content Aviator agents as MCP tools.
+
+        Payload item keys:
+            - enabled (bool, optional, default=True)
+            - name (str, required)
+
+        Args:
+            section_name (str, optional):
+                The name of the payload section. It can be overridden
+                for cases where multiple sections of same type
+                are used (e.g. the "Post" sections).
+                This name is also used for the "success" status
+                files written to the Admin Personal Workspace.
+
+        Returns:
+            bool:
+                True, if payload has been processed without errors, False otherwise.
+
+        """
+
+        if not self._aviator_mcp_tools:
+            self.logger.info(
+                "Payload section -> '%s' is empty. Skipping...",
+                section_name,
+            )
+            return True
+
+        # If this payload section has been processed successfully before we
+        # can return True and skip processing it once more:
+        if self.check_status_file(payload_section_name=section_name):
+            return True
+
+        success: bool = True
+
+        # list_mcp_tools() returns a list of settings entries (e.g. key -> 'ALLOWED_MCP_TOOLS')
+        # whose "value" is the actual list of tool dictionaries with "name" and "description":
+        existing_mcp_tools = self._otca.list_registered_mcp_tools()
+        if existing_mcp_tools is None:
+            self.logger.warning(
+                "Failed to retrieve the list of available MCP tools from Content Aviator. Cannot check if tools are already registered."
+            )
+
+        existing_mcp_tool_names = [
+            tool.get("name")
+            for entry in existing_mcp_tools or []
+            for tool in entry.get("value") or []
+            if tool.get("name")
+        ]
+        if existing_mcp_tool_names:
+            self.logger.info(
+                "Already registered MCP tools in Content Aviator: %s",
+                ", ".join(existing_mcp_tool_names),
+            )
+
+        for mcp_tool in self._aviator_mcp_tools:
+            tool_name = mcp_tool.get("name")
+            if not tool_name:
+                self.logger.error("Content Aviator MCP tool needs a name in payload! Skipping...")
+                success = False
+                continue
+
+            # Check if element has been disabled in payload (enabled = false).
+            # In this case we skip the element:
+            if not mcp_tool.get("enabled", True):
+                self.logger.info(
+                    "Payload for Content Aviator MCP tool -> '%s' is disabled. Skipping...",
+                    tool_name,
+                )
+                continue
+
+            if tool_name in existing_mcp_tool_names:
+                self.logger.info(
+                    "Content Aviator MCP tool -> '%s' is already registered in Content Aviator. No need to register it again. Skipping...",
+                    tool_name,
+                )
+                continue
+
+            response = self._otca.register_mcp_tools(tools=[tool_name])
+            if response:
+                tool_id = response.get("id", "Unknown ID")
+                # The response value is the complete list of tools registered for the
+                # tenant - we need to pick the entry of the tool we just registered:
+                value = response.get("value") or []
+                tool_entry = next((entry for entry in value if entry.get("name") == tool_name), None)
+                if tool_entry is None:
+                    self.logger.warning(
+                        "Content Aviator MCP tool -> '%s' is not included in the registration response!",
+                        tool_name,
+                    )
+                tool_description = (
+                    tool_entry.get("description", "Unknown Description") if tool_entry else "Unknown Description"
+                )
+                self.logger.info(
+                    "Registered Content Aviator MCP tool -> '%s' (%s).",
+                    tool_name,
+                    tool_id,
+                )
+                mcp_tool["id"] = tool_id  # record the ID of the MCP tool settings record in the payload
+                mcp_tool["description"] = tool_description  # record the created tool description in the payload
+                mcp_tool["registered"] = True
+            else:
+                self.logger.error(
+                    "Failed to register Content Aviator MCP tool -> '%s'!",
+                    tool_name,
+                )
+                mcp_tool["registered"] = False
+                success = False
+        # end for mcp_tool in self._aviator_mcp_tools
+
+        registered_tools = [tool.get("name") for tool in self._aviator_mcp_tools if tool.get("registered") is True]
+        if registered_tools:
+            self.logger.info(
+                "Successfully registered the following additional MCP tools: %s",
+                registered_tools,
+            )
+        failed_tools = [tool.get("name") for tool in self._aviator_mcp_tools if tool.get("registered") is False]
+        if failed_tools:
+            self.logger.info(
+                "Failed to register the following MCP tools: %s",
+                failed_tools,
+            )
+
+        self.write_status_file(
+            success=success,
+            payload_section_name=section_name,
+            payload_section=self._aviator_mcp_tools,
+        )
+
+        return success
+
+    # end method definition