datarobot-genai 0.2.30__py3-none-any.whl → 0.2.32__py3-none-any.whl

datarobot_genai/drmcp/__init__.py

@@ -19,11 +19,11 @@ A reusable library for building Model Context Protocol (MCP) servers with DataRo
 """
 
 # Export main server components
+from datarobot_genai.drmcp.test_utils.clients.openai import OpenAILLMMCPClient
 from datarobot_genai.drmcp.test_utils.mcp_utils_ete import ete_test_mcp_session
 from datarobot_genai.drmcp.test_utils.mcp_utils_ete import get_dr_mcp_server_url
 from datarobot_genai.drmcp.test_utils.mcp_utils_ete import get_headers
 from datarobot_genai.drmcp.test_utils.mcp_utils_integration import integration_test_mcp_session
-from datarobot_genai.drmcp.test_utils.openai_llm_mcp_client import LLMMCPClient
 from datarobot_genai.drmcp.test_utils.tool_base_ete import ETETestExpectations
 from datarobot_genai.drmcp.test_utils.tool_base_ete import ToolBaseE2E
 from datarobot_genai.drmcp.test_utils.tool_base_ete import ToolCallTestExpectations
@@ -70,7 +70,7 @@ __all__ = [
     "get_dr_mcp_server_url",
     "get_headers",
     "ete_test_mcp_session",
-    "LLMMCPClient",
+    "OpenAILLMMCPClient",
     "ETETestExpectations",
     "ToolBaseE2E",
     "ToolCallTestExpectations",

datarobot_genai/drmcp/core/exceptions.py

@@ -19,7 +19,3 @@ class DynamicToolRegistrationError(Exception):
 
 class DynamicPromptRegistrationError(Exception):
     """Exception raised for errors in the dynamic prompt registration process."""
-
-
-class MCPError(Exception):
-    """Base class for MCP errors."""

datarobot_genai/drmcp/core/logging.py

@@ -20,7 +20,7 @@ from collections.abc import Callable
 from typing import Any
 from typing import TypeVar
 
-from .exceptions import MCPError
+from fastmcp.exceptions import ToolError
 
 # Secret patterns to redact from logs
 SECRET_PATTERNS = [
@@ -93,6 +93,6 @@ def log_execution(func: F) -> F:
             return result
         except Exception as e:
             error_msg = _log_error(logger, func.__name__, e, args=args, kwargs=kwargs)
-            raise MCPError(error_msg)
+            raise ToolError(error_msg)
 
     return wrapper  # type: ignore[return-value]

datarobot_genai/drmcp/test_utils/clients/anthropic.py

@@ -0,0 +1,68 @@
+# Copyright 2026 DataRobot, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Anthropic LLM MCP Client implementation (example).
+
+This is an example implementation showing how easy it is to add a new LLM provider.
+Anthropic's API is OpenAI-compatible, so we can use the OpenAI SDK with their endpoint.
+"""
+
+import openai
+
+from .base import BaseLLMMCPClient
+
+
+class AnthropicMCPClient(BaseLLMMCPClient):
+    """
+    Client for interacting with LLMs via MCP using Anthropic Claude.
+
+    Note: Elicitation is handled at the protocol level by FastMCP's ctx.elicit().
+    Tools using FastMCP's built-in elicitation will work automatically.
+
+    Example:
+        ```python
+        config = {
+            "anthropic_api_key": "sk-ant-...",
+            "model": "claude-3-5-sonnet-20241022",
+        }
+        client = AnthropicMCPClient(str(config))
+        ```
+    """
+
+    def __init__(
+        self,
+        config: str | dict,
+    ):
+        """
+        Initialize the LLM MCP client.
+
+        Args:
+            config: Configuration string or dict with:
+                - anthropic_api_key: Anthropic API key
+                - model: Model name (default: "claude-3-5-sonnet-20241022")
+                - save_llm_responses: Whether to save responses (default: True)
+        """
+        super().__init__(config)
+
+    def _create_llm_client(self, config_dict: dict) -> tuple[openai.OpenAI, str]:
+        """Create the LLM client for Anthropic (OpenAI-compatible endpoint)."""
+        anthropic_api_key = config_dict.get("anthropic_api_key")
+        model = config_dict.get("model", "claude-3-5-sonnet-20241022")
+
+        # Anthropic provides an OpenAI-compatible endpoint
+        client = openai.OpenAI(
+            api_key=anthropic_api_key,
+            base_url="https://api.anthropic.com/v1",
+        )
+        return client, model

datarobot_genai/drmcp/test_utils/{openai_llm_mcp_client.py → clients/base.py}

@@ -1,4 +1,4 @@
-# Copyright 2025 DataRobot, Inc.
+# Copyright 2026 DataRobot, Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -12,7 +12,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+"""Base classes for LLM MCP clients."""
+
 import json
+from abc import ABC
+from abc import abstractmethod
 from ast import literal_eval
 from typing import Any
 
@@ -23,7 +27,7 @@ from mcp.types import ListToolsResult
 from mcp.types import TextContent
 from openai.types.chat.chat_completion import ChatCompletion
 
-from .utils import save_response_to_file
+from datarobot_genai.drmcp.test_utils.utils import save_response_to_file
 
 
 class ToolCall:
@@ -44,9 +48,9 @@ class LLMResponse:
         self.tool_results = tool_results
 
 
-class LLMMCPClient:
+class BaseLLMMCPClient(ABC):
     """
-    Client for interacting with LLMs via MCP.
+    Base class for LLM MCP clients.
 
     Note: Elicitation is handled at the protocol level by FastMCP's ctx.elicit().
     Tools using FastMCP's built-in elicitation will work automatically.
@@ -54,54 +58,48 @@ class LLMMCPClient:
 
     def __init__(
         self,
-        config: str,
+        config: str | dict,
     ):
         """
         Initialize the LLM MCP client.
 
         Args:
-            config: Configuration string or dict with:
-                - openai_api_key: OpenAI API key
-                - openai_api_base: Optional Azure OpenAI endpoint
-                - openai_api_deployment_id: Optional Azure deployment ID
-                - openai_api_version: Optional Azure API version
-                - model: Model name (default: "gpt-3.5-turbo")
-                - save_llm_responses: Whether to save responses (default: True)
+            config: Configuration string or dict with provider-specific keys.
         """
-        # Parse config string to extract parameters
+        config_dict = self._parse_config(config)
+        self.openai_client, self.model = self._create_llm_client(config_dict)
+        self.save_llm_responses = config_dict.get("save_llm_responses", True)
+        self.available_tools: list[dict[str, Any]] = []
+        self.available_prompts: list[dict[str, Any]] = []
+        self.available_resources: list[dict[str, Any]] = []
+
+    @staticmethod
+    def _parse_config(config: str | dict) -> dict:
+        """Parse config string to dict."""
         if isinstance(config, str):
             # Try JSON first (safer), fall back to literal_eval for Python dict strings
             try:
-                config_dict = json.loads(config)
+                return json.loads(config)
             except json.JSONDecodeError:
                 # Fall back to literal_eval for Python dict literal strings
-                config_dict = literal_eval(config)
-        else:
-            config_dict = config
-
-        openai_api_key = config_dict.get("openai_api_key")
-        openai_api_base = config_dict.get("openai_api_base")
-        openai_api_deployment_id = config_dict.get("openai_api_deployment_id")
-        model = config_dict.get("model", "gpt-3.5-turbo")
-        save_llm_responses = config_dict.get("save_llm_responses", True)
-
-        if openai_api_base and openai_api_deployment_id:
-            # Azure OpenAI
-            self.openai_client = openai.AzureOpenAI(
-                api_key=openai_api_key,
-                azure_endpoint=openai_api_base,
-                api_version=config_dict.get("openai_api_version", "2024-02-15-preview"),
-            )
-            self.model = openai_api_deployment_id
-        else:
-            # Regular OpenAI
-            self.openai_client = openai.OpenAI(api_key=openai_api_key)  # type: ignore[assignment]
-            self.model = model
+                return literal_eval(config)
+        return config
 
-        self.save_llm_responses = save_llm_responses
-        self.available_tools: list[dict[str, Any]] = []
-        self.available_prompts: list[dict[str, Any]] = []
-        self.available_resources: list[dict[str, Any]] = []
+    @abstractmethod
+    def _create_llm_client(
+        self, config_dict: dict
+    ) -> tuple[openai.OpenAI | openai.AzureOpenAI, str]:
+        """
+        Create the LLM client.
+
+        Args:
+            config_dict: Parsed configuration dictionary
+
+        Returns
+        -------
+            Tuple of (LLM client instance, model name)
+        """
+        pass
 
     async def _add_mcp_tool_to_available_tools(self, mcp_session: ClientSession) -> None:
         """Add a tool to the available tools."""

datarobot_genai/drmcp/test_utils/clients/dr_gateway.py

@@ -0,0 +1,58 @@
+# Copyright 2026 DataRobot, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""DataRobot LLM Gateway MCP Client implementation."""
+
+import openai
+
+from .base import BaseLLMMCPClient
+
+
+class DRLLMGatewayMCPClient(BaseLLMMCPClient):
+    """
+    Client for interacting with LLMs via MCP using DataRobot LLM Gateway.
+
+    Note: Elicitation is handled at the protocol level by FastMCP's ctx.elicit().
+    Tools using FastMCP's built-in elicitation will work automatically.
+    """
+
+    def __init__(
+        self,
+        config: str | dict,
+    ):
+        """
+        Initialize the LLM MCP client.
+
+        Args:
+            config: Configuration string or dict with:
+                - datarobot_api_token: DataRobot API token
+                - datarobot_endpoint: DataRobot endpoint URL (default: "https://app.datarobot.com/api/v2")
+                - model: Model name (default: "gpt-4o-mini")
+                - save_llm_responses: Whether to save responses (default: True)
+        """
+        super().__init__(config)
+
+    def _create_llm_client(self, config_dict: dict) -> tuple[openai.OpenAI, str]:
+        """Create the LLM client for DataRobot LLM Gateway."""
+        datarobot_api_token = config_dict.get("datarobot_api_token")
+        datarobot_endpoint = config_dict.get(
+            "datarobot_endpoint", "https://app.datarobot.com/api/v2"
+        )
+        model = config_dict.get("model", "gpt-4o-mini")
+
+        # Build gateway URL: {endpoint}/genai/llmgw
+        gateway_url = datarobot_endpoint.rstrip("/") + "/genai/llmgw"
+
+        client = openai.OpenAI(api_key=datarobot_api_token, base_url=gateway_url)
+        return client, model

datarobot_genai/drmcp/test_utils/clients/openai.py

@@ -0,0 +1,68 @@
+# Copyright 2026 DataRobot, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""OpenAI LLM MCP Client implementation."""
+
+import openai
+
+from .base import BaseLLMMCPClient
+
+
+class OpenAILLMMCPClient(BaseLLMMCPClient):
+    """
+    Client for interacting with LLMs via MCP using OpenAI or Azure OpenAI.
+
+    Note: Elicitation is handled at the protocol level by FastMCP's ctx.elicit().
+    Tools using FastMCP's built-in elicitation will work automatically.
+    """
+
+    def __init__(
+        self,
+        config: str | dict,
+    ):
+        """
+        Initialize the LLM MCP client.
+
+        Args:
+            config: Configuration string or dict with:
+                - openai_api_key: OpenAI API key
+                - openai_api_base: Optional Azure OpenAI endpoint
+                - openai_api_deployment_id: Optional Azure deployment ID
+                - openai_api_version: Optional Azure API version
+                - model: Model name (default: "gpt-3.5-turbo")
+                - save_llm_responses: Whether to save responses (default: True)
+        """
+        super().__init__(config)
+
+    def _create_llm_client(
+        self, config_dict: dict
+    ) -> tuple[openai.OpenAI | openai.AzureOpenAI, str]:
+        """Create the LLM client for OpenAI or Azure OpenAI."""
+        openai_api_key = config_dict.get("openai_api_key")
+        openai_api_base = config_dict.get("openai_api_base")
+        openai_api_deployment_id = config_dict.get("openai_api_deployment_id")
+        model = config_dict.get("model", "gpt-3.5-turbo")
+
+        if openai_api_base and openai_api_deployment_id:
+            # Azure OpenAI
+            client = openai.AzureOpenAI(
+                api_key=openai_api_key,
+                azure_endpoint=openai_api_base,
+                api_version=config_dict.get("openai_api_version", "2024-02-15-preview"),
+            )
+            return client, openai_api_deployment_id
+        else:
+            # Regular OpenAI
+            client = openai.OpenAI(api_key=openai_api_key)  # type: ignore[assignment]
+            return client, model

datarobot_genai/drmcp/test_utils/test_interactive.py

@@ -40,40 +40,40 @@ from mcp.types import ElicitResult
 
 from datarobot_genai.drmcp import get_dr_mcp_server_url
 from datarobot_genai.drmcp import get_headers
-from datarobot_genai.drmcp.test_utils.openai_llm_mcp_client import LLMMCPClient
-from datarobot_genai.drmcp.test_utils.openai_llm_mcp_client import LLMResponse
-from datarobot_genai.drmcp.test_utils.openai_llm_mcp_client import ToolCall
+from datarobot_genai.drmcp.test_utils.clients.base import LLMResponse
+from datarobot_genai.drmcp.test_utils.clients.base import ToolCall
+from datarobot_genai.drmcp.test_utils.clients.dr_gateway import DRLLMGatewayMCPClient
 
 # Re-export for backwards compatibility
-__all__ = ["LLMMCPClient", "LLMResponse", "ToolCall", "test_mcp_interactive"]
+__all__ = ["DRLLMGatewayMCPClient", "LLMResponse", "ToolCall", "test_mcp_interactive"]
 
 
 async def test_mcp_interactive() -> None:
     """Test the MCP server interactively with LLM agent."""
     # Check for required environment variables
-    openai_api_key = os.environ.get("OPENAI_API_KEY")
-    if not openai_api_key:
-        print("❌ Error: OPENAI_API_KEY environment variable is required")
+    datarobot_api_token = os.environ.get("DATAROBOT_API_TOKEN")
+    if not datarobot_api_token:
+        print("❌ Error: DATAROBOT_API_TOKEN environment variable is required")
         print("Please set it in your .env file or export it")
         return
 
-    # Optional Azure OpenAI settings
-    openai_api_base = os.environ.get("OPENAI_API_BASE")
-    openai_api_deployment_id = os.environ.get("OPENAI_API_DEPLOYMENT_ID")
-    openai_api_version = os.environ.get("OPENAI_API_VERSION")
+    # Optional DataRobot settings
+    datarobot_endpoint = os.environ.get("DATAROBOT_ENDPOINT")
+    model = os.environ.get("MODEL")
 
     print("🤖 Initializing LLM MCP Client...")
 
     # Initialize the LLM client with elicitation handler
     config = {
-        "openai_api_key": openai_api_key,
-        "openai_api_base": openai_api_base,
-        "openai_api_deployment_id": openai_api_deployment_id,
-        "openai_api_version": openai_api_version,
+        "datarobot_api_token": datarobot_api_token,
         "save_llm_responses": False,
     }
+    if datarobot_endpoint:
+        config["datarobot_endpoint"] = datarobot_endpoint
+    if model:
+        config["model"] = model
 
-    llm_client = LLMMCPClient(str(config))
+    llm_client = DRLLMGatewayMCPClient(str(config))
 
     # Get MCP server URL
     mcp_server_url = get_dr_mcp_server_url()

datarobot_genai/drmcp/test_utils/tool_base_ete.py

@@ -17,7 +17,7 @@ from typing import Any
 
 from pydantic import BaseModel
 
-from .openai_llm_mcp_client import LLMResponse
+from .clients.base import LLMResponse
 
 
 class ToolCallTestExpectations(BaseModel):

datarobot_genai/drmcp/test_utils/utils.py

@@ -19,7 +19,7 @@ from typing import TYPE_CHECKING
 from typing import Any
 
 if TYPE_CHECKING:
-    from .openai_llm_mcp_client import LLMResponse
+    from .clients.base import LLMResponse
 
 from dotenv import load_dotenv
 

datarobot_genai/drmcp/tools/clients/gdrive.py

@@ -20,6 +20,7 @@ import logging
 import uuid
 from typing import Annotated
 from typing import Any
+from typing import Literal
 
 import httpx
 from datarobot.auth.datarobot.exceptions import OAuthServiceClientErr
@@ -821,6 +822,96 @@ class GoogleDriveClient:
             headers={"Content-Type": f"multipart/related; boundary={boundary}"},
         )
 
+    async def manage_access(
+        self,
+        *,
+        file_id: str,
+        action: Literal["add", "update", "remove"],
+        role: Literal["reader", "commenter", "writer", "fileOrganizer", "organizer", "owner"]
+        | None = None,
+        email_address: str | None = None,
+        permission_id: str | None = None,
+        transfer_ownership: bool = False,
+    ) -> str:
+        """Manage access permissions for a Google Drive file or folder.
+
+        Adds, updates, or removes sharing permissions on an existing Google Drive
+        file or folder using the Google Drive Permissions API.
+
+        This method supports granting access to users or groups, changing access
+        roles, and revoking permissions. Ownership transfer is supported for files
+        in "My Drive" when explicitly requested.
+
+        Args:
+            file_id: The ID of the Google Drive file or folder whose permissions
+                are being managed.
+            action: The permission operation to perform.
+            role: The access role to assign or update. Valid values include
+                Required for "add" and "update" actions.
+            email_address: The email address of the user or group to grant access to.
+                Required for the "add" action.
+            permission_id: The ID of the permission to update or remove.
+                Required for "update" and "remove" actions.
+            transfer_ownership: Whether to transfer ownership of the file.
+                Only applicable when action="update" and role="owner".
+
+        Returns
+        -------
+            Permission id.
+            For "add" its newly added permission.
+            For "update"/"remove" its previous permission.
+
+        Raises
+        ------
+            GoogleDriveError: If the permission operation fails (invalid arguments,
+                insufficient permissions, resource not found, ownership transfer
+                not allowed, rate limited, etc.).
+        """
+        if not file_id.strip():
+            raise GoogleDriveError("Argument validation error: 'file_id' cannot be empty.")
+
+        if action == "add" and not email_address:
+            raise GoogleDriveError("'email_address' is required for action 'add'.")
+
+        if action in ("update", "remove") and not permission_id:
+            raise GoogleDriveError("'permission_id' is required for action 'update' or 'remove'.")
+
+        if action != "remove" and not role:
+            raise GoogleDriveError("'role' is required for action 'add' or 'update'.")
+
+        if action == "add":
+            response = await self._client.post(
+                url=f"/{file_id}/permissions",
+                json={
+                    "type": "user",
+                    "role": role,
+                    "emailAddress": email_address,
+                },
+                params={"sendNotificationEmail": False, "supportsAllDrives": True},
+            )
+
+        elif action == "update":
+            response = await self._client.patch(
+                url=f"/{file_id}/permissions/{permission_id}",
+                json={"role": role},
+                params={"transferOwnership": transfer_ownership, "supportsAllDrives": True},
+            )
+
+        elif action == "remove":
+            response = await self._client.delete(url=f"/{file_id}/permissions/{permission_id}")
+
+        else:
+            raise GoogleDriveError(f"Invalid action '{action}'")
+
+        if response.status_code not in (200, 201, 204):
+            raise GoogleDriveError(f"Drive API error {response.status_code}: {response.text}")
+
+        if action == "add":
+            return response.json()["id"]
+
+        # Cannot be null here because of above validators
+        return permission_id  # type: ignore
+
     async def __aenter__(self) -> "GoogleDriveClient":
         """Async context manager entry."""
         return self

datarobot_genai/drmcp/tools/gdrive/tools.py

@@ -16,6 +16,7 @@
 
 import logging
 from typing import Annotated
+from typing import Literal
 
 from fastmcp.exceptions import ToolError
 from fastmcp.tools.tool import ToolResult
@@ -33,7 +34,9 @@ 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"})
+@dr_mcp_tool(
+    tags={"google", "gdrive", "list", "search", "files", "find", "contents"}, enabled=False
+)
 async def gdrive_find_contents(
     *,
     page_size: Annotated[
@@ -345,3 +348,99 @@ async def gdrive_update_metadata(
         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"})
+async def gdrive_manage_access(
+    *,
+    file_id: Annotated[str, "The ID of the file or folder."],
+    action: Annotated[Literal["add", "update", "remove"], "The operation to perform."],
+    role: Annotated[
+        Literal["reader", "commenter", "writer", "fileOrganizer", "organizer", "owner"] | None,
+        "The access level.",
+    ] = None,
+    email_address: Annotated[
+        str | None, "The email of the user or group (required for 'add')."
+    ] = None,
+    permission_id: Annotated[
+        str | None, "The specific permission ID (required for 'update' or 'remove')."
+    ] = None,
+    transfer_ownership: Annotated[
+        bool, "Whether to transfer ownership (only for 'update' to 'owner' role)."
+    ] = False,
+) -> ToolResult:
+    """
+    Consolidated tool for sharing files and managing permissions.
+    Pushes all logic to the Google Drive API permissions resource (create, update, delete).
+
+    Usage:
+        - Add role: gdrive_manage_access(
+            file_id="SomeFileId",
+            action="add",
+            role="reader",
+            email_address="dummy@user.com"
+          )
+        - Update role: gdrive_manage_access(
+            file_id="SomeFileId",
+            action="update",
+            role="reader",
+            permission_id="SomePermissionId"
+          )
+        - Remove permission: gdrive_manage_access(
+            file_id="SomeFileId",
+            action="remove",
+            permission_id="SomePermissionId"
+          )
+    """
+    if not file_id or not file_id.strip():
+        raise ToolError("Argument validation error: 'file_id' cannot be empty.")
+
+    if action == "add" and not email_address:
+        raise ToolError("'email_address' is required for action 'add'.")
+
+    if action in ("update", "remove") and not permission_id:
+        raise ToolError("'permission_id' is required for action 'update' or 'remove'.")
+
+    if action != "remove" and not role:
+        raise ToolError("'role' is required for action 'add' or 'update'.")
+
+    access_token = await get_gdrive_access_token()
+    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)}"
+        )
+
+    # 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)

datarobot_genai/drmcp/tools/predictive/data.py

@@ -35,9 +35,9 @@ async def upload_dataset_to_ai_catalog(
 ) -> ToolError | ToolResult:
     """Upload a dataset to the DataRobot AI Catalog / Data Registry."""
     if not file_path and not file_url:
-        return ToolError("Either file_path or file_url must be provided.")
+        raise ToolError("Either file_path or file_url must be provided.")
     if file_path and file_url:
-        return ToolError("Please provide either file_path or file_url, not both.")
+        raise ToolError("Please provide either file_path or file_url, not both.")
 
     # Get client
     client = get_sdk_client()
@@ -47,17 +47,17 @@ async def upload_dataset_to_ai_catalog(
         # Does file exist?
         if not os.path.exists(file_path):
             logger.error("File not found: %s", file_path)
-            return ToolError(f"File not found: {file_path}")
+            raise ToolError(f"File not found: {file_path}")
         catalog_item = client.Dataset.create_from_file(file_path)
     else:
         # Does URL exist?
         if file_url is None or not is_valid_url(file_url):
             logger.error("Invalid file URL: %s", file_url)
-            return ToolError(f"Invalid file URL: {file_url}")
+            raise ToolError(f"Invalid file URL: {file_url}")
         catalog_item = client.Dataset.create_from_url(file_url)
 
     if not catalog_item:
-        return ToolError("Failed to upload dataset.")
+        raise ToolError("Failed to upload dataset.")
 
     return ToolResult(
         content=f"Successfully uploaded dataset: {catalog_item.id}",

datarobot_genai/drmcp/tools/predictive/model.py

@@ -14,9 +14,12 @@
 
 import json
 import logging
+from typing import Annotated
 from typing import Any
 
 from datarobot.models.model import Model
+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
@@ -50,33 +53,25 @@ class ModelEncoder(json.JSONEncoder):
         return super().default(obj)
 
 
-@dr_mcp_tool(tags={"model", "management", "info"})
-async def get_best_model(project_id: str, metric: str | None = None) -> str:
-    """
-    Get the best model for a DataRobot project, optionally by a specific metric.
+@dr_mcp_tool(tags={"predictive", "model", "read", "management", "info"})
+async def get_best_model(
+    *,
+    project_id: Annotated[str, "The DataRobot project ID"] | None = None,
+    metric: Annotated[str, "The metric to use for best model selection (e.g., 'AUC', 'LogLoss')"]
+    | None = None,
+) -> ToolError | ToolResult:
+    """Get the best model for a DataRobot project, optionally by a specific metric."""
+    if not project_id:
+        raise ToolError("Project ID must be provided")
 
-    Args:
-        project_id: The ID of the DataRobot project.
-        metric: (Optional) The metric to use for best model selection (e.g., 'AUC', 'LogLoss').
-
-    Returns
-    -------
-        A formatted string describing the best model.
-
-    Raises
-    ------
-        Exception: If project not found or no models exist in the project.
-    """
     client = get_sdk_client()
     project = client.Project.get(project_id)
     if not project:
-        logger.error(f"Project with ID {project_id} not found")
-        raise Exception(f"Project with ID {project_id} not found.")
+        raise ToolError(f"Project with ID {project_id} not found.")
 
     leaderboard = project.get_models()
     if not leaderboard:
-        logger.info(f"No models found for project {project_id}")
-        raise Exception("No models found for this project.")
+        raise ToolError("No models found for this project.")
 
     if metric:
         reverse_sort = metric.upper() in [
@@ -98,51 +93,91 @@ async def get_best_model(project_id: str, metric: str | None = None) -> str:
     best_model = leaderboard[0]
     logger.info(f"Found best model {best_model.id} for project {project_id}")
 
-    # Format the response as a human-readable string
     metric_info = ""
+    metric_value = None
+
     if metric and best_model.metrics and metric in best_model.metrics:
         metric_value = best_model.metrics[metric].get("validation")
         if metric_value is not None:
             metric_info = f" with {metric}: {metric_value:.2f}"
 
-    return f"Best model: {best_model.model_type}{metric_info}"
-
-
-@dr_mcp_tool(tags={"model", "prediction", "scoring"})
-async def score_dataset_with_model(project_id: str, model_id: str, dataset_url: str) -> str:
-    """
-    Score a dataset using a specific DataRobot model.
+    # Include full metrics in the response
+    best_model_dict = model_to_dict(best_model)
+    best_model_dict["metric"] = metric
+    best_model_dict["metric_value"] = metric_value
+
+    # Format metrics for human-readable content
+    metrics_text = ""
+    if best_model.metrics:
+        metrics_list = []
+        for metric_name, metric_data in best_model.metrics.items():
+            if isinstance(metric_data, dict) and "validation" in metric_data:
+                val = metric_data["validation"]
+                if val is not None:
+                    metrics_list.append(f"{metric_name}: {val:.4f}")
+        if metrics_list:
+            metrics_text = "\nPerformance metrics:\n" + "\n".join(f"  - {m}" for m in metrics_list)
+
+    return ToolResult(
+        content=f"Best model: {best_model.model_type}{metric_info}{metrics_text}",
+        structured_content={
+            "project_id": project_id,
+            "best_model": best_model_dict,
+        },
+    )
+
+
+@dr_mcp_tool(tags={"predictive", "model", "read", "scoring", "dataset"})
+async def score_dataset_with_model(
+    *,
+    project_id: Annotated[str, "The DataRobot project ID"] | None = None,
+    model_id: Annotated[str, "The DataRobot model ID"] | None = None,
+    dataset_url: Annotated[str, "The dataset URL"] | None = None,
+) -> ToolError | ToolResult:
+    """Score a dataset using a specific DataRobot model."""
+    if not project_id:
+        raise ToolError("Project ID must be provided")
+    if not model_id:
+        raise ToolError("Model ID must be provided")
+    if not dataset_url:
+        raise ToolError("Dataset URL must be provided")
 
-    Args:
-        project_id: The ID of the DataRobot project.
-        model_id: The ID of the DataRobot model to use for scoring.
-        dataset_url: The URL to the dataset to score (must be accessible to DataRobot).
-
-    Returns
-    -------
-        A string summary of the scoring job or a meaningful error message.
-    """
     client = get_sdk_client()
     project = client.Project.get(project_id)
     model = client.Model.get(project, model_id)
     job = model.score(dataset_url)
-    logger.info(f"Started scoring job {job.id} for model {model_id}")
-    return f"Scoring job started: {job.id}"
-
 
-@dr_mcp_tool(tags={"model", "management", "list"})
-async def list_models(project_id: str) -> str:
-    """
-    List all models in a project.
+    return ToolResult(
+        content=f"Scoring job started: {job.id}",
+        structured_content={
+            "scoring_job_id": job.id,
+            "project_id": project_id,
+            "model_id": model_id,
+            "dataset_url": dataset_url,
+        },
+    )
+
+
+@dr_mcp_tool(tags={"predictive", "model", "read", "management", "list"})
+async def list_models(
+    *,
+    project_id: Annotated[str, "The DataRobot project ID"] | None = None,
+) -> ToolError | ToolResult:
+    """List all models in a project."""
+    if not project_id:
+        raise ToolError("Project ID must be provided")
 
-    Args:
-        project_id: The ID of the DataRobot project.
-
-    Returns
-    -------
-        A string summary of the models in the project.
-    """
     client = get_sdk_client()
     project = client.Project.get(project_id)
     models = project.get_models()
-    return json.dumps(models, indent=2, cls=ModelEncoder)
+
+    return ToolResult(
+        content=(
+            f"Found {len(models)} models in project {project_id}, here are the details:\n"
+            f"{json.dumps(models, indent=2, cls=ModelEncoder)}"
+        ),
+        structured_content={
+            "project_id": project_id,
+            "models": [model_to_dict(model) for model in models],
+        },
+    )

datarobot_genai/drmcp/tools/predictive/project.py

@@ -54,9 +54,9 @@ async def get_project_dataset_by_name(
     The dataset ID and the dataset type (source or prediction) as a string, or an error message.
     """
     if not project_id:
-        return ToolError("Project ID is required.")
+        raise ToolError("Project ID is required.")
     if not dataset_name:
-        return ToolError("Dataset name is required.")
+        raise ToolError("Dataset name is required.")
 
     client = get_sdk_client()
     project = client.Project.get(project_id)

datarobot_genai/drmcp/tools/predictive/training.py

@@ -63,7 +63,7 @@ async def analyze_dataset(
 ) -> ToolError | ToolResult:
     """Analyze a dataset to understand its structure and potential use cases."""
     if not dataset_id:
-        return ToolError("Dataset ID must be provided")
+        raise ToolError("Dataset ID must be provided")
 
     client = get_sdk_client()
     dataset = client.Dataset.get(dataset_id)
@@ -116,7 +116,7 @@ async def suggest_use_cases(
 ) -> ToolError | ToolResult:
     """Analyze a dataset and suggest potential machine learning use cases."""
     if not dataset_id:
-        return ToolError("Dataset ID must be provided")
+        raise ToolError("Dataset ID must be provided")
 
     client = get_sdk_client()
     dataset = client.Dataset.get(dataset_id)
@@ -148,7 +148,7 @@ async def get_exploratory_insights(
 ) -> ToolError | ToolResult:
     """Generate exploratory data insights for a dataset."""
     if not dataset_id:
-        return ToolError("Dataset ID must be provided")
+        raise ToolError("Dataset ID must be provided")
 
     client = get_sdk_client()
     dataset = client.Dataset.get(dataset_id)
@@ -481,9 +481,9 @@ async def start_autopilot(
 
     if not project_id:
         if not dataset_url and not dataset_id:
-            return ToolError("Either dataset_url or dataset_id must be provided")
+            raise ToolError("Either dataset_url or dataset_id must be provided")
         if dataset_url and dataset_id:
-            return ToolError("Please provide either dataset_url or dataset_id, not both")
+            raise ToolError("Please provide either dataset_url or dataset_id, not both")
 
         if dataset_url:
             dataset = client.Dataset.create_from_url(dataset_url)
@@ -497,7 +497,7 @@ async def start_autopilot(
         project = client.Project.get(project_id)
 
     if not target:
-        return ToolError("Target variable must be specified")
+        raise ToolError("Target variable must be specified")
 
     try:
         # Start modeling
@@ -517,7 +517,7 @@ async def start_autopilot(
         )
 
     except Exception as e:
-        return ToolError(
+        raise ToolError(
             content=json.dumps(
                 {
                     "error": f"Failed to start Autopilot: {str(e)}",
@@ -546,9 +546,9 @@ async def get_model_roc_curve(
 ) -> ToolError | ToolResult:
     """Get detailed ROC curve for a specific model."""
     if not project_id:
-        return ToolError("Project ID must be provided")
+        raise ToolError("Project ID must be provided")
     if not model_id:
-        return ToolError("Model ID must be provided")
+        raise ToolError("Model ID must be provided")
 
     client = get_sdk_client()
     project = client.Project.get(project_id)
@@ -587,7 +587,7 @@ async def get_model_roc_curve(
             structured_content={"data": roc_data},
         )
     except Exception as e:
-        return ToolError(f"Failed to get ROC curve: {str(e)}")
+        raise ToolError(f"Failed to get ROC curve: {str(e)}")
 
 
 @dr_mcp_tool(tags={"predictive", "training", "read", "model", "evaluation"})
@@ -598,9 +598,9 @@ async def get_model_feature_impact(
 ) -> ToolError | ToolResult:
     """Get detailed feature impact for a specific model."""
     if not project_id:
-        return ToolError("Project ID must be provided")
+        raise ToolError("Project ID must be provided")
     if not model_id:
-        return ToolError("Model ID must be provided")
+        raise ToolError("Model ID must be provided")
 
     client = get_sdk_client()
     project = client.Project.get(project_id)
@@ -631,9 +631,9 @@ async def get_model_lift_chart(
 ) -> ToolError | ToolResult:
     """Get detailed lift chart for a specific model."""
     if not project_id:
-        return ToolError("Project ID must be provided")
+        raise ToolError("Project ID must be provided")
     if not model_id:
-        return ToolError("Model ID must be provided")
+        raise ToolError("Model ID must be provided")
 
     client = get_sdk_client()
     project = client.Project.get(project_id)

{datarobot_genai-0.2.30.dist-info → datarobot_genai-0.2.32.dist-info}/METADATA

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

{datarobot_genai-0.2.30.dist-info → datarobot_genai-0.2.32.dist-info}/RECORD

@@ -22,7 +22,7 @@ datarobot_genai/crewai/agent.py,sha256=vp8_2LExpeLls7Fpzo0R6ud5I6Ryfu3n3oVTN4Yyi
 datarobot_genai/crewai/base.py,sha256=JLljEN7sj8zaH8OamYoevFBZzza5BjZ4f0CGHRp2jUU,6447
 datarobot_genai/crewai/events.py,sha256=K67bO1zwPrxmppz2wh8dFGNbVebyWGXAMD7oodFE2sQ,5462
 datarobot_genai/crewai/mcp.py,sha256=AJTrs-8KdiRSjRECfBT1lJOsszWMoFoN9NIa1p5_wsM,2115
-datarobot_genai/drmcp/__init__.py,sha256=JE83bfpGU7v77VzrDdlb0l8seM5OwUsUbaQErJ2eisc,2983
+datarobot_genai/drmcp/__init__.py,sha256=WyKW7p77kS63EsmuW8cnZpqgcxCzIv1TmRPo2qo-Z8A,2988
 datarobot_genai/drmcp/server.py,sha256=KE4kjS5f9bfdYftG14HBHrfvxDfCD4pwCXePfvl1OvU,724
 datarobot_genai/drmcp/core/__init__.py,sha256=y4yapzp3KnFMzSR6HlNDS4uSuyNT7I1iPBvaCLsS0sU,577
 datarobot_genai/drmcp/core/auth.py,sha256=E-5wrGbBFEBlD5377g6Exddrc7HsazamwX8tWr2RLXY,5815
@@ -33,8 +33,8 @@ datarobot_genai/drmcp/core/constants.py,sha256=lUwoW_PTrbaBGqRJifKqCn3EoFacoEgdO
 datarobot_genai/drmcp/core/credentials.py,sha256=PYEUDNMVw1BoMzZKLkPVTypNkVevEPtmk3scKnE-zYg,6706
 datarobot_genai/drmcp/core/dr_mcp_server.py,sha256=czcjbwhZAeW9EtG_Bys0GARPOuQulstkiU7FG48Q9bg,14118
 datarobot_genai/drmcp/core/dr_mcp_server_logo.py,sha256=hib-nfR1SNTW6CnpFsFCkL9H_OMwa4YYyinV7VNOuLk,4708
-datarobot_genai/drmcp/core/exceptions.py,sha256=eqsGI-lxybgvWL5w4BFhbm3XzH1eU5tetwjnhJxelpc,905
-datarobot_genai/drmcp/core/logging.py,sha256=Y_hig4eBWiXGaVV7B_3wBcaYVRNH4ydptbEQhrP9-mY,3414
+datarobot_genai/drmcp/core/exceptions.py,sha256=9zoNh5ph6QihWIYuw37ljZ73_iUfy38YVYyFSnEwivc,839
+datarobot_genai/drmcp/core/logging.py,sha256=rnUkws0vIDy_uLevwNj-wgA9uijW1Go774JPCrG0Yfw,3423
 datarobot_genai/drmcp/core/mcp_instance.py,sha256=nt4gOlAQklMcqmohRIKovYcyhgLdb08NHMo28DBYmOk,18362
 datarobot_genai/drmcp/core/routes.py,sha256=dqE2M0UzAyyN9vQjlyTjYW4rpju3LT039po5weuO__I,17936
 datarobot_genai/drmcp/core/routes_utils.py,sha256=vSseXWlplMSnRgoJgtP_rHxWSAVYcx_tpTv4lyTpQoc,944
@@ -70,35 +70,39 @@ datarobot_genai/drmcp/test_utils/elicitation_test_tool.py,sha256=UVKwy39nl3XcVAh
 datarobot_genai/drmcp/test_utils/integration_mcp_server.py,sha256=YSk19tbaka_0ziqi7LoXie4SJs-cvi9-H00Go0ZtQWE,3575
 datarobot_genai/drmcp/test_utils/mcp_utils_ete.py,sha256=46rH0fYYmUj7ygf968iRbdSp5u95v23BEw3Ts_c431Y,4788
 datarobot_genai/drmcp/test_utils/mcp_utils_integration.py,sha256=sHA_BWtpgIAFp9IXiNkUeBartBMjLAauqkV9bYtCr-g,3874
-datarobot_genai/drmcp/test_utils/openai_llm_mcp_client.py,sha256=YgyqHK09MB-PBaqT34heqvmvYYFtLpzzSJt7xuTJmDg,11224
-datarobot_genai/drmcp/test_utils/test_interactive.py,sha256=guXvR8q2H6VUdmvIjEJcElQJCC6lQ-oTrzbD2EkHeCs,8025
-datarobot_genai/drmcp/test_utils/tool_base_ete.py,sha256=3yMfOsz3LdHYywuE5BhdJDpTUowx37HsFSsMdBTxA80,9337
-datarobot_genai/drmcp/test_utils/utils.py,sha256=esGKFv8aO31-Qg3owayeWp32BYe1CdYOEutjjdbweCw,3048
+datarobot_genai/drmcp/test_utils/test_interactive.py,sha256=KAScFT65GUkOxuiiBcjli8HHvV1NusVN01nOib3xVCc,7939
+datarobot_genai/drmcp/test_utils/tool_base_ete.py,sha256=2RvVmwHYczl7F6qZHkKYiI77IoL-PaMT3y59t0aQtTE,9328
+datarobot_genai/drmcp/test_utils/utils.py,sha256=JF2W9J4Q8pCqro7dj_bHObHNP7dfybDXesTLFOUsIVM,3039
+datarobot_genai/drmcp/test_utils/clients/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datarobot_genai/drmcp/test_utils/clients/anthropic.py,sha256=qFhLvLZHMpZa2tZwI8pZQaaeG1lsM56VaONt6a9VU8c,2333
+datarobot_genai/drmcp/test_utils/clients/base.py,sha256=WoPdddYmmXGylEuKRtKHPfprcHMjbHqPB9PwzWmORV4,10637
+datarobot_genai/drmcp/test_utils/clients/dr_gateway.py,sha256=qlx0WxEOtTkxt9PiCxgWAp02k5jyUgXcKb9AwCGw6cw,2150
+datarobot_genai/drmcp/test_utils/clients/openai.py,sha256=tyIibvjtFp7u2BoHJqwIRlHn9UPtysKOgStoA9SZUYs,2566
 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=h_G0By_kDnJeWDT_d-IREsaZ5-0xB5GoLXOqblYP5MA,20706
-datarobot_genai/drmcp/tools/clients/gdrive.py,sha256=Sonc8g52z8gDeaIGxh2GkoWYbtveCBGfDU0z3m4iSRU,29292
+datarobot_genai/drmcp/tools/clients/gdrive.py,sha256=RK4IISpYb99aK6WgDthesDoglaZxwGpG_PPAAe6xsVM,33064
 datarobot_genai/drmcp/tools/clients/jira.py,sha256=Rm91JAyrNIqxu66-9rU1YqoRXVnWbEy-Ahvy6f6HlVg,9823
 datarobot_genai/drmcp/tools/clients/microsoft_graph.py,sha256=PASGThDPE8zkBZqach8lurJL1y47DWUPLwvf9N6uLGM,19234
 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=_-ws65WLK8KZP_mKkf4yJ7ZunR8qdyoiMwHQX47MSMw,12362
 datarobot_genai/drmcp/tools/gdrive/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-datarobot_genai/drmcp/tools/gdrive/tools.py,sha256=jSKz0TuqAdHFitUZ-BW8NDl31Aq4VGpWa0yWSksLi00,13887
+datarobot_genai/drmcp/tools/gdrive/tools.py,sha256=7bNrp7E3opKwsBDYfLIOsOGfPXW-Ae9KvcimEzetR0A,17631
 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/microsoft_graph/__init__.py,sha256=CuOaMt1AJo7cHx_GuhO3s_aqxZas_wlDsoBorBsvbeU,577
 datarobot_genai/drmcp/tools/microsoft_graph/tools.py,sha256=zJ-UA1TMhPOYcExvgWv0YBjDsSIDPA-U1SEbBrVfAc8,7744
 datarobot_genai/drmcp/tools/predictive/__init__.py,sha256=WuOHlNNEpEmcF7gVnhckruJRKU2qtmJLE3E7zoCGLDo,1030
-datarobot_genai/drmcp/tools/predictive/data.py,sha256=sSFAmO6x0DSuolw8urhMaOj5PwfUH29oc2mEOZI3YU4,4631
+datarobot_genai/drmcp/tools/predictive/data.py,sha256=VbGs8ERP8vNFtTTryGhI61JItNVaJsx1gxpRX1ZFZcg,4626
 datarobot_genai/drmcp/tools/predictive/deployment.py,sha256=lm02Ayuo11L1hP41fgi3QpR1Eyty-Wc16rM0c8SgliM,3277
 datarobot_genai/drmcp/tools/predictive/deployment_info.py,sha256=BGEF_dmbxOBJR0n1Tt9TO2-iNTQSBTr-oQUyaxLZ0ZI,15297
-datarobot_genai/drmcp/tools/predictive/model.py,sha256=Yih5-KedJ-1yupPLXCJsCXOdyWWi9pRvgapXDlgXWJA,4891
+datarobot_genai/drmcp/tools/predictive/model.py,sha256=BVxOMHh3--liwBU4VB1OWRrqkhJ4y_Rq053f7y94TF8,6276
 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=xC52UdYvuFeNZC7Y5MfXcvzTL70WwAacQXESr6rqN6s,3255
-datarobot_genai/drmcp/tools/predictive/training.py,sha256=LzMxbBT8wxKYDrRlVElfmTUrzpmGvwrR-mTGf6YUnIA,23998
+datarobot_genai/drmcp/tools/predictive/project.py,sha256=Mzf7rQogBV6h1-MWQYTwtDHOsMWfjOyyJpSYmmvNNuc,3253
+datarobot_genai/drmcp/tools/predictive/training.py,sha256=WWzzGibYMSvI8kqHnvav6qNIVjoe1EG4RyiYa3XhFYA,23984
 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
@@ -113,9 +117,9 @@ datarobot_genai/nat/datarobot_llm_clients.py,sha256=-_q_KlKOVQecIYJd8YRiYnS4ZNaz
 datarobot_genai/nat/datarobot_llm_providers.py,sha256=aDoQcTeGI-odqydPXEX9OGGNFbzAtpqzTvHHEkmJuEQ,4963
 datarobot_genai/nat/datarobot_mcp_client.py,sha256=jL8sXb8g4gvt0VYgB2tfMGsMjpB1GV2XIbN0iv_LxVU,10701
 datarobot_genai/nat/helpers.py,sha256=Q7E3ADZdtFfS8E6OQPyw2wgA6laQ58N3bhLj5CBWwJs,3265
-datarobot_genai-0.2.30.dist-info/METADATA,sha256=OfWIH55TShkE_jPNSKFx04ZceCEYP-qFCHyr31sHD6U,6301
-datarobot_genai-0.2.30.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-datarobot_genai-0.2.30.dist-info/entry_points.txt,sha256=jEW3WxDZ8XIK9-ISmTyt5DbmBb047rFlzQuhY09rGrM,284
-datarobot_genai-0.2.30.dist-info/licenses/AUTHORS,sha256=isJGUXdjq1U7XZ_B_9AH8Qf0u4eX0XyQifJZ_Sxm4sA,80
-datarobot_genai-0.2.30.dist-info/licenses/LICENSE,sha256=U2_VkLIktQoa60Nf6Tbt7E4RMlfhFSjWjcJJfVC-YCE,11341
-datarobot_genai-0.2.30.dist-info/RECORD,,
+datarobot_genai-0.2.32.dist-info/METADATA,sha256=I5_bDUsP1rsNCYVIXvZjYYb91UwhA7N51E_Y0EN-fSc,6301
+datarobot_genai-0.2.32.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+datarobot_genai-0.2.32.dist-info/entry_points.txt,sha256=jEW3WxDZ8XIK9-ISmTyt5DbmBb047rFlzQuhY09rGrM,284
+datarobot_genai-0.2.32.dist-info/licenses/AUTHORS,sha256=isJGUXdjq1U7XZ_B_9AH8Qf0u4eX0XyQifJZ_Sxm4sA,80
+datarobot_genai-0.2.32.dist-info/licenses/LICENSE,sha256=U2_VkLIktQoa60Nf6Tbt7E4RMlfhFSjWjcJJfVC-YCE,11341
+datarobot_genai-0.2.32.dist-info/RECORD,,