digitalkin 0.3.1.dev2__py3-none-any.whl → 0.3.2a3__py3-none-any.whl

digitalkin/services/user_profile/user_profile_strategy.py

@@ -13,21 +13,6 @@ class UserProfileServiceError(Exception):
 class UserProfileStrategy(BaseStrategy, ABC):
     """Abstract base class for UserProfile strategies."""
 
-    def __init__(
-        self,
-        mission_id: str,
-        setup_id: str,
-        setup_version_id: str,
-    ) -> None:
-        """Initialize the strategy.
-
-        Args:
-            mission_id: The ID of the mission this strategy is associated with
-            setup_id: The ID of the setup
-            setup_version_id: The ID of the setup version this strategy is associated with
-        """
-        super().__init__(mission_id, setup_id, setup_version_id)
-
     @abstractmethod
     def get_user_profile(self) -> dict[str, Any]:
         """Get user profile data.

digitalkin/utils/__init__.py

@@ -1,7 +1,15 @@
 """General utils folder."""
 
+from digitalkin.utils.conditional_schema import (
+    Conditional,
+    ConditionalField,
+    ConditionalSchemaMixin,
+    get_conditional_metadata,
+    has_conditional,
+)
 from digitalkin.utils.dynamic_schema import (
     DEFAULT_TIMEOUT,
+    Dynamic,
     DynamicField,
     Fetcher,
     ResolveResult,
@@ -12,17 +20,21 @@ from digitalkin.utils.dynamic_schema import (
     resolve_safe,
 )
 
-# Alias for cleaner API: `Dynamic` is shorter than `DynamicField`
-Dynamic = DynamicField
-
 __all__ = [
+    # Dynamic schema
     "DEFAULT_TIMEOUT",
+    # Conditional schema
+    "Conditional",
+    "ConditionalField",
+    "ConditionalSchemaMixin",
     "Dynamic",
     "DynamicField",
     "Fetcher",
     "ResolveResult",
+    "get_conditional_metadata",
     "get_dynamic_metadata",
     "get_fetchers",
+    "has_conditional",
     "has_dynamic",
     "resolve",
     "resolve_safe",

digitalkin/utils/conditional_schema.py

@@ -0,0 +1,260 @@
+"""Conditional field visibility for react-jsonschema-form.
+
+This module provides a clean way to mark fields as conditional using Annotated metadata,
+generating JSON Schema with if/then clauses for react-jsonschema-form.
+
+Example:
+    from typing import Annotated, Literal
+    from pydantic import BaseModel, Field
+    from digitalkin.utils import Conditional, ConditionalSchemaMixin
+
+    class Tools(ConditionalSchemaMixin, BaseModel):
+        web_search_enabled: bool = Field(...)
+
+        web_search_engine: Annotated[
+            Literal["duckduckgo", "tavily"],
+            Conditional(trigger="web_search_enabled", show_when=True),
+        ] = Field(...)
+
+See Also:
+    - Documentation: docs/api/conditional_schema.md
+    - Tests: tests/utils/test_conditional_schema.py
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, ClassVar
+
+from pydantic import BaseModel
+
+if TYPE_CHECKING:
+    from pydantic.annotated_handlers import GetJsonSchemaHandler
+    from pydantic.fields import FieldInfo
+    from pydantic.json_schema import JsonSchemaValue
+    from pydantic_core.core_schema import CoreSchema
+
+
+@dataclass
+class ConditionalField:
+    """Metadata for conditional field visibility.
+
+    Use with typing.Annotated to mark fields that should only appear
+    when a trigger field has a specific value.
+
+    Args:
+        trigger: Name of the field that controls visibility.
+        show_when: Value(s) that trigger field must have to show this field.
+            Can be a boolean, string, or list of strings for multiple values.
+        required_when_shown: Whether field is required when visible. Defaults to True.
+
+    Example:
+        # Boolean condition
+        web_search_engine: Annotated[
+            str,
+            Conditional(trigger="web_search_enabled", show_when=True),
+        ] = Field(...)
+
+        # Enum condition
+        advanced_option: Annotated[
+            str,
+            Conditional(trigger="mode", show_when="advanced"),
+        ] = Field(...)
+
+        # Multiple values condition
+        shared_feature: Annotated[
+            bool,
+            Conditional(trigger="mode", show_when=["standard", "advanced"]),
+        ] = Field(...)
+    """
+
+    trigger: str
+    show_when: bool | str | list[str]
+    required_when_shown: bool = True
+
+    def __post_init__(self) -> None:
+        """Normalize single-item lists to scalar values."""
+        if isinstance(self.show_when, list) and len(self.show_when) == 1:
+            self.show_when = self.show_when[0]
+
+
+# Short alias for cleaner API
+Conditional = ConditionalField
+
+
+def get_conditional_metadata(field_info: FieldInfo) -> ConditionalField | None:
+    """Extract ConditionalField from field metadata.
+
+    Args:
+        field_info: The Pydantic FieldInfo object to inspect.
+
+    Returns:
+        The ConditionalField metadata instance if found, None otherwise.
+    """
+    for meta in field_info.metadata:
+        if isinstance(meta, ConditionalField):
+            return meta
+    return None
+
+
+def has_conditional(field_info: FieldInfo) -> bool:
+    """Check if field has ConditionalField metadata.
+
+    Args:
+        field_info: The Pydantic FieldInfo object to check.
+
+    Returns:
+        True if the field has ConditionalField metadata, False otherwise.
+    """
+    return get_conditional_metadata(field_info) is not None
+
+
+def _collect_conditions(
+    model_fields: dict[str, FieldInfo],
+    props: dict[str, Any],
+) -> tuple[dict[tuple[str, Any], list[tuple[str, bool]]], set[str]]:
+    """Collect conditional fields grouped by trigger and show_when value.
+
+    Args:
+        model_fields: The model's field definitions.
+        props: The schema properties dict.
+
+    Returns:
+        Tuple of (conditions dict, fields to remove set).
+    """
+    conditions: dict[tuple[str, Any], list[tuple[str, bool]]] = {}
+    fields_to_remove: set[str] = set()
+
+    for field_name, field_info in model_fields.items():
+        cond = get_conditional_metadata(field_info)
+        if cond is None or field_name not in props:
+            continue
+
+        show_key = tuple(cond.show_when) if isinstance(cond.show_when, list) else cond.show_when
+        key = (cond.trigger, show_key)
+
+        if key not in conditions:
+            conditions[key] = []
+        conditions[key].append((field_name, cond.required_when_shown))
+        fields_to_remove.add(field_name)
+
+    return conditions, fields_to_remove
+
+
+def _build_if_clause(trigger: str, *, show_when: bool | str | tuple[str, ...]) -> dict[str, Any]:
+    """Build the if clause for a conditional.
+
+    Args:
+        trigger: The trigger field name.
+        show_when: The value(s) that trigger visibility.
+
+    Returns:
+        The if clause dict.
+    """
+    if isinstance(show_when, tuple):
+        return {"properties": {trigger: {"enum": list(show_when)}}, "required": [trigger]}
+    return {"properties": {trigger: {"const": show_when}}, "required": [trigger]}
+
+
+def _resolve_field_schema(
+    field_schema: dict[str, Any],
+    handler: GetJsonSchemaHandler,
+) -> dict[str, Any]:
+    """Resolve $ref in field schema if present.
+
+    Args:
+        field_schema: The field's schema dict.
+        handler: The JSON schema handler for resolving refs.
+
+    Returns:
+        The resolved schema dict.
+    """
+    if "$ref" not in field_schema:
+        return field_schema
+
+    resolved = handler.resolve_ref_schema(field_schema)
+    extra = {k: v for k, v in field_schema.items() if k != "$ref"}
+    return {**resolved, **extra}
+
+
+class ConditionalSchemaMixin(BaseModel):
+    """Mixin for automatic conditional field processing in JSON schema.
+
+    Inherit from this mixin to automatically generate JSON Schema with
+    if/then clauses for fields marked with ConditionalField metadata.
+
+    The mixin processes Annotated fields with Conditional metadata and:
+    1. Removes conditional fields from main properties
+    2. Adds them to allOf with if/then clauses
+    3. Groups multiple fields with the same condition together
+
+    Example:
+        class Config(ConditionalSchemaMixin, BaseModel):
+            mode: Literal["basic", "advanced"] = Field(...)
+
+            advanced_option: Annotated[
+                str,
+                Conditional(trigger="mode", show_when="advanced"),
+            ] = Field(...)
+
+        # Generates schema with:
+        # {
+        #     "properties": {"mode": {...}},
+        #     "allOf": [{
+        #         "if": {"properties": {"mode": {"const": "advanced"}}},
+        #         "then": {"properties": {"advanced_option": {...}}}
+        #     }]
+        # }
+    """
+
+    model_fields: ClassVar[dict[str, FieldInfo]]  # type: ignore[misc]
+
+    @classmethod
+    def __get_pydantic_json_schema__(  # noqa: PLW3201
+        cls,
+        core_schema: CoreSchema,
+        handler: GetJsonSchemaHandler,
+    ) -> JsonSchemaValue:
+        """Generate JSON schema with conditional field handling.
+
+        Args:
+            core_schema: The Pydantic core schema.
+            handler: The JSON schema handler for resolving refs.
+
+        Returns:
+            The JSON schema with if/then clauses for conditional fields.
+        """
+        schema = handler(core_schema)
+        props = schema.get("properties", {})
+        if not props:
+            return schema
+
+        conditions, fields_to_remove = _collect_conditions(cls.model_fields, props)
+        if not conditions:
+            return schema
+
+        all_of = schema.setdefault("allOf", [])
+
+        for (trigger, show_when), field_list in conditions.items():
+            then_props: dict[str, Any] = {}
+            then_required: list[str] = []
+
+            for field_name, required in field_list:
+                then_props[field_name] = _resolve_field_schema(props[field_name], handler)
+                if required:
+                    then_required.append(field_name)
+
+            if_clause = _build_if_clause(trigger, show_when=show_when)
+            then_clause: dict[str, Any] = {"properties": then_props}
+            if then_required:
+                then_clause["required"] = then_required
+
+            all_of.append({"if": if_clause, "then": then_clause})
+
+        for field_name in fields_to_remove:
+            del props[field_name]
+
+        if "required" in schema:
+            schema["required"] = [r for r in schema["required"] if r not in fields_to_remove]
+
+        return schema

digitalkin/utils/dynamic_schema.py

@@ -136,6 +136,10 @@ class DynamicField:
         return hash(tuple(sorted(self.fetchers.keys())))
 
 
+# Alias for cleaner API: `Dynamic` is shorter than `DynamicField`
+Dynamic = DynamicField
+
+
 def get_dynamic_metadata(field_info: FieldInfo) -> DynamicField | None:
     """Extract DynamicField metadata from a FieldInfo's metadata list.
 

digitalkin/utils/schema_splitter.py

@@ -0,0 +1,290 @@
+"""Schema splitter for react-jsonschema-form."""
+
+from typing import Any
+
+
+class SchemaSplitter:
+    """Splits a combined JSON schema into jsonschema and uischema for react-jsonschema-form."""
+
+    @classmethod
+    def split(cls, combined_schema: dict[str, Any]) -> tuple[dict[str, Any], dict[str, Any]]:
+        """Split schema into (jsonschema, uischema).
+
+        Args:
+            combined_schema: Combined JSON schema with ui:* properties.
+
+        Returns:
+            Tuple of (jsonschema, uischema).
+        """
+        defs_ui: dict[str, dict[str, Any]] = {}
+        schema_defs = combined_schema.get("$defs", {})
+        if schema_defs:
+            for def_name, def_value in schema_defs.items():
+                if isinstance(def_value, dict):
+                    defs_ui[def_name] = {}
+                    cls._extract_ui_properties(def_value, defs_ui[def_name], schema_defs)
+
+        json_schema: dict[str, Any] = {}
+        ui_schema: dict[str, Any] = {}
+        cls._process_object(combined_schema, json_schema, ui_schema, defs_ui, schema_defs)
+        return json_schema, ui_schema
+
+    @classmethod
+    def _extract_ui_properties(  # noqa: C901, PLR0912
+        cls,
+        source: dict[str, Any],
+        ui_target: dict[str, Any],
+        defs: dict[str, Any] | None = None,
+    ) -> None:
+        """Extract ui:* properties from source into ui_target recursively.
+
+        Args:
+            source: Source dict to extract from.
+            ui_target: Target dict for ui properties.
+            defs: The $defs dictionary to resolve $ref references.
+        """
+        for key, value in source.items():
+            if key.startswith("ui:"):
+                ui_target[key] = value
+            elif key == "properties" and isinstance(value, dict):
+                for prop_name, prop_value in value.items():
+                    if isinstance(prop_value, dict):
+                        prop_ui: dict[str, Any] = {}
+                        cls._extract_ui_properties(prop_value, prop_ui, defs)
+                        if prop_ui:
+                            ui_target[prop_name] = prop_ui
+            elif key == "items" and isinstance(value, dict):
+                items_ui: dict[str, Any] = {}
+                cls._extract_ui_properties(value, items_ui, defs)
+                if items_ui:
+                    ui_target["items"] = items_ui
+            elif key in {"allOf", "oneOf", "anyOf"} and isinstance(value, list):
+                # For oneOf/anyOf, create a mirrored structure in ui_target
+                if key in {"oneOf", "anyOf"}:
+                    ui_target[key] = []
+                    for item in value:
+                        if isinstance(item, dict):
+                            item_ui: dict[str, Any] = {}
+                            cls._extract_ui_properties(item, item_ui, defs)
+                            ui_target[key].append(item_ui)
+                else:  # allOf - merge into parent
+                    for item in value:
+                        if isinstance(item, dict):
+                            cls._extract_ui_properties(item, ui_target, defs)
+            elif key in {"if", "then", "else"} and isinstance(value, dict):
+                cls._extract_ui_properties(value, ui_target, defs)
+            elif key == "$ref" and isinstance(value, str) and defs is not None and value.startswith("#/$defs/"):
+                # Resolve $ref and extract UI properties from the referenced definition
+                def_name = value[8:]
+                if def_name in defs:
+                    cls._extract_ui_properties(defs[def_name], ui_target, defs)
+
+    @classmethod
+    def _process_object(  # noqa: C901, PLR0912, PLR0915
+        cls,
+        source: dict[str, Any],
+        json_target: dict[str, Any],
+        ui_target: dict[str, Any],
+        defs_ui: dict[str, dict[str, Any]],
+        schema_defs: dict[str, Any] | None = None,
+    ) -> None:
+        """Process an object, splitting json and ui properties.
+
+        Args:
+            source: Source object to process.
+            json_target: Target dict for json schema.
+            ui_target: Target dict for ui schema.
+            defs_ui: Pre-extracted UI properties from $defs.
+            schema_defs: The original $defs dictionary to resolve $ref in _extract_ui_properties.
+        """
+        for key, value in source.items():
+            if key.startswith("ui:"):
+                ui_target[key] = value
+            elif key == "properties" and isinstance(value, dict):
+                json_target["properties"] = {}
+                for prop_name, prop_value in value.items():
+                    if isinstance(prop_value, dict):
+                        # Skip hidden fields
+                        if prop_value.get("hidden") is True:
+                            continue
+                        json_target["properties"][prop_name] = {}
+                        prop_ui: dict[str, Any] = {}
+                        cls._process_property(prop_value, json_target["properties"][prop_name], prop_ui, defs_ui)
+                        if prop_ui:
+                            ui_target[prop_name] = prop_ui
+                    else:
+                        json_target["properties"][prop_name] = prop_value
+            elif key == "$defs" and isinstance(value, dict):
+                json_target["$defs"] = {}
+                for def_name, def_value in value.items():
+                    if isinstance(def_value, dict):
+                        json_target["$defs"][def_name] = {}
+                        cls._strip_ui_properties(def_value, json_target["$defs"][def_name])
+                    else:
+                        json_target["$defs"][def_name] = def_value
+            elif key == "items" and isinstance(value, dict):
+                json_target["items"] = {}
+                items_ui: dict[str, Any] = {}
+                cls._process_property(value, json_target["items"], items_ui, defs_ui)
+                if items_ui:
+                    ui_target["items"] = items_ui
+            elif key == "allOf" and isinstance(value, list):
+                json_target["allOf"] = []
+                for item in value:
+                    if isinstance(item, dict):
+                        item_json_all_of: dict[str, Any] = {}
+                        cls._strip_ui_properties(item, item_json_all_of)
+                        json_target["allOf"].append(item_json_all_of)
+                        # Extract UI properties from allOf item
+                        cls._extract_ui_properties(item, ui_target, schema_defs)
+                    else:
+                        json_target["allOf"].append(item)
+            elif key in {"oneOf", "anyOf"} and isinstance(value, list):
+                json_target[key] = []
+                ui_target[key] = []  # Mirror structure in ui_schema
+                for item in value:
+                    if isinstance(item, dict):
+                        item_json_oneof_anyof: dict[str, Any] = {}
+                        cls._strip_ui_properties(item, item_json_oneof_anyof)
+                        json_target[key].append(item_json_oneof_anyof)
+                        # Extract UI properties into a separate dict for this variant
+                        item_ui_oneof_anyof: dict[str, Any] = {}
+                        cls._extract_ui_properties(item, item_ui_oneof_anyof, schema_defs)
+                        ui_target[key].append(item_ui_oneof_anyof)
+                    else:
+                        json_target[key].append(item)
+            elif key in {"if", "then", "else"} and isinstance(value, dict):
+                json_target[key] = {}
+                cls._strip_ui_properties(value, json_target[key])
+                # Extract UI properties from conditional
+                cls._extract_ui_properties(value, ui_target, schema_defs)
+            elif key == "hidden":
+                # Strip hidden key from json schema
+                continue
+            else:
+                json_target[key] = value
+
+    @classmethod
+    def _process_property(  # noqa: C901, PLR0912
+        cls,
+        source: dict[str, Any],
+        json_target: dict[str, Any],
+        ui_target: dict[str, Any],
+        defs_ui: dict[str, dict[str, Any]],
+    ) -> None:
+        """Process a property, resolving $ref for UI properties.
+
+        Args:
+            source: Source property dict.
+            json_target: Target dict for json schema.
+            ui_target: Target dict for ui schema.
+            defs_ui: Pre-extracted UI properties from $defs.
+        """
+        if "$ref" in source:
+            ref_path = source["$ref"]
+            if ref_path.startswith("#/$defs/"):
+                def_name = ref_path[8:]
+                if def_name in defs_ui:
+                    ui_target.update(defs_ui[def_name])
+
+        for key, value in source.items():
+            if key.startswith("ui:"):
+                ui_target[key] = value
+            elif key == "properties" and isinstance(value, dict):
+                json_target["properties"] = {}
+                for prop_name, prop_value in value.items():
+                    if isinstance(prop_value, dict):
+                        # Skip hidden fields
+                        if prop_value.get("hidden") is True:
+                            continue
+                        json_target["properties"][prop_name] = {}
+                        prop_ui: dict[str, Any] = {}
+                        cls._process_property(prop_value, json_target["properties"][prop_name], prop_ui, defs_ui)
+                        if prop_ui:
+                            ui_target[prop_name] = prop_ui
+                    else:
+                        json_target["properties"][prop_name] = prop_value
+            elif key == "items" and isinstance(value, dict):
+                json_target["items"] = {}
+                items_ui: dict[str, Any] = {}
+                cls._process_property(value, json_target["items"], items_ui, defs_ui)
+                if items_ui:
+                    ui_target["items"] = items_ui
+            elif key in {"oneOf", "anyOf"} and isinstance(value, list):
+                json_target[key] = []
+                ui_target[key] = []  # Mirror structure in ui_schema
+                for item in value:
+                    if isinstance(item, dict):
+                        item_json_oneof_anyof: dict[str, Any] = {}
+                        cls._strip_ui_properties(item, item_json_oneof_anyof)
+                        json_target[key].append(item_json_oneof_anyof)
+                        # Extract UI properties for this variant
+                        item_ui_oneof_anyof: dict[str, Any] = {}
+                        ref_path = item.get("$ref", "")
+                        if ref_path.startswith("#/$defs/") and ref_path[8:] in defs_ui:
+                            item_ui_oneof_anyof.update(defs_ui[ref_path[8:]])
+                        ui_target[key].append(item_ui_oneof_anyof)
+                    else:
+                        json_target[key].append(item)
+            elif key == "hidden":
+                # Strip hidden key from json schema
+                continue
+            else:
+                json_target[key] = value
+
+    @classmethod
+    def _strip_ui_properties(cls, source: dict[str, Any], json_target: dict[str, Any]) -> None:  # noqa: C901, PLR0912
+        """Copy source to json_target, stripping ui:* properties.
+
+        Args:
+            source: Source dict.
+            json_target: Target dict without ui:* properties.
+        """
+        for key, value in source.items():
+            if key.startswith("ui:") or key == "hidden":
+                continue
+            if key == "properties" and isinstance(value, dict):
+                json_target["properties"] = {}
+                for prop_name, prop_value in value.items():
+                    if isinstance(prop_value, dict):
+                        # Skip hidden fields
+                        if prop_value.get("hidden") is True:
+                            continue
+                        json_target["properties"][prop_name] = {}
+                        cls._strip_ui_properties(prop_value, json_target["properties"][prop_name])
+                    else:
+                        json_target["properties"][prop_name] = prop_value
+            elif key == "$defs" and isinstance(value, dict):
+                json_target["$defs"] = {}
+                for def_name, def_value in value.items():
+                    if isinstance(def_value, dict):
+                        json_target["$defs"][def_name] = {}
+                        cls._strip_ui_properties(def_value, json_target["$defs"][def_name])
+                    else:
+                        json_target["$defs"][def_name] = def_value
+            elif key == "items" and isinstance(value, dict):
+                json_target["items"] = {}
+                cls._strip_ui_properties(value, json_target["items"])
+            elif key == "allOf" and isinstance(value, list):
+                json_target["allOf"] = []
+                for item in value:
+                    if isinstance(item, dict):
+                        item_json_all_of: dict[str, Any] = {}
+                        cls._strip_ui_properties(item, item_json_all_of)
+                        json_target["allOf"].append(item_json_all_of)
+                    else:
+                        json_target["allOf"].append(item)
+            elif key in {"oneOf", "anyOf"} and isinstance(value, list):
+                json_target[key] = []
+                for item in value:
+                    if isinstance(item, dict):
+                        item_json_oneof_anyof: dict[str, Any] = {}
+                        cls._strip_ui_properties(item, item_json_oneof_anyof)
+                        json_target[key].append(item_json_oneof_anyof)
+                    else:
+                        json_target[key].append(item)
+            elif key in {"if", "then", "else"} and isinstance(value, dict):
+                json_target[key] = {}
+                cls._strip_ui_properties(value, json_target[key])
+            else:
+                json_target[key] = value

{digitalkin-0.3.1.dev2.dist-info → digitalkin-0.3.2a3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: digitalkin
-Version: 0.3.1.dev2
+Version: 0.3.2a3
 Summary: SDK to build kin used in DigitalKin
 Author-email: "DigitalKin.ai" <contact@digitalkin.ai>
 License: Attribution-NonCommercial-ShareAlike 4.0 International
@@ -434,35 +434,35 @@ License: Attribution-NonCommercial-ShareAlike 4.0 International
         Creative Commons may be contacted at creativecommons.org.
         https://creativecommons.org/licenses/by-nc-sa/4.0/
         
-Project-URL: Homepage, https://github.com/DigitalKin-ai/digitalkin
 Project-URL: Documentation, https://github.com/DigitalKin-ai/digitalkin
+Project-URL: Homepage, https://github.com/DigitalKin-ai/digitalkin
 Project-URL: Issues, https://github.com/DigitalKin-ai/digitalkin/issues
-Keywords: digitalkin,kin,agent,gprc,sdk
+Keywords: agent,digitalkin,gprc,kin,sdk
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
+Classifier: License :: Other/Proprietary License
 Classifier: Operating System :: OS Independent
-Classifier: Topic :: Software Development :: Libraries
-Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
-Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: License :: Other/Proprietary License
+Classifier: Programming Language :: Python
+Classifier: Topic :: Software Development :: Libraries
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: digitalkin-proto==0.2.0.dev5
+Requires-Dist: agentic-mesh-protocol==0.2.1.dev1
 Requires-Dist: grpcio-health-checking>=1.76.0
 Requires-Dist: grpcio-reflection>=1.76.0
 Requires-Dist: grpcio-status>=1.76.0
 Requires-Dist: pydantic>=2.12.5
-Requires-Dist: surrealdb>=1.0.6
+Requires-Dist: surrealdb>=1.0.7
 Provides-Extra: taskiq
-Requires-Dist: rstream>=0.40.0; extra == "taskiq"
+Requires-Dist: rstream>=0.40.1; extra == "taskiq"
 Requires-Dist: taskiq-aio-pika>=0.5.0; extra == "taskiq"
-Requires-Dist: taskiq-redis>=1.1.2; extra == "taskiq"
-Requires-Dist: taskiq[reload]>=0.12.0; extra == "taskiq"
+Requires-Dist: taskiq-redis>=1.2.0; extra == "taskiq"
+Requires-Dist: taskiq[reload]>=0.12.1; extra == "taskiq"
 Dynamic: license-file
 
 # DigitalKin Python SDK