digitalkin 1.0.0.dev9__tar.gz → 1.0.0.dev11__tar.gz

{digitalkin-1.0.0.dev9 → digitalkin-1.0.0.dev11}/PKG-INFO

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

{digitalkin-1.0.0.dev9 → digitalkin-1.0.0.dev11}/pyproject.toml

@@ -37,7 +37,7 @@
         "pydantic-settings>=2.14.1",
         "redis[hiredis]>=7.4.0,<8",
     ]
-    version = "1.0.0.dev9"
+    version = "1.0.0.dev11"
 
     [project.optional-dependencies]
         performance = [ "uvloop>=0.21" ]

{digitalkin-1.0.0.dev9 → digitalkin-1.0.0.dev11}/src/digitalkin/__version__.py

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

{digitalkin-1.0.0.dev9 → digitalkin-1.0.0.dev11}/src/digitalkin/models/module/setup_types.py

@@ -37,6 +37,7 @@ class SetupModel(BaseModel, Generic[SetupModelT]):
     resolved_tools: dict[str, ToolModuleInfo] = Field(
         default_factory=dict,
         json_schema_extra={"ui:widget": "hidden"},
+        exclude=True,
     )
 
     @classmethod
@@ -438,11 +439,12 @@ class SetupModel(BaseModel, Generic[SetupModelT]):
         registry: "RegistryStrategy | None" = None,
         communication: "CommunicationStrategy | None" = None,
     ) -> ToolCache:
-        """Build tool cache, resolving uncached tools via registry.
+        """Build tool cache, resolving tools via registry.
 
-        Walks ToolReference fields recursively. For each selected tool,
-        checks resolved_tools first (cache). If missing and registry is
-        available, resolves via gRPC and populates the cache.
+        ``resolved_tools`` is a within-build dedup cache, not a cross-request
+        store: when a registry is available it is cleared first so a stale or
+        empty entry can never be served — every build re-resolves. Without a
+        registry the existing entries are kept (degraded/embedded path).
 
         Args:
             registry: Registry service for resolving uncached tools.
@@ -451,9 +453,12 @@ class SetupModel(BaseModel, Generic[SetupModelT]):
         Returns:
             ToolCache with resolved tool entries.
         """
+        if registry and communication:
+            self.resolved_tools.clear()
         cache = ToolCache()
         await self._collect_tools_recursive(self, cache, registry, communication)
-        logger.info("Tool cache built: %d entries", len(cache.entries))
+        counts = " ".join(f"{sid}={len(info.tools)}" for sid, info in cache.entries.items())
+        logger.info("Tool cache built: %d entries [%s]", len(cache.entries), counts)
         return cache
 
     async def _collect_tools_recursive(  # noqa: C901
@@ -531,7 +536,18 @@ class SetupModel(BaseModel, Generic[SetupModelT]):
             except Exception:
                 logger.exception("Failed to resolve ToolReference '%s'", field_name)
 
+        missing: list[str] = []
         for entry in tool_ref.selected_tools:
             tool_info = self.resolved_tools.get(entry.setup_id) if entry.setup_id else None
-            if tool_info:
-                cache.add(tool_info)
+            if tool_info is None:
+                if entry.setup_id:
+                    missing.append(entry.setup_id)
+                continue
+            cache.add(tool_info)
+
+        if missing:
+            logger.warning(
+                "ToolReference '%s' has %d unresolved setup_id(s): %s "
+                "(each has an upstream 'Tool resolve failed' log with the reason)",
+                field_name, len(missing), missing,
+            )

{digitalkin-1.0.0.dev9 → digitalkin-1.0.0.dev11}/src/digitalkin/models/module/tool_reference.py

@@ -1,6 +1,7 @@
 """Tool reference types for module configuration."""
 
 import asyncio
+import logging
 from typing import Annotated, ClassVar
 
 from pydantic import AfterValidator, BaseModel, BeforeValidator, Field, PlainSerializer
@@ -29,37 +30,49 @@ class ToolReference(BaseModel):
         default_factory=list, description="Selected tools with trigger filters."
     )
 
-    async def resolve(self, registry: RegistryStrategy, communication: CommunicationStrategy) -> list[ToolModuleInfo]:
+    async def resolve(
+        self,
+        registry: RegistryStrategy,
+        communication: CommunicationStrategy,
+    ) -> list[ToolModuleInfo]:
         """Resolve selected tools using the registry.
 
-        Each tool resolution is bounded by DIGITALKIN_MODULE_TOOL_RESOLVE_TIMEOUT (default 10s).
+        Each tool resolution is bounded by ``DIGITALKIN_MODULE_TOOL_RESOLVE_TIMEOUT``
+        (default 10s). Inputs that fail to resolve are logged as WARNING with the
+        ``setup_id`` and a ``reason=...`` field; the returned list contains only
+        successful ``ToolModuleInfo``s. The caller can correlate against
+        ``self.selected_tools`` by ``setup_id``.
 
         Args:
             registry: Registry service for module discovery.
             communication: Communication service for module schemas.
 
         Returns:
-            List of ToolModuleInfo for resolved tools, filtered by enabled triggers.
+            List of resolved ``ToolModuleInfo``. Failed resolutions are logged and omitted.
         """
         timeout = get_module_settings().tool_resolve_timeout
 
-        async def _resolve_with_timeout(entry: ToolSelection) -> ToolModuleInfo | None:
-            return await asyncio.wait_for(
-                ToolReference._resolve_single(entry, registry, communication),
-                timeout=timeout,
-            )
+        async def _bounded(entry: ToolSelection) -> ToolModuleInfo | None:
+            try:
+                return await asyncio.wait_for(
+                    ToolReference._resolve_single(entry, registry, communication),
+                    timeout=timeout,
+                )
+            except asyncio.TimeoutError:
+                logger.warning(
+                    "Tool resolve failed: setup_id=%s reason=resolve_timeout timeout_s=%.1f",
+                    entry.setup_id, timeout,
+                )
+                return None
+            except Exception:
+                logger.exception(
+                    "Tool resolve failed: setup_id=%s reason=resolve_exception",
+                    entry.setup_id,
+                )
+                return None
 
-        results = await asyncio.gather(
-            *(_resolve_with_timeout(entry) for entry in self.selected_tools),
-            return_exceptions=True,
-        )
-        resolved: list[ToolModuleInfo] = []
-        for entry, result in zip(self.selected_tools, results):
-            if isinstance(result, BaseException):
-                logger.warning("Failed to resolve tool (setup_id=%s): %s", entry.setup_id, result)
-            elif isinstance(result, ToolModuleInfo):
-                resolved.append(result)
-        return resolved
+        results = await asyncio.gather(*(_bounded(e) for e in self.selected_tools))
+        return [r for r in results if r is not None]
 
     @staticmethod
     async def _resolve_single(
@@ -67,7 +80,15 @@ class ToolReference(BaseModel):
         registry: RegistryStrategy,
         communication: CommunicationStrategy,
     ) -> ToolModuleInfo | None:
-        """Resolve a single tool selection.
+        """Resolve a single tool selection; emit one structured audit line per call.
+
+        Every failure path logs a ``WARNING`` with a ``reason=...`` field
+        (``setup_not_found``, ``module_not_discovered``, ``schema_fetch_failed``)
+        so callers don't need to re-derive the cause. Successful resolutions
+        emit ``[lat-audit] tool_resolve`` at INFO with input/output counts.
+        Post-filter results of zero functions emit a second ``WARNING`` naming
+        the structural cause (``module_exposes_no_triggers``,
+        ``all_user_triggers_unknown``, or ``post_filter_empty``).
 
         Args:
             entry: Tool selection to resolve.
@@ -75,26 +96,74 @@ class ToolReference(BaseModel):
             communication: Communication service for module schemas.
 
         Returns:
-            ToolModuleInfo if resolved, None otherwise.
+            ToolModuleInfo on success (possibly with empty ``tools``); ``None`` on registry miss.
         """
         setup = await registry.get_setup(entry.setup_id)
         if not setup or not setup.module_id:
+            logger.warning(
+                "Tool resolve failed: setup_id=%s reason=setup_not_found",
+                entry.setup_id,
+            )
             return None
         info = await registry.discover_by_id(setup.module_id)
         if not info:
+            logger.warning(
+                "Tool resolve failed: setup_id=%s tool_name=%s module_id=%s reason=module_not_discovered",
+                entry.setup_id, setup.name, setup.module_id,
+            )
             return None
-        tool_info = await module_info_to_tool_module_info(info, entry.setup_id, setup.name, communication)
+
+        try:
+            tool_info = await module_info_to_tool_module_info(
+                info, entry.setup_id, setup.name, communication,
+            )
+        except Exception:
+            logger.exception(
+                "Tool resolve failed: setup_id=%s tool_name=%s reason=schema_fetch_failed",
+                entry.setup_id, setup.name,
+            )
+            return None
+
+        available = {t.name for t in tool_info.tools}
         enabled_triggers = {name for name, enabled in entry.triggers.items() if enabled}
+
         if enabled_triggers:
-            available = {t.name for t in tool_info.tools}
             if unknown := enabled_triggers - available:
                 logger.warning(
                     "Tool '%s' enables triggers the module does not expose: %s (available: %s)",
-                    entry.setup_id,
-                    sorted(unknown),
-                    sorted(available),
+                    entry.setup_id, sorted(unknown), sorted(available),
                 )
             tool_info.tools = [t for t in tool_info.tools if t.name in enabled_triggers]
+
+        post_count = len(tool_info.tools)
+        logger.info(
+            "[lat-audit] tool_resolve: setup_id=%s slug=%s "
+            "user_triggers_enabled=%d user_triggers_total=%d "
+            "module_available=%d post_filter=%d",
+            entry.setup_id, tool_info.slug,
+            len(enabled_triggers), len(entry.triggers),
+            len(available), post_count,
+        )
+        if logger.isEnabledFor(logging.DEBUG):
+            logger.debug(
+                "tool_resolve detail: setup_id=%s user_triggers=%s available=%s",
+                entry.setup_id, dict(entry.triggers), sorted(available),
+            )
+
+        if post_count == 0:
+            if not available:
+                reason = "module_exposes_no_triggers"
+            elif enabled_triggers and not (enabled_triggers & available):
+                reason = "all_user_triggers_unknown"
+            else:
+                reason = "post_filter_empty"
+            logger.warning(
+                "Tool resolved with 0 functions: setup_id=%s slug=%s reason=%s "
+                "user_enabled=%d module_available=%d",
+                entry.setup_id, tool_info.slug, reason,
+                len(enabled_triggers), len(available),
+            )
+
         return tool_info
 
 

{digitalkin-1.0.0.dev9 → digitalkin-1.0.0.dev11}/src/digitalkin/modules/_base_module.py

@@ -667,18 +667,15 @@ class BaseModule(  # Module SDK base class requires many public methods # noqa:
             except Exception:
                 logger.warning("Failed to flush handler history during stop", exc_info=True)
             t2 = _t.perf_counter_ns()
-            try:
+            if "send_message" in vars(self.context.callbacks):
                 await self.context.callbacks.send_message(
                     _EndOfStreamDataModel(
                         root=EndOfStreamOutput(),
                         annotations={"role": BaseRole.SYSTEM},
                     )
                 )
-            except AttributeError:
-                logger.warning(
-                    "send_message callback not set, skipping end-of-stream"
-                    " (expected for start_config_setup which does not register send_message)"
-                )
+            else:
+                logger.debug("send_message not registered; skipping end-of-stream (config-setup path)")
             t3 = _t.perf_counter_ns()
             self._status = ModuleStatus.STOPPED
             ids = self.context.session.current_ids()

{digitalkin-1.0.0.dev9 → digitalkin-1.0.0.dev11}/src/digitalkin.egg-info/PKG-INFO

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