feat: add Property binding resource support to SDK

Adds support for the Property resource type in bindings.json, enabling
users to read connector-defined property values (e.g. SharePoint folder
IDs) without writing custom helpers.

- Extend BindingResourceValue with optional description/propertyName fields
- Add "property" to GenericResourceOverwrite (replaces a separate class)
- Add BindingsService with get_property() that reads from bindings.json
  and respects runtime resource overwrites via the existing ContextVar
- Expose sdk.bindings as a cached_property on the UiPath class
- Update bindings.spec.md to document Property as the 7th resource type
- Add unit tests covering file reads, suffix key matching, runtime
  overwrites (including Studio-loaded and real runtime payload formats),
  and error cases

ResourceOverwriteParser.parse now normalises the Property key prefix
to lowercase ("Property" -> "property") and accepts the real runtime
flat-dict format in addition to the explicit {"values": {...}} form.
Both changes are additive — existing valid inputs are unaffected.

Author: ionmincu

packages/uipath-platform/src/uipath/platform/_uipath.py

@@ -11,6 +11,7 @@
 from .chat import ConversationsService, UiPathLlmChatService, UiPathOpenAIService
 from .common import (
     ApiClient,
+    BindingsService,
     ExternalApplicationService,
     UiPathApiConfig,
     UiPathExecutionContext,
@@ -76,6 +77,10 @@ def __init__(
                     raise SecretMissingError() from e
         self._execution_context = UiPathExecutionContext()
 
+    @cached_property
+    def bindings(self) -> BindingsService:
+        return BindingsService()
+
     @property
     def api_client(self) -> ApiClient:
         return ApiClient(self._config, self._execution_context)

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

@@ -13,6 +13,7 @@
     ResourceOverwritesContext,
     resource_override,
 )
+from ._bindings_service import BindingsService
 from ._config import UiPathApiConfig, UiPathConfig
 from ._endpoints_manager import EndpointManager
 from ._execution_context import UiPathExecutionContext
@@ -99,6 +100,7 @@
     "validate_pagination_params",
     "EndpointManager",
     "jsonschema_to_pydantic",
+    "BindingsService",
     "ConnectionResourceOverwrite",
     "GenericResourceOverwrite",
     "ResourceOverwrite",

packages/uipath-platform/src/uipath/platform/common/_bindings.py

@@ -44,9 +44,12 @@ def folder_identifier(self) -> str:
 
 
 class GenericResourceOverwrite(ResourceOverwrite):
-    resource_type: Literal["process", "index", "app", "asset", "bucket", "mcpServer"]
-    name: str = Field(alias="name")
-    folder_path: str = Field(alias="folderPath")
+    resource_type: Literal[
+        "process", "index", "app", "asset", "bucket", "mcpServer", "property"
+    ]
+    name: str = Field(default="", alias="name")
+    folder_path: str = Field(default="", alias="folderPath")
+    values: Optional[dict[str, str]] = Field(default=None)
 
     @property
     def resource_identifier(self) -> str:
@@ -110,6 +113,13 @@ def parse(cls, key: str, value: dict[str, Any]) -> ResourceOverwrite:
             The appropriate ResourceOverwrite subclass instance
         """
         resource_type = key.split(".")[0]
+        if resource_type.lower() == "property":
+            # Normalise casing ("Property" → "property") and handle the real
+            # runtime format where sub-properties are a flat dict rather than
+            # nested under a "values" key.
+            resource_type = "property"
+            if "values" not in value:
+                value = {"values": value}
         value_with_type = {"resource_type": resource_type, **value}
         return cls._adapter.validate_python(value_with_type)
 

packages/uipath-platform/src/uipath/platform/common/_bindings_service.py

@@ -0,0 +1,137 @@
+import json
+import logging
+from pathlib import Path
+from typing import Optional, Union, overload
+
+from ._bindings import GenericResourceOverwrite, _resource_overwrites
+from ._config import UiPathConfig
+
+logger = logging.getLogger(__name__)
+
+
+class BindingsService:
+    """Service for reading Property binding resources from bindings.json.
+
+    Provides access to connector-defined property values (e.g. SharePoint folder IDs)
+    that are configured at design time and resolved at runtime.
+    """
+
+    def __init__(self, bindings_file_path: Optional[Path] = None) -> None:
+        self._bindings_file_path = bindings_file_path or UiPathConfig.bindings_file_path
+
+    def _load_bindings(self) -> list[dict]:
+        try:
+            with open(self._bindings_file_path, "r") as f:
+                data = json.load(f)
+            return data.get("resources", [])
+        except FileNotFoundError:
+            logger.debug("Bindings file not found: %s", self._bindings_file_path)
+            return []
+        except (json.JSONDecodeError, OSError) as e:
+            logger.warning(
+                "Failed to load bindings file %s: %s", self._bindings_file_path, e
+            )
+            return []
+
+    def _find_property_resource(self, key: str) -> Optional[dict]:
+        """Find a Property binding resource by exact or suffix key match."""
+        resources = self._load_bindings()
+        for resource in resources:
+            if resource.get("resource", "").lower() != "property":
+                continue
+            resource_key = resource.get("key", "")
+            if (
+                resource_key == key
+                or resource_key.endswith(f".{key}")
+                or resource_key.endswith(key)
+            ):
+                return resource
+        return None
+
+    def _get_overwrite(self, key: str) -> Optional[GenericResourceOverwrite]:
+        """Check context var for a runtime overwrite for the given key.
+
+        Supports exact key match (``property.<key>``) and suffix match so that
+        a short label like ``"SharePoint Invoices folder"`` resolves against a
+        fully-qualified stored key like
+        ``"property.sharepoint-connection.SharePoint Invoices folder"``.
+        """
+        context_overwrites = _resource_overwrites.get()
+        if context_overwrites is None:
+            return None
+        for stored_key, overwrite in context_overwrites.items():
+            if not (
+                isinstance(overwrite, GenericResourceOverwrite)
+                and overwrite.resource_type == "property"
+            ):
+                continue
+            # Strip the "property." prefix for comparison (case-insensitive)
+            lower_stored = stored_key.lower()
+            bare_key = (
+                stored_key[len("property.") :]
+                if lower_stored.startswith("property.")
+                else stored_key
+            )
+            if bare_key == key or bare_key.endswith(f".{key}") or stored_key == key:
+                return overwrite
+        return None
+
+    @overload
+    def get_property(self, key: str) -> dict[str, str]: ...
+
+    @overload
+    def get_property(self, key: str, sub_property: str) -> str: ...
+
+    def get_property(
+        self, key: str, sub_property: Optional[str] = None
+    ) -> Union[str, dict[str, str]]:
+        """Get the value(s) of a Property binding resource.
+
+        Args:
+            key: The binding key, e.g. ``"sharepoint-connection.SharePoint Invoices folder"``.
+                Accepts the full key or a suffix that uniquely identifies the binding.
+            sub_property: The name of a specific sub-property to retrieve (e.g. ``"ID"``).
+                If omitted, returns all sub-properties as a ``{name: value}`` dict.
+
+        Returns:
+            The ``defaultValue`` of the requested sub-property when ``sub_property`` is
+            given, or a dict of all sub-property names mapped to their ``defaultValue``
+            when ``sub_property`` is omitted.
+
+        Raises:
+            KeyError: When the binding key is not found, or when ``sub_property`` is given
+                but does not exist on the binding.
+        """
+        # Check for runtime overwrite first
+        overwrite = self._get_overwrite(key)
+        if overwrite is not None:
+            if sub_property is not None:
+                if sub_property not in overwrite.values:
+                    raise KeyError(
+                        f"Sub-property '{sub_property}' not found in Property binding '{key}'. "
+                        f"Available: {list(overwrite.values.keys())}"
+                    )
+                return overwrite.values[sub_property]
+            return dict(overwrite.values)
+
+        # Fall back to bindings.json
+        resource = self._find_property_resource(key)
+        if resource is None:
+            raise KeyError(
+                f"Property binding '{key}' not found in {self._bindings_file_path}."
+            )
+
+        value: dict = resource.get("value", {})
+        all_values = {
+            name: props.get("defaultValue", "") for name, props in value.items()
+        }
+
+        if sub_property is not None:
+            if sub_property not in all_values:
+                raise KeyError(
+                    f"Sub-property '{sub_property}' not found in Property binding '{key}'. "
+                    f"Available: {list(all_values.keys())}"
+                )
+            return all_values[sub_property]
+
+        return all_values