datarobot-genai 0.2.21__py3-none-any.whl → 0.2.24__py3-none-any.whl

datarobot_genai/drmcp/tools/clients/confluence.py

@@ -50,6 +50,7 @@ class ConfluencePage(BaseModel):
     space_id: str = Field(..., description="Space ID where the page resides")
     space_key: str | None = Field(None, description="Space key (if available)")
     body: str = Field(..., description="Page content in storage format (HTML-like)")
+    version: int = Field(..., description="Current version number of the page")
 
     def as_flat_dict(self) -> dict[str, Any]:
         """Return a flat dictionary representation of the page."""
@@ -59,6 +60,7 @@ class ConfluencePage(BaseModel):
             "space_id": self.space_id,
             "space_key": self.space_key,
             "body": self.body,
+            "version": self.version,
         }
 
 
@@ -111,7 +113,7 @@ class ConfluenceClient:
     At the moment of creating this client, official Confluence SDK is not supporting async.
     """
 
-    EXPAND_FIELDS = "body.storage,space"
+    EXPAND_FIELDS = "body.storage,space,version"
 
     def __init__(self, access_token: str) -> None:
         """
@@ -164,6 +166,8 @@ class ConfluenceClient:
         space = data.get("space", {})
         space_key = space.get("key") if isinstance(space, dict) else None
         space_id = space.get("id", "") if isinstance(space, dict) else data.get("spaceId", "")
+        version_data = data.get("version", {})
+        version_number = version_data.get("number", 1) if isinstance(version_data, dict) else 1
 
         return ConfluencePage(
             page_id=str(data.get("id", "")),
@@ -171,6 +175,7 @@ class ConfluenceClient:
             space_id=str(space_id),
             space_key=space_key,
             body=body_content,
+            version=version_number,
         )
 
     async def get_page_by_id(self, page_id: str) -> ConfluencePage:
@@ -339,6 +344,93 @@ class ConfluenceClient:
 
         return self._parse_response(response.json())
 
+    async def update_page(
+        self,
+        page_id: str,
+        new_body_content: str,
+        version_number: int,
+    ) -> ConfluencePage:
+        """
+        Update the content of an existing Confluence page.
+
+        Args:
+            page_id: The ID of the page to update
+            new_body_content: The new content in Confluence Storage Format (XML) or raw text
+            version_number: The current version number of the page (for optimistic locking).
+                           The update will increment this by 1.
+
+        Returns
+        -------
+            ConfluencePage with the updated page data including the new version number
+
+        Raises
+        ------
+            ConfluenceError: If page not found (404), version conflict (409),
+                            permission denied (403), invalid content (400),
+                            or rate limited (429)
+            httpx.HTTPStatusError: If the API request fails with unexpected status
+        """
+        cloud_id = await self._get_cloud_id()
+        url = f"{ATLASSIAN_API_BASE}/ex/confluence/{cloud_id}/wiki/rest/api/content/{page_id}"
+
+        try:
+            current_page = await self.get_page_by_id(page_id)
+            title_to_use = current_page.title
+        except ConfluenceError as e:
+            if e.status_code == 404:
+                raise ConfluenceError(
+                    f"Page with ID '{page_id}' not found: cannot fetch existing title",
+                    status_code=404,
+                )
+            raise
+
+        payload: dict[str, Any] = {
+            "type": "page",
+            "title": title_to_use,
+            "body": {
+                "storage": {
+                    "value": new_body_content,
+                    "representation": "storage",
+                }
+            },
+            "version": {
+                "number": version_number + 1,
+            },
+        }
+
+        response = await self._client.put(url, json=payload)
+
+        if response.status_code == HTTPStatus.NOT_FOUND:
+            error_msg = self._extract_error_message(response)
+            raise ConfluenceError(
+                f"Page with ID '{page_id}' not found: {error_msg}",
+                status_code=404,
+            )
+
+        if response.status_code == HTTPStatus.CONFLICT:
+            error_msg = self._extract_error_message(response)
+            raise ConfluenceError(
+                f"Version conflict: the page has been modified since version {version_number}. "
+                f"Please fetch the latest version and retry. Details: {error_msg}",
+                status_code=409,
+            )
+
+        if response.status_code == HTTPStatus.FORBIDDEN:
+            raise ConfluenceError(
+                f"Permission denied: you don't have access to update page '{page_id}'",
+                status_code=403,
+            )
+
+        if response.status_code == HTTPStatus.BAD_REQUEST:
+            error_msg = self._extract_error_message(response)
+            raise ConfluenceError(f"Invalid request: {error_msg}", status_code=400)
+
+        if response.status_code == HTTPStatus.TOO_MANY_REQUESTS:
+            raise ConfluenceError("Rate limit exceeded. Please try again later.", status_code=429)
+
+        response.raise_for_status()
+        return self._parse_response(response.json())
+
     def _parse_comment_response(self, data: dict, page_id: str) -> ConfluenceComment:
         """Parse API response into ConfluenceComment."""
         body_content = ""

datarobot_genai/drmcp/tools/clients/gdrive.py

@@ -14,6 +14,7 @@
 
 """Google Drive API Client and utilities for OAuth."""
 
+import io
 import logging
 from typing import Annotated
 from typing import Any
@@ -24,16 +25,37 @@ from fastmcp.exceptions import ToolError
 from pydantic import BaseModel
 from pydantic import ConfigDict
 from pydantic import Field
+from pypdf import PdfReader
 
 from datarobot_genai.drmcp.core.auth import get_access_token
 
 logger = logging.getLogger(__name__)
 
-DEFAULT_FIELDS = "nextPageToken,files(id,name,size,mimeType,webViewLink,createdTime,modifiedTime)"
+SUPPORTED_FIELDS = {"id", "name", "size", "mimeType", "webViewLink", "createdTime", "modifiedTime"}
+SUPPORTED_FIELDS_STR = ",".join(SUPPORTED_FIELDS)
+DEFAULT_FIELDS = f"nextPageToken,files({SUPPORTED_FIELDS_STR})"
+GOOGLE_DRIVE_FOLDER_MIME = "application/vnd.google-apps.folder"
 DEFAULT_ORDER = "modifiedTime desc"
 MAX_PAGE_SIZE = 100
 LIMIT = 500
 
+GOOGLE_WORKSPACE_EXPORT_MIMES: dict[str, str] = {
+    "application/vnd.google-apps.document": "text/markdown",
+    "application/vnd.google-apps.spreadsheet": "text/csv",
+    "application/vnd.google-apps.presentation": "text/plain",
+}
+
+BINARY_MIME_PREFIXES = (
+    "image/",
+    "audio/",
+    "video/",
+    "application/zip",
+    "application/octet-stream",
+    "application/vnd.google-apps.drawing",
+)
+
+PDF_MIME_TYPE = "application/pdf"
+
 
 async def get_gdrive_access_token() -> str | ToolError:
     """
@@ -113,6 +135,35 @@ class PaginatedResult(BaseModel):
     next_page_token: str | None = None
 
 
+class GoogleDriveFileContent(BaseModel):
+    """Content retrieved from a Google Drive file."""
+
+    id: str
+    name: str
+    mime_type: str
+    content: str
+    original_mime_type: str
+    was_exported: bool = False
+    size: int | None = None
+    web_view_link: str | None = None
+
+    def as_flat_dict(self) -> dict[str, Any]:
+        """Return a flat dictionary representation of the file content."""
+        result: dict[str, Any] = {
+            "id": self.id,
+            "name": self.name,
+            "mimeType": self.mime_type,
+            "content": self.content,
+            "originalMimeType": self.original_mime_type,
+            "wasExported": self.was_exported,
+        }
+        if self.size is not None:
+            result["size"] = self.size
+        if self.web_view_link is not None:
+            result["webViewLink"] = self.web_view_link
+        return result
+
+
 class GoogleDriveClient:
     """Client for interacting with Google Drive API."""
 
@@ -129,6 +180,8 @@ class GoogleDriveClient:
         limit: int,
         page_token: str | None = None,
         query: str | None = None,
+        folder_id: str | None = None,
+        recursive: bool = False,
     ) -> PaginatedResult:
         """
         List files from Google Drive.
@@ -143,6 +196,10 @@ class GoogleDriveClient:
                 If not provided it'll list all authorized user files.
                 If the query doesn't contain operators (contains, =, etc.), it will be treated as
                 a name search: "name contains '{query}'".
+            folder_id: The ID of a specific folder to list or search within.
+                If omitted, searches the entire Drive.
+            recursive: If True, searches all subfolders.
+                If False and folder_id is provided, only lists immediate children.
 
         Returns
         -------
@@ -159,26 +216,85 @@ class GoogleDriveClient:
 
         page_size = min(page_size, MAX_PAGE_SIZE)
         limit = min(limit, LIMIT)
-        fetched = 0
+        formatted_query = self._build_query(query, folder_id)
+
+        if not recursive or not folder_id:
+            files, next_token = await self._fetch_paginated(
+                page_size=page_size,
+                limit=limit,
+                page_token=page_token,
+                query=formatted_query,
+            )
+            return PaginatedResult(files=files, next_page_token=next_token)
+
+        files = await self._fetch_recursive(
+            root_folder_id=folder_id,
+            base_query=query,
+            page_size=page_size,
+            limit=limit,
+        )
 
-        formatted_query = self._get_formatted_query(query)
+        return PaginatedResult(files=files, next_page_token=page_token)
 
+    async def _fetch_paginated(
+        self,
+        page_size: int,
+        limit: int,
+        page_token: str | None,
+        query: str | None,
+    ) -> tuple[list[GoogleDriveFile], str | None]:
+        fetched = 0
         files: list[GoogleDriveFile] = []
+        next_page_token = page_token
 
         while fetched < limit:
             data = await self._list_files(
                 page_size=page_size,
-                page_token=page_token,
-                query=formatted_query,
+                page_token=next_page_token,
+                query=query,
             )
+
             files.extend(data.files)
             fetched += len(data.files)
-            page_token = data.next_page_token
+            next_page_token = data.next_page_token
 
-            if not page_token:
+            if not next_page_token:
                 break
 
-        return PaginatedResult(files=files, next_page_token=page_token)
+        return files, next_page_token
+
+    async def _fetch_recursive(
+        self,
+        root_folder_id: str,
+        base_query: str | None,
+        page_size: int,
+        limit: int,
+    ) -> list[GoogleDriveFile]:
+        collected: list[GoogleDriveFile] = []
+        folders_to_visit: list[str] = [root_folder_id]
+
+        while folders_to_visit and len(collected) < limit:
+            current_folder = folders_to_visit.pop(0)
+
+            query = self._build_query(base_query, current_folder)
+
+            files, _ = await self._fetch_paginated(
+                page_size=page_size,
+                limit=limit - len(collected),
+                page_token=None,
+                query=query,
+            )
+
+            for file in files:
+                collected.append(file)
+
+                if file.mime_type == GOOGLE_DRIVE_FOLDER_MIME:
+                    folders_to_visit.append(file.id)
+
+                if len(collected) >= limit:
+                    break
+
+        return collected
 
     async def _list_files(
         self,
@@ -207,6 +323,45 @@ class GoogleDriveClient:
         next_page_token = data.get("nextPageToken")
         return PaginatedResult(files=files, next_page_token=next_page_token)
 
+    def _build_query(self, query: str | None, folder_id: str | None) -> str | None:
+        """Build Google Drive API query.
+
+        Args:
+            query: Optional search query string (e.g., "name contains 'report'"").
+                If the query doesn't contain operators (contains, =, etc.), it will be treated as
+                a name search: "name contains '{query}'".
+            folder_id: Optional folder id.
+                If provided it'll narrow query to search/list only in given folder.
+
+        Returns
+        -------
+            Correctly builded query (if provided)
+        """
+        base_query = self._get_formatted_query(query)
+
+        if base_query:
+            # Case #1 -- Some query provided and contains in parents (gdrive "folder id")
+            if "in parents" in base_query and folder_id:
+                logger.debug(
+                    "In-parents (parent folder) already used in query. "
+                    "Omiting folder_id argument. "
+                    f"Query: {base_query} | FolderId: {folder_id}"
+                )
+                return base_query
+            # Case #2 -- Some query provided without "in parents" and folder id provided.
+            elif folder_id:
+                return f"{base_query} and '{folder_id}' in parents"
+            # Case #3 -- Query provided without "in parents" and no folder id.
+            else:
+                return base_query
+
+        # Case #4 -- Base query is null but folder id provided
+        if folder_id:
+            return f"'{folder_id}' in parents"
+
+        # Case #5 -- Neither query not folder provided
+        return None
+
     @staticmethod
     def _get_formatted_query(query: str | None) -> str | None:
         """Get formatted Google Drive API query.
@@ -237,6 +392,213 @@ class GoogleDriveClient:
             logger.debug(f"Auto-formatted query '{query}' to '{formatted_query}'")
         return formatted_query
 
+    @staticmethod
+    def _is_binary_mime_type(mime_type: str) -> bool:
+        """Check if MIME type indicates binary content that's not useful for LLM consumption.
+
+        Args:
+            mime_type: The MIME type to check.
+
+        Returns
+        -------
+            True if the MIME type is considered binary, False otherwise.
+        """
+        return any(mime_type.startswith(prefix) for prefix in BINARY_MIME_PREFIXES)
+
+    async def get_file_metadata(self, file_id: str) -> GoogleDriveFile:
+        """Get file metadata from Google Drive.
+
+        Args:
+            file_id: The ID of the file to get metadata for.
+
+        Returns
+        -------
+            GoogleDriveFile with file metadata.
+
+        Raises
+        ------
+            GoogleDriveError: If the file is not found or access is denied.
+        """
+        params = {"fields": SUPPORTED_FIELDS_STR}
+        response = await self._client.get(f"/{file_id}", params=params)
+
+        if response.status_code == 404:
+            raise GoogleDriveError(f"File with ID '{file_id}' not found.")
+        if response.status_code == 403:
+            raise GoogleDriveError(f"Permission denied: you don't have access to file '{file_id}'.")
+        if response.status_code == 429:
+            raise GoogleDriveError("Rate limit exceeded. Please try again later.")
+
+        response.raise_for_status()
+        return GoogleDriveFile.from_api_response(response.json())
+
+    async def _export_workspace_file(self, file_id: str, export_mime_type: str) -> str:
+        """Export a Google Workspace file to the specified format.
+
+        Args:
+            file_id: The ID of the Google Workspace file.
+            export_mime_type: The MIME type to export to (e.g., 'text/markdown').
+
+        Returns
+        -------
+            The exported content as a string.
+
+        Raises
+        ------
+            GoogleDriveError: If export fails.
+        """
+        response = await self._client.get(
+            f"/{file_id}/export",
+            params={"mimeType": export_mime_type},
+        )
+
+        if response.status_code == 404:
+            raise GoogleDriveError(f"File with ID '{file_id}' not found.")
+        if response.status_code == 403:
+            raise GoogleDriveError(
+                f"Permission denied: you don't have access to export file '{file_id}'."
+            )
+        if response.status_code == 400:
+            raise GoogleDriveError(
+                f"Cannot export file '{file_id}' to format '{export_mime_type}'. "
+                "The file may not support this export format."
+            )
+        if response.status_code == 429:
+            raise GoogleDriveError("Rate limit exceeded. Please try again later.")
+
+        response.raise_for_status()
+        return response.text
+
+    async def _download_file(self, file_id: str) -> str:
+        """Download a regular file's content from Google Drive as text."""
+        content = await self._download_file_bytes(file_id)
+        return content.decode("utf-8")
+
+    async def _download_file_bytes(self, file_id: str) -> bytes:
+        """Download a file's content as bytes from Google Drive.
+
+        Args:
+            file_id: The ID of the file to download.
+
+        Returns
+        -------
+            The file content as bytes.
+
+        Raises
+        ------
+            GoogleDriveError: If download fails.
+        """
+        response = await self._client.get(
+            f"/{file_id}",
+            params={"alt": "media"},
+        )
+
+        if response.status_code == 404:
+            raise GoogleDriveError(f"File with ID '{file_id}' not found.")
+        if response.status_code == 403:
+            raise GoogleDriveError(
+                f"Permission denied: you don't have access to download file '{file_id}'."
+            )
+        if response.status_code == 429:
+            raise GoogleDriveError("Rate limit exceeded. Please try again later.")
+
+        response.raise_for_status()
+        return response.content
+
+    def _extract_text_from_pdf(self, pdf_bytes: bytes) -> str:
+        """Extract text from PDF bytes using pypdf.
+
+        Args:
+            pdf_bytes: The PDF file content as bytes.
+
+        Returns
+        -------
+            Extracted text from the PDF.
+
+        Raises
+        ------
+            GoogleDriveError: If PDF text extraction fails.
+        """
+        try:
+            reader = PdfReader(io.BytesIO(pdf_bytes))
+            text_parts = []
+            for page in reader.pages:
+                page_text = page.extract_text()
+                if page_text:
+                    text_parts.append(page_text)
+            return "\n\n".join(text_parts)
+        except Exception as e:
+            raise GoogleDriveError(f"Failed to extract text from PDF: {e}")
+
+    async def read_file_content(
+        self, file_id: str, target_format: str | None = None
+    ) -> GoogleDriveFileContent:
+        """Read the content of a file from Google Drive.
+
+        Google Workspace files (Docs, Sheets, Slides) are automatically exported to
+        LLM-readable formats:
+        - Google Docs -> Markdown (text/markdown)
+        - Google Sheets -> CSV (text/csv)
+        - Google Slides -> Plain text (text/plain)
+        - PDF files -> Extracted text (text/plain)
+
+        Regular text files are downloaded directly.
+        Binary files (images, videos, etc.) will raise an error.
+
+        Args:
+            file_id: The ID of the file to read.
+            target_format: Optional MIME type to export Google Workspace files to.
+                If not specified, uses sensible defaults. Has no effect on non-Workspace files.
+
+        Returns
+        -------
+            GoogleDriveFileContent with the file content and metadata.
+
+        Raises
+        ------
+            GoogleDriveError: If the file cannot be read (not found, permission denied,
+                             binary file, etc.).
+        """
+        file_metadata = await self.get_file_metadata(file_id)
+        original_mime_type = file_metadata.mime_type
+
+        if self._is_binary_mime_type(original_mime_type):
+            raise GoogleDriveError(
+                f"Binary files are not supported for reading. "
+                f"File '{file_metadata.name}' has MIME type '{original_mime_type}'."
+            )
+
+        if original_mime_type == GOOGLE_DRIVE_FOLDER_MIME:
+            raise GoogleDriveError(
+                f"Cannot read content of a folder. '{file_metadata.name}' is a folder, not a file."
+            )
+
+        was_exported = False
+        if original_mime_type in GOOGLE_WORKSPACE_EXPORT_MIMES:
+            export_mime = target_format or GOOGLE_WORKSPACE_EXPORT_MIMES[original_mime_type]
+            content = await self._export_workspace_file(file_id, export_mime)
+            result_mime_type = export_mime
+            was_exported = True
+        elif original_mime_type == PDF_MIME_TYPE:
+            pdf_bytes = await self._download_file_bytes(file_id)
+            content = self._extract_text_from_pdf(pdf_bytes)
+            result_mime_type = "text/plain"
+            was_exported = True
+        else:
+            content = await self._download_file(file_id)
+            result_mime_type = original_mime_type
+
+        return GoogleDriveFileContent(
+            id=file_metadata.id,
+            name=file_metadata.name,
+            mime_type=result_mime_type,
+            content=content,
+            original_mime_type=original_mime_type,
+            was_exported=was_exported,
+            size=file_metadata.size,
+            web_view_link=file_metadata.web_view_link,
+        )
+
     async def __aenter__(self) -> "GoogleDriveClient":
         """Async context manager entry."""
         return self

datarobot_genai/drmcp/tools/confluence/tools.py

@@ -252,3 +252,70 @@ async def confluence_search(
         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

@@ -23,6 +23,8 @@ 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 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
@@ -30,8 +32,8 @@ from datarobot_genai.drmcp.tools.clients.gdrive import get_gdrive_access_token
 logger = logging.getLogger(__name__)
 
 
-@dr_mcp_tool(tags={"google", "gdrive", "list", "files"})
-async def google_drive_list_files(
+@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})."
@@ -43,9 +45,24 @@ async def google_drive_list_files(
     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 | ToolError:
     """
-    List files in the user's Google Drive with pagination and filtering support.
+    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.
@@ -61,7 +78,12 @@ async def google_drive_list_files(
     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
+                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}")
@@ -70,6 +92,7 @@ async def google_drive_list_files(
         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}"
@@ -80,9 +103,75 @@ async def google_drive_list_files(
         content=f"Successfully listed {number_of_files} files. {next_page_info}",
         structured_content={
             "files": [
-                file.model_dump(by_alias=True, include={"id", "name"}) for file in data.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 | ToolError:
+    """
+    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)}"
+        )
+
+    # Provide helpful context about the conversion
+    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(),
+    )

datarobot_genai/drmcp/tools/predictive/training.py

@@ -18,8 +18,11 @@ import json
 import logging
 from dataclasses import asdict
 from dataclasses import dataclass
+from typing import Annotated
 
 import pandas as pd
+from fastmcp.exceptions import ToolError
+from fastmcp.tools.tool import ToolResult
 
 from datarobot_genai.drmcp.core.clients import get_sdk_client
 from datarobot_genai.drmcp.core.mcp_instance import dr_mcp_tool
@@ -53,22 +56,15 @@ class DatasetInsight:
     missing_data_summary: dict[str, float]
 
 
-@dr_mcp_tool(tags={"training", "analysis", "dataset"})
-async def analyze_dataset(dataset_id: str) -> str:
-    """
-    Analyze a dataset to understand its structure and potential use cases.
+@dr_mcp_tool(tags={"predictive", "training", "read", "analysis", "dataset"})
+async def analyze_dataset(
+    *,
+    dataset_id: Annotated[str, "The ID of the DataRobot dataset to analyze"] | None = None,
+) -> ToolError | ToolResult:
+    """Analyze a dataset to understand its structure and potential use cases."""
+    if not dataset_id:
+        return ToolError("Dataset ID must be provided")
 
-    Args:
-        dataset_id: The ID of the DataRobot dataset to analyze
-
-    Returns
-    -------
-        JSON string containing dataset insights including:
-        - Basic statistics (rows, columns)
-        - Column types (numerical, categorical, datetime, text)
-        - Potential target columns
-        - Missing data summary
-    """
     client = get_sdk_client()
     dataset = client.Dataset.get(dataset_id)
     df = dataset.get_as_dataframe()
@@ -105,27 +101,23 @@ async def analyze_dataset(dataset_id: str) -> str:
         potential_targets=potential_targets,
         missing_data_summary=missing_data,
     )
+    insights_dict = asdict(insights)
 
-    return json.dumps(asdict(insights), indent=2)
-
+    return ToolResult(
+        content=json.dumps(insights_dict, indent=2),
+        structured_content=insights_dict,
+    )
 
-@dr_mcp_tool(tags={"training", "analysis", "usecase"})
-async def suggest_use_cases(dataset_id: str) -> str:
-    """
-    Analyze a dataset and suggest potential machine learning use cases.
 
-    Args:
-        dataset_id: The ID of the DataRobot dataset to analyze
+@dr_mcp_tool(tags={"predictive", "training", "read", "analysis", "usecase"})
+async def suggest_use_cases(
+    *,
+    dataset_id: Annotated[str, "The ID of the DataRobot dataset to analyze"] | None = None,
+) -> ToolError | ToolResult:
+    """Analyze a dataset and suggest potential machine learning use cases."""
+    if not dataset_id:
+        return ToolError("Dataset ID must be provided")
 
-    Returns
-    -------
-        JSON string containing suggested use cases with:
-        - Use case name and description
-        - Suggested target column
-        - Problem type
-        - Confidence score
-        - Reasoning for the suggestion
-    """
     client = get_sdk_client()
     dataset = client.Dataset.get(dataset_id)
     df = dataset.get_as_dataframe()
@@ -141,27 +133,23 @@ async def suggest_use_cases(dataset_id: str) -> str:
 
     # Sort by confidence score
     suggestions.sort(key=lambda x: x["confidence"], reverse=True)
-    return json.dumps(suggestions, indent=2)
-
-
-@dr_mcp_tool(tags={"training", "analysis", "eda"})
-async def get_exploratory_insights(dataset_id: str, target_col: str | None = None) -> str:
-    """
-    Generate exploratory data insights for a dataset.
-
-    Args:
-        dataset_id: The ID of the DataRobot dataset to analyze
-        target_col: Optional target column to focus EDA insights on
-
-    Returns
-    -------
-        JSON string containing EDA insights including:
-        - Dataset summary statistics
-        - Target variable analysis (if specified)
-        - Feature correlations with target
-        - Missing data analysis
-        - Data type distribution
-    """
+
+    return ToolResult(
+        content=json.dumps(suggestions, indent=2),
+        structured_content={"use_case_suggestions": suggestions},
+    )
+
+
+@dr_mcp_tool(tags={"predictive", "training", "read", "analysis", "eda"})
+async def get_exploratory_insights(
+    *,
+    dataset_id: Annotated[str, "The ID of the DataRobot dataset to analyze"] | None = None,
+    target_col: Annotated[str, "Optional target column to focus EDA insights on"] | None = None,
+) -> ToolError | ToolResult:
+    """Generate exploratory data insights for a dataset."""
+    if not dataset_id:
+        return ToolError("Dataset ID must be provided")
+
     client = get_sdk_client()
     dataset = client.Dataset.get(dataset_id)
     df = dataset.get_as_dataframe()
@@ -238,8 +226,10 @@ async def get_exploratory_insights(dataset_id: str, target_col: str | None = Non
                     sorted(correlations.items(), key=lambda x: abs(x[1]), reverse=True)
                 )
 
-    eda_insights["ui_panel"] = ["eda"]
-    return json.dumps(eda_insights, indent=2)
+    return ToolResult(
+        content=json.dumps(eda_insights, indent=2),
+        structured_content=eda_insights,
+    )
 
 
 def _identify_potential_targets(
@@ -450,47 +440,50 @@ def _analyze_target_for_use_cases(df: pd.DataFrame, target_col: str) -> list[Use
     return suggestions
 
 
-@dr_mcp_tool(tags={"training", "autopilot", "model"})
+@dr_mcp_tool(tags={"predictive", "training", "write", "autopilot", "model"})
 async def start_autopilot(
-    target: str,
-    project_id: str | None = None,
-    mode: str | None = "quick",
-    dataset_url: str | None = None,
-    dataset_id: str | None = None,
-    project_name: str | None = "MCP Project",
-    use_case_id: str | None = None,
-) -> str:
-    """
-    Start automated model training (Autopilot) for a project.
-
-    Args:
-        target: Name of the target column for modeling.
-        project_id: Optional, the ID of the DataRobot project or a new project if no id is provided.
-        mode: Optional, Autopilot mode ('quick', 'comprehensive', or 'manual')
-        dataset_url: Optional, The URL to the dataset to upload (optional if dataset_id is provided)
-            for a new project.
-        dataset_id: Optional, The ID of an existing dataset in AI Catalog (optional if dataset_url
-            is provided) for a new project.
-        project_name: Optional, name for the project if no id is provided, creates a new project.
-        use_case_id: Optional, ID of the use case to associate this project with (required for
-            next-gen platform).
-
-    Returns
-    -------
-        JSON string containing:
-        - project_id: Project ID
-        - target: Target column name
-        - mode: Selected Autopilot mode
-        - status: Current project status
-        - ui_panel: List of recommended UI panels for visualization
-    """
+    *,
+    target: Annotated[str, "Name of the target column for modeling"] | None = None,
+    project_id: Annotated[
+        str, "Optional, the ID of the DataRobot project or a new project if no id is provided"
+    ]
+    | None = None,
+    mode: Annotated[str, "Optional, Autopilot mode ('quick', 'comprehensive', or 'manual')"]
+    | None = "quick",
+    dataset_url: Annotated[
+        str,
+        """
+        Optional, The URL to the dataset to upload
+        (optional if dataset_id is provided) for a new project.
+        """,
+    ]
+    | None = None,
+    dataset_id: Annotated[
+        str,
+        """
+        Optional, The ID of an existing dataset in AI Catalog
+        (optional if dataset_url is provided) for a new project.
+        """,
+    ]
+    | None = None,
+    project_name: Annotated[
+        str, "Optional, name for the project if no id is provided, creates a new project"
+    ]
+    | None = "MCP Project",
+    use_case_id: Annotated[
+        str,
+        "Optional, ID of the use case to associate this project (required for next-gen platform)",
+    ]
+    | None = None,
+) -> ToolError | ToolResult:
+    """Start automated model training (Autopilot) for a project."""
     client = get_sdk_client()
 
     if not project_id:
         if not dataset_url and not dataset_id:
-            return "Error: Either dataset_url or dataset_id must be provided"
+            return ToolError("Either dataset_url or dataset_id must be provided")
         if dataset_url and dataset_id:
-            return "Error: Please provide either dataset_url or dataset_id, not both"
+            return ToolError("Please provide either dataset_url or dataset_id, not both")
 
         if dataset_url:
             dataset = client.Dataset.create_from_url(dataset_url)
@@ -504,7 +497,7 @@ async def start_autopilot(
         project = client.Project.get(project_id)
 
     if not target:
-        return "Error: Target variable must be specified"
+        return ToolError("Target variable must be specified")
 
     try:
         # Start modeling
@@ -515,40 +508,48 @@ async def start_autopilot(
             "target": target,
             "mode": mode,
             "status": project.get_status(),
-            "ui_panel": ["eda", "model-training", "leaderboard"],
             "use_case_id": project.use_case_id,
         }
 
-        return json.dumps(result, indent=2)
-    except Exception as e:
-        return json.dumps(
-            {
-                "error": f"Failed to start Autopilot: {str(e)}",
-                "project_id": project.id,
-                "target": target,
-                "mode": mode,
-            },
-            indent=2,
+        return ToolResult(
+            content=json.dumps(result, indent=2),
+            structured_content=result,
         )
 
+    except Exception as e:
+        return ToolError(
+            content=json.dumps(
+                {
+                    "error": f"Failed to start Autopilot: {str(e)}",
+                    "project_id": project.id if project else None,
+                    "target": target,
+                    "mode": mode,
+                },
+                indent=2,
+            )
+        )
 
-@dr_mcp_tool(tags={"training", "model", "evaluation"})
-async def get_model_roc_curve(project_id: str, model_id: str, source: str = "validation") -> str:
-    """
-    Get detailed ROC curve for a specific model.
 
-    Args:
-        project_id: The ID of the DataRobot project
-        model_id: The ID of the model to analyze
-        source: The source of the data to use for the ROC curve ('validation' or 'holdout' or
-            'crossValidation')
+@dr_mcp_tool(tags={"prediction", "training", "read", "model", "evaluation"})
+async def get_model_roc_curve(
+    *,
+    project_id: Annotated[str, "The ID of the DataRobot project"] | None = None,
+    model_id: Annotated[str, "The ID of the model to analyze"] | None = None,
+    source: Annotated[
+        str,
+        """
+        The source of the data to use for the ROC curve
+        ('validation' or 'holdout' or 'crossValidation')
+        """,
+    ]
+    | str = "validation",
+) -> ToolError | ToolResult:
+    """Get detailed ROC curve for a specific model."""
+    if not project_id:
+        return ToolError("Project ID must be provided")
+    if not model_id:
+        return ToolError("Model ID must be provided")
 
-    Returns
-    -------
-        JSON string containing:
-        - roc_curve: ROC curve data
-        - ui_panel: List of recommended UI panels for visualization
-    """
     client = get_sdk_client()
     project = client.Project.get(project_id)
     model = client.Model.get(project=project, model_id=model_id)
@@ -581,26 +582,26 @@ async def get_model_roc_curve(project_id: str, model_id: str, source: str = "val
             "source": source,
         }
 
-        return json.dumps({"data": roc_data, "ui_panel": ["roc-curve"]}, indent=2)
+        return ToolResult(
+            content=json.dumps({"data": roc_data}, indent=2),
+            structured_content={"data": roc_data},
+        )
     except Exception as e:
-        return json.dumps({"error": f"Failed to get ROC curve: {str(e)}"}, indent=2)
+        return ToolError(f"Failed to get ROC curve: {str(e)}")
 
 
-@dr_mcp_tool(tags={"training", "model", "evaluation"})
-async def get_model_feature_impact(project_id: str, model_id: str) -> str:
-    """
-    Get detailed feature impact for a specific model.
-
-    Args:
-        project_id: The ID of the DataRobot project
-        model_id: The ID of the model to analyze
+@dr_mcp_tool(tags={"predictive", "training", "read", "model", "evaluation"})
+async def get_model_feature_impact(
+    *,
+    project_id: Annotated[str, "The ID of the DataRobot project"] | None = None,
+    model_id: Annotated[str, "The ID of the model to analyze"] | None = None,
+) -> ToolError | ToolResult:
+    """Get detailed feature impact for a specific model."""
+    if not project_id:
+        return ToolError("Project ID must be provided")
+    if not model_id:
+        return ToolError("Model ID must be provided")
 
-    Returns
-    -------
-        JSON string containing:
-        - feature_impact: Feature importance scores
-        - ui_panel: List of recommended UI panels for visualization
-    """
     client = get_sdk_client()
     project = client.Project.get(project_id)
     model = client.Model.get(project=project, model_id=model_id)
@@ -608,26 +609,31 @@ async def get_model_feature_impact(project_id: str, model_id: str) -> str:
     model.request_feature_impact()
     feature_impact = model.get_or_request_feature_impact()
 
-    return json.dumps({"data": feature_impact, "ui_panel": ["feature-impact"]}, indent=2)
-
+    return ToolResult(
+        content=json.dumps({"data": feature_impact}, indent=2),
+        structured_content={"data": feature_impact},
+    )
 
-@dr_mcp_tool(tags={"training", "model", "evaluation"})
-async def get_model_lift_chart(project_id: str, model_id: str, source: str = "validation") -> str:
-    """
-    Get detailed lift chart for a specific model.
 
-    Args:
-        project_id: The ID of the DataRobot project
-        model_id: The ID of the model to analyze
-        source: The source of the data to use for the lift chart ('validation' or 'holdout' or
-            'crossValidation')
+@dr_mcp_tool(tags={"predictive", "training", "read", "model", "evaluation"})
+async def get_model_lift_chart(
+    project_id: Annotated[str, "The ID of the DataRobot project"] | None = None,
+    model_id: Annotated[str, "The ID of the model to analyze"] | None = None,
+    source: Annotated[
+        str,
+        """
+        The source of the data to use for the lift chart
+        ('validation' or 'holdout' or 'crossValidation')
+        """,
+    ]
+    | str = "validation",
+) -> ToolError | ToolResult:
+    """Get detailed lift chart for a specific model."""
+    if not project_id:
+        return ToolError("Project ID must be provided")
+    if not model_id:
+        return ToolError("Model ID must be provided")
 
-    Returns
-    -------
-        JSON string containing:
-        - lift_chart: Lift chart data
-        - ui_panel: List of recommended UI panels for visualization
-    """
     client = get_sdk_client()
     project = client.Project.get(project_id)
     model = client.Model.get(project=project, model_id=model_id)
@@ -648,4 +654,7 @@ async def get_model_lift_chart(project_id: str, model_id: str, source: str = "va
         "target_class": lift_chart.target_class,
     }
 
-    return json.dumps({"data": lift_chart_data, "ui_panel": ["lift-chart"]}, indent=2)
+    return ToolResult(
+        content=json.dumps({"data": lift_chart_data}, indent=2),
+        structured_content={"data": lift_chart_data},
+    )

{datarobot_genai-0.2.21.dist-info → datarobot_genai-0.2.24.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datarobot-genai
-Version: 0.2.21
+Version: 0.2.24
 Summary: Generic helpers for GenAI
 Project-URL: Homepage, https://github.com/datarobot-oss/datarobot-genai
 Author: DataRobot, Inc.

{datarobot_genai-0.2.21.dist-info → datarobot_genai-0.2.24.dist-info}/RECORD

@@ -78,14 +78,14 @@ datarobot_genai/drmcp/test_utils/utils.py,sha256=esGKFv8aO31-Qg3owayeWp32BYe1CdY
 datarobot_genai/drmcp/tools/__init__.py,sha256=0kq9vMkF7EBsS6lkEdiLibmUrghTQqosHbZ5k-V9a5g,578
 datarobot_genai/drmcp/tools/clients/__init__.py,sha256=0kq9vMkF7EBsS6lkEdiLibmUrghTQqosHbZ5k-V9a5g,578
 datarobot_genai/drmcp/tools/clients/atlassian.py,sha256=__M_uz7FrcbKCYRzeMn24DCEYD6OmFx_LuywHCxgXsA,6472
-datarobot_genai/drmcp/tools/clients/confluence.py,sha256=YS5XsKd-jK5Yg0rgwOcC76v9e8fDJgUZIW5B9kcq5B0,17101
-datarobot_genai/drmcp/tools/clients/gdrive.py,sha256=QmNTmJdSqYO5Y5Vnp3roNZiNNJeocBVjF9UcSzcjgRY,8635
+datarobot_genai/drmcp/tools/clients/confluence.py,sha256=h_G0By_kDnJeWDT_d-IREsaZ5-0xB5GoLXOqblYP5MA,20706
+datarobot_genai/drmcp/tools/clients/gdrive.py,sha256=e28XwX0C8E3nql85-_NbUEMB-4s0lsQ2f5spj9BgsgM,21455
 datarobot_genai/drmcp/tools/clients/jira.py,sha256=Rm91JAyrNIqxu66-9rU1YqoRXVnWbEy-Ahvy6f6HlVg,9823
 datarobot_genai/drmcp/tools/clients/s3.py,sha256=GmwzvurFdNfvxOooA8g5S4osRysHYU0S9ypg_177Glg,953
 datarobot_genai/drmcp/tools/confluence/__init__.py,sha256=0kq9vMkF7EBsS6lkEdiLibmUrghTQqosHbZ5k-V9a5g,578
-datarobot_genai/drmcp/tools/confluence/tools.py,sha256=ySwABe8osAzky3BO3lRaF6UHnXQgaurkmvM0iHFfL30,9849
+datarobot_genai/drmcp/tools/confluence/tools.py,sha256=_-ws65WLK8KZP_mKkf4yJ7ZunR8qdyoiMwHQX47MSMw,12362
 datarobot_genai/drmcp/tools/gdrive/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-datarobot_genai/drmcp/tools/gdrive/tools.py,sha256=wmCUSaCWqepdlOIApA8tZ-grPYSV7wZKoer6uRy26Qg,3459
+datarobot_genai/drmcp/tools/gdrive/tools.py,sha256=EvoEr3AEI-xRldwCTZHiQfBRHQfLtgHuojTx8mXhlU4,7074
 datarobot_genai/drmcp/tools/jira/__init__.py,sha256=0kq9vMkF7EBsS6lkEdiLibmUrghTQqosHbZ5k-V9a5g,578
 datarobot_genai/drmcp/tools/jira/tools.py,sha256=dfkqTU2HH-7n44hX80ODFacKq0p0LOchFcZtIIKFNMM,9687
 datarobot_genai/drmcp/tools/predictive/__init__.py,sha256=WuOHlNNEpEmcF7gVnhckruJRKU2qtmJLE3E7zoCGLDo,1030
@@ -96,7 +96,7 @@ datarobot_genai/drmcp/tools/predictive/model.py,sha256=Yih5-KedJ-1yupPLXCJsCXOdy
 datarobot_genai/drmcp/tools/predictive/predict.py,sha256=Qoob2_t2crfWtyPzkXMRz2ITZumnczU6Dq4C7q9RBMI,9370
 datarobot_genai/drmcp/tools/predictive/predict_realtime.py,sha256=urq6rPyZFsAP-bPyclSNzrkvb6FTamdlFau8q0IWWJ0,13472
 datarobot_genai/drmcp/tools/predictive/project.py,sha256=KaMDAvJY4s12j_4ybA7-KcCS1yMOj-KPIKNBgCSE2iM,2536
-datarobot_genai/drmcp/tools/predictive/training.py,sha256=kxeDVLqUh9ajDk8wK7CZRRydDK8UNuTVZCB3huUihF8,23660
+datarobot_genai/drmcp/tools/predictive/training.py,sha256=S9V7AlO6mAgIAJNww0g5agFOw4YqRiCsIGaRDJcOe4A,23991
 datarobot_genai/langgraph/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 datarobot_genai/langgraph/agent.py,sha256=DRnywmS9KDywyChtuIZZwNKbJs8BpC259EG_kxYbiQ8,15828
 datarobot_genai/langgraph/mcp.py,sha256=iA2_j46mZAaNaL7ntXT-LW6C-NMJkzr3VfKDDfe7mh8,2851
@@ -111,9 +111,9 @@ datarobot_genai/nat/datarobot_llm_clients.py,sha256=Yu208Ed_p_4P3HdpuM7fYnKcXtim
 datarobot_genai/nat/datarobot_llm_providers.py,sha256=aDoQcTeGI-odqydPXEX9OGGNFbzAtpqzTvHHEkmJuEQ,4963
 datarobot_genai/nat/datarobot_mcp_client.py,sha256=35FzilxNp4VqwBYI0NsOc91-xZm1C-AzWqrOdDy962A,9612
 datarobot_genai/nat/helpers.py,sha256=Q7E3ADZdtFfS8E6OQPyw2wgA6laQ58N3bhLj5CBWwJs,3265
-datarobot_genai-0.2.21.dist-info/METADATA,sha256=wdbafq2Z77RRyxy7nG-kYCUU5pfCbsDbBTH7QdENnRU,6301
-datarobot_genai-0.2.21.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-datarobot_genai-0.2.21.dist-info/entry_points.txt,sha256=jEW3WxDZ8XIK9-ISmTyt5DbmBb047rFlzQuhY09rGrM,284
-datarobot_genai-0.2.21.dist-info/licenses/AUTHORS,sha256=isJGUXdjq1U7XZ_B_9AH8Qf0u4eX0XyQifJZ_Sxm4sA,80
-datarobot_genai-0.2.21.dist-info/licenses/LICENSE,sha256=U2_VkLIktQoa60Nf6Tbt7E4RMlfhFSjWjcJJfVC-YCE,11341
-datarobot_genai-0.2.21.dist-info/RECORD,,
+datarobot_genai-0.2.24.dist-info/METADATA,sha256=-QGxEqh8oSYn-gL93kIxqGhOTkrlHQRMf4HqMYTyfDs,6301
+datarobot_genai-0.2.24.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+datarobot_genai-0.2.24.dist-info/entry_points.txt,sha256=jEW3WxDZ8XIK9-ISmTyt5DbmBb047rFlzQuhY09rGrM,284
+datarobot_genai-0.2.24.dist-info/licenses/AUTHORS,sha256=isJGUXdjq1U7XZ_B_9AH8Qf0u4eX0XyQifJZ_Sxm4sA,80
+datarobot_genai-0.2.24.dist-info/licenses/LICENSE,sha256=U2_VkLIktQoa60Nf6Tbt7E4RMlfhFSjWjcJJfVC-YCE,11341
+datarobot_genai-0.2.24.dist-info/RECORD,,