rootly-mcp-server 0.0.4__tar.gz → 1.0.0__tar.gz

rootly_mcp_server-1.0.0/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [2025] [Rootly]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

rootly_mcp_server-1.0.0/PKG-INFO

@@ -0,0 +1,128 @@
+Metadata-Version: 2.4
+Name: rootly-mcp-server
+Version: 1.0.0
+Summary: A Model Context Protocol server for Rootly APIs using OpenAPI spec
+Project-URL: Homepage, https://github.com/Rootly-AI-Labs/Rootly-MCP-server
+Project-URL: Issues, https://github.com/Rootly-AI-Labs/Rootly-MCP-server/issues
+Author-email: Rootly AI Labs <support@rootly.com>
+License-Expression: Apache-2.0
+License-File: LICENSE
+Keywords: automation,incidents,llm,mcp,rootly
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Build Tools
+Requires-Python: >=3.12
+Requires-Dist: mcp>=1.1.2
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: requests>=2.28.0
+Provides-Extra: dev
+Requires-Dist: black>=23.0.0; extra == 'dev'
+Requires-Dist: isort>=5.0.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# Rootly MCP Server
+
+An MCP server for [Rootly API](https://docs.rootly.com/api-reference/overview) that you can plug into your favorite MCP-compatible editors like Cursor, Windsurf, and Claude. Resolve production incidents in under a minute without leaving your IDE.
+<br>
+<br>
+
+![Demo GIF](rootly-mcp-server-demo.gif)
+
+
+## Prerequisites
+
+- Python 3.12 or higher
+- `uv` package manager
+  ```bash
+  curl -LsSf https://astral.sh/uv/install.sh | sh
+  ```
+- [Rootly API token](https://docs.rootly.com/api-reference/overview#how-to-generate-an-api-key%3F)
+
+## Run it in your IDE
+Install with our [PyPi package](https://pypi.org/project/rootly-mcp-server/) or by cloning this repo.
+
+To set it up in your favorite MCP-compatible editor (we tested it with Cursor and Windsurf), here is the config :
+```json
+{
+  "mcpServers": {
+    "rootly": {
+      "command": "uvx",
+      "args": [
+        "--from",
+        "rootly-mcp-server",
+        "rootly-mcp-server"
+      ],
+      "env": {
+        "ROOTLY_API_TOKEN": "<YOUR_ROOTLY_API_TOKEN>"
+      }
+    }
+  }
+}
+```
+If you want to customize `allowed_paths` to access more Rootly API paths, clone the package and use this config.
+```json
+{
+    "mcpServers": {
+      "rootly": {
+        "command": "uv",
+        "args": [
+          "run",
+          "--directory",
+          "/path/to/rootly-mcp-server",
+          "rootly-mcp-server"
+        ],
+        "env": {
+          "ROOTLY_API_TOKEN": "<YOUR_ROOTLY_API_TOKEN>"
+        }
+      }
+    }
+  }
+```
+
+## Features
+This server dynamically generates MCP resources based on Rootly's OpenAPI (Swagger) specification:
+- Dynamically generated MCP tools based on Rootly's OpenAPI specification
+- Default pagination (10 items) for incident endpoints to prevent context window overflow
+- Limits the number of API paths exposed to the AI agent
+
+We limited the number of API paths exposed for 2 reasons
+* Context size: because [Rootly's API](https://docs.rootly.com/api-reference/overview) is very rich in paths, AI agents can get overwhelmed and not perform simple actions properly. As of now we only expose the [/incidents](https://docs.rootly.com/api-reference/incidents/list-incidents) and [/incidents/{incident_id}/alerts](https://docs.rootly.com/api-reference/incidentevents/list-incident-events).
+* Security: if you want to limit the type of information or actions that users can access through the MCP server
+
+If you want to make more path available, edit the variable `allowed_paths` in `src/rootly_mcp_server/server.py`.
+
+## Disclaimer
+This project is a prototype and not intended for production use. If you have featured ideas or spotted some issues, feel free to submit a PR or open an issue.
+
+## About the Rootly AI Labs
+This project was developed by the [Rootly AI Labs](https://labs.rootly.ai/). The AI Labs is building the future of system reliability and operational excellence. We operate as an open-source incubator, sharing ideas, experimenting, and rapidly prototyping. We're committed to ensuring our research benefits the entire community.
+![Rootly AI logo](https://github.com/Rootly-AI-Labs/EventOrOutage/raw/main/rootly-ai.png)
+
+## Developer Setup & Troubleshooting
+
+### 1. Install dependencies with `uv`
+This project uses [`uv`](https://github.com/astral-sh/uv) for fast dependency management. To install all dependencies from your `pyproject.toml`:
+```bash
+uv pip install .
+```
+
+### 2. Using a virtual environment
+It is recommended to use a virtual environment for development:
+```bash
+uv venv .venv
+source .venv/bin/activate
+```
+
+### 3. Running the test client
+To run the test client and verify your setup:
+```bash
+python test_mcp_client.py
+```
+
+### 5. General tips
+- Always activate your virtual environment before running scripts.
+- If you add new dependencies, use `uv pip install <package>` to keep your environment up to date.
+- If you encounter issues, check your Python version and ensure it matches the project's requirements.
+

rootly_mcp_server-1.0.0/README.md

@@ -0,0 +1,104 @@
+# Rootly MCP Server
+
+An MCP server for [Rootly API](https://docs.rootly.com/api-reference/overview) that you can plug into your favorite MCP-compatible editors like Cursor, Windsurf, and Claude. Resolve production incidents in under a minute without leaving your IDE.
+<br>
+<br>
+
+![Demo GIF](rootly-mcp-server-demo.gif)
+
+
+## Prerequisites
+
+- Python 3.12 or higher
+- `uv` package manager
+  ```bash
+  curl -LsSf https://astral.sh/uv/install.sh | sh
+  ```
+- [Rootly API token](https://docs.rootly.com/api-reference/overview#how-to-generate-an-api-key%3F)
+
+## Run it in your IDE
+Install with our [PyPi package](https://pypi.org/project/rootly-mcp-server/) or by cloning this repo.
+
+To set it up in your favorite MCP-compatible editor (we tested it with Cursor and Windsurf), here is the config :
+```json
+{
+  "mcpServers": {
+    "rootly": {
+      "command": "uvx",
+      "args": [
+        "--from",
+        "rootly-mcp-server",
+        "rootly-mcp-server"
+      ],
+      "env": {
+        "ROOTLY_API_TOKEN": "<YOUR_ROOTLY_API_TOKEN>"
+      }
+    }
+  }
+}
+```
+If you want to customize `allowed_paths` to access more Rootly API paths, clone the package and use this config.
+```json
+{
+    "mcpServers": {
+      "rootly": {
+        "command": "uv",
+        "args": [
+          "run",
+          "--directory",
+          "/path/to/rootly-mcp-server",
+          "rootly-mcp-server"
+        ],
+        "env": {
+          "ROOTLY_API_TOKEN": "<YOUR_ROOTLY_API_TOKEN>"
+        }
+      }
+    }
+  }
+```
+
+## Features
+This server dynamically generates MCP resources based on Rootly's OpenAPI (Swagger) specification:
+- Dynamically generated MCP tools based on Rootly's OpenAPI specification
+- Default pagination (10 items) for incident endpoints to prevent context window overflow
+- Limits the number of API paths exposed to the AI agent
+
+We limited the number of API paths exposed for 2 reasons
+* Context size: because [Rootly's API](https://docs.rootly.com/api-reference/overview) is very rich in paths, AI agents can get overwhelmed and not perform simple actions properly. As of now we only expose the [/incidents](https://docs.rootly.com/api-reference/incidents/list-incidents) and [/incidents/{incident_id}/alerts](https://docs.rootly.com/api-reference/incidentevents/list-incident-events).
+* Security: if you want to limit the type of information or actions that users can access through the MCP server
+
+If you want to make more path available, edit the variable `allowed_paths` in `src/rootly_mcp_server/server.py`.
+
+## Disclaimer
+This project is a prototype and not intended for production use. If you have featured ideas or spotted some issues, feel free to submit a PR or open an issue.
+
+## About the Rootly AI Labs
+This project was developed by the [Rootly AI Labs](https://labs.rootly.ai/). The AI Labs is building the future of system reliability and operational excellence. We operate as an open-source incubator, sharing ideas, experimenting, and rapidly prototyping. We're committed to ensuring our research benefits the entire community.
+![Rootly AI logo](https://github.com/Rootly-AI-Labs/EventOrOutage/raw/main/rootly-ai.png)
+
+## Developer Setup & Troubleshooting
+
+### 1. Install dependencies with `uv`
+This project uses [`uv`](https://github.com/astral-sh/uv) for fast dependency management. To install all dependencies from your `pyproject.toml`:
+```bash
+uv pip install .
+```
+
+### 2. Using a virtual environment
+It is recommended to use a virtual environment for development:
+```bash
+uv venv .venv
+source .venv/bin/activate
+```
+
+### 3. Running the test client
+To run the test client and verify your setup:
+```bash
+python test_mcp_client.py
+```
+
+### 5. General tips
+- Always activate your virtual environment before running scripts.
+- If you add new dependencies, use `uv pip install <package>` to keep your environment up to date.
+- If you encounter issues, check your Python version and ensure it matches the project's requirements.
+

{rootly_mcp_server-0.0.4 → rootly_mcp_server-1.0.0}/pyproject.toml

@@ -1,12 +1,12 @@
 [project]
 name = "rootly-mcp-server"
-version = "0.0.4"
+version = "1.0.0"
 description = "A Model Context Protocol server for Rootly APIs using OpenAPI spec"
 readme = "README.md"
 requires-python = ">=3.12"
 authors = [{ name = "Rootly AI Labs", email="support@rootly.com"}]
 keywords = ["rootly", "mcp", "llm", "automation", "incidents"]
-license = "AGPL-3.0-only"
+license = "Apache-2.0"
 license-files = ["LICEN[CS]E*"]
 classifiers = [
     "Development Status :: 4 - Beta",

{rootly_mcp_server-0.0.4 → rootly_mcp_server-1.0.0}/src/rootly_mcp_server/__main__.py

@@ -67,7 +67,11 @@ def setup_logging(log_level, debug=False):
     
     # Set specific logger levels
     logging.getLogger("rootly_mcp_server").setLevel(numeric_level)
-    logging.getLogger("mcp").setLevel(numeric_level)
+    logging.getLogger("rootly_mcp_server.server").setLevel(logging.WARNING)  # Reduce server-specific logs
+    
+    # Always set MCP logger to ERROR level to fix Cline UI issue
+    # This prevents INFO logs from causing problems with Cline tool display
+    logging.getLogger("mcp").setLevel(logging.ERROR)
     
     # Log the configuration
     logger = logging.getLogger(__name__)

{rootly_mcp_server-0.0.4 → rootly_mcp_server-1.0.0}/src/rootly_mcp_server/client.py

@@ -24,7 +24,7 @@ class RootlyClient:
             raise ValueError("ROOTLY_API_TOKEN environment variable is not set")
         return api_token
 
-    def make_request(self, method: str, path: str, query_params: Optional[Dict[str, Any]] = None, json_data: Optional[Dict[str, Any]] = None) -> str:
+    def make_request(self, method: str, path: str, query_params: Optional[Dict[str, Any]] = None, json_data: Optional[Dict[str, Any]] = None, json_api_type: Optional[str] = None) -> str:
         """
         Make an authenticated request to the Rootly API.
         
@@ -33,16 +33,32 @@ class RootlyClient:
             path: The API path.
             query_params: Query parameters for the request.
             json_data: JSON data for the request body.
+            json_api_type: If set, use JSON-API format and this type value.
             
         Returns:
             The API response as a JSON string.
         """
+        # Default headers
         headers = {
             "Authorization": f"Bearer {self._api_token}",
             "Content-Type": "application/json",
             "Accept": "application/json"
         }
-        
+
+        # If JSON-API, update headers and wrap payload
+        if json_api_type and method.upper() in ["POST", "PUT", "PATCH"]:
+            headers["Content-Type"] = "application/vnd.api+json"
+            headers["Accept"] = "application/vnd.api+json"
+            if json_data:
+                json_data = {
+                    "data": {
+                        "type": json_api_type,
+                        "attributes": json_data
+                    }
+                }
+            else:
+                json_data = None
+
         # Ensure path starts with a slash
         if not path.startswith("/"):
             path = f"/{path}"

{rootly_mcp_server-0.0.4 → rootly_mcp_server-1.0.0}/src/rootly_mcp_server/server.py

@@ -55,7 +55,40 @@ class RootlyMCPServer(FastMCP):
         # Set default allowed paths if none provided
         self.allowed_paths = allowed_paths or [
             "/incidents",
-            "/incidents/{incident_id}/alerts"
+            "/incidents/{incident_id}/alerts",
+            "/alerts",
+            "/alerts/{alert_id}",
+            "/severities",
+            "/severities/{severity_id}",
+            "/teams",
+            "/teams/{team_id}",
+            "/services",
+            "/services/{service_id}",
+            "/functionalities",
+            "/functionalities/{functionality_id}",
+            # Incident types
+            "/incident_types",
+            "/incident_types/{incident_type_id}",
+            # Action items (all, by id, by incident)
+            "/incident_action_items",
+            "/incident_action_items/{incident_action_item_id}",
+            "/incidents/{incident_id}/action_items",
+            # Workflows
+            "/workflows",
+            "/workflows/{workflow_id}",
+            # Workflow runs
+            "/workflow_runs",
+            "/workflow_runs/{workflow_run_id}",
+            # Environments
+            "/environments",
+            "/environments/{environment_id}",
+            # Users
+            "/users",
+            "/users/{user_id}",
+            "/users/me",
+            # Status pages
+            "/status_pages",
+            "/status_pages/{status_page_id}"
         ]
         # Add /v1 prefix to paths if not present
         self.allowed_paths = [
@@ -64,7 +97,8 @@ class RootlyMCPServer(FastMCP):
         ]
 
         logger.info(f"Initializing RootlyMCPServer with allowed paths: {self.allowed_paths}")
-        super().__init__(name)
+        # Initialize FastMCP with ERROR log level to fix Cline UI issue
+        super().__init__(name, log_level="ERROR")
 
         # Initialize the Rootly API client
         self.client = RootlyClient()
@@ -356,7 +390,7 @@ class RootlyMCPServer(FastMCP):
             path: The API path.
             method: The HTTP method.
             operation: The Swagger operation object.
-            **kwargs: The parameters for the request.
+            **v: The parameters for the request.
 
         Returns:
             The API response as a JSON string.
@@ -378,38 +412,39 @@ class RootlyMCPServer(FastMCP):
         body_params = {}
 
         if method.lower() == "get":
-            # For GET requests, all remaining parameters are query parameters
             query_params = kwargs
-
-            # Add default pagination for incident-related endpoints
             if "incidents" in path and method.lower() == "get":
-                # Check if pagination parameters are already specified
                 has_pagination = any(param.startswith("page[") for param in query_params.keys())
-
-                # If no pagination parameters are specified, add default page size
                 if not has_pagination:
                     query_params["page[size]"] = self.default_page_size
-                    logger.info(f"Added default pagination (page[size]={self.default_page_size}) for incidents endpoint: {path}")
+                    logger.debug(f"Added default pagination (page[size]={self.default_page_size}) for incidents endpoint: {path}")
         else:
-            # For other methods, check which parameters are query parameters
             for param in operation.get("parameters", []):
                 param_name = param.get("name")
                 param_in = param.get("in")
-
                 if param_in == "query" and param_name in kwargs:
                     query_params[param_name] = kwargs.pop(param_name)
-
-            # All remaining parameters go in the request body
             body_params = kwargs
 
-        # Make the API request
         try:
+            json_api_type = None
+            if method.lower() in ["post", "put", "patch"]:
+                segments = [seg for seg in actual_path.split("/") if seg and not seg.startswith(":") and not seg.startswith("{")]
+                if segments:
+                    if segments[-1].startswith("by_") or segments[-1].endswith("_id") or segments[-1].startswith("id") or segments[-1].startswith("{id"):
+                        if len(segments) > 1:
+                            json_api_type = segments[-2]
+                    else:
+                        json_api_type = segments[-1]
+
             response = self.client.make_request(
                 method=method.upper(),
                 path=actual_path,
                 query_params=query_params if query_params else None,
-                json_data=body_params if body_params else None
+                json_data=body_params if body_params else None,
+                json_api_type=json_api_type
             )
+            # Do not include kwargs or payload in the output, just return the response
             return response
         except Exception as e:
             logger.error(f"Error calling Rootly API: {e}")

{rootly_mcp_server-0.0.4 → rootly_mcp_server-1.0.0}/test_mcp_client.py

@@ -78,7 +78,16 @@ def main():
                 }
             })
             response = receive_message(process)
-            print(f"Call Tool Response: {json.dumps(response, indent=2)}")
+            # Check for 'kwargs' in the response and print only its value parsed as JSON
+            if response and isinstance(response, dict) and "kwargs" in response:
+                try:
+                    parsed_kwargs = json.loads(response["kwargs"])
+                    print(json.dumps(parsed_kwargs, indent=2))
+                except Exception as e:
+                    print(f"Error parsing 'kwargs': {e}")
+                    print(f"Raw kwargs: {response['kwargs']}")
+            else:
+                print(f"Call Tool Response: {json.dumps(response, indent=2)}")
             
     except Exception as e:
         print(f"Error: {e}")

{rootly_mcp_server-0.0.4 → rootly_mcp_server-1.0.0}/uv.lock

@@ -380,7 +380,7 @@ wheels = [
 
 [[package]]
 name = "rootly-mcp-server"
-version = "0.0.4"
+version = "1.0.0"
 source = { editable = "." }
 dependencies = [
     { name = "mcp" },