datarobot-genai 0.2.37__py3-none-any.whl → 0.3.1__py3-none-any.whl

datarobot_genai/drmcp/tools/gdrive/tools.py

@@ -22,21 +22,17 @@ 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"}, enabled=False
-)
+@dr_mcp_tool(tags={"google", "gdrive", "list", "search", "files", "find", "contents"})
 async def gdrive_find_contents(
     *,
     page_size: Annotated[
@@ -67,44 +63,34 @@ async def gdrive_find_contents(
 ) -> 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.
+    Use this tool to discover GDrive 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
+
+    Examples
+    --------
+        - 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)}")
+    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,
+        )
 
     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
@@ -127,8 +113,7 @@ async def gdrive_read_content(
     ] = None,
 ) -> ToolResult:
     """
-    Retrieve the content of a specific file by its ID. Google Workspace files are
-    automatically exported to LLM-readable formats (Push-Down).
+    Retrieve the content of a specific Google drive file by its ID.
 
     Usage:
         - Basic: gdrive_read_content(file_id="1ABC123def456")
@@ -155,27 +140,10 @@ async def gdrive_read_content(
     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})"
+    async with GoogleDriveClient(access_token) as client:
+        file_content = await client.read_file_content(file_id, target_format)
 
     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(),
     )
 
@@ -239,28 +207,15 @@ async def gdrive_create_file(
     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"
+    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,
+        )
 
     return ToolResult(
-        content=f"Successfully created {file_type} '{created_file.name}'{content_info}.",
         structured_content=created_file.as_flat_dict(),
     )
 
@@ -313,44 +268,20 @@ async def gdrive_update_metadata(
     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)}"
+    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,
         )
 
-    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(),
     )
 
 
-@dr_mcp_tool(tags={"google", "gdrive", "manage", "access", "acl"})
+@dr_mcp_tool(tags={"google", "gdrive", "manage", "access", "acl"}, enabled=False)
 async def gdrive_manage_access(
     *,
     file_id: Annotated[str, "The ID of the file or folder."],
@@ -408,39 +339,19 @@ async def gdrive_manage_access(
     if isinstance(access_token, ToolError):
         raise access_token
 
-    try:
-        async with GoogleDriveClient(access_token) as client:
-            permission_id = await client.manage_access(
-                file_id=file_id,
-                action=action,
-                role=role,
-                email_address=email_address,
-                permission_id=permission_id,
-                transfer_ownership=transfer_ownership,
-            )
-    except GoogleDriveError as e:
-        logger.error(f"Google Drive permission operation failed: {e}")
-        raise ToolError(str(e))
-    except Exception as e:
-        logger.error(f"Unexpected error changing permissions for Google Drive file {file_id}: {e}")
-        raise ToolError(
-            f"Unexpected error changing permissions for Google Drive file {file_id}: {str(e)}"
+    async with GoogleDriveClient(access_token) as client:
+        permission_id = await client.manage_access(
+            file_id=file_id,
+            action=action,
+            role=role,
+            email_address=email_address,
+            permission_id=permission_id,
+            transfer_ownership=transfer_ownership,
         )
 
     # Build response
     structured_content = {"affectedFileId": file_id}
     if action == "add":
-        content = (
-            f"Successfully added role '{role}' for '{email_address}' for gdrive file '{file_id}'. "
-            f"New permission id '{permission_id}'."
-        )
         structured_content["newPermissionId"] = permission_id
-    elif action == "update":
-        content = (
-            f"Successfully updated role '{role}' (permission '{permission_id}') "
-            f"for gdrive file '{file_id}'."
-        )
-    else:  # action == "remove":
-        content = f"Successfully removed permission '{permission_id}' for gdrive file '{file_id}'."
 
-    return ToolResult(content=content, structured_content=structured_content)
+    return ToolResult(structured_content=structured_content)

datarobot_genai/drmcp/tools/jira/tools.py

@@ -53,10 +53,11 @@ async def jira_search_issues(
     async with JiraClient(access_token) as client:
         issues = await client.search_jira_issues(jql_query=jql_query, max_results=max_results)
 
-    n = len(issues)
     return ToolResult(
-        content=f"Successfully executed JQL query and retrieved {n} issue(s).",
-        structured_content={"data": [issue.as_flat_dict() for issue in issues], "count": n},
+        structured_content={
+            "data": [issue.as_flat_dict() for issue in issues],
+            "count": len(issues),
+        },
     )
 
 
@@ -72,17 +73,10 @@ async def jira_get_issue(
     if isinstance(access_token, ToolError):
         raise access_token
 
-    try:
-        async with JiraClient(access_token) as client:
-            issue = await client.get_jira_issue(issue_key)
-    except Exception as e:
-        logger.error(f"Unexpected error while getting Jira issue: {e}")
-        raise ToolError(
-            f"An unexpected error occurred while getting Jira issue '{issue_key}': {str(e)}"
-        )
+    async with JiraClient(access_token) as client:
+        issue = await client.get_jira_issue(issue_key)
 
     return ToolResult(
-        content=f"Successfully retrieved details for issue '{issue_key}'.",
         structured_content=issue.as_flat_dict(),
     )
 
@@ -118,20 +112,15 @@ async def jira_create_issue(
                 f"Unexpected issue type `{issue_type}`. Possible values are {possible_issue_types}."
             )
 
-    try:
-        async with JiraClient(access_token) as client:
-            issue_key = await client.create_jira_issue(
-                project_key=project_key,
-                summary=summary,
-                issue_type_id=issue_type_id,
-                description=description,
-            )
-    except Exception as e:
-        logger.error(f"Unexpected error while creating Jira issue: {e}")
-        raise ToolError(f"An unexpected error occurred while creating Jira issue: {str(e)}")
+    async with JiraClient(access_token) as client:
+        issue_key = await client.create_jira_issue(
+            project_key=project_key,
+            summary=summary,
+            issue_type_id=issue_type_id,
+            description=description,
+        )
 
     return ToolResult(
-        content=f"Successfully created issue '{issue_key}'.",
         structured_content={"newIssueKey": issue_key, "projectKey": project_key},
     )
 
@@ -179,18 +168,12 @@ async def jira_update_issue(
     if isinstance(access_token, ToolError):
         raise access_token
 
-    try:
-        async with JiraClient(access_token) as client:
-            updated_fields = await client.update_jira_issue(
-                issue_key=issue_key, fields=fields_to_update
-            )
-    except Exception as e:
-        logger.error(f"Unexpected error while updating Jira issue: {e}")
-        raise ToolError(f"An unexpected error occurred while updating Jira issue: {str(e)}")
+    async with JiraClient(access_token) as client:
+        updated_fields = await client.update_jira_issue(
+            issue_key=issue_key, fields=fields_to_update
+        )
 
-    updated_fields_str = ",".join(updated_fields)
     return ToolResult(
-        content=f"Successfully updated issue '{issue_key}'. Fields modified: {updated_fields_str}.",
         structured_content={"updatedIssueKey": issue_key, "fields": updated_fields},
     )
 
@@ -226,15 +209,10 @@ async def jira_transition_issue(
                 f"Possible values are {available_transitions_str}."
             )
 
-    try:
-        async with JiraClient(access_token) as client:
-            await client.transition_jira_issue(issue_key=issue_key, transition_id=transition_id)
-    except Exception as e:
-        logger.error(f"Unexpected error while transitioning Jira issue: {e}")
-        raise ToolError(f"An unexpected error occurred while transitioning Jira issue: {str(e)}")
+    async with JiraClient(access_token) as client:
+        await client.transition_jira_issue(issue_key=issue_key, transition_id=transition_id)
 
     return ToolResult(
-        content=f"Successfully transitioned issue '{issue_key}' to status '{transition_name}'.",
         structured_content={
             "transitionedIssueKey": issue_key,
             "newStatusName": transition_name,

datarobot_genai/drmcp/tools/microsoft_graph/tools.py

@@ -16,13 +16,14 @@
 
 import logging
 from typing import Annotated
+from typing import Any
+from typing import Literal
 
 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.microsoft_graph import MicrosoftGraphClient
-from datarobot_genai.drmcp.tools.clients.microsoft_graph import MicrosoftGraphError
 from datarobot_genai.drmcp.tools.clients.microsoft_graph import get_microsoft_graph_access_token
 from datarobot_genai.drmcp.tools.clients.microsoft_graph import validate_site_url
 
@@ -124,10 +125,6 @@ async def microsoft_graph_search_content(
     - Documentation: https://learn.microsoft.com/en-us/graph/api/search-query
     - Search concepts: https://learn.microsoft.com/en-us/graph/search-concept-files
 
-    Permissions:
-    - Requires Sites.Read.All or Sites.Search.All permission
-    - include_hidden_content only works with delegated permissions
-    - region parameter is required for application permissions in multi-region environments
     """
     if not search_query:
         raise ToolError("Argument validation error: 'search_query' cannot be empty.")
@@ -142,25 +139,16 @@ async def microsoft_graph_search_content(
     if isinstance(access_token, ToolError):
         raise access_token
 
-    try:
-        async with MicrosoftGraphClient(access_token=access_token, site_url=site_url) as client:
-            items = await client.search_content(
-                search_query=search_query,
-                site_id=site_id,
-                from_offset=from_offset,
-                size=size,
-                entity_types=entity_types,
-                filters=filters,
-                include_hidden_content=include_hidden_content,
-                region=region,
-            )
-    except MicrosoftGraphError as e:
-        logger.error(f"Microsoft Graph error searching content: {e}")
-        raise ToolError(str(e))
-    except Exception as e:
-        logger.error(f"Unexpected error searching Microsoft Graph content: {e}", exc_info=True)
-        raise ToolError(
-            f"An unexpected error occurred while searching Microsoft Graph content: {str(e)}"
+    async with MicrosoftGraphClient(access_token=access_token, site_url=site_url) as client:
+        items = await client.search_content(
+            search_query=search_query,
+            site_id=site_id,
+            from_offset=from_offset,
+            size=size,
+            entity_types=entity_types,
+            filters=filters,
+            include_hidden_content=include_hidden_content,
+            region=region,
         )
 
     results = []
@@ -180,12 +168,7 @@ async def microsoft_graph_search_content(
         }
         results.append(result_dict)
 
-    n = len(results)
     return ToolResult(
-        content=(
-            f"Successfully searched Microsoft Graph and retrieved {n} result(s) for "
-            f"'{search_query}' (from={from_offset}, size={size})."
-        ),
         structured_content={
             "query": search_query,
             "siteUrl": site_url,
@@ -193,7 +176,63 @@ async def microsoft_graph_search_content(
             "from": from_offset,
             "size": size,
             "results": results,
-            "count": n,
+            "count": len(results),
+        },
+    )
+
+
+@dr_mcp_tool(tags={"microsoft", "graph api", "sharepoint", "onedrive", "share"}, enabled=False)
+async def microsoft_graph_share_item(
+    *,
+    file_id: Annotated[str, "The ID of the file or folder to share."],
+    document_library_id: Annotated[str, "The ID of the document library containing the item."],
+    recipient_emails: Annotated[list[str], "A list of email addresses to invite."],
+    role: Annotated[Literal["read", "write"], "The role to assign: 'read' or 'write'."] = "read",
+    send_invitation: Annotated[
+        bool, "Flag determining if recipients should be notified. Default False"
+    ] = False,
+) -> ToolResult | ToolError:
+    """
+    Share a SharePoint or Onedrive file or folder with one or more users.
+    It works with internal users or existing guest users in the
+    tenant. It does NOT create new guest accounts and does NOT use the tenant-level
+    /invitations endpoint.
+
+    Microsoft Graph API is treating OneDrive and SharePoint resources as driveItem.
+
+    API Reference:
+    - DriveItem Resource Type: https://learn.microsoft.com/en-us/graph/api/resources/driveitem
+    - API Documentation: https://learn.microsoft.com/en-us/graph/api/driveitem-invite
+    """
+    if not file_id or not file_id.strip():
+        raise ToolError("Argument validation error: 'file_id' cannot be empty.")
+
+    if not document_library_id or not document_library_id.strip():
+        raise ToolError("Argument validation error: 'document_library_id' cannot be empty.")
+
+    if not recipient_emails:
+        raise ToolError("Argument validation error: you must provide at least one 'recipient'.")
+
+    access_token = await get_microsoft_graph_access_token()
+    if isinstance(access_token, ToolError):
+        raise access_token
+
+    async with MicrosoftGraphClient(access_token=access_token) as client:
+        await client.share_item(
+            file_id=file_id,
+            document_library_id=document_library_id,
+            recipient_emails=recipient_emails,
+            role=role,
+            send_invitation=send_invitation,
+        )
+
+    return ToolResult(
+        structured_content={
+            "fileId": file_id,
+            "documentLibraryId": document_library_id,
+            "recipientEmails": recipient_emails,
+            "n": len(recipient_emails),
+            "role": role,
         },
     )
 
@@ -208,7 +247,8 @@ async def microsoft_graph_search_content(
         "create",
         "file",
         "write",
-    }
+    },
+    enabled=False,
 )
 async def microsoft_create_file(
     *,
@@ -265,7 +305,6 @@ async def microsoft_create_file(
         )
 
     return ToolResult(
-        content=f"File '{created_file.name}' created successfully.",
         structured_content={
             "file_name": created_file.name,
             "destination": "onedrive" if is_personal_onedrive else "sharepoint",
@@ -275,3 +314,133 @@ async def microsoft_create_file(
             "parentFolderId": created_file.parent_folder_id,
         },
     )
+
+
+@dr_mcp_tool(
+    tags={
+        "microsoft",
+        "graph api",
+        "sharepoint",
+        "onedrive",
+        "metadata",
+        "update",
+        "fields",
+        "compliance",
+    },
+    enabled=False,
+)
+async def microsoft_update_metadata(
+    *,
+    item_id: Annotated[str, "The ID of the file or list item to update."],
+    fields_to_update: Annotated[
+        dict[str, Any],
+        "Key-value pairs of metadata fields to modify. "
+        "For SharePoint list items: any custom column values. "
+        "For drive items: 'name' and/or 'description'.",
+    ],
+    site_id: Annotated[
+        str | None,
+        "The site ID (required for SharePoint list items, along with list_id).",
+    ] = None,
+    list_id: Annotated[
+        str | None,
+        "The list ID (required for SharePoint list items, along with site_id).",
+    ] = None,
+    document_library_id: Annotated[
+        str | None,
+        "The drive ID (required for OneDrive/drive item updates). "
+        "Cannot be used together with site_id and list_id.",
+    ] = None,
+) -> ToolResult | ToolError:
+    """
+    Update metadata on a SharePoint list item or OneDrive/SharePoint drive item.
+
+    **SharePoint List Items:** Provide site_id and list_id to update custom
+    column values on a list item. All custom columns can be updated.
+
+    **OneDrive/Drive Items:** Provide document_library_id to update drive item
+    properties. Only 'name' and 'description' fields can be updated.
+
+    **Context Requirements:**
+    - For SharePoint list items: Both site_id AND list_id are required
+    - For OneDrive/drive items: document_library_id is required
+    - Cannot specify both contexts simultaneously
+
+    **Examples:**
+    - SharePoint list item: Update a 'Status' column to 'Approved'
+    - Drive item: Rename a file or update its description
+
+    """
+    if not item_id or not item_id.strip():
+        raise ToolError("Error: item_id is required.")
+    if not fields_to_update:
+        raise ToolError("Error: fields_to_update is required and cannot be empty.")
+
+    # Validate context parameters
+    has_sharepoint_context = site_id is not None and list_id is not None
+    has_partial_sharepoint_context = (site_id is not None) != (list_id is not None)
+    has_drive_context = document_library_id is not None
+
+    if has_partial_sharepoint_context:
+        raise ToolError(
+            "Error: For SharePoint list items, both site_id and list_id must be provided."
+        )
+
+    if has_sharepoint_context and has_drive_context:
+        raise ToolError(
+            "Error: Cannot specify both SharePoint (site_id + list_id) and OneDrive "
+            "(document_library_id) context. Choose one."
+        )
+
+    if not has_sharepoint_context and not has_drive_context:
+        raise ToolError(
+            "Error: Must specify either SharePoint context (site_id + list_id) or "
+            "OneDrive context (document_library_id)."
+        )
+
+    access_token = await get_microsoft_graph_access_token()
+    if isinstance(access_token, ToolError):
+        raise access_token
+
+    async with MicrosoftGraphClient(access_token=access_token) as client:
+        result = await client.update_item_metadata(
+            item_id=item_id.strip(),
+            fields_to_update=fields_to_update,
+            site_id=site_id,
+            list_id=list_id,
+            drive_id=document_library_id,
+        )
+
+    context_type = "sharepoint_list_item" if has_sharepoint_context else "drive_item"
+    structured: dict[str, Any] = {
+        "item_id": item_id,
+        "context_type": context_type,
+        "fields_updated": list(fields_to_update.keys()),
+    }
+
+    # Add context-specific IDs for traceability
+    if has_sharepoint_context:
+        structured["site_id"] = site_id
+        structured["list_id"] = list_id
+    else:
+        structured["document_library_id"] = document_library_id
+
+    # Include relevant response data
+    if isinstance(result, dict):
+        # For drive items, include key properties if present
+        if has_drive_context:
+            if "id" in result:
+                structured["id"] = result["id"]
+            if "name" in result:
+                structured["name"] = result["name"]
+            if "webUrl" in result:
+                structured["webUrl"] = result["webUrl"]
+            if "description" in result:
+                structured["description"] = result.get("description")
+        # For list items, the response is the fields object itself
+        else:
+            structured["updated_fields"] = result
+
+    return ToolResult(
+        structured_content=structured,
+    )