datarobot-genai 0.2.31__py3-none-any.whl

datarobot_genai/drmcp/tools/confluence/tools.py

@@ -0,0 +1,321 @@
+# Copyright 2025 DataRobot, Inc.
+#
+# 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.
+
+"""Confluence MCP tools for interacting with Confluence Cloud."""
+
+import logging
+from typing import Annotated
+
+from fastmcp.exceptions import ToolError
+from fastmcp.tools.tool import ToolResult
+
+from datarobot_genai.drmcp.core.mcp_instance import dr_mcp_tool
+from datarobot_genai.drmcp.tools.clients.atlassian import get_atlassian_access_token
+from datarobot_genai.drmcp.tools.clients.confluence import ConfluenceClient
+from datarobot_genai.drmcp.tools.clients.confluence import ConfluenceError
+
+logger = logging.getLogger(__name__)
+
+
+@dr_mcp_tool(tags={"confluence", "read", "get", "page"})
+async def confluence_get_page(
+    *,
+    page_id_or_title: Annotated[str, "The ID or the exact title of the Confluence page."],
+    space_key: Annotated[
+        str | None,
+        "Required if identifying the page by title. The space key (e.g., 'PROJ').",
+    ] = None,
+) -> ToolResult | ToolError:
+    """Retrieve the content of a specific Confluence page.
+
+    Use this tool to fetch Confluence pages by their numeric ID or by title.
+    Returns page content in HTML storage format.
+
+    Usage:
+        - By ID: page_id_or_title="856391684"
+        - By title: page_id_or_title="Meeting Notes", space_key="TEAM"
+
+    When using a page title, the space_key parameter is required.
+    """
+    if not page_id_or_title:
+        raise ToolError("Argument validation error: 'page_id_or_title' cannot be empty.")
+
+    access_token = await get_atlassian_access_token()
+    if isinstance(access_token, ToolError):
+        raise access_token
+
+    try:
+        async with ConfluenceClient(access_token) as client:
+            if page_id_or_title.isdigit():
+                page_response = await client.get_page_by_id(page_id_or_title)
+            else:
+                if not space_key:
+                    raise ToolError(
+                        "Argument validation error: "
+                        "'space_key' is required when identifying a page by title."
+                    )
+                page_response = await client.get_page_by_title(page_id_or_title, space_key)
+    except ConfluenceError as e:
+        logger.error(f"Confluence error getting page: {e}")
+        raise ToolError(str(e))
+    except Exception as e:
+        logger.error(f"Unexpected error getting Confluence page: {e}")
+        raise ToolError(
+            f"An unexpected error occurred while getting Confluence page "
+            f"'{page_id_or_title}': {str(e)}"
+        )
+
+    return ToolResult(
+        content=f"Successfully retrieved page '{page_response.title}'.",
+        structured_content=page_response.as_flat_dict(),
+    )
+
+
+@dr_mcp_tool(tags={"confluence", "write", "create", "page"})
+async def confluence_create_page(
+    *,
+    space_key: Annotated[str, "The key of the Confluence space where the new page should live."],
+    title: Annotated[str, "The title of the new page."],
+    body_content: Annotated[
+        str,
+        "The content of the page, typically in Confluence Storage Format (XML) or raw text.",
+    ],
+    parent_id: Annotated[
+        int | None,
+        "The ID of the parent page, used to create a child page.",
+    ] = None,
+) -> ToolResult:
+    """Create a new documentation page in a specified Confluence space.
+
+    Use this tool to create new Confluence pages with content in storage format.
+    The page will be created at the root level of the space unless a parent_id
+    is provided, in which case it will be created as a child page.
+
+    Usage:
+        - Root page: space_key="PROJ", title="New Page", body_content="<p>Content</p>"
+        - Child page: space_key="PROJ", title="Sub Page", body_content="<p>Content</p>",
+                      parent_id=123456
+    """
+    if not all([space_key, title, body_content]):
+        raise ToolError(
+            "Argument validation error: space_key, title, and body_content are required fields."
+        )
+
+    access_token = await get_atlassian_access_token()
+    if isinstance(access_token, ToolError):
+        raise access_token
+
+    try:
+        async with ConfluenceClient(access_token) as client:
+            page_response = await client.create_page(
+                space_key=space_key,
+                title=title,
+                body_content=body_content,
+                parent_id=parent_id,
+            )
+    except ConfluenceError as e:
+        logger.error(f"Confluence error creating page: {e}")
+        raise ToolError(str(e))
+    except Exception as e:
+        logger.error(f"Unexpected error creating Confluence page: {e}")
+        raise ToolError(
+            f"An unexpected error occurred while creating Confluence page "
+            f"'{title}' in space '{space_key}': {str(e)}"
+        )
+
+    return ToolResult(
+        content=f"New page '{title}' created successfully in space '{space_key}'.",
+        structured_content={"new_page_id": page_response.page_id, "title": page_response.title},
+    )
+
+
+@dr_mcp_tool(tags={"confluence", "write", "add", "comment"})
+async def confluence_add_comment(
+    *,
+    page_id: Annotated[str, "The numeric ID of the page where the comment will be added."],
+    comment_body: Annotated[str, "The text content of the comment."],
+) -> ToolResult:
+    """Add a new comment to a specified Confluence page for collaboration.
+
+    Use this tool to add comments to Confluence pages to facilitate collaboration
+    and discussion. Comments are added at the page level.
+
+    Usage:
+        - Add comment: page_id="856391684", comment_body="Great work on this documentation!"
+    """
+    if not page_id:
+        raise ToolError("Argument validation error: 'page_id' cannot be empty.")
+
+    if not comment_body:
+        raise ToolError("Argument validation error: 'comment_body' cannot be empty.")
+
+    access_token = await get_atlassian_access_token()
+    if isinstance(access_token, ToolError):
+        raise access_token
+
+    try:
+        async with ConfluenceClient(access_token) as client:
+            comment_response = await client.add_comment(
+                page_id=page_id,
+                comment_body=comment_body,
+            )
+    except ConfluenceError as e:
+        logger.error(f"Confluence error adding comment: {e}")
+        raise ToolError(str(e))
+    except Exception as e:
+        logger.error(f"Unexpected error adding comment to Confluence page: {e}")
+        raise ToolError(
+            f"An unexpected error occurred while adding comment to page '{page_id}': {str(e)}"
+        )
+
+    return ToolResult(
+        content=f"Comment added successfully to page ID {page_id}.",
+        structured_content={
+            "comment_id": comment_response.comment_id,
+            "page_id": page_id,
+        },
+    )
+
+
+@dr_mcp_tool(tags={"confluence", "search", "content"})
+async def confluence_search(
+    *,
+    cql_query: Annotated[
+        str,
+        "The CQL (Confluence Query Language) string used to filter content, "
+        "e.g., 'type=page and space=DOC'.",
+    ],
+    max_results: Annotated[int, "Maximum number of content items to return. Default is 10."] = 10,
+    include_body: Annotated[
+        bool,
+        "If True, fetch full page body content for each result (slower, "
+        "makes additional API calls). Default is False, which returns only excerpts.",
+    ] = False,
+) -> ToolResult:
+    """
+    Search Confluence pages and content efficiently using a CQL query string.
+    This pushes the search logic to the Confluence API (Push-Down).
+
+    Refer to Confluence documentation for advanced searching using CQL:
+    https://developer.atlassian.com/cloud/confluence/advanced-searching-using-cql/
+    """
+    if not cql_query:
+        raise ToolError("Argument validation error: 'cql_query' cannot be empty.")
+
+    if max_results < 1 or max_results > 100:
+        raise ToolError("Argument validation error: 'max_results' must be between 1 and 100.")
+
+    access_token = await get_atlassian_access_token()
+    if isinstance(access_token, ToolError):
+        raise access_token
+
+    try:
+        async with ConfluenceClient(access_token) as client:
+            results = await client.search_confluence_content(
+                cql_query=cql_query, max_results=max_results
+            )
+
+            # If include_body is True, fetch full content for each page
+            if include_body and results:
+                data = []
+                for result in results:
+                    flat = result.as_flat_dict()
+                    try:
+                        page = await client.get_page_by_id(result.id)
+                        flat["body"] = page.body
+                    except ConfluenceError:
+                        flat["body"] = None  # Keep excerpt if page fetch fails
+                    data.append(flat)
+            else:
+                data = [result.as_flat_dict() for result in results]
+
+    except ConfluenceError as e:
+        logger.error(f"Confluence error searching content: {e}")
+        raise ToolError(str(e))
+    except Exception as e:
+        logger.error(f"Unexpected error searching Confluence content: {e}")
+        raise ToolError(f"An unexpected error occurred while searching Confluence: {str(e)}")
+
+    n = len(results)
+    return ToolResult(
+        content=f"Successfully executed CQL query and retrieved {n} result(s).",
+        structured_content={"data": data, "count": n},
+    )
+
+
+@dr_mcp_tool(tags={"confluence", "write", "update", "page"})
+async def confluence_update_page(
+    *,
+    page_id: Annotated[str, "The ID of the Confluence page to update."],
+    new_body_content: Annotated[
+        str,
+        "The full updated content of the page in Confluence Storage Format (XML) or raw text.",
+    ],
+    version_number: Annotated[
+        int,
+        "The current version number of the page, required to prevent update conflicts. "
+        "Get this from the confluence_get_page tool.",
+    ],
+) -> ToolResult:
+    """Update the content of an existing Confluence page.
+
+    Requires the current version number to ensure atomic updates.
+    Use this tool to update the body content of an existing Confluence page.
+    The version_number is required for optimistic locking - it prevents overwriting
+    changes made by others since you last fetched the page.
+
+    Usage:
+        page_id="856391684", new_body_content="<p>New content</p>", version_number=5
+
+    Important: Always fetch the page first using confluence_get_page to get the
+    current version number before updating.
+    """
+    if not page_id:
+        raise ToolError("Argument validation error: 'page_id' cannot be empty.")
+
+    if not new_body_content:
+        raise ToolError("Argument validation error: 'new_body_content' cannot be empty.")
+
+    if version_number < 1:
+        raise ToolError(
+            "Argument validation error: 'version_number' must be a positive integer (>= 1)."
+        )
+
+    access_token = await get_atlassian_access_token()
+    if isinstance(access_token, ToolError):
+        raise access_token
+
+    try:
+        async with ConfluenceClient(access_token) as client:
+            page_response = await client.update_page(
+                page_id=page_id,
+                new_body_content=new_body_content,
+                version_number=version_number,
+            )
+    except ConfluenceError as e:
+        logger.error(f"Confluence error updating page: {e}")
+        raise ToolError(str(e))
+    except Exception as e:
+        logger.error(f"Unexpected error updating Confluence page: {e}")
+        raise ToolError(
+            f"An unexpected error occurred while updating Confluence page '{page_id}': {str(e)}"
+        )
+
+    return ToolResult(
+        content=f"Page ID {page_id} updated successfully to version {page_response.version}.",
+        structured_content={
+            "updated_page_id": page_response.page_id,
+            "new_version": page_response.version,
+        },
+    )

datarobot_genai/drmcp/tools/gdrive/tools.py

@@ -0,0 +1,347 @@
+# Copyright 2025 DataRobot, Inc.
+#
+# 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.
+
+"""Google Drive MCP tools for interacting with Google Drive API."""
+
+import logging
+from typing import Annotated
+
+from fastmcp.exceptions import ToolError
+from fastmcp.tools.tool import ToolResult
+
+from datarobot_genai.drmcp.core.mcp_instance import dr_mcp_tool
+from datarobot_genai.drmcp.tools.clients.gdrive import GOOGLE_DRIVE_FOLDER_MIME
+from datarobot_genai.drmcp.tools.clients.gdrive import LIMIT
+from datarobot_genai.drmcp.tools.clients.gdrive import MAX_PAGE_SIZE
+from datarobot_genai.drmcp.tools.clients.gdrive import SUPPORTED_FIELDS
+from datarobot_genai.drmcp.tools.clients.gdrive import SUPPORTED_FIELDS_STR
+from datarobot_genai.drmcp.tools.clients.gdrive import GoogleDriveClient
+from datarobot_genai.drmcp.tools.clients.gdrive import GoogleDriveError
+from datarobot_genai.drmcp.tools.clients.gdrive import get_gdrive_access_token
+
+logger = logging.getLogger(__name__)
+
+
+@dr_mcp_tool(tags={"google", "gdrive", "list", "search", "files", "find", "contents"})
+async def gdrive_find_contents(
+    *,
+    page_size: Annotated[
+        int, f"Maximum number of files to return per page (max {MAX_PAGE_SIZE})."
+    ] = 10,
+    limit: Annotated[int, f"Total maximum number of files to return (max {LIMIT})."] = 50,
+    page_token: Annotated[
+        str | None, "The token for the next page of results, retrieved from a previous call."
+    ] = None,
+    query: Annotated[
+        str | None, "Optional filter to narrow results (e.g., 'trashed = false')."
+    ] = None,
+    folder_id: Annotated[
+        str | None,
+        "The ID of a specific folder to list or search within. "
+        "If omitted, searches the entire Drive.",
+    ] = None,
+    recursive: Annotated[
+        bool,
+        "If True, searches all subfolders. "
+        "If False and folder_id is provided, only lists immediate children.",
+    ] = False,
+    fields: Annotated[
+        list[str] | None,
+        "Optional list of metadata fields to include. Ex. id, name, mimeType. "
+        f"Default = {SUPPORTED_FIELDS_STR}",
+    ] = None,
+) -> ToolResult:
+    """
+    Search or list files in the user's Google Drive with pagination and filtering support.
+    Use this tool to discover file names and IDs for use with other tools.
+
+    Limit must be bigger than or equal to page size and it must be multiplication of page size.
+    Ex.
+        page size = 10 limit = 50
+        page size = 3 limit = 3
+        page size = 12 limit = 36
+    """
+    access_token = await get_gdrive_access_token()
+    if isinstance(access_token, ToolError):
+        raise access_token
+
+    try:
+        async with GoogleDriveClient(access_token) as client:
+            data = await client.list_files(
+                page_size=page_size,
+                page_token=page_token,
+                query=query,
+                limit=limit,
+                folder_id=folder_id,
+                recursive=recursive,
+            )
+    except GoogleDriveError as e:
+        logger.error(f"Google Drive error listing files: {e}")
+        raise ToolError(str(e))
+    except Exception as e:
+        logger.error(f"Unexpected error listing Google Drive files: {e}")
+        raise ToolError(f"An unexpected error occurred while listing Google Drive files: {str(e)}")
+
+    filtered_fields = set(fields).intersection(SUPPORTED_FIELDS) if fields else SUPPORTED_FIELDS
+    number_of_files = len(data.files)
+    next_page_info = (
+        f"Next page token needed to fetch more data: {data.next_page_token}"
+        if data.next_page_token
+        else "There're no more pages."
+    )
+    return ToolResult(
+        content=f"Successfully listed {number_of_files} files. {next_page_info}",
+        structured_content={
+            "files": [
+                file.model_dump(by_alias=True, include=filtered_fields) for file in data.files
+            ],
+            "count": number_of_files,
+            "nextPageToken": data.next_page_token,
+        },
+    )
+
+
+@dr_mcp_tool(tags={"google", "gdrive", "read", "content", "file", "download"})
+async def gdrive_read_content(
+    *,
+    file_id: Annotated[str, "The ID of the file to read."],
+    target_format: Annotated[
+        str | None,
+        "The preferred output format for Google Workspace files "
+        "(e.g., 'text/markdown' for Docs, 'text/csv' for Sheets). "
+        "If not specified, uses sensible defaults. Has no effect on regular files.",
+    ] = None,
+) -> ToolResult:
+    """
+    Retrieve the content of a specific file by its ID. Google Workspace files are
+    automatically exported to LLM-readable formats (Push-Down).
+
+    Usage:
+        - Basic: gdrive_read_content(file_id="1ABC123def456")
+        - Custom format: gdrive_read_content(file_id="1ABC...", target_format="text/plain")
+        - First use gdrive_find_contents to discover file IDs
+
+    Supported conversions (defaults):
+        - Google Docs -> Markdown (text/markdown)
+        - Google Sheets -> CSV (text/csv)
+        - Google Slides -> Plain text (text/plain)
+        - PDF files -> Extracted text (text/plain)
+        - Other text files -> Downloaded as-is
+
+    Note: Binary files (images, videos, etc.) are not supported and will return an error.
+    Large Google Workspace files (>10MB) may fail to export due to API limits.
+
+    Refer to Google Drive export formats documentation:
+    https://developers.google.com/workspace/drive/api/guides/ref-export-formats
+    """
+    if not file_id or not file_id.strip():
+        raise ToolError("Argument validation error: 'file_id' cannot be empty.")
+
+    access_token = await get_gdrive_access_token()
+    if isinstance(access_token, ToolError):
+        raise access_token
+
+    try:
+        async with GoogleDriveClient(access_token) as client:
+            file_content = await client.read_file_content(file_id, target_format)
+    except GoogleDriveError as e:
+        logger.error(f"Google Drive error reading file content: {e}")
+        raise ToolError(str(e))
+    except Exception as e:
+        logger.error(f"Unexpected error reading Google Drive file content: {e}")
+        raise ToolError(
+            f"An unexpected error occurred while reading Google Drive file content: {str(e)}"
+        )
+
+    export_info = ""
+    if file_content.was_exported:
+        export_info = f" (exported from {file_content.original_mime_type})"
+
+    return ToolResult(
+        content=(
+            f"Successfully retrieved content of '{file_content.name}' "
+            f"({file_content.mime_type}){export_info}."
+        ),
+        structured_content=file_content.as_flat_dict(),
+    )
+
+
+@dr_mcp_tool(tags={"google", "gdrive", "create", "write", "file", "folder"}, enabled=False)
+async def gdrive_create_file(
+    *,
+    name: Annotated[str, "The name for the new file or folder."],
+    mime_type: Annotated[
+        str,
+        "The MIME type of the file (e.g., 'text/plain', "
+        "'application/vnd.google-apps.document', 'application/vnd.google-apps.folder').",
+    ],
+    parent_id: Annotated[
+        str | None, "The ID of the parent folder where the file should be created."
+    ] = None,
+    initial_content: Annotated[
+        str | None, "Text content to populate the new file, if applicable."
+    ] = None,
+) -> ToolResult:
+    """
+    Create a new file or folder in Google Drive.
+
+    This tool is essential for an AI agent to generate new output (like reports or
+    documentation) directly into the Drive structure.
+
+    Usage:
+        - Create empty file: gdrive_create_file(name="report.txt", mime_type="text/plain")
+        - Create Google Doc: gdrive_create_file(
+            name="My Report",
+            mime_type="application/vnd.google-apps.document",
+            initial_content="# Report Title"
+          )
+        - Create folder: gdrive_create_file(
+            name="Reports",
+            mime_type="application/vnd.google-apps.folder"
+          )
+        - Create in subfolder: gdrive_create_file(
+            name="file.txt",
+            mime_type="text/plain",
+            parent_id="folder_id_here",
+            initial_content="File content"
+          )
+
+    Supported MIME types:
+        - text/plain: Plain text file
+        - application/vnd.google-apps.document: Google Doc (content auto-converted)
+        - application/vnd.google-apps.spreadsheet: Google Sheet (CSV content works best)
+        - application/vnd.google-apps.folder: Folder (initial_content is ignored)
+
+    Note: For Google Workspace files, the Drive API automatically converts plain text
+    content to the appropriate format.
+    """
+    if not name or not name.strip():
+        raise ToolError("Argument validation error: 'name' cannot be empty.")
+
+    if not mime_type or not mime_type.strip():
+        raise ToolError("Argument validation error: 'mime_type' cannot be empty.")
+
+    access_token = await get_gdrive_access_token()
+    if isinstance(access_token, ToolError):
+        raise access_token
+
+    try:
+        async with GoogleDriveClient(access_token) as client:
+            created_file = await client.create_file(
+                name=name,
+                mime_type=mime_type,
+                parent_id=parent_id,
+                initial_content=initial_content,
+            )
+    except GoogleDriveError as e:
+        logger.error(f"Google Drive error creating file: {e}")
+        raise ToolError(str(e))
+    except Exception as e:
+        logger.error(f"Unexpected error creating Google Drive file: {e}")
+        raise ToolError(f"An unexpected error occurred while creating Google Drive file: {str(e)}")
+
+    file_type = "folder" if mime_type == GOOGLE_DRIVE_FOLDER_MIME else "file"
+    content_info = ""
+    if initial_content and mime_type != GOOGLE_DRIVE_FOLDER_MIME:
+        content_info = " with initial content"
+
+    return ToolResult(
+        content=f"Successfully created {file_type} '{created_file.name}'{content_info}.",
+        structured_content=created_file.as_flat_dict(),
+    )
+
+
+@dr_mcp_tool(
+    tags={"google", "gdrive", "update", "metadata", "rename", "star", "trash"}, enabled=False
+)
+async def gdrive_update_metadata(
+    *,
+    file_id: Annotated[str, "The ID of the file or folder to update."],
+    new_name: Annotated[str | None, "A new name to rename the file."] = None,
+    starred: Annotated[bool | None, "Set to True to star the file or False to unstar it."] = None,
+    trash: Annotated[bool | None, "Set to True to trash the file or False to restore it."] = None,
+) -> ToolResult:
+    """
+    Update non-content metadata fields of a Google Drive file or folder.
+
+    This tool allows you to:
+    - Rename files and folders by setting new_name
+    - Star or unstar files (per-user preference) with starred
+    - Move files to trash or restore them with trash
+
+    Usage:
+        - Rename: gdrive_update_metadata(file_id="1ABC...", new_name="New Name.txt")
+        - Star: gdrive_update_metadata(file_id="1ABC...", starred=True)
+        - Unstar: gdrive_update_metadata(file_id="1ABC...", starred=False)
+        - Trash: gdrive_update_metadata(file_id="1ABC...", trash=True)
+        - Restore: gdrive_update_metadata(file_id="1ABC...", trash=False)
+        - Multiple: gdrive_update_metadata(file_id="1ABC...", new_name="New.txt", starred=True)
+
+    Note:
+        - At least one of new_name, starred, or trash must be provided.
+        - Starring is per-user: starring a shared file only affects your view.
+        - Trashing a folder trashes all contents recursively.
+        - Trashing requires permissions (owner for My Drive, organizer for Shared Drives).
+    """
+    if not file_id or not file_id.strip():
+        raise ToolError("Argument validation error: 'file_id' cannot be empty.")
+
+    if new_name is None and starred is None and trash is None:
+        raise ToolError(
+            "Argument validation error: at least one of 'new_name', 'starred', or 'trash' "
+            "must be provided."
+        )
+
+    if new_name is not None and not new_name.strip():
+        raise ToolError("Argument validation error: 'new_name' cannot be empty or whitespace.")
+
+    access_token = await get_gdrive_access_token()
+    if isinstance(access_token, ToolError):
+        raise access_token
+
+    try:
+        async with GoogleDriveClient(access_token) as client:
+            updated_file = await client.update_file_metadata(
+                file_id=file_id,
+                new_name=new_name,
+                starred=starred,
+                trashed=trash,
+            )
+    except GoogleDriveError as e:
+        logger.error(f"Google Drive error updating file metadata: {e}")
+        raise ToolError(str(e))
+    except Exception as e:
+        logger.error(f"Unexpected error updating Google Drive file metadata: {e}")
+        raise ToolError(
+            f"An unexpected error occurred while updating Google Drive file metadata: {str(e)}"
+        )
+
+    changes: list[str] = []
+    if new_name is not None:
+        changes.append(f"renamed to '{new_name}'")
+    if starred is True:
+        changes.append("starred")
+    elif starred is False:
+        changes.append("unstarred")
+    if trash is True:
+        changes.append("moved to trash")
+    elif trash is False:
+        changes.append("restored from trash")
+
+    changes_description = ", ".join(changes)
+
+    return ToolResult(
+        content=f"Successfully updated file '{updated_file.name}': {changes_description}.",
+        structured_content=updated_file.as_flat_dict(),
+    )

datarobot_genai/drmcp/tools/jira/__init__.py

@@ -0,0 +1,14 @@
+# Copyright 2025 DataRobot, Inc.
+#
+# 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.
+