datarobot-genai 0.2.9__tar.gz → 0.2.13__tar.gz

{datarobot_genai-0.2.9 → datarobot_genai-0.2.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datarobot-genai
-Version: 0.2.9
+Version: 0.2.13
 Summary: Generic helpers for GenAI
 Project-URL: Homepage, https://github.com/datarobot-oss/datarobot-genai
 Author: DataRobot, Inc.
@@ -25,6 +25,8 @@ Requires-Dist: pypdf<7.0.0,>=6.1.3
 Requires-Dist: ragas<0.4.0,>=0.3.8
 Requires-Dist: requests<3.0.0,>=2.32.4
 Provides-Extra: crewai
+Requires-Dist: anthropic<1.0.0,~=0.71.0; extra == 'crewai'
+Requires-Dist: azure-ai-inference<2.0.0,>=1.0.0b9; extra == 'crewai'
 Requires-Dist: crewai-tools[mcp]<0.77.0,>=0.69.0; extra == 'crewai'
 Requires-Dist: crewai>=1.1.0; extra == 'crewai'
 Requires-Dist: opentelemetry-instrumentation-crewai<1.0.0,>=0.40.5; extra == 'crewai'

{datarobot_genai-0.2.9 → datarobot_genai-0.2.13}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "datarobot-genai"
-version = "0.2.9"
+version = "0.2.13"
 description = "Generic helpers for GenAI"
 readme = "README.md"
 requires-python = ">=3.10, <3.13"
@@ -40,6 +40,8 @@ datarobot_auth_provider = "datarobot_genai.nat.datarobot_auth_provider"
 
 [project.optional-dependencies]
 crewai = [
+  "anthropic~=0.71.0,<1.0.0",  # Needed for integration with anthropic endpoints
+  "azure-ai-inference>=1.0.0b9,<2.0.0",  # Needed for integration with azure endpoints
   "crewai>=1.1.0",
   "crewai-tools[mcp]>=0.69.0,<0.77.0",
   "opentelemetry-instrumentation-crewai>=0.40.5,<1.0.0",

{datarobot_genai-0.2.9 → datarobot_genai-0.2.13}/src/datarobot_genai/drmcp/test_utils/openai_llm_mcp_client.py

@@ -95,11 +95,16 @@ class LLMMCPClient:
     ) -> str:
         """Call an MCP tool and return the result as a string."""
         result: CallToolResult = await mcp_session.call_tool(tool_name, parameters)
-        return (
+        content = (
             result.content[0].text
             if result.content and isinstance(result.content[0], TextContent)
             else str(result.content)
         )
+        if result.structuredContent is not None:
+            structured_content = json.dumps(result.structuredContent)
+        else:
+            structured_content = ""
+        return f"Content: {content}\nStructured content: {structured_content}"
 
     async def _process_tool_calls(
         self,

datarobot_genai-0.2.13/src/datarobot_genai/drmcp/tools/clients/confluence.py

@@ -0,0 +1,196 @@
+# Copyright 2025 DataRobot, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Async client for interacting with Confluence Cloud REST API.
+
+At the moment of creating this client, official Confluence SDK is not supporting async.
+"""
+
+import logging
+from http import HTTPStatus
+from typing import Any
+
+import httpx
+from pydantic import BaseModel
+from pydantic import Field
+
+from .atlassian import ATLASSIAN_API_BASE
+from .atlassian import get_atlassian_cloud_id
+
+logger = logging.getLogger(__name__)
+
+
+class ConfluencePage(BaseModel):
+    """Pydantic model for Confluence page."""
+
+    page_id: str = Field(..., description="The unique page ID")
+    title: str = Field(..., description="Page title")
+    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)")
+
+    def as_flat_dict(self) -> dict[str, Any]:
+        """Return a flat dictionary representation of the page."""
+        return {
+            "page_id": self.page_id,
+            "title": self.title,
+            "space_id": self.space_id,
+            "space_key": self.space_key,
+            "body": self.body,
+        }
+
+
+class ConfluenceClient:
+    """
+    Client for interacting with Confluence API using OAuth access token.
+
+    At the moment of creating this client, official Confluence SDK is not supporting async.
+    """
+
+    EXPAND_FIELDS = "body.storage,space"
+
+    def __init__(self, access_token: str) -> None:
+        """
+        Initialize Confluence client with access token.
+
+        Args:
+            access_token: OAuth access token for Atlassian API
+        """
+        self.access_token = access_token
+        self._client = httpx.AsyncClient(
+            headers={
+                "Authorization": f"Bearer {access_token}",
+                "Accept": "application/json",
+                "Content-Type": "application/json",
+            },
+            timeout=30.0,
+        )
+        self._cloud_id: str | None = None
+
+    async def _get_cloud_id(self) -> str:
+        """
+        Get the cloud ID for the authenticated Atlassian Confluence instance.
+
+        According to Atlassian OAuth 2.0 documentation, API calls should use:
+        https://api.atlassian.com/ex/confluence/{cloudId}/wiki/rest/api/...
+
+        Returns
+        -------
+            Cloud ID string
+
+        Raises
+        ------
+            ValueError: If cloud ID cannot be retrieved
+        """
+        if self._cloud_id:
+            return self._cloud_id
+
+        self._cloud_id = await get_atlassian_cloud_id(self._client, service_type="confluence")
+        return self._cloud_id
+
+    def _parse_response(self, data: dict) -> ConfluencePage:
+        """Parse API response into ConfluencePage."""
+        body_content = ""
+        body = data.get("body", {})
+        if isinstance(body, dict):
+            storage = body.get("storage", {})
+            if isinstance(storage, dict):
+                body_content = storage.get("value", "")
+
+        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", "")
+
+        return ConfluencePage(
+            page_id=str(data.get("id", "")),
+            title=data.get("title", ""),
+            space_id=str(space_id),
+            space_key=space_key,
+            body=body_content,
+        )
+
+    async def get_page_by_id(self, page_id: str) -> ConfluencePage:
+        """
+        Get a Confluence page by its ID.
+
+        Args:
+            page_id: The numeric page ID
+
+        Returns
+        -------
+            ConfluencePage with page data
+
+        Raises
+        ------
+            ValueError: If page is not found
+            httpx.HTTPStatusError: If the API request fails
+        """
+        cloud_id = await self._get_cloud_id()
+        url = f"{ATLASSIAN_API_BASE}/ex/confluence/{cloud_id}/wiki/rest/api/content/{page_id}"
+
+        response = await self._client.get(url, params={"expand": self.EXPAND_FIELDS})
+
+        if response.status_code == HTTPStatus.NOT_FOUND:
+            raise ValueError(f"Page with ID '{page_id}' not found")
+
+        response.raise_for_status()
+        return self._parse_response(response.json())
+
+    async def get_page_by_title(self, title: str, space_key: str) -> ConfluencePage:
+        """
+        Get a Confluence page by its title within a specific space.
+
+        Args:
+            title: The exact page title
+            space_key: The space key where the page resides
+
+        Returns
+        -------
+            ConfluencePage with page data
+
+        Raises
+        ------
+            ValueError: If the page is not found
+            httpx.HTTPStatusError: If the API request fails
+        """
+        cloud_id = await self._get_cloud_id()
+        url = f"{ATLASSIAN_API_BASE}/ex/confluence/{cloud_id}/wiki/rest/api/content"
+
+        response = await self._client.get(
+            url,
+            params={
+                "title": title,
+                "spaceKey": space_key,
+                "expand": self.EXPAND_FIELDS,
+            },
+        )
+        response.raise_for_status()
+
+        data = response.json()
+        results = data.get("results", [])
+
+        if not results:
+            raise ValueError(f"Page with title '{title}' not found in space '{space_key}'")
+
+        return self._parse_response(results[0])
+
+    async def __aenter__(self) -> "ConfluenceClient":
+        """Async context manager entry."""
+        return self
+
+    async def __aexit__(
+        self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: Any
+    ) -> None:
+        """Async context manager exit."""
+        await self._client.aclose()

datarobot_genai-0.2.13/src/datarobot_genai/drmcp/tools/clients/jira.py

@@ -0,0 +1,220 @@
+# Copyright 2025 DataRobot, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import logging
+from http import HTTPStatus
+from typing import Any
+
+import httpx
+from pydantic import BaseModel
+from pydantic import Field
+
+from .atlassian import ATLASSIAN_API_BASE
+from .atlassian import get_atlassian_cloud_id
+
+logger = logging.getLogger(__name__)
+
+
+class _IssuePerson(BaseModel):
+    email_address: str = Field(alias="emailAddress")
+
+
+class _IssueStatus(BaseModel):
+    name: str
+
+
+class _IssueFields(BaseModel):
+    summary: str
+    status: _IssueStatus
+    reporter: _IssuePerson
+    assignee: _IssuePerson
+    created: str
+    updated: str
+
+
+class Issue(BaseModel):
+    id: str
+    key: str
+    fields: _IssueFields
+
+    def as_flat_dict(self) -> dict[str, Any]:
+        return {
+            "id": self.id,
+            "key": self.key,
+            "summary": self.fields.summary,
+            "reporterEmailAddress": self.fields.reporter.email_address,
+            "assigneeEmailAddress": self.fields.assignee.email_address,
+            "created": self.fields.created,
+            "updated": self.fields.updated,
+            "status": self.fields.status.name,
+        }
+
+
+class JiraClient:
+    """
+    Client for interacting with Jira API using OAuth access token.
+
+    At the moment of creating this client, official Jira SDK is not supporting async.
+    """
+
+    def __init__(self, access_token: str) -> None:
+        """
+        Initialize Jira client with access token.
+
+        Args:
+            access_token: OAuth access token for Atlassian API
+        """
+        self.access_token = access_token
+        self._client = httpx.AsyncClient(
+            headers={
+                "Authorization": f"Bearer {access_token}",
+                "Accept": "application/json",
+                "Content-Type": "application/json",
+            },
+            timeout=30.0,
+        )
+        self._cloud_id: str | None = None
+
+    async def _get_cloud_id(self) -> str:
+        """
+        Get the cloud ID for the authenticated Atlassian Jira instance.
+
+        According to Atlassian OAuth 2.0 documentation, API calls should use:
+        https://api.atlassian.com/ex/jira/{cloudId}/rest/api/3/...
+
+        Returns
+        -------
+            Cloud ID string
+
+        Raises
+        ------
+            ValueError: If cloud ID cannot be retrieved
+        """
+        if self._cloud_id:
+            return self._cloud_id
+
+        self._cloud_id = await get_atlassian_cloud_id(self._client, service_type="jira")
+        return self._cloud_id
+
+    async def _get_full_url(self, url: str) -> str:
+        """Return URL for Jira API."""
+        cloud_id = await self._get_cloud_id()
+        return f"{ATLASSIAN_API_BASE}/ex/jira/{cloud_id}/rest/api/3/{url}"
+
+    async def get_jira_issue(self, issue_key: str) -> Issue:
+        """
+        Get a Jira issue by its key.
+
+        Args:
+            issue_key: The key of the Jira issue, e.g., 'PROJ-123'
+
+        Returns
+        -------
+            Jira issue
+
+        Raises
+        ------
+            httpx.HTTPStatusError: If the API request fails
+        """
+        url = await self._get_full_url(f"issue/{issue_key}")
+        response = await self._client.get(
+            url, params={"fields": "id,key,summary,status,reporter,assignee,created,updated"}
+        )
+
+        if response.status_code == HTTPStatus.NOT_FOUND:
+            raise ValueError(f"{issue_key} not found")
+
+        response.raise_for_status()
+        issue = Issue(**response.json())
+        return issue
+
+    async def get_jira_issue_types(self, project_key: str) -> dict[str, str]:
+        """
+        Get Jira issue types possible for given project.
+
+        Args:
+            project_key: The key of the Jira project, e.g., 'PROJ'
+
+        Returns
+        -------
+            Dictionary where key is the issue type name and value is the issue type ID
+
+        Raises
+        ------
+            httpx.HTTPStatusError: If the API request fails
+        """
+        url = await self._get_full_url(f"issue/createmeta/{project_key}/issuetypes")
+        response = await self._client.get(url)
+
+        response.raise_for_status()
+        jsoned = response.json()
+        issue_types = {
+            issue_type["untranslatedName"]: issue_type["id"]
+            for issue_type in jsoned.get("issueTypes", [])
+        }
+        return issue_types
+
+    async def create_jira_issue(
+        self, project_key: str, summary: str, issue_type_id: str, description: str | None
+    ) -> str:
+        """
+        Create Jira issue.
+
+        Args:
+            project_key: The key of the Jira project, e.g., 'PROJ'
+            summary: Summary of Jira issue (title), e.g., 'Fix bug abc'
+            issue_type_id: ID type of Jira issue, e.g., "1"
+            description: Optional description of Jira issue
+
+        Returns
+        -------
+            Jira issue key
+
+        Raises
+        ------
+            httpx.HTTPStatusError: If the API request fails
+        """
+        url = await self._get_full_url("issue")
+        payload = {
+            "fields": {
+                "project": {"key": project_key},
+                "summary": summary,
+                "issuetype": {"id": issue_type_id},
+            }
+        }
+
+        if description:
+            payload["fields"]["description"] = {
+                "content": [
+                    {"content": [{"text": description, "type": "text"}], "type": "paragraph"}
+                ],
+                "type": "doc",
+                "version": 1,
+            }
+
+        response = await self._client.post(url, json=payload)
+
+        response.raise_for_status()
+        jsoned = response.json()
+        return jsoned["key"]
+
+    async def __aenter__(self) -> "JiraClient":
+        """Async context manager entry."""
+        return self
+
+    async def __aexit__(
+        self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: Any
+    ) -> None:
+        """Async context manager exit."""
+        await self._client.aclose()

datarobot_genai-0.2.13/src/datarobot_genai/drmcp/tools/confluence/tools.py

@@ -0,0 +1,81 @@
+# Copyright 2025 DataRobot, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Confluence MCP tools for interacting with Confluence Cloud."""
+
+import logging
+from typing import Annotated
+
+from fastmcp.exceptions import ToolError
+from fastmcp.tools.tool import ToolResult
+
+from datarobot_genai.drmcp.core.mcp_instance import dr_mcp_tool
+from datarobot_genai.drmcp.tools.clients.atlassian import get_atlassian_access_token
+from datarobot_genai.drmcp.tools.clients.confluence import ConfluenceClient
+
+logger = logging.getLogger(__name__)
+
+
+@dr_mcp_tool(tags={"confluence", "read", "get", "page"})
+async def confluence_get_page(
+    *,
+    page_id_or_title: Annotated[str, "The ID or the exact title of the Confluence page."],
+    space_key: Annotated[
+        str | None,
+        "Required if identifying the page by title. The space key (e.g., 'PROJ').",
+    ] = None,
+) -> ToolResult | ToolError:
+    """Retrieve the content of a specific Confluence page.
+
+    Use this tool to fetch Confluence pages by their numeric ID or by title.
+    Returns page content in HTML storage format.
+
+    Usage:
+        - By ID: page_id_or_title="856391684"
+        - By title: page_id_or_title="Meeting Notes", space_key="TEAM"
+
+    When using a page title, the space_key parameter is required.
+    """
+    if not page_id_or_title:
+        raise ToolError("Argument validation error: 'page_id_or_title' cannot be empty.")
+
+    access_token = await get_atlassian_access_token()
+    if isinstance(access_token, ToolError):
+        raise access_token
+
+    try:
+        async with ConfluenceClient(access_token) as client:
+            if page_id_or_title.isdigit():
+                page_response = await client.get_page_by_id(page_id_or_title)
+            else:
+                if not space_key:
+                    raise ToolError(
+                        "Argument validation error: "
+                        "'space_key' is required when identifying a page by title."
+                    )
+                page_response = await client.get_page_by_title(page_id_or_title, space_key)
+    except ValueError as e:
+        logger.error(f"Value error getting Confluence page: {e}")
+        raise ToolError(str(e))
+    except Exception as e:
+        logger.error(f"Unexpected error getting Confluence page: {e}")
+        raise ToolError(
+            f"An unexpected error occurred while getting Confluence page "
+            f"'{page_id_or_title}': {str(e)}"
+        )
+
+    return ToolResult(
+        content=f"Successfully retrieved page '{page_response.title}'.",
+        structured_content=page_response.as_flat_dict(),
+    )

datarobot_genai-0.2.13/src/datarobot_genai/drmcp/tools/jira/tools.py

@@ -0,0 +1,101 @@
+# Copyright 2025 DataRobot, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import logging
+from typing import Annotated
+
+from fastmcp.exceptions import ToolError
+from fastmcp.tools.tool import ToolResult
+
+from datarobot_genai.drmcp.core.mcp_instance import dr_mcp_tool
+from datarobot_genai.drmcp.tools.clients.atlassian import get_atlassian_access_token
+from datarobot_genai.drmcp.tools.clients.jira import JiraClient
+
+logger = logging.getLogger(__name__)
+
+
+@dr_mcp_tool(tags={"jira", "read", "get", "issue"})
+async def jira_get_issue(
+    *, issue_key: Annotated[str, "The key (ID) of the Jira issue to retrieve, e.g., 'PROJ-123'."]
+) -> ToolResult:
+    """Retrieve all fields and details for a single Jira issue by its key."""
+    if not issue_key:
+        raise ToolError("Argument validation error: 'issue_key' cannot be empty.")
+
+    access_token = await get_atlassian_access_token()
+    if isinstance(access_token, ToolError):
+        raise access_token
+
+    try:
+        async with JiraClient(access_token) as client:
+            issue = await client.get_jira_issue(issue_key)
+    except Exception as e:
+        logger.error(f"Unexpected error while getting Jira issue: {e}")
+        raise ToolError(
+            f"An unexpected error occurred while getting Jira issue '{issue_key}': {str(e)}"
+        )
+
+    return ToolResult(
+        content=f"Successfully retrieved details for issue '{issue_key}'.",
+        structured_content=issue.as_flat_dict(),
+    )
+
+
+@dr_mcp_tool(tags={"jira", "create", "add", "issue"})
+async def jira_create_issue(
+    *,
+    project_key: Annotated[str, "The key of the project where the issue should be created."],
+    summary: Annotated[str, "A brief summary or title for the new issue."],
+    issue_type: Annotated[str, "The type of issue to create (e.g., 'Task', 'Bug', 'Story')."],
+    description: Annotated[str | None, "Detailed description of the issue."] = None,
+) -> ToolResult:
+    """Create a new Jira issue with mandatory project, summary, and type information."""
+    if not all([project_key, summary, issue_type]):
+        raise ToolError(
+            "Argument validation error: project_key, summary, and issue_type are required fields."
+        )
+
+    access_token = await get_atlassian_access_token()
+    if isinstance(access_token, ToolError):
+        raise access_token
+
+    async with JiraClient(access_token) as client:
+        # Maybe we should cache it somehow?
+        # It'll be probably constant through whole mcp server lifecycle...
+        issue_types = await client.get_jira_issue_types(project_key=project_key)
+
+        try:
+            issue_type_id = issue_types[issue_type]
+        except KeyError:
+            possible_issue_types = ",".join(issue_types)
+            raise ToolError(
+                f"Unexpected issue type `{issue_type}`. Possible values are {possible_issue_types}."
+            )
+
+    try:
+        async with JiraClient(access_token) as client:
+            issue_key = await client.create_jira_issue(
+                project_key=project_key,
+                summary=summary,
+                issue_type_id=issue_type_id,
+                description=description,
+            )
+    except Exception as e:
+        logger.error(f"Unexpected error while creating Jira issue: {e}")
+        raise ToolError(f"An unexpected error occurred while creating Jira issue: {str(e)}")
+
+    return ToolResult(
+        content=f"Successfully created issue '{issue_key}'.",
+        structured_content={"newIssueKey": issue_key, "projectKey": project_key},
+    )