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

digitalkin/__version__.py

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

digitalkin/core/job_manager/single_job_manager.py

@@ -143,7 +143,8 @@ class SingleJobManager(BaseJobManager[InputModelT, OutputModelT, SetupModelT]):
             job_id: The unique identifier of the job.
             output_data: The output data produced by the job.
         """
-        await self.tasks_sessions[job_id].queue.put(output_data.model_dump())
+        session = self.tasks_sessions[job_id]
+        await session.queue.put(output_data.model_dump())
 
     @asynccontextmanager  # type: ignore
     async def generate_stream_consumer(self, job_id: str) -> AsyncIterator[AsyncGenerator[dict[str, Any], None]]:  # type: ignore
@@ -262,6 +263,18 @@ class SingleJobManager(BaseJobManager[InputModelT, OutputModelT, SetupModelT]):
         logger.info("Managed task started: '%s'", job_id, extra={"task_id": job_id})
         return job_id
 
+    async def clean_session(self, task_id: str, mission_id: str) -> bool:
+        """Clean a task's session.
+
+        Args:
+            task_id: Unique identifier for the task.
+            mission_id: Mission identifier.
+
+        Returns:
+            bool: True if the task was successfully cleaned, False otherwise.
+        """
+        return await self._task_manager.clean_session(task_id, mission_id)
+
     async def stop_module(self, job_id: str) -> bool:
         """Stop a running module job.
 
@@ -287,7 +300,7 @@ class SingleJobManager(BaseJobManager[InputModelT, OutputModelT, SetupModelT]):
                 await self.cancel_task(job_id, session.mission_id)
                 logger.debug(
                     "Module stopped successfully",
-                    extra={"job_id": job_id, "mission_id": session.mission_id, "module_name": session.module.name},
+                    extra={"job_id": job_id, "mission_id": session.mission_id},
                 )
             except Exception:
                 logger.exception("Error stopping module", extra={"job_id": job_id})

digitalkin/grpc_servers/module_servicer.py

@@ -41,6 +41,7 @@ class ModuleServicer(module_service_pb2_grpc.ModuleServiceServicer, ArgParser):
     args: Namespace
     setup: SetupStrategy
     job_manager: BaseJobManager
+    _registry_cache: RegistryStrategy | None = None
 
     def _add_parser_args(self, parser: ArgumentParser) -> None:
         super()._add_parser_args(parser)
@@ -84,11 +85,14 @@ class ModuleServicer(module_service_pb2_grpc.ModuleServiceServicer, ArgParser):
         self.setup = GrpcSetup() if self.args.services_mode == ServicesMode.REMOTE else DefaultSetup()
 
     def _get_registry(self) -> RegistryStrategy | None:
-        """Get a registry instance if configured.
+        """Get a cached registry instance if configured.
 
         Returns:
-            GrpcRegistry instance if registry config exists, None otherwise.
+            Cached GrpcRegistry instance if registry config exists, None otherwise.
         """
+        if self._registry_cache is not None:
+            return self._registry_cache
+
         registry_config = self.module_class.services_config_params.get("registry")
         if not registry_config:
             return None
@@ -97,7 +101,8 @@ class ModuleServicer(module_service_pb2_grpc.ModuleServiceServicer, ArgParser):
         if not client_config:
             return None
 
-        return GrpcRegistry("", "", "", client_config)
+        self._registry_cache = GrpcRegistry("", "", "", client_config)
+        return self._registry_cache
 
     async def ConfigSetupModule(  # noqa: N802
         self,
@@ -143,9 +148,13 @@ class ModuleServicer(module_service_pb2_grpc.ModuleServiceServicer, ArgParser):
             raise ServicerError(msg)
 
         # Resolve tool references in config_setup_data if registry is configured
+        # This also builds the tool_cache for LLM access during execution
         registry = self._get_registry()
         if registry:
-            config_setup_data.resolve_tool_references(registry)
+            if hasattr(config_setup_data, "resolve_tool_references"):
+                config_setup_data.resolve_tool_references(registry)
+            if hasattr(config_setup_data, "build_tool_cache"):
+                config_setup_data.build_tool_cache()
 
         # create a task to run the module in background
         job_id = await self.job_manager.create_config_setup_instance_job(

digitalkin/models/module/module_context.py

@@ -6,6 +6,7 @@ from types import SimpleNamespace
 from typing import TYPE_CHECKING, Any
 from zoneinfo import ZoneInfo
 
+from digitalkin.models.module.tool_cache import ToolCache
 from digitalkin.services.agent.agent_strategy import AgentStrategy
 from digitalkin.services.communication.communication_strategy import CommunicationStrategy
 from digitalkin.services.cost.cost_strategy import CostStrategy
@@ -101,7 +102,7 @@ class ModuleContext:
     metadata: SimpleNamespace
     helpers: SimpleNamespace
     state: SimpleNamespace = SimpleNamespace()
-    tool_cache: dict[str, "ModuleInfo"]
+    tool_cache: ToolCache
 
     def __init__(  # noqa: PLR0913, PLR0917
         self,
@@ -118,7 +119,7 @@ class ModuleContext:
         metadata: dict[str, Any] = {},
         helpers: dict[str, Any] = {},
         callbacks: dict[str, Any] = {},
-        tool_cache: dict[str, "ModuleInfo"] | None = None,
+        tool_cache: ToolCache | None = None,
     ) -> None:
         """Register mandatory services, session, metadata and callbacks.
 
@@ -136,7 +137,7 @@ class ModuleContext:
             helpers: dict different user defined helpers.
             session: dict referring the session IDs or informations.
             callbacks: Functions allowing user to agent interaction.
-            tool_cache: Pre-resolved tool references from setup.
+            tool_cache: ToolCache with pre-resolved tool references from setup.
         """
         # Core services
         self.agent = agent
@@ -153,15 +154,33 @@ class ModuleContext:
         self.session = Session(**session)
         self.helpers = SimpleNamespace(**helpers)
         self.callbacks = SimpleNamespace(**callbacks)
-        self.tool_cache = tool_cache or {}
+        self.tool_cache = tool_cache or ToolCache()
 
-    def get_tool(self, field_name: str) -> "ModuleInfo | None":
-        """Get resolved tool info by setup field name.
+    def get_tool(self, slug: str) -> "ModuleInfo | None":
+        """Get resolved tool info by slug.
+
+        Fast lookup from the pre-populated tool cache.
+
+        Args:
+            slug: The tool slug to look up.
+
+        Returns:
+            ModuleInfo if found and valid, None otherwise.
+        """
+        return self.tool_cache.get(slug)
+
+    def check_and_get_tool(self, slug: str) -> "ModuleInfo | None":
+        """Check cache first, then query registry if not found.
+
+        This is the primary method for LLMs to discover tools. It:
+        1. Checks the pre-populated cache (fast path)
+        2. If not in cache, queries the registry
+        3. If found via registry, caches the result
 
         Args:
-            field_name: The name of the ToolReference field in the setup model.
+            slug: The tool slug to look up.
 
         Returns:
             ModuleInfo if found, None otherwise.
         """
-        return self.tool_cache.get(field_name)
+        return self.tool_cache.check_and_get(slug, self.registry)

digitalkin/models/module/setup_types.py

@@ -5,11 +5,12 @@ from __future__ import annotations
 import copy
 import types
 import typing
-from typing import TYPE_CHECKING, Any, Generic, TypeVar, cast, get_args, get_origin
+from typing import TYPE_CHECKING, Any, ClassVar, Generic, TypeVar, cast, get_args, get_origin
 
-from pydantic import BaseModel, ConfigDict, create_model
+from pydantic import BaseModel, ConfigDict, PrivateAttr, create_model
 
 from digitalkin.logger import logger
+from digitalkin.models.module.tool_cache import ToolCache
 from digitalkin.models.module.tool_reference import ToolReference
 from digitalkin.utils.dynamic_schema import (
     DynamicField,
@@ -33,6 +34,9 @@ class SetupModel(BaseModel, Generic[SetupModelT]):
     to be used to initialize the Kin. Supports dynamic schema providers for
     runtime value generation.
 
+    The tool_cache is populated during run_config_setup and contains resolved
+    ModuleInfo indexed by slug. It is validated during initialize.
+
     Attributes:
         model_fields: Inherited from Pydantic BaseModel, contains field definitions.
 
@@ -41,6 +45,9 @@ class SetupModel(BaseModel, Generic[SetupModelT]):
         - Tests: tests/modules/test_setup_model.py
     """
 
+    _clean_model_cache: ClassVar[dict[tuple[type, bool, bool], type]] = {}
+    _tool_cache: ToolCache = PrivateAttr(default_factory=ToolCache)
+
     @classmethod
     async def get_clean_model(
         cls,
@@ -71,6 +78,11 @@ class SetupModel(BaseModel, Generic[SetupModelT]):
         Returns:
             A new BaseModel subclass with filtered fields.
         """
+        # Check cache for non-forced requests
+        cache_key = (cls, config_fields, hidden_fields)
+        if not force and cache_key in cls._clean_model_cache:
+            return cast("type[SetupModelT]", cls._clean_model_cache[cache_key])
+
         clean_fields: dict[str, Any] = {}
 
         for name, field_info in cls.model_fields.items():
@@ -117,6 +129,11 @@ class SetupModel(BaseModel, Generic[SetupModelT]):
             __config__=ConfigDict(arbitrary_types_allowed=True),
             **clean_fields,
         )
+
+        # Cache for non-forced requests
+        if not force:
+            cls._clean_model_cache[cache_key] = m
+
         return cast("type[SetupModelT]", m)
 
     @classmethod
@@ -461,3 +478,96 @@ class SetupModel(BaseModel, Generic[SetupModelT]):
                 cls._resolve_single_tool_reference("dict_value", item, registry)
             elif isinstance(item, BaseModel):
                 cls._resolve_tool_references_recursive(item, registry)
+
+    @property
+    def tool_cache(self) -> ToolCache:
+        """Get the tool cache for this setup instance.
+
+        Returns:
+            The ToolCache containing resolved tools.
+        """
+        return self._tool_cache
+
+    def build_tool_cache(self) -> ToolCache:
+        """Build the tool cache from resolved ToolReferences.
+
+        This should be called during run_config_setup after resolve_tool_references.
+        It walks all ToolReference fields and adds resolved ones to the cache.
+
+        Returns:
+            The populated ToolCache.
+        """
+        self._build_tool_cache_recursive(self)
+        logger.debug(
+            "Tool cache built",
+            extra={"slugs": self._tool_cache.list_slugs()},
+        )
+        return self._tool_cache
+
+    def _build_tool_cache_recursive(self, model_instance: BaseModel) -> None:
+        """Recursively build tool cache from model fields.
+
+        Args:
+            model_instance: The model instance to process.
+        """
+        for field_name, field_value in model_instance.__dict__.items():
+            if field_value is None:
+                continue
+
+            if isinstance(field_value, ToolReference):
+                self._add_tool_reference_to_cache(field_name, field_value)
+            elif isinstance(field_value, BaseModel):
+                self._build_tool_cache_recursive(field_value)
+            elif isinstance(field_value, list):
+                self._build_tool_cache_from_list(field_value)
+            elif isinstance(field_value, dict):
+                self._build_tool_cache_from_dict(field_value)
+
+    def _add_tool_reference_to_cache(self, field_name: str, tool_ref: ToolReference) -> None:
+        """Add a resolved ToolReference to the cache.
+
+        Args:
+            field_name: Name of the field (used as fallback slug).
+            tool_ref: The ToolReference instance.
+        """
+        if tool_ref.module_info:
+            # Use slug from config, or field name as fallback
+            slug = tool_ref.slug or field_name
+            self._tool_cache.add(slug, tool_ref.module_info)
+
+    def _build_tool_cache_from_list(self, items: list) -> None:
+        """Build tool cache from list items.
+
+        Args:
+            items: List of items to process.
+        """
+        for idx, item in enumerate(items):
+            if isinstance(item, ToolReference):
+                self._add_tool_reference_to_cache(f"list_{idx}", item)
+            elif isinstance(item, BaseModel):
+                self._build_tool_cache_recursive(item)
+
+    def _build_tool_cache_from_dict(self, mapping: dict) -> None:
+        """Build tool cache from dict values.
+
+        Args:
+            mapping: Dict to process.
+        """
+        for key, item in mapping.items():
+            if isinstance(item, ToolReference):
+                self._add_tool_reference_to_cache(str(key), item)
+            elif isinstance(item, BaseModel):
+                self._build_tool_cache_recursive(item)
+
+    def validate_tool_cache(self, registry: RegistryStrategy) -> list[str]:
+        """Validate all cached tools are still available.
+
+        Should be called during initialize to ensure tools are still valid.
+
+        Args:
+            registry: Registry to validate against.
+
+        Returns:
+            List of slugs that are no longer valid.
+        """
+        return self._tool_cache.validate(registry)

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

@@ -23,6 +23,7 @@ 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")
@@ -58,6 +59,20 @@ class ToolReference(BaseModel):
     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."""

digitalkin/modules/_base_module.py

@@ -18,9 +18,7 @@ from digitalkin.models.module.module_types import (
     SecretModelT,
     SetupModelT,
 )
-from digitalkin.models.module.tool_reference import ToolReference
 from digitalkin.models.module.utility import EndOfStreamOutput, ModuleStartInfoOutput
-from digitalkin.models.services.registry import ModuleInfo
 from digitalkin.models.services.storage import BaseRole
 from digitalkin.modules.trigger_handler import TriggerHandler
 from digitalkin.services.services_config import ServicesConfig, ServicesStrategy
@@ -439,22 +437,6 @@ class BaseModule(  # noqa: PLR0904
         else:
             self._status = ModuleStatus.STOPPING
 
-    @staticmethod
-    def _extract_tool_cache(setup_data: SetupModelT) -> dict[str, ModuleInfo]:
-        """Extract resolved ToolReference info from setup data.
-
-        Args:
-            setup_data: The setup model containing potential ToolReference fields.
-
-        Returns:
-            Dict mapping field names to resolved ModuleInfo.
-        """
-        cache: dict[str, ModuleInfo] = {}
-        for name, value in setup_data.__dict__.items():
-            if isinstance(value, ToolReference) and value.module_info:
-                cache[name] = value.module_info
-        return cache
-
     async def start(
         self,
         input_data: InputModelT,
@@ -466,8 +448,19 @@ class BaseModule(  # noqa: PLR0904
         try:
             self.context.callbacks.send_message = callback
 
-            # Populate tool cache from resolved ToolReference fields
-            self.context.tool_cache = self._extract_tool_cache(setup_data)
+            # 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(

digitalkin/services/services_config.py

@@ -4,7 +4,6 @@ from typing import Any, ClassVar
 
 from pydantic import BaseModel, Field, PrivateAttr
 
-from digitalkin import logger
 from digitalkin.services.agent import AgentStrategy, DefaultAgent
 from digitalkin.services.communication import CommunicationStrategy, DefaultCommunication, GrpcCommunication
 from digitalkin.services.cost import CostStrategy, DefaultCost, GrpcCost
@@ -144,9 +143,6 @@ class ServicesConfig(BaseModel):
             msg = f"Strategy {name} not found in ServicesConfig."
             raise ValueError(msg)
 
-        logger.logger.critical(
-            f"{name=}\n{mission_id=}, {setup_id=}, {setup_version_id=}, {self.get_strategy_config(name)=}"
-        )
         # Instantiate the strategy with the mission ID, setup version ID, and configuration
         return strategy_type(mission_id, setup_id, setup_version_id, **self.get_strategy_config(name) or {})
 

{digitalkin-0.3.2.dev3.dist-info → digitalkin-0.3.2.dev4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: digitalkin
-Version: 0.3.2.dev3
+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.dev3.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=eJ__RY2lPoQprF2CURDjtvLHzHcyg0TSiE4skNzcSoQ,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=ivR9L6sUMdQ7i3bhIgPLESxgWWGl6IlaBz__4csIEro,14069
+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
@@ -28,7 +28,7 @@ digitalkin/core/task_manager/task_session.py,sha256=5jw21bT_SPXUzWE7tk6YG62EXqlR
 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=DvoBEGzDgzWQq5PHt_ZqUgyl2NK7vPaSrOkfQPRITuY,20619
+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
@@ -53,17 +53,18 @@ digitalkin/models/grpc_servers/types.py,sha256=rQ78s4nAet2jy-NIDj_PUWriT0kuGHr_w
 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=HDtKbQxwJU_RSE7xTA3kFkjXGQiDbG64q45fNudKUYI,5734
+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=BzRLpYDAPbKLUOZ9C8ChTguuxzTveYYf4pC_0gda9a0,17215
-digitalkin/models/module/tool_reference.py,sha256=vg5isqXXouY4GFNS0mOodenojA_AWe1lISS6LABdEY8,3719
+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=WLByYSOdXhwEzO-7S1ujIOzRa4TE1ckFQdjySPjaHeA,21321
+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
@@ -73,7 +74,7 @@ digitalkin/modules/triggers/healthcheck_services_trigger.py,sha256=TpPw5XTnw3Bt9
 digitalkin/modules/triggers/healthcheck_status_trigger.py,sha256=rozWQWvO7a2ZTg8BjFCyEWeAai5vdbi7BBwu0vR5jv8,1768
 digitalkin/services/__init__.py,sha256=DugdZZ3uKXFsA5C-DuP41ssGegU1FybI3HQcW_Se4bk,1101
 digitalkin/services/base_strategy.py,sha256=yA9KUJGRKuuaxA6l3GcMv8zKfWoIsW03UxJT80Yea2I,766
-digitalkin/services/services_config.py,sha256=PySj8qKJISFUMNmsSWM-1VmqQMCqyi1sIz5SX4GtZm8,8868
+digitalkin/services/services_config.py,sha256=rz1cJdO_dfUN3kwOQ40XRSE4ZH3mgM43vXka94gjymY,8689
 digitalkin/services/services_models.py,sha256=Cb-ajJxHlEOQmoylMCfNdN08T6IOmMLXHrAZ6pxprrQ,1855
 digitalkin/services/agent/__init__.py,sha256=vJc8JN0pdtA8ecypLBeHrwAUIW6H2C8NyW-dk24rTpk,244
 digitalkin/services/agent/agent_strategy.py,sha256=42Q9RciHX6tg3CgDQkbrlIx4h_TX0WIuSpLmCjitVmA,492
@@ -120,7 +121,7 @@ digitalkin/utils/development_mode_action.py,sha256=2hznh0ajW_4ZTysfoc0Y49161f_PQ
 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.dev3.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
@@ -128,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.dev3.dist-info/METADATA,sha256=-yHoriRYCcXVXhVrO_IOa3S3yRK0yCkZXhpfqP3S1KI,29724
-digitalkin-0.3.2.dev3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-digitalkin-0.3.2.dev3.dist-info/top_level.txt,sha256=gcjqlyrZuLjIyxrOIavCQM_olpr6ND5kPKkZd2j0xGo,40
-digitalkin-0.3.2.dev3.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,,