feat(agent): add ontology binding to Data Fabric context config

packages/uipath-platform/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "uipath-platform"
-version = "0.1.90"
+version = "0.1.91"
 description = "HTTP client library for programmatic access to UiPath Platform"
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.11"

packages/uipath-platform/src/uipath/platform/entities/__init__.py

@@ -4,6 +4,7 @@
 """
 
 from ._entities_service import EntitiesService
+from ._entity_ontology_service import DataFabricOntologyItem
 from .entities import (
     AggregateRow,
     ChoiceSetValue,
@@ -46,6 +47,7 @@
     "AggregateRow",
     "ChoiceSetValue",
     "DataFabricEntityItem",
+    "DataFabricOntologyItem",
     "EntitiesService",
     "Entity",
     "EntityAggregate",

packages/uipath-platform/src/uipath/platform/entities/_entities_service.py

@@ -27,6 +27,7 @@
 from ..errors._datafabric_error import attach_datafabric_error_mapping
 from ..orchestrator._folder_service import FolderService
 from ._entity_data_service import EntityDataService, FileContent
+from ._entity_ontology_service import EntityOntologyService
 from ._entity_resolution import (
     build_resolution_service,
     create_resolution_plan,
@@ -105,6 +106,11 @@ def __init__(
             folders_service=folders_service,
             routing_strategy=self._routing_strategy,
         )
+        self._ontology = EntityOntologyService(
+            config=config,
+            execution_context=execution_context,
+            folders_service=folders_service,
+        )
 
     # ------------------------------------------------------------------
     # Schema operations — delegate to EntitySchemaService
@@ -1101,6 +1107,29 @@ async def delete_record_async(self, entity_key: str, record_id: str) -> None:
         """
         await self._data.delete_record_async(entity_key, record_id)
 
+    async def get_ontology_file_async(
+        self,
+        ontology_name: str,
+        file_type: str = "owl",
+        folder_key: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Fetch one file of an ontology from Data Fabric.
+
+        !!! warning "Preview Feature"
+            This method is currently experimental. Behavior and parameters are
+            subject to change in future versions.
+
+        Args:
+            ontology_name (str): Name of the ontology.
+            file_type (str): The ontology file to fetch — one of owl, r2rml,
+                shacl, summary, context.
+            folder_key (Optional[str]): Key of the folder the ontology lives in.
+
+        Returns:
+            Dict[str, Any]: The file record (e.g. ``content``, ``mediaType``).
+        """
+        return await self._ontology.get_file_async(ontology_name, file_type, folder_key)
+
     @traced(name="entity_record_insert_batch", run_type="uipath")
     def insert_records(
         self,

packages/uipath-platform/src/uipath/platform/entities/_entity_ontology_service.py

@@ -0,0 +1,80 @@
+"""Ontology-side operations for the Data Fabric entities surface.
+
+Handles retrieval of ontology component files (OWL schema, R2RML mapping, and
+other typed files). Entity schema and record operations are managed by
+:class:`EntitySchemaService` / :class:`EntityDataService` and exposed alongside
+ontology operations through :class:`EntitiesService`.
+"""
+
+from typing import Any, Dict, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from ..common._base_service import BaseService
+from ..common._config import UiPathApiConfig
+from ..common._execution_context import UiPathExecutionContext
+from ..common._folder_context import header_folder
+from ..common._models import Endpoint, RequestSpec
+from ..orchestrator._folder_service import FolderService
+
+
+class DataFabricOntologyItem(BaseModel):
+    """A single Data Fabric ontology reference from agent configuration."""
+
+    model_config = ConfigDict(
+        validate_by_name=True, validate_by_alias=True, extra="allow"
+    )
+
+    name: str
+    folder_key: str = Field(alias="folderId")
+    description: Optional[str] = None
+    id: Optional[str] = None
+
+
+class EntityOntologyService(BaseService):
+    """HTTP service for Data Fabric ontology file retrieval.
+
+    Backend target: ``datafabric_/api/ontologies``.
+
+    See Also:
+        https://docs.uipath.com/data-service/automation-cloud/latest/user-guide/introduction
+
+    !!! warning "Preview Feature"
+        This service is currently experimental. Behavior and parameters are
+        subject to change in future versions.
+    """
+
+    def __init__(
+        self,
+        config: UiPathApiConfig,
+        execution_context: UiPathExecutionContext,
+        folders_service: Optional[FolderService] = None,
+    ) -> None:
+        """Initialise the ontology service."""
+        super().__init__(config=config, execution_context=execution_context)
+        self._folders_service = folders_service
+
+    async def get_file_async(
+        self,
+        ontology_name: str,
+        file_type: str = "owl",
+        folder_key: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Internal implementation; see :meth:`EntitiesService.get_ontology_file_async`."""
+        spec = self._ontology_file_spec(ontology_name, file_type, folder_key)
+        response = await self.request_async(
+            spec.method, spec.endpoint, headers=spec.headers
+        )
+        return response.json()
+
+    @staticmethod
+    def _ontology_file_spec(
+        ontology_name: str, file_type: str, folder_key: Optional[str] = None
+    ) -> RequestSpec:
+        return RequestSpec(
+            method="GET",
+            endpoint=Endpoint(
+                f"datafabric_/api/ontologies/{ontology_name}/files/{file_type}"
+            ),
+            headers=header_folder(folder_key, None),
+        )

packages/uipath-platform/tests/services/test_entities_service.py

@@ -16,6 +16,7 @@
 from uipath.platform.entities import ChoiceSetValue, DataFabricEntityItem, Entity
 from uipath.platform.entities._entities_service import EntitiesService
 from uipath.platform.entities._entity_data_service import EntityDataService
+from uipath.platform.errors import EnrichedException
 
 
 @pytest.fixture
@@ -2660,3 +2661,93 @@ def test_5xx_with_batch_shape_still_propagates(
                 entity_key=str(entity_key),
                 records=[{"name": "x"}],
             )
+
+
+class TestGetOntologyFileAsync:
+    """Tests for EntitiesService.get_ontology_file_async (delegates to
+    EntityOntologyService). The HTTP call goes through ``service._ontology``,
+    so the sub-service's ``request_async`` is what gets patched."""
+
+    @pytest.mark.anyio
+    async def test_builds_endpoint_and_folder_header(
+        self, service: EntitiesService
+    ) -> None:
+        response = MagicMock()
+        response.json.return_value = {"content": "OWL", "mediaType": "text/plain"}
+        service._ontology.request_async = AsyncMock(return_value=response)  # type: ignore[method-assign]
+
+        result = await service.get_ontology_file_async(
+            "library", "owl", folder_key="folder-1"
+        )
+
+        assert result == {"content": "OWL", "mediaType": "text/plain"}
+        service._ontology.request_async.assert_called_once()
+        call = service._ontology.request_async.call_args
+        method, endpoint = call.args[0], call.args[1]
+        headers = call.kwargs["headers"]
+        assert method == "GET"
+        assert str(endpoint) == "/datafabric_/api/ontologies/library/files/owl"
+        # Accept is added centrally by BaseService, not per-call.
+        assert headers["x-uipath-folderkey"] == "folder-1"
+
+    @pytest.mark.anyio
+    async def test_no_folder_header_when_folder_key_none(
+        self, service: EntitiesService
+    ) -> None:
+        response = MagicMock()
+        response.json.return_value = {"content": "OWL", "mediaType": "text/plain"}
+        service._ontology.request_async = AsyncMock(return_value=response)  # type: ignore[method-assign]
+
+        await service.get_ontology_file_async("library")
+
+        headers = service._ontology.request_async.call_args.kwargs["headers"]
+        assert "x-uipath-folderkey" not in headers
+
+    @pytest.mark.anyio
+    @pytest.mark.parametrize(
+        "file_type", ["owl", "r2rml", "shacl", "summary", "context"]
+    )
+    async def test_accepts_allowed_file_types(
+        self, service: EntitiesService, file_type: str
+    ) -> None:
+        response = MagicMock()
+        response.json.return_value = {"content": "x"}
+        service._ontology.request_async = AsyncMock(return_value=response)  # type: ignore[method-assign]
+
+        await service.get_ontology_file_async("library", file_type)
+
+        endpoint = service._ontology.request_async.call_args.args[1]
+        assert str(endpoint) == f"/datafabric_/api/ontologies/library/files/{file_type}"
+
+    @pytest.mark.anyio
+    async def test_rejects_unsupported_file_type(
+        self,
+        httpx_mock: HTTPXMock,
+        service: EntitiesService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        """File-type validation is server-side (the ontology API), not in the
+        client. The SDK forwards the requested type and must surface the API's
+        rejection of an unsupported one as ``EnrichedException`` rather than
+        swallowing it."""
+        api_message = "Unsupported ontology file type: exe"
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/datafabric_/api/ontologies/library/files/exe",
+            method="GET",
+            status_code=400,
+            json={"message": api_message},
+        )
+
+        with pytest.raises(EnrichedException) as exc_info:
+            await service.get_ontology_file_async("library", "exe")
+
+        # The SDK surfaces the API's rejection verbatim — status code, response
+        # body, and the extracted message — rather than masking it.
+        exc = exc_info.value
+        assert exc.status_code == 400
+        assert api_message in exc.response_content
+        assert exc.error_info is not None
+        assert exc.error_info.message == api_message

packages/uipath/pyproject.toml

@@ -1,13 +1,13 @@
 [project]
 name = "uipath"
-version = "2.12.5"
+version = "2.12.6"
 description = "Python SDK and CLI for UiPath Platform, enabling programmatic interaction with automation services, process management, and deployment tools."
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.11"
 dependencies = [
   "uipath-core>=0.5.26, <0.6.0",
   "uipath-runtime>=0.11.5, <0.12.0",
-  "uipath-platform>=0.1.89, <0.2.0",
+  "uipath-platform>=0.1.91, <0.2.0",
   "click>=8.3.1",
   "httpx>=0.28.1",
   "pyjwt>=2.10.1",

packages/uipath/src/uipath/agent/models/agent.py

@@ -35,7 +35,7 @@
 )
 from uipath.eval.mocks import ExampleCall
 from uipath.platform.connections import Connection
-from uipath.platform.entities import DataFabricEntityItem
+from uipath.platform.entities import DataFabricEntityItem, DataFabricOntologyItem
 from uipath.platform.guardrails import (
     BuiltInValidatorGuardrail,
 )
@@ -169,6 +169,7 @@ class AgentContextType(str, CaseInsensitiveEnum):
     INDEX = "index"
     ATTACHMENTS = "attachments"
     DATA_FABRIC_ENTITY_SET = "datafabricentityset"
+    DATA_FABRIC_ONTOLOGY = "datafabricontology"
 
 
 class AgentMessageRole(str, CaseInsensitiveEnum):
@@ -440,6 +441,9 @@ class AgentContextResourceConfig(BaseAgentResourceConfig):
         None, description="Context settings"
     )
     entity_set: Optional[List[DataFabricEntityItem]] = Field(None, alias="entitySet")
+    ontology_set: Optional[List[DataFabricOntologyItem]] = Field(
+        None, alias="ontologySet"
+    )
     argument_properties: Dict[str, AgentToolArgumentProperties] = Field(
         {}, alias="argumentProperties"
     )
@@ -449,6 +453,11 @@ def is_datafabric(self) -> bool:
         """Check if this context is a Data Fabric entity set resource."""
         return self.context_type == AgentContextType.DATA_FABRIC_ENTITY_SET
 
+    @property
+    def is_datafabric_ontology(self) -> bool:
+        """Check if this context is a Data Fabric ontology resource."""
+        return self.context_type == AgentContextType.DATA_FABRIC_ONTOLOGY
+
     @property
     def datafabric_entity_identifiers(self) -> list[str]:
         """Extract entity identifiers from entitySet."""