digitalkin 0.3.2.dev8__tar.gz → 0.3.2.dev11__tar.gz

{digitalkin-0.3.2.dev8 → digitalkin-0.3.2.dev11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: digitalkin
-Version: 0.3.2.dev8
+Version: 0.3.2.dev11
 Summary: SDK to build kin used in DigitalKin
 Author-email: "DigitalKin.ai" <contact@digitalkin.ai>
 License: Attribution-NonCommercial-ShareAlike 4.0 International

{digitalkin-0.3.2.dev8 → digitalkin-0.3.2.dev11}/pyproject.toml

@@ -12,7 +12,7 @@
 
     keywords = [ "digitalkin", "kin", "agent", "gprc", "sdk" ]
 
-    version = "0.3.2.dev8"
+    version = "0.3.2.dev11"
     classifiers = [
         "Development Status :: 3 - Alpha",
         "Intended Audience :: Developers",

{digitalkin-0.3.2.dev8 → digitalkin-0.3.2.dev11}/src/digitalkin/__version__.py

@@ -5,4 +5,4 @@ from importlib.metadata import PackageNotFoundError, version
 try:
     __version__ = version("digitalkin")
 except PackageNotFoundError:
-    __version__ = "0.3.2.dev8"
+    __version__ = "0.3.2.dev11"

{digitalkin-0.3.2.dev8 → digitalkin-0.3.2.dev11}/src/digitalkin/grpc_servers/utils/grpc_client_wrapper.py

@@ -43,9 +43,9 @@ class GrpcClientWrapper:
                 private_key=private_key,
             )
 
-            return grpc.secure_channel(config.address, channel_credentials, options=config.channel_options)
+            return grpc.secure_channel(config.address, channel_credentials, options=config.grpc_options)
         # Insecure channel
-        return grpc.insecure_channel(config.address, options=config.channel_options)
+        return grpc.insecure_channel(config.address, options=config.grpc_options)
 
     def exec_grpc_query(self, query_endpoint: str, request: Any) -> Any:  # noqa: ANN401
         """Execute a gRPC query with from the query's rpc endpoint name.

{digitalkin-0.3.2.dev8 → digitalkin-0.3.2.dev11}/src/digitalkin/models/grpc_servers/models.py

@@ -65,6 +65,42 @@ class ServerCredentials(BaseModel):
         return v
 
 
+class RetryPolicy(BaseModel):
+    """gRPC retry policy configuration for resilient connections.
+
+    Attributes:
+        max_attempts: Maximum retry attempts including the original call
+        initial_backoff: Initial backoff duration (e.g., "0.1s")
+        max_backoff: Maximum backoff duration (e.g., "10s")
+        backoff_multiplier: Multiplier for exponential backoff
+        retryable_status_codes: gRPC status codes that trigger retry
+    """
+
+    max_attempts: int = Field(default=5, ge=1, le=10, description="Maximum retry attempts including the original call")
+    initial_backoff: str = Field(default="0.1s", description="Initial backoff duration (e.g., '0.1s')")
+    max_backoff: str = Field(default="10s", description="Maximum backoff duration (e.g., '10s')")
+    backoff_multiplier: float = Field(default=2.0, ge=1.0, description="Multiplier for exponential backoff")
+    retryable_status_codes: list[str] = Field(
+        default_factory=lambda: ["UNAVAILABLE", "RESOURCE_EXHAUSTED"],
+        description="gRPC status codes that trigger retry",
+    )
+
+    model_config = {"extra": "forbid", "frozen": True}
+
+    def to_service_config_json(self) -> str:
+        """Serialize to gRPC service config JSON string.
+
+        Returns:
+            JSON string for grpc.service_config channel option.
+        """
+        codes = "[" + ",".join(f'"{c}"' for c in self.retryable_status_codes) + "]"
+        return (
+            f'{{"methodConfig":[{{"name":[{{}}],"retryPolicy":{{"maxAttempts":{self.max_attempts},'
+            f'"initialBackoff":"{self.initial_backoff}","maxBackoff":"{self.max_backoff}",'
+            f'"backoffMultiplier":{self.backoff_multiplier},"retryableStatusCodes":{codes}}}}}]}}'
+        )
+
+
 class ClientCredentials(BaseModel):
     """Model for client credentials in secure mode.
 
@@ -170,15 +206,47 @@ class ClientConfig(ChannelConfig):
         security: Security mode (secure/insecure)
         credentials: Client credentials for secure mode
         channel_options: Additional channel options
+        retry_policy: Retry policy for failed RPCs
     """
 
     credentials: ClientCredentials | None = Field(None, description="Client credentials for secure mode")
+    retry_policy: RetryPolicy = Field(default_factory=lambda: RetryPolicy(), description="Retry policy for failed RPCs")  # noqa: PLW0108
     channel_options: list[tuple[str, Any]] = Field(
         default_factory=lambda: [
-            ("grpc.max_receive_message_length", 100 * 1024 * 1024),  # 100MB
-            ("grpc.max_send_message_length", 100 * 1024 * 1024),  # 100MB
+            ("grpc.max_receive_message_length", 100 * 1024 * 1024),
+            ("grpc.max_send_message_length", 100 * 1024 * 1024),
+            # === DNS Re-resolution (Critical for Container Environments) ===
+            # Minimum milliseconds between DNS re-resolution attempts (500 ms)
+            # When connection fails, gRPC will re-query DNS after this interval
+            # Solves: Container restarts with new IPs causing "No route to host"
+            ("grpc.dns_min_time_between_resolutions_ms", 500),
+            # Initial delay before first reconnection attempt (1 second)
+            ("grpc.initial_reconnect_backoff_ms", 1000),
+            # Maximum delay between reconnection attempts (10 seconds)
+            # Prevents overwhelming the network during extended outages
+            ("grpc.max_reconnect_backoff_ms", 10000),
+            # Minimum delay between reconnection attempts (500ms)
+            # Ensures rapid recovery for brief network glitches
+            ("grpc.min_reconnect_backoff_ms", 500),
+            # === Keepalive Settings (Detect Dead Connections) ===
+            # Send keepalive ping every 60 seconds when connection is idle
+            # Proactively detects dead connections before RPC calls fail
+            ("grpc.keepalive_time_ms", 60000),
+            # Wait 20 seconds for keepalive response before declaring connection dead
+            # Triggers reconnection (with DNS re-resolution) if pong not received
+            ("grpc.keepalive_timeout_ms", 20000),
+            # Send keepalive pings even when no RPCs are in flight
+            # Essential for long-lived connections that may sit idle
+            ("grpc.keepalive_permit_without_calls", True),
+            # Minimum interval between HTTP/2 pings (30 seconds)
+            # Must be >= server's grpc.http2.min_ping_interval_without_data_ms (10s)
+            ("grpc.http2.min_time_between_pings_ms", 30000),
+            # === Retry Configuration ===
+            # Enable automatic retry for failed RPCs (1 = enabled)
+            # Works with retryable status codes: UNAVAILABLE, RESOURCE_EXHAUSTED
+            ("grpc.enable_retries", 1),
         ],
-        description="Additional channel options",
+        description="Resilient gRPC channel options with DNS re-resolution, keepalive, and retries",
     )
 
     @field_validator("credentials")
@@ -204,6 +272,15 @@ class ClientConfig(ChannelConfig):
             raise ConfigurationError(msg)
         return v
 
+    @property
+    def grpc_options(self) -> list[tuple[str, Any]]:
+        """Get channel options with retry policy service config.
+
+        Returns:
+            Full list of gRPC channel options.
+        """
+        return [*self.channel_options, ("grpc.service_config", self.retry_policy.to_service_config_json())]
+
 
 class ServerConfig(ChannelConfig):
     """Base configuration for gRPC servers.
@@ -223,10 +300,18 @@ class ServerConfig(ChannelConfig):
     credentials: ServerCredentials | None = Field(None, description="Server credentials for secure mode")
     server_options: list[tuple[str, Any]] = Field(
         default_factory=lambda: [
-            ("grpc.max_receive_message_length", 100 * 1024 * 1024),  # 100MB
-            ("grpc.max_send_message_length", 100 * 1024 * 1024),  # 100MB
+            ("grpc.max_receive_message_length", 100 * 1024 * 1024),
+            ("grpc.max_send_message_length", 100 * 1024 * 1024),
+            # === Keepalive Permission (Required for Client Keepalive) ===
+            # Allow clients to send keepalive pings without active RPCs
+            # Without this, server rejects client keepalives with GOAWAY
+            ("grpc.keepalive_permit_without_calls", True),
+            # Minimum interval server allows between client pings (10 seconds)
+            # Prevents "too_many_pings" GOAWAY errors
+            # Must match or be less than client's http2.min_time_between_pings_ms
+            ("grpc.http2.min_ping_interval_without_data_ms", 10000),
         ],
-        description="Additional server options",
+        description="gRPC server options with keepalive support",
     )
     enable_reflection: bool = Field(default=True, description="Enable reflection for the server")
     enable_health_check: bool = Field(default=True, description="Enable health check service")

{digitalkin-0.3.2.dev8 → digitalkin-0.3.2.dev11}/src/digitalkin/models/module/setup_types.py

@@ -140,10 +140,15 @@ class SetupModel(BaseModel, Generic[SetupModelT]):
 
             clean_fields[name] = (current_annotation, current_field_info)
 
+        root_extra = cls.model_config.get("json_schema_extra", {})
+
         m = create_model(
             f"{cls.__name__}",
             __base__=SetupModel,
-            __config__=ConfigDict(arbitrary_types_allowed=True),
+            __config__=ConfigDict(
+                arbitrary_types_allowed=True,
+                json_schema_extra=copy.deepcopy(root_extra) if isinstance(root_extra, dict) else root_extra,
+            ),
             **clean_fields,
         )
 
@@ -280,10 +285,15 @@ class SetupModel(BaseModel, Generic[SetupModelT]):
         if not has_changes:
             return model_cls
 
+        root_extra = cls.model_config.get("json_schema_extra", {})
+
         return create_model(
             model_cls.__name__,
             __base__=BaseModel,
-            __config__=ConfigDict(arbitrary_types_allowed=True),
+            __config__=ConfigDict(
+                arbitrary_types_allowed=True,
+                json_schema_extra=copy.deepcopy(root_extra) if isinstance(root_extra, dict) else root_extra,
+            ),
             **clean_fields,
         )
 
@@ -437,7 +447,7 @@ class SetupModel(BaseModel, Generic[SetupModelT]):
         logger.info("Tool cache built: %d entries", len(cache.entries))
         return cache
 
-    def _build_tool_cache_recursive(self, model_instance: BaseModel, cache: ToolCache) -> None:  # noqa: C901, PLR0912
+    def _build_tool_cache_recursive(self, model_instance: BaseModel, cache: ToolCache) -> None:  # noqa: C901
         """Recursively build tool cache and populate companion fields.
 
         Args:
@@ -447,13 +457,16 @@ class SetupModel(BaseModel, Generic[SetupModelT]):
         for field_name, field_value in model_instance.__dict__.items():
             if field_value is None:
                 continue
-
-            if isinstance(field_value, ToolReference) and field_value.module_info:
+            if isinstance(field_value, ToolReference):
                 cache_field_name = f"{field_name}_cache"
-                if cache_field_name in type(model_instance).model_fields:
-                    setattr(model_instance, cache_field_name, field_value.module_info)
-                cache.add(field_value.module_info.module_id, field_value.module_info)
-                logger.debug("Added tool to cache: %s", field_value.module_info.module_id)
+
+                cached_info = getattr(model_instance, cache_field_name, None)
+                module_info = field_value.module_info or cached_info
+                if module_info:
+                    if not cached_info:
+                        setattr(model_instance, cache_field_name, module_info)
+                    cache.add(module_info.module_id, module_info)
+                    logger.debug("Added tool to cache: %s", module_info.module_id)
             elif isinstance(field_value, BaseModel):
                 self._build_tool_cache_recursive(field_value, cache)
             elif isinstance(field_value, list):
@@ -473,12 +486,5 @@ class SetupModel(BaseModel, Generic[SetupModelT]):
                         self._build_tool_cache_recursive(item, cache)
 
                 # Update companion field with resolved infos
-                if resolved_infos and cache_field_name in type(model_instance).model_fields:
+                if resolved_infos:
                     setattr(model_instance, cache_field_name, resolved_infos)
-            elif isinstance(field_value, dict):
-                for item in field_value.values():
-                    if isinstance(item, ToolReference) and item.module_info:
-                        cache.add(item.module_info.module_id, item.module_info)
-                        logger.debug("Added tool to cache: %s", item.module_info.module_id)
-                    elif isinstance(item, BaseModel):
-                        self._build_tool_cache_recursive(item, cache)

{digitalkin-0.3.2.dev8 → digitalkin-0.3.2.dev11}/src/digitalkin/models/module/tool_reference.py

@@ -20,9 +20,9 @@ class ToolReferenceConfig(BaseModel):
     """Tool selection configuration. The module_id serves as both identifier and cache key."""
 
     mode: ToolSelectionMode = Field(default=ToolSelectionMode.FIXED)
-    module_id: str | None = Field(default=None)
-    tag: str | None = Field(default=None)
-    organization_id: str | None = Field(default=None)
+    module_id: str = Field(default="")
+    tag: str = Field(default="")
+    organization_id: str = Field(default="")
 
     @model_validator(mode="after")
     def validate_config(self) -> "ToolReferenceConfig":
@@ -50,7 +50,7 @@ class ToolReference(BaseModel):
     _cached_info: ModuleInfo | None = PrivateAttr(default=None)
 
     @property
-    def slug(self) -> str | None:
+    def slug(self) -> str:
         """Cache key (same as module_id).
 
         Returns:
@@ -59,11 +59,11 @@ class ToolReference(BaseModel):
         return self.config.module_id
 
     @property
-    def module_id(self) -> str | None:
+    def module_id(self) -> str:
         """Module identifier.
 
         Returns:
-            Module ID or None if not set.
+            Module ID or empty string if not set.
         """
         return self.config.module_id
 

{digitalkin-0.3.2.dev8 → digitalkin-0.3.2.dev11}/src/digitalkin/modules/_base_module.py

@@ -22,8 +22,8 @@ from digitalkin.models.module.utility import EndOfStreamOutput, ModuleStartInfoO
 from digitalkin.models.services.storage import BaseRole
 from digitalkin.modules.trigger_handler import TriggerHandler
 from digitalkin.services.services_config import ServicesConfig, ServicesStrategy
-from digitalkin.utils.llm_ready_schema import llm_ready_schema
 from digitalkin.utils.package_discover import ModuleDiscoverer
+from digitalkin.utils.schema_splitter import SchemaSplitter
 
 
 class BaseModule(  # noqa: PLR0904
@@ -137,7 +137,8 @@ class BaseModule(  # noqa: PLR0904
         """
         if cls.secret_format is not None:
             if llm_format:
-                return json.dumps(llm_ready_schema(cls.secret_format), indent=2)
+                result_json, result_ui = SchemaSplitter.split(cls.secret_format.model_json_schema())
+                return json.dumps({"json_schema": result_json, "ui_schema": result_ui}, indent=2)
             return json.dumps(cls.secret_format.model_json_schema(), indent=2)
         msg = f"{cls.__name__}' class does not define a 'secret_format'."
         raise NotImplementedError(msg)
@@ -163,7 +164,8 @@ class BaseModule(  # noqa: PLR0904
         extended_model = UtilitySchemaExtender.create_extended_input_model(cls.input_format)
 
         if llm_format:
-            return json.dumps(llm_ready_schema(extended_model), indent=2)
+            result_json, result_ui = SchemaSplitter.split(extended_model.model_json_schema())
+            return json.dumps({"json_schema": result_json, "ui_schema": result_ui}, indent=2)
         return json.dumps(extended_model.model_json_schema(), indent=2)
 
     @classmethod
@@ -187,7 +189,8 @@ class BaseModule(  # noqa: PLR0904
         extended_model = UtilitySchemaExtender.create_extended_output_model(cls.output_format)
 
         if llm_format:
-            return json.dumps(llm_ready_schema(extended_model), indent=2)
+            result_json, result_ui = SchemaSplitter.split(extended_model.model_json_schema())
+            return json.dumps({"json_schema": result_json, "ui_schema": result_ui}, indent=2)
         return json.dumps(extended_model.model_json_schema(), indent=2)
 
     @classmethod
@@ -215,7 +218,8 @@ class BaseModule(  # noqa: PLR0904
         if cls.setup_format is not None:
             setup_format = await cls.setup_format.get_clean_model(config_fields=True, hidden_fields=False, force=True)
             if llm_format:
-                return json.dumps(llm_ready_schema(setup_format), indent=2)
+                result_json, result_ui = SchemaSplitter.split(setup_format.model_json_schema())
+                return json.dumps({"json_schema": result_json, "ui_schema": result_ui}, indent=2)
             return json.dumps(setup_format.model_json_schema(), indent=2)
         msg = "'%s' class does not define an 'config_setup_format'."
         raise NotImplementedError(msg)
@@ -244,7 +248,8 @@ class BaseModule(  # noqa: PLR0904
         if cls.setup_format is not None:
             setup_format = await cls.setup_format.get_clean_model(config_fields=False, hidden_fields=True, force=True)
             if llm_format:
-                return json.dumps(llm_ready_schema(setup_format), indent=2)
+                result_json, result_ui = SchemaSplitter.split(setup_format.model_json_schema())
+                return json.dumps({"json_schema": result_json, "ui_schema": result_ui}, indent=2)
             return json.dumps(setup_format.model_json_schema(), indent=2)
         msg = "'%s' class does not define an 'setup_format'."
         raise NotImplementedError(msg)

digitalkin-0.3.2.dev11/src/digitalkin/utils/schema_splitter.py

@@ -0,0 +1,207 @@
+"""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]] = {}
+        if "$defs" in combined_schema:
+            for def_name, def_value in combined_schema["$defs"].items():
+                if isinstance(def_value, dict):
+                    defs_ui[def_name] = {}
+                    cls._extract_ui_properties(def_value, defs_ui[def_name])
+
+        json_schema: dict[str, Any] = {}
+        ui_schema: dict[str, Any] = {}
+        cls._process_object(combined_schema, json_schema, ui_schema, defs_ui)
+        return json_schema, ui_schema
+
+    @classmethod
+    def _extract_ui_properties(cls, source: dict[str, Any], ui_target: dict[str, Any]) -> None:  # noqa: C901
+        """Extract ui:* properties from source into ui_target recursively.
+
+        Args:
+            source: Source dict to extract from.
+            ui_target: Target dict for ui properties.
+        """
+        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)
+                        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)
+                if items_ui:
+                    ui_target["items"] = items_ui
+            elif key == "allOf" and isinstance(value, list):
+                for item in value:
+                    if isinstance(item, dict):
+                        cls._extract_ui_properties(item, ui_target)
+
+    @classmethod
+    def _process_object(  # 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 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.
+        """
+        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):
+                        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: dict[str, Any] = {}
+                        cls._strip_ui_properties(item, item_json)
+                        json_target["allOf"].append(item_json)
+                    else:
+                        json_target["allOf"].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
+
+    @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):
+                        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
+            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:"):
+                continue
+            if key == "properties" and isinstance(value, dict):
+                json_target["properties"] = {}
+                for prop_name, prop_value in value.items():
+                    if isinstance(prop_value, dict):
+                        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: dict[str, Any] = {}
+                        cls._strip_ui_properties(item, item_json)
+                        json_target["allOf"].append(item_json)
+                    else:
+                        json_target["allOf"].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.2.dev8 → digitalkin-0.3.2.dev11}/src/digitalkin.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: digitalkin
-Version: 0.3.2.dev8
+Version: 0.3.2.dev11
 Summary: SDK to build kin used in DigitalKin
 Author-email: "DigitalKin.ai" <contact@digitalkin.ai>
 License: Attribution-NonCommercial-ShareAlike 4.0 International

{digitalkin-0.3.2.dev8 → digitalkin-0.3.2.dev11}/src/digitalkin.egg-info/SOURCES.txt

@@ -142,4 +142,5 @@ src/digitalkin/utils/arg_parser.py
 src/digitalkin/utils/development_mode_action.py
 src/digitalkin/utils/dynamic_schema.py
 src/digitalkin/utils/llm_ready_schema.py
-src/digitalkin/utils/package_discover.py
+src/digitalkin/utils/package_discover.py
+src/digitalkin/utils/schema_splitter.py