datarobot-genai 0.2.22__py3-none-any.whl → 0.2.23__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,6 +25,7 @@ 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
 
@@ -37,6 +39,23 @@ 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:
     """
@@ -116,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."""
 
@@ -344,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

@@ -109,3 +109,69 @@ async def gdrive_find_contents(
             "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-0.2.22.dist-info → datarobot_genai-0.2.23.dist-info}/METADATA

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

{datarobot_genai-0.2.22.dist-info → datarobot_genai-0.2.23.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=gRtWWCENHcmLepKQbS7qsF4R6vbQQK1Ru-EqfeUbldY,12550
+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=BP5tcpciuijakmXTjEgS6CySg5TUBAmlKYPkTgpVZbc,4406
+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
@@ -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.22.dist-info/METADATA,sha256=Jc7FEPYKQq7DI3dpk2qbMSYJolHyrBeO-A_9i7IsFFM,6301
-datarobot_genai-0.2.22.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-datarobot_genai-0.2.22.dist-info/entry_points.txt,sha256=jEW3WxDZ8XIK9-ISmTyt5DbmBb047rFlzQuhY09rGrM,284
-datarobot_genai-0.2.22.dist-info/licenses/AUTHORS,sha256=isJGUXdjq1U7XZ_B_9AH8Qf0u4eX0XyQifJZ_Sxm4sA,80
-datarobot_genai-0.2.22.dist-info/licenses/LICENSE,sha256=U2_VkLIktQoa60Nf6Tbt7E4RMlfhFSjWjcJJfVC-YCE,11341
-datarobot_genai-0.2.22.dist-info/RECORD,,
+datarobot_genai-0.2.23.dist-info/METADATA,sha256=5BfpvvJLwdoecSF1_TQsKLrgdzjfc2_vY9gvACOqGFo,6301
+datarobot_genai-0.2.23.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+datarobot_genai-0.2.23.dist-info/entry_points.txt,sha256=jEW3WxDZ8XIK9-ISmTyt5DbmBb047rFlzQuhY09rGrM,284
+datarobot_genai-0.2.23.dist-info/licenses/AUTHORS,sha256=isJGUXdjq1U7XZ_B_9AH8Qf0u4eX0XyQifJZ_Sxm4sA,80
+datarobot_genai-0.2.23.dist-info/licenses/LICENSE,sha256=U2_VkLIktQoa60Nf6Tbt7E4RMlfhFSjWjcJJfVC-YCE,11341
+datarobot_genai-0.2.23.dist-info/RECORD,,