digitalkin 0.3.2.dev2__py3-none-any.whl → 0.3.2.dev4__py3-none-any.whl

digitalkin/models/module/tool_cache.py

@@ -0,0 +1,230 @@
+"""Tool cache for managing resolved tool references.
+
+The ToolCache is a registry that stores resolved ModuleInfo by slug.
+It is populated during run_config_setup and validated during initialize.
+LLMs check the cache before calling the registry for tool discovery.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from pydantic import BaseModel, Field
+
+from digitalkin.logger import logger
+
+if TYPE_CHECKING:
+    from digitalkin.models.services.registry import ModuleInfo
+    from digitalkin.services.registry import RegistryStrategy
+
+
+class ToolCacheEntry(BaseModel):
+    """Single entry in the tool cache."""
+
+    slug: str = Field(description="Unique identifier/slug for this tool")
+    module_id: str = Field(description="Resolved module ID")
+    module_info: ModuleInfo = Field(description="Full module information")
+    is_valid: bool = Field(default=True, description="Whether this entry is still valid")
+
+    model_config = {"arbitrary_types_allowed": True}
+
+
+class ToolCache(BaseModel):
+    """Registry cache for resolved tools.
+
+    Stores tool references by slug during run_config_setup and provides
+    lookup methods for LLMs during execution. Tools must be checked
+    against the cache before calling the registry.
+
+    Flow:
+    1. run_config_setup: Registry called, results cached by slug
+    2. initialize: Cache validated (tools still available)
+    3. Runtime: LLM checks cache first, then registry if not found
+    """
+
+    entries: dict[str, ToolCacheEntry] = Field(default_factory=dict)
+
+    def add(self, slug: str, module_info: ModuleInfo) -> None:
+        """Add a tool to the cache.
+
+        Args:
+            slug: Unique identifier for this tool.
+            module_info: Resolved module information.
+        """
+        self.entries[slug] = ToolCacheEntry(
+            slug=slug,
+            module_id=module_info.module_id,
+            module_info=module_info,
+            is_valid=True,
+        )
+        logger.debug("Tool cached", extra={"slug": slug, "module_id": module_info.module_id})
+
+    def get(self, slug: str) -> ModuleInfo | None:
+        """Get a tool from the cache by slug.
+
+        Args:
+            slug: The tool slug to look up.
+
+        Returns:
+            ModuleInfo if found and valid, None otherwise.
+        """
+        entry = self.entries.get(slug)
+        if entry and entry.is_valid:
+            return entry.module_info
+        return None
+
+    def contains(self, slug: str) -> bool:
+        """Check if a tool exists in the cache.
+
+        Args:
+            slug: The tool slug to check.
+
+        Returns:
+            True if tool exists and is valid.
+        """
+        entry = self.entries.get(slug)
+        return entry is not None and entry.is_valid
+
+    def invalidate(self, slug: str) -> None:
+        """Mark a tool as invalid.
+
+        Args:
+            slug: The tool slug to invalidate.
+        """
+        if slug in self.entries:
+            self.entries[slug].is_valid = False
+            logger.debug("Tool invalidated", extra={"slug": slug})
+
+    def remove(self, slug: str) -> None:
+        """Remove a tool from the cache.
+
+        Args:
+            slug: The tool slug to remove.
+        """
+        if slug in self.entries:
+            del self.entries[slug]
+            logger.debug("Tool removed from cache", extra={"slug": slug})
+
+    def clear(self) -> None:
+        """Clear all entries from the cache."""
+        self.entries.clear()
+
+    def check_and_get(
+        self,
+        slug: str,
+        registry: RegistryStrategy | None = None,
+    ) -> ModuleInfo | None:
+        """Check cache first, then optionally query registry.
+
+        This is the primary method for LLMs to discover tools. It:
+        1. Checks if the tool is in cache (fast path)
+        2. If not in cache and registry provided, queries registry
+        3. If found via registry, caches the result
+
+        Args:
+            slug: The tool slug to look up.
+            registry: Optional registry to query if not in cache.
+
+        Returns:
+            ModuleInfo if found, None otherwise.
+        """
+        # Fast path: check cache
+        cached = self.get(slug)
+        if cached:
+            logger.debug("Tool cache hit", extra={"slug": slug})
+            return cached
+
+        # Not in cache - try registry if available
+        if registry:
+            logger.debug("Tool cache miss, querying registry", extra={"slug": slug})
+            try:
+                # Try by ID first (slug might be module_id)
+                info = registry.discover_by_id(slug)
+                if info:
+                    self.add(slug, info)
+                    return info
+
+                # Try by tag search
+                results = registry.search(name=slug, module_type="tool", organization_id=None)
+                if results:
+                    info = results[0]
+                    self.add(slug, info)
+                    return info
+            except Exception:
+                logger.exception("Registry lookup failed", extra={"slug": slug})
+
+        return None
+
+    def validate(self, registry: RegistryStrategy) -> list[str]:
+        """Validate all cached tools are still available.
+
+        Checks each cached tool against the registry and marks
+        invalid entries. Returns list of invalid slugs.
+
+        Args:
+            registry: Registry to validate against.
+
+        Returns:
+            List of slugs that are no longer valid.
+        """
+        invalid: list[str] = []
+        for slug, entry in self.entries.items():
+            if not entry.is_valid:
+                continue
+            try:
+                info = registry.discover_by_id(entry.module_id)
+                if not info:
+                    entry.is_valid = False
+                    invalid.append(slug)
+                    logger.warning("Tool no longer available", extra={"slug": slug, "module_id": entry.module_id})
+            except Exception:
+                entry.is_valid = False
+                invalid.append(slug)
+                logger.exception("Tool validation failed", extra={"slug": slug})
+        return invalid
+
+    def list_slugs(self) -> list[str]:
+        """Get list of all valid tool slugs.
+
+        Returns:
+            List of valid tool slugs.
+        """
+        return [slug for slug, entry in self.entries.items() if entry.is_valid]
+
+    def to_dict(self) -> dict[str, dict]:
+        """Serialize cache to dict for storage.
+
+        Returns:
+            Dict representation of cache entries.
+        """
+        return {
+            slug: {
+                "slug": entry.slug,
+                "module_id": entry.module_id,
+                "is_valid": entry.is_valid,
+                "module_info": entry.module_info.model_dump(),
+            }
+            for slug, entry in self.entries.items()
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict[str, dict]) -> ToolCache:
+        """Deserialize cache from dict.
+
+        Args:
+            data: Dict representation of cache entries.
+
+        Returns:
+            ToolCache instance.
+        """
+        from digitalkin.models.services.registry import ModuleInfo  # noqa: PLC0415
+
+        cache = cls()
+        for slug, entry_data in data.items():
+            cache.entries[slug] = ToolCacheEntry(
+                slug=entry_data["slug"],
+                module_id=entry_data["module_id"],
+                module_info=ModuleInfo(**entry_data["module_info"]),
+                is_valid=entry_data.get("is_valid", True),
+            )
+        return cache

digitalkin/models/module/tool_reference.py

@@ -0,0 +1,120 @@
+"""Tool reference types for archetype module configuration."""
+
+from enum import Enum
+from typing import TYPE_CHECKING
+
+from pydantic import BaseModel, Field, PrivateAttr, model_validator
+
+from digitalkin.models.services.registry import ModuleInfo
+
+if TYPE_CHECKING:
+    from digitalkin.services.registry import RegistryStrategy
+
+
+class ToolSelectionMode(str, Enum):
+    """Mode for tool selection in archetype setup."""
+
+    FIXED = "fixed"
+    TAG = "tag"
+    DISCOVERABLE = "discoverable"
+
+
+class ToolReferenceConfig(BaseModel):
+    """Configuration for how a tool should be selected."""
+
+    mode: ToolSelectionMode = Field(default=ToolSelectionMode.FIXED)
+    slug: str | None = Field(default=None, description="Unique slug for cache lookup")
+    fixed_id: str | None = Field(default=None, description="Module ID for FIXED mode")
+    tag: str | None = Field(default=None, description="Search tag for TAG mode")
+    organization_id: str | None = Field(default=None, description="Filter by organization")
+
+    @model_validator(mode="after")
+    def validate_config(self) -> "ToolReferenceConfig":
+        """Validate configuration based on mode.
+
+        Returns:
+            Self if validation passes.
+
+        Raises:
+            ValueError: If required field is missing for the mode.
+        """
+        if self.mode == ToolSelectionMode.FIXED and not self.fixed_id:
+            msg = "fixed_id required when mode is FIXED"
+            raise ValueError(msg)
+        if self.mode == ToolSelectionMode.TAG and not self.tag:
+            msg = "tag required when mode is TAG"
+            raise ValueError(msg)
+        return self
+
+
+class ToolReference(BaseModel):
+    """Reference to a tool module for archetype configuration.
+
+    Frontend sets config, backend resolves to actual ModuleInfo.
+    The resolved module_id is persisted in selected_module_id for
+    subsequent StartModule calls without re-resolution.
+    """
+
+    config: ToolReferenceConfig
+    selected_module_id: str | None = Field(default=None, description="Resolved module ID after resolution")
+    _cached_info: ModuleInfo | None = PrivateAttr(default=None)
+
+    @property
+    def slug(self) -> str | None:
+        """Get the slug for cache lookup.
+
+        Returns config.slug if set, otherwise falls back to fixed_id or tag.
+        """
+        if self.config.slug:
+            return self.config.slug
+        if self.config.mode == ToolSelectionMode.FIXED and self.config.fixed_id:
+            return self.config.fixed_id
+        if self.config.mode == ToolSelectionMode.TAG and self.config.tag:
+            return self.config.tag
+        return None
+
+    @property
+    def module_info(self) -> ModuleInfo | None:
+        """Get cached ModuleInfo if resolved."""
+        return self._cached_info
+
+    @property
+    def is_resolved(self) -> bool:
+        """Check if this reference has been resolved."""
+        return self._cached_info is not None or self.selected_module_id is not None
+
+    def resolve(self, registry: "RegistryStrategy") -> ModuleInfo | None:
+        """Resolve this reference using the provided registry.
+
+        For FIXED mode, looks up by fixed_id.
+        For TAG mode, searches by tag and takes first result.
+        For DISCOVERABLE mode, returns None (LLM handles at runtime).
+
+        Args:
+            registry: Registry service to use for resolution.
+
+        Returns:
+            ModuleInfo if resolved, None if not resolvable or DISCOVERABLE mode.
+        """
+        if self.config.mode == ToolSelectionMode.DISCOVERABLE:
+            return None
+
+        if self.config.mode == ToolSelectionMode.FIXED and self.config.fixed_id:
+            info = registry.discover_by_id(self.config.fixed_id)
+            if info:
+                self._cached_info = info
+                self.selected_module_id = self.config.fixed_id
+            return info
+
+        if self.config.mode == ToolSelectionMode.TAG and self.config.tag:
+            results = registry.search(
+                name=self.config.tag,
+                module_type="tool",
+                organization_id=self.config.organization_id,
+            )
+            if results:
+                self._cached_info = results[0]
+                self.selected_module_id = results[0].module_id
+                return results[0]
+
+        return None

digitalkin/models/module/utility.py

@@ -4,11 +4,12 @@ These protocols are automatically available to all modules and don't need to be
 explicitly included in module output unions.
 """
 
+from datetime import datetime, timezone
 from typing import Any, ClassVar, Literal
 
 from pydantic import BaseModel, Field
 
-from digitalkin.models.module.module_types import DataTrigger
+from digitalkin.models.module.base_types import DataTrigger
 
 
 class UtilityProtocol(DataTrigger):
@@ -27,6 +28,26 @@ class EndOfStreamOutput(UtilityProtocol):
     protocol: Literal["end_of_stream"] = "end_of_stream"  # type: ignore
 
 
+class ModuleStartInfoOutput(UtilityProtocol):
+    """Output sent when module starts with execution context.
+
+    This protocol is sent as the first message when a module starts,
+    providing the client with essential execution context information.
+    """
+
+    protocol: Literal["module_start_info"] = "module_start_info"  # type: ignore
+    job_id: str = Field(..., description="Unique job identifier")
+    mission_id: str = Field(..., description="Mission identifier")
+    setup_id: str = Field(..., description="Setup identifier")
+    setup_version_id: str = Field(..., description="Setup version identifier")
+    module_id: str = Field(..., description="Module identifier")
+    module_name: str = Field(..., description="Human-readable module name")
+    started_at: str = Field(
+        default_factory=lambda: datetime.now(tz=timezone.utc).isoformat(),
+        description="ISO timestamp when module started",
+    )
+
+
 class HealthcheckPingInput(UtilityProtocol):
     """Input for healthcheck ping request."""
 

digitalkin/modules/_base_module.py

@@ -18,7 +18,7 @@ from digitalkin.models.module.module_types import (
     SecretModelT,
     SetupModelT,
 )
-from digitalkin.models.module.utility import EndOfStreamOutput
+from digitalkin.models.module.utility import EndOfStreamOutput, ModuleStartInfoOutput
 from digitalkin.models.services.storage import BaseRole
 from digitalkin.modules.trigger_handler import TriggerHandler
 from digitalkin.services.services_config import ServicesConfig, ServicesStrategy
@@ -76,6 +76,7 @@ class BaseModule(  # noqa: PLR0904
                 registry: RegistryStrategy
                 snapshot: SnapshotStrategy
                 storage: StorageStrategy
+                user_profile: UserProfileStrategy
         """
         logger.debug("Service initialisation: %s", self.services_config_strategies.keys())
         return {
@@ -446,7 +447,37 @@ class BaseModule(  # noqa: PLR0904
         """Start the module."""
         try:
             self.context.callbacks.send_message = callback
-            logger.info(f"Inititalize module {self.context.session.job_id}")
+
+            # Use tool cache from setup_data if available (populated during run_config_setup)
+            # Tool cache is optional - modules can work without it
+            if hasattr(setup_data, "tool_cache") and setup_data.tool_cache is not None:
+                self.context.tool_cache = setup_data.tool_cache
+
+                # Validate tool cache - ensure all cached tools are still available
+                if self.context.registry and hasattr(setup_data, "validate_tool_cache"):
+                    invalid_tools = setup_data.validate_tool_cache(self.context.registry)
+                    if invalid_tools:
+                        logger.warning(
+                            "Some cached tools are no longer available",
+                            extra={"invalid_tools": invalid_tools},
+                        )
+
+            # Send module start info as first message
+            await callback(
+                DataModel(
+                    root=ModuleStartInfoOutput(
+                        job_id=self.context.session.job_id,
+                        mission_id=self.context.session.mission_id,
+                        setup_id=self.context.session.setup_id,
+                        setup_version_id=self.context.session.setup_version_id,
+                        module_id=self.get_module_id(),
+                        module_name=self.name,
+                    ),
+                    annotations={"role": BaseRole.SYSTEM},
+                )
+            )
+
+            logger.info("Initialize module %s", self.context.session.job_id)
             await self.initialize(self.context, setup_data)
         except Exception as e:
             self._status = ModuleStatus.FAILED
@@ -467,7 +498,7 @@ class BaseModule(  # noqa: PLR0904
         try:
             logger.debug("Init the discovered input handlers.")
             self.triggers_discoverer.init_handlers(self.context)
-            logger.debug(f"Run lifecycle {self.context.session.job_id}")
+            logger.debug("Run lifecycle %s", self.context.session.job_id)
             await self._run_lifecycle(input_data, setup_data)
         except Exception:
             self._status = ModuleStatus.FAILED

digitalkin/modules/triggers/__init__.py

@@ -6,7 +6,3 @@ They provide standard functionality available to all modules.
 Note: These are internal triggers. External code should not import them directly.
 Use UtilityRegistry.get_builtin_triggers() to access the trigger classes.
 """
-
-# No public exports - all triggers are internal
-# Access via: UtilityRegistry.get_builtin_triggers()
-__all__: list[str] = []

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-0.3.2.dev2.dist-info → digitalkin-0.3.2.dev4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: digitalkin
-Version: 0.3.2.dev2
+Version: 0.3.2.dev4
 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.dev2.dist-info → digitalkin-0.3.2.dev4.dist-info}/RECORD

@@ -7,7 +7,7 @@ base_server/mock/__init__.py,sha256=YZFT-F1l_TpvJYuIPX-7kTeE1CfOjhx9YmNRXVoi-jQ,
 base_server/mock/mock_pb2.py,sha256=sETakcS3PAAm4E-hTCV1jIVaQTPEAIoVVHupB8Z_k7Y,1843
 base_server/mock/mock_pb2_grpc.py,sha256=BbOT70H6q3laKgkHfOx1QdfmCS_HxCY4wCOX84YAdG4,3180
 digitalkin/__init__.py,sha256=7LLBAba0th-3SGqcpqFO-lopWdUkVLKzLZiMtB-mW3M,162
-digitalkin/__version__.py,sha256=miotufnQIrysc6Q1wA7bqIvHjvM0kM-OJNtS0dfl3VU,195
+digitalkin/__version__.py,sha256=k7ywgivs-7wcYmxpZLVkbYfyQZo7NuQeNm6D2K0VbkI,195
 digitalkin/logger.py,sha256=8ze_tjt2G6mDTuQcsf7-UTXWP3UHZ7LZVSs_iqF4rX4,4685
 digitalkin/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 digitalkin/core/__init__.py,sha256=FJRcJ-B1Viyn-38L8XpOpZ8KOnf1I7PCDOAmKXLQhqc,71
@@ -15,7 +15,7 @@ digitalkin/core/common/__init__.py,sha256=Gh2eJAJRnrUE93jSEfG7r0nb01Xh1kSkNL6nEp
 digitalkin/core/common/factories.py,sha256=mV6SmXXrZxzIQ7DLdDtPdjapSDZt5Ua-nBIDsozs_Vk,5047
 digitalkin/core/job_manager/__init__.py,sha256=gGtgQpE6vbBHxAj1SYMbcpj45Q6x8IcsqnyQPfyZZ-8,25
 digitalkin/core/job_manager/base_job_manager.py,sha256=fRnoR74uduImGYOKj4kZ5bo0xv9hrXSCUuq0NHfDpPE,10089
-digitalkin/core/job_manager/single_job_manager.py,sha256=-xid4GbdjNo1J32GtKDx5sco2IECWTN9mtduNzRO3Ds,13802
+digitalkin/core/job_manager/single_job_manager.py,sha256=xOgl8HNUpfd_OPmoJpUt8hJznxDTeUzFpEFBRgEYzp4,14464
 digitalkin/core/job_manager/taskiq_broker.py,sha256=ORGg2QSLDaWiCqie8ZGkbcDq7LDuWWSx7hg-SoUv99E,11544
 digitalkin/core/job_manager/taskiq_job_manager.py,sha256=d23iylsc2RUvoE95VxZWa5Kb_yqptMOF63l7MDtuZtk,21264
 digitalkin/core/task_manager/__init__.py,sha256=k9i-qIoee_1yXogyQolaVFDUQBIZU3ENbYKtjrCNmTQ,31
@@ -24,11 +24,11 @@ digitalkin/core/task_manager/local_task_manager.py,sha256=Z1gv4dCGD32LBSfMZJ4dGy
 digitalkin/core/task_manager/remote_task_manager.py,sha256=zgccmnwwtB0nyeIZlL5Ji8SY1J89z_vjA4JD9ur7HzY,3082
 digitalkin/core/task_manager/surrealdb_repository.py,sha256=a22FblutOYbtWtoh0SEqNIm_f6it3XkRReyBBLqy6Qk,9874
 digitalkin/core/task_manager/task_executor.py,sha256=8xh5_1zuRAaGZIH_gWyNsA4T7YYaF0sl51dLS8a6aAk,10981
-digitalkin/core/task_manager/task_session.py,sha256=ZU2GqtWAZidG7M7K_6GgEemBKRZ_RP2pW-3ODQSqP84,13665
+digitalkin/core/task_manager/task_session.py,sha256=5jw21bT_SPXUzWE7tk6YG62EXqlRJcrSakFXDFDRy28,12730
 digitalkin/grpc_servers/__init__.py,sha256=ZIRMJ1Lcas8yQ106GCup6hn2UBOsx1sNk8ap0lpEDnY,72
 digitalkin/grpc_servers/_base_server.py,sha256=ZVeCDwI7w7fFbPTXPkeJb_SOuLfd2T7za3T4oCu2UWY,18680
 digitalkin/grpc_servers/module_server.py,sha256=7jO6Bz4pxno0AjRFercZMwgOFW7dutywynoCCht3dnQ,7858
-digitalkin/grpc_servers/module_servicer.py,sha256=spZfJZ3NZjo0tWkt5fckFc86Bs4c33A1lBOnycGjcE8,19675
+digitalkin/grpc_servers/module_servicer.py,sha256=a5qVOd0beAwXlFAch9VfLNR8PdaYj_fF2O8rXcwInSU,21087
 digitalkin/grpc_servers/utils/__init__.py,sha256=ZnAIb_F8z4NhtPypqkdmzgRSzolKnJTk3oZx5GfWH5Y,38
 digitalkin/grpc_servers/utils/exceptions.py,sha256=LtaDtlqXCeT6iqApogs4pbtezotOVeg4fhnFzGBvFsY,692
 digitalkin/grpc_servers/utils/grpc_client_wrapper.py,sha256=ElGvp6evY5q-EBmDVyQZaDJktfShtMsptMmq16jfgxA,3285
@@ -46,25 +46,29 @@ digitalkin/mixins/storage_mixin.py,sha256=ptZ4a2bydIa48q0V9e395vWHTu7yw4A6rI4jwK
 digitalkin/models/__init__.py,sha256=xK0YGXsHI4ghGzIURRhIRYYM3sxbnOsk9UeMXdl5l-o,170
 digitalkin/models/core/__init__.py,sha256=jOMDmPX0uSfGA9zUi0u_kOvYJ46VdIssoIhVYvNSeew,19
 digitalkin/models/core/job_manager_models.py,sha256=wvf2dzRzAu0-zzzAXQe6XTC36cNA10sXRLt2p_TFqjk,1003
-digitalkin/models/core/task_monitor.py,sha256=XNYCxhN9QqJZhuO2LoiWEHZwhA35dsupyfYvek_pgE8,2295
+digitalkin/models/core/task_monitor.py,sha256=CW-jydSgXMV464W0pqfar0HpgqlSxqdujmC-f8p9EQc,2639
 digitalkin/models/grpc_servers/__init__.py,sha256=0tA71nPSXgRrh9DoLvx-TSwZXdYIRUEItoadpTL1cTo,42
 digitalkin/models/grpc_servers/models.py,sha256=unV1Wo0u3Efm7ddgYyYZZYUC_W6F0S5BQYH3xsOmXjw,8965
 digitalkin/models/grpc_servers/types.py,sha256=rQ78s4nAet2jy-NIDj_PUWriT0kuGHr_w6ELjmjgBao,539
-digitalkin/models/module/__init__.py,sha256=jeUyKipCb1eUOXApMeeAmEmpsKOtK8HbwOdB7lWVkQU,570
+digitalkin/models/module/__init__.py,sha256=N55wan3rAUVPEGLIDjXoFM_-DYY_zxvbQOZHzNDfwoY,751
+digitalkin/models/module/base_types.py,sha256=oIylVNqo0idTFj4dRgCt7P19daNZ-AlvgCPpL9TJvto,1850
 digitalkin/models/module/module.py,sha256=k0W8vfJJFth8XdDzkHm32SyTuSf3h2qF0hSrxAfGF1s,956
-digitalkin/models/module/module_context.py,sha256=q9Mk-Wj_x6JIWzw04oGeHrqPteGrRMZcvlBBLUPkDjs,5089
-digitalkin/models/module/module_types.py,sha256=Z46NPBCf8yDot4ZT_iJfBMo8J-IhpYiJJlKJsXxe6vA,14445
-digitalkin/models/module/utility.py,sha256=7TjdwMA9YLzfxJB88OrpEBlASwJkdzqo74ZCr8S0KTM,4627
+digitalkin/models/module/module_context.py,sha256=cnk5OpgevgqkmD_gU5KWSBzZ2vsNFUyN8rEzW0TNI-s,6354
+digitalkin/models/module/module_types.py,sha256=C9azCNBk76xMa-Mww8_6AiwQR8MLAsEyUOvBYxytovI,739
+digitalkin/models/module/setup_types.py,sha256=e9CG8x75Mkh7dDIQ66UWU99VcWmyk-JAqHCpUtcgyns,21323
+digitalkin/models/module/tool_cache.py,sha256=H8k2ue9m61oNHGMDgF9i3e4FxfFQoNW1iIZqoWyZNOc,7523
+digitalkin/models/module/tool_reference.py,sha256=A4EewKMlfhdI2hW7F3kgPc6_UinUrN-hhOweM0KzSa0,4302
+digitalkin/models/module/utility.py,sha256=gnbYfWpXGbomUI0fWf7T-Qm_VvT-LXDv1OuA9zObwVg,5589
 digitalkin/models/services/__init__.py,sha256=jhfVw6egq0OcHmos_fypH9XFehbHTBw09wluVFVFEyw,226
 digitalkin/models/services/cost.py,sha256=9PXvd5RrIk9vCrRjcUGQ9ZyAokEbwLg4s0RfnE-aLP4,1616
 digitalkin/models/services/registry.py,sha256=0qMAIi52ovofZ4XTV7UkI4i7sR5C3_VFLp-kw9AjQ24,829
 digitalkin/models/services/storage.py,sha256=wp7F-AvTsU46ujGPcguqM5kUKRZx4399D4EGAAJt2zs,1143
 digitalkin/modules/__init__.py,sha256=vTQk8DWopxQSJ17BjE5dNhq247Rou55iQLJdBxoPUmo,296
-digitalkin/modules/_base_module.py,sha256=EtfIShFG7GwZ98kAq1rV0aP5VGrKEqpADeGouetmFgU,19740
+digitalkin/modules/_base_module.py,sha256=0bbiPOcLSiKqjrVYaWdmc72jbpaPa8dOzozEcQO0zMg,21285
 digitalkin/modules/archetype_module.py,sha256=XC9tl1Yr6QlbPn_x0eov6UUZwQgwW--BYPPMYVJH_NU,505
 digitalkin/modules/tool_module.py,sha256=GBis7bKCkvWFCYLRvaS9oZVmLBBve1w8BhVnKOU2sCc,506
 digitalkin/modules/trigger_handler.py,sha256=qPNMi-8NHqscOxciHeaXtpwjXApT3YzjMF23zQAjaZY,1770
-digitalkin/modules/triggers/__init__.py,sha256=x6VdtfEefY1pk26gD-vxvDTKcTn-2X4AG2AcyroGls0,449
+digitalkin/modules/triggers/__init__.py,sha256=OKzUWqlnm9wzAAvztPocSK36i69giWEQnxn0hbdfCsM,323
 digitalkin/modules/triggers/healthcheck_ping_trigger.py,sha256=fQjfOB_NMPocISXAT8rlk896_pXIY8v0op0JhZNv_G0,1558
 digitalkin/modules/triggers/healthcheck_services_trigger.py,sha256=TpPw5XTnw3Bt9VCoFXQ_V-SIAR8LMoJmDGiyegWW6To,2286
 digitalkin/modules/triggers/healthcheck_status_trigger.py,sha256=rozWQWvO7a2ZTg8BjFCyEWeAai5vdbi7BBwu0vR5jv8,1768
@@ -110,14 +114,14 @@ digitalkin/services/storage/storage_strategy.py,sha256=sERF5tIJnzpb1iNqTXic9xRkG
 digitalkin/services/user_profile/__init__.py,sha256=RKEZCsgCHS7fmswhWgUoQd6vZ_1pYnRqERoF8fmu7jw,434
 digitalkin/services/user_profile/default_user_profile.py,sha256=46DH_VBCHKXJVyagVcc8kH5sLwRK54Fe_0ahqYJ1maA,1847
 digitalkin/services/user_profile/grpc_user_profile.py,sha256=xDiUC5Ceofa6QtGPmqJV3ik5j8HDHc1zxtpia49rlRw,2780
-digitalkin/services/user_profile/user_profile_strategy.py,sha256=luzpPvm2f4xXajWAbRGSk5YCIPBUrn5EOrXSz8NL1So,1148
+digitalkin/services/user_profile/user_profile_strategy.py,sha256=CH8kT__1MUwA21k5djjmB5ZZ6pYg57OWbe_7owBCgwU,681
 digitalkin/utils/__init__.py,sha256=gDoEk5CP8tiBmIq-38aPhIMlnDUiqRrduuVXhpSPQnc,541
 digitalkin/utils/arg_parser.py,sha256=wzscRlE1Qp1gGl-lAJlkkwnbU1O2oezj6BwK_BZFBIk,3158
 digitalkin/utils/development_mode_action.py,sha256=2hznh0ajW_4ZTysfoc0Y49161f_PQPATRgNk8NAn1_o,1623
 digitalkin/utils/dynamic_schema.py,sha256=5-B3dBGlCYYv6uRJkgudtc0ZpBOTYxl0yKedDGsteZQ,15184
 digitalkin/utils/llm_ready_schema.py,sha256=JjMug_lrQllqFoanaC091VgOqwAd-_YzcpqFlS7p778,2375
 digitalkin/utils/package_discover.py,sha256=sa6Zp5Kape1Zr4iYiNrnZxiHDnqM06ODk6yfWHom53w,13465
-digitalkin-0.3.2.dev2.dist-info/licenses/LICENSE,sha256=Ies4HFv2r2hzDRakJYxk3Y60uDFLiG-orIgeTpstnIo,20327
+digitalkin-0.3.2.dev4.dist-info/licenses/LICENSE,sha256=Ies4HFv2r2hzDRakJYxk3Y60uDFLiG-orIgeTpstnIo,20327
 modules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 modules/cpu_intensive_module.py,sha256=GZlirQDZdYuXrI46sv1q4RNAHZjL4EptHVQTvgK9zz8,8363
 modules/dynamic_setup_module.py,sha256=tKvUWZdlYZkfAgKR0mLuFcLiFGKpVgpsz10LeJ6B2QI,11410
@@ -125,7 +129,7 @@ modules/minimal_llm_module.py,sha256=N9aIzZQI-miyH4AB4xTmGHpMvdSLnYyXNOD4Z3YFzis
 modules/text_transform_module.py,sha256=MfhI_Ki1U6qk379ne6oazNEu4PhO4R3cRezEcr0nGPw,7251
 services/filesystem_module.py,sha256=U4dgqtuDadaXz8PJ1d_uQ_1EPncBqudAQCLUICF9yL4,7421
 services/storage_module.py,sha256=Wz2MzLvqs2D_bnBBgtnujYcAKK2V2KFMk8K21RoepSE,6972
-digitalkin-0.3.2.dev2.dist-info/METADATA,sha256=q9zIFRfJtJhSVd_NKfFCjGdBtElCEH-EC6A7ku3wtwk,29724
-digitalkin-0.3.2.dev2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-digitalkin-0.3.2.dev2.dist-info/top_level.txt,sha256=gcjqlyrZuLjIyxrOIavCQM_olpr6ND5kPKkZd2j0xGo,40
-digitalkin-0.3.2.dev2.dist-info/RECORD,,
+digitalkin-0.3.2.dev4.dist-info/METADATA,sha256=9owo2Dtpnwbm4Rjkx9iXA_rKkzstywsbhe8hU9Mn8pY,29724
+digitalkin-0.3.2.dev4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+digitalkin-0.3.2.dev4.dist-info/top_level.txt,sha256=gcjqlyrZuLjIyxrOIavCQM_olpr6ND5kPKkZd2j0xGo,40
+digitalkin-0.3.2.dev4.dist-info/RECORD,,