digitalkin 1.0.3.dev1__tar.gz → 1.0.3.dev2__tar.gz

{digitalkin-1.0.3.dev1 → digitalkin-1.0.3.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: digitalkin
-Version: 1.0.3.dev1
+Version: 1.0.3.dev2
 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.3.dev1 → digitalkin-1.0.3.dev2}/pyproject.toml

@@ -41,7 +41,7 @@
         "pydantic>=2.12.4",
         "redis[hiredis]>=7.4.0,<9",
     ]
-    version = "1.0.3.dev1"
+    version = "1.0.3.dev2"
 
     [project.optional-dependencies]
         agno = [ "agno>=2.6" ]

{digitalkin-1.0.3.dev1 → digitalkin-1.0.3.dev2}/src/digitalkin/__version__.py

@@ -5,4 +5,4 @@ from importlib.metadata import PackageNotFoundError, version
 try:
     __version__ = version("digitalkin")
 except PackageNotFoundError:
-    __version__ = "1.0.3.dev1"
+    __version__ = "1.0.3.dev2"

{digitalkin-1.0.3.dev1 → digitalkin-1.0.3.dev2}/src/digitalkin/community/agno/toolkits/registry/loader/action.py

@@ -78,6 +78,62 @@ class LoadToolAction(LoadAction):
     action: Literal["tool"] = "tool"
     setup_id: str = Field(..., description="The tool's setup id (from a tools_manager search/get) to load.")
 
+    async def _duplicate_outcome(self, ctx: LoadActionCtx, module_id: str) -> LoadOutcome | None:
+        """Resolve the two "already there" cases, or ``None`` if this is a genuinely new load.
+
+        Runs BEFORE ``resolve_tool``: ``module_id`` is already known from the registry lookup, so
+        a repeat load costs no schema fetch. Reads ``base_tools`` — what is callable right now —
+        which after rehydration also covers a tool loaded on an earlier turn of this mission.
+
+        Args:
+            ctx: The load context carrying the live tool list and the module context.
+            module_id: The requested setup's module, from the registry lookup.
+
+        Returns:
+            An ``already_loaded`` success, a conflict failure, or ``None`` to continue loading.
+        """
+        # Imported here, not at module top: ModuleToolkit requires the optional agno dependency at
+        # import time, while this module must stay importable without it (same convention as the
+        # rest of community.agno).
+        from digitalkin.community.agno.module_toolkit import ModuleToolkit
+
+        loaded = [tool for tool in ctx.base_tools if isinstance(tool, ModuleToolkit)]
+        existing = next((tool for tool in loaded if tool.tool_module_info.setup_id == self.setup_id), None)
+        if existing is not None:
+            # Re-persist rather than just report: the id is only durable if an earlier turn's write
+            # actually landed, and that write is fail-soft. Without this, one failed persist makes
+            # the tool re-loadable forever but never durable — the model keeps getting "already
+            # loaded" and the record never appears. The upsert is a no-op when it did land.
+            # Setup-declared tools are excluded: they need no mission record.
+            if self.setup_id not in ctx.context.tool_cache.declared:
+                await ctx.context.persist_loaded_tool(self.setup_id)
+            info = existing.tool_module_info
+            name = info.tool_name or info.module_name or info.slug
+            # Name the callable functions (they ARE callable right now) so an already-loaded result
+            # is as verifiable as a fresh load, instead of an empty list reading as "nothing to call".
+            callable_names = sorted({*existing.functions, *existing.async_functions})
+            listed = f" You can now call: {', '.join(callable_names)}." if callable_names else ""
+            return LoadOutcome(
+                ok=True,
+                status="already_loaded",
+                tool_name=name,
+                loaded_functions=callable_names,
+                message=f"'{name}' is already loaded; call it directly.{listed}",
+            )
+        # A *different* setup of an already-loaded module cannot rebind — the live binding wins
+        # server-side, so appending it would only add duplicate tool names and confirm a change that
+        # never takes effect. Refuse explicitly instead of lying.
+        conflict = next((tool for tool in loaded if tool.tool_module_info.module_id == module_id), None)
+        if conflict is not None:
+            return LoadOutcome(
+                ok=False,
+                message=(
+                    f"could not load setup {self.setup_id}: its tool module is already loaded via setup "
+                    f"{conflict.tool_module_info.setup_id}, whose configuration stays in effect"
+                ),
+            )
+        return None
+
     async def execute(self, ctx: LoadActionCtx) -> LoadOutcome:  # noqa: C901, PLR0911 — each return is a distinct, LLM-readable outcome
         """Resolve the setup into a ModuleToolkit and append it to the live tool list.
 
@@ -125,7 +181,11 @@ class LoadToolAction(LoadAction):
                 ),
             )
 
-        # Confirmed tool module — resolve it into a callable toolkit.
+        duplicate = await self._duplicate_outcome(ctx, setup.module_id)
+        if duplicate is not None:
+            return duplicate
+
+        # Confirmed tool module, not already loaded — resolve it into a callable toolkit.
         try:
             info = await ctx.context.resolve_tool(self.setup_id)
         except PermissionDeniedError:
@@ -140,42 +200,15 @@ class LoadToolAction(LoadAction):
                 ok=False, message=f"could not load setup {self.setup_id}: this tool module exposes no callable tools"
             )
 
-        # Imported here, not at module top: ModuleToolkit requires the optional agno dependency at
-        # import time, while this module must stay importable without it (same convention as the
-        # rest of community.agno).
         from digitalkin.community.agno.module_toolkit import ModuleToolkit
 
         name = info.tool_name or info.module_name or info.slug
-        loaded = [tool for tool in ctx.base_tools if isinstance(tool, ModuleToolkit)]
-        # Idempotent: re-loading the exact same setup is a no-op success. Still name the callable
-        # functions (they ARE callable right now) so an already-loaded result is as verifiable as a
-        # fresh load, instead of an empty ``loaded_functions`` that reads as "nothing to call".
-        existing = next((tool for tool in loaded if tool.tool_module_info.setup_id == self.setup_id), None)
-        if existing is not None:
-            callable_names = sorted({*existing.functions, *existing.async_functions})
-            listed = f" You can now call: {', '.join(callable_names)}." if callable_names else ""
-            return LoadOutcome(
-                ok=True,
-                status="already_loaded",
-                tool_name=name,
-                loaded_functions=callable_names,
-                message=f"'{name}' is already loaded; call it directly.{listed}",
-            )
-        # A *different* setup of an already-loaded module cannot rebind — the live binding wins
-        # server-side, so appending it would only add duplicate tool names and confirm a change that
-        # never takes effect. Refuse explicitly instead of lying.
-        conflict = next((tool for tool in loaded if tool.tool_module_info.module_id == info.module_id), None)
-        if conflict is not None:
-            return LoadOutcome(
-                ok=False,
-                message=(
-                    f"could not load setup {self.setup_id}: its tool module is already loaded via setup "
-                    f"{conflict.tool_module_info.setup_id}, whose configuration stays in effect"
-                ),
-            )
-
         toolkit = ModuleToolkit(ctx.context, info)
         ctx.base_tools.append(toolkit)
+        # Persist the id so the load outlives this turn. ``resolve_tool`` only reached the
+        # mission-scoped ``dynamic`` cache layer, which is rebuilt from scratch on the next
+        # user message; without this the tool would have to be re-loaded every turn.
+        await ctx.context.persist_loaded_tool(self.setup_id)
         await ctx.notify("tool_loaded", {"setup_id": self.setup_id, "tool_name": name})
         # Name the now-callable functions so the model can verify and call them directly.
         callable_names = sorted({*toolkit.functions, *toolkit.async_functions})

{digitalkin-1.0.3.dev1 → digitalkin-1.0.3.dev2}/src/digitalkin/models/module/__init__.py

@@ -1,5 +1,10 @@
 """Module model exports. Import ag_ui types from ``digitalkin.models.module.ag_ui``."""
 
+from digitalkin.models.module.loaded_tools import (
+    LOADED_TOOLS_STORAGE_CONFIG,
+    LoadedToolRecord,
+    LoadedToolStore,
+)
 from digitalkin.models.module.module_context import ModuleContext
 from digitalkin.models.module.module_types import (
     DataModel,
@@ -25,9 +30,12 @@ from digitalkin.models.module.utility import (
 )
 
 __all__ = [
+    "LOADED_TOOLS_STORAGE_CONFIG",
     "DataModel",
     "DataTrigger",
     "EndOfStreamOutput",
+    "LoadedToolRecord",
+    "LoadedToolStore",
     "ModuleContext",
     "RequestMetadata",
     "SelectSchema",

digitalkin-1.0.3.dev2/src/digitalkin/models/module/loaded_tools.py

@@ -0,0 +1,140 @@
+"""Mission-scoped persistence for tools the agent loaded at runtime.
+
+A dynamic tool load (``load_manager`` → :meth:`ModuleContext.resolve_tool`) has to
+outlive the turn that made it: every user message builds a fresh module instance,
+so the in-memory toolkit list and the ``dynamic`` layer of the
+:class:`~digitalkin.models.module.tool_cache.ToolCache` are both gone by the next
+message. This module owns the only thing that survives — the list of loaded
+``setup_id``s, written to the mission-scoped ``loaded_tools`` storage collection.
+
+Only ids are stored, never resolved schemas: rehydration re-runs ``resolve_tool``,
+which re-checks authorization and picks up any schema change, so a tool revoked or
+altered between two turns is handled correctly instead of being replayed from a
+stale snapshot.
+
+Modules that want runtime tool loading must register the collection::
+
+    services_config_params = {"storage": {"config": {**LOADED_TOOLS_STORAGE_CONFIG}}}
+"""
+
+from typing import ClassVar
+
+from pydantic import BaseModel
+
+from digitalkin.logger import logger
+from digitalkin.services.storage.storage_strategy import StorageStrategy
+
+_LOADED_TOOLS_COLLECTION = "loaded_tools"
+
+# The storage service caps a list() at 100 records; ask for the cap rather than the
+# default 20, so a heavily-loaded mission rehydrates completely.
+_LIST_LIMIT = 100
+
+
+class LoadedToolRecord(BaseModel):
+    """A tool the agent loaded at runtime during this mission."""
+
+    setup_id: str
+
+
+LOADED_TOOLS_STORAGE_CONFIG: dict[str, type[BaseModel]] = {_LOADED_TOOLS_COLLECTION: LoadedToolRecord}
+"""Storage config fragment for the ``loaded_tools`` collection."""
+
+
+class LoadedToolStore:
+    """Storage wrapper for the mission-scoped ``loaded_tools`` collection.
+
+    Every method is fail-soft and returns instead of raising: a module that never
+    registered the collection (see :data:`LOADED_TOOLS_STORAGE_CONFIG`) must degrade
+    to the old turn-scoped behaviour, not crash the run through the HITL runner.
+    Registration is checked before each call so a module that does not opt into runtime
+    tool loading pays no storage round-trip per turn.
+    """
+
+    COLLECTION: ClassVar[str] = _LOADED_TOOLS_COLLECTION
+
+    def __init__(self, storage: StorageStrategy) -> None:
+        """Initialize the store.
+
+        Args:
+            storage: The module's storage strategy. Records are written under the
+                default mission context, which is what scopes a load to one
+                conversation.
+        """
+        self._storage = storage
+
+    async def save(self, setup_id: str) -> bool:
+        """Record ``setup_id`` as loaded for this mission (idempotent).
+
+        Args:
+            setup_id: The loaded tool's registry setup id.
+
+        Returns:
+            ``True`` if the id is now persisted, ``False`` if persistence is
+            unavailable — the caller keeps the tool for the current turn either way.
+        """
+        try:
+            if self.COLLECTION not in self._storage.config:
+                logger.warning(
+                    "LoadedToolStore: collection '%s' is not registered on this module "
+                    "(add LOADED_TOOLS_STORAGE_CONFIG to services_config_params); "
+                    "tool '%s' will not survive the current turn",
+                    self.COLLECTION,
+                    setup_id,
+                )
+                return False
+            await self._storage.upsert(
+                collection=self.COLLECTION,
+                record_id=setup_id,
+                data=LoadedToolRecord(setup_id=setup_id).model_dump(),
+            )
+        except Exception:
+            logger.warning(
+                "LoadedToolStore: could not persist loaded tool '%s'; it will not survive this turn",
+                setup_id,
+                exc_info=True,
+            )
+            return False
+        logger.info("LoadedToolStore: persisted loaded tool '%s'", setup_id)
+        return True
+
+    async def list_setup_ids(self) -> list[str]:
+        """List the tool setup ids loaded so far in this mission.
+
+        Returns:
+            The persisted setup ids, or an empty list if none exist or the
+            collection is not registered.
+        """
+        try:
+            # Checked first so a module that never opted into runtime tool loading pays no
+            # storage round-trip on every turn.
+            if self.COLLECTION not in self._storage.config:
+                return []
+            records = await self._storage.list(collection=self.COLLECTION, limit=_LIST_LIMIT)
+        except Exception:
+            logger.debug("LoadedToolStore: could not list loaded tools", exc_info=True)
+            return []
+        # ``StorageRecord.data`` holds the instance the strategy validated against the
+        # registered model, so this is a narrowing, not a parse. Anything else in the
+        # collection is someone else's record and is skipped rather than guessed at.
+        setup_ids = [
+            record.data.setup_id
+            for record in records
+            if isinstance(record.data, LoadedToolRecord) and record.data.setup_id
+        ]
+        if setup_ids:
+            logger.info("LoadedToolStore: %d loaded tool(s) to rehydrate: %s", len(setup_ids), setup_ids)
+        return setup_ids
+
+    async def forget(self, setup_id: str) -> None:
+        """Drop a persisted id that no longer resolves, so it is not retried every turn.
+
+        Args:
+            setup_id: The setup id to remove from the mission's loaded set.
+        """
+        try:
+            if self.COLLECTION not in self._storage.config:
+                return
+            await self._storage.remove(collection=self.COLLECTION, record_id=setup_id)
+        except Exception:
+            logger.debug("LoadedToolStore: could not forget '%s'", setup_id, exc_info=True)

{digitalkin-1.0.3.dev1 → digitalkin-1.0.3.dev2}/src/digitalkin/models/module/module_context.py

@@ -1,5 +1,6 @@
 """Define the module context used in the triggers."""
 
+import asyncio
 from collections.abc import AsyncGenerator, Callable
 from datetime import tzinfo
 from types import SimpleNamespace
@@ -8,7 +9,9 @@ from zoneinfo import ZoneInfo
 
 from google.protobuf import json_format
 
+from digitalkin.grpc_servers.exceptions import PermissionDeniedError
 from digitalkin.logger import logger
+from digitalkin.models.module.loaded_tools import LoadedToolStore
 from digitalkin.models.module.request_metadata import RequestMetadata
 from digitalkin.models.module.tool_cache import ToolCache, ToolDefinition, ToolModuleInfo
 from digitalkin.models.settings.module import get_module_settings
@@ -334,7 +337,7 @@ class ModuleContext:
         Returns:
             List of (ToolDefinition, async_generator_function) tuples. Empty if not found.
         """
-        tool_module_info = self.tool_cache.entries.get(slug)
+        tool_module_info = self.tool_cache.get(slug)
         if not tool_module_info:
             return []
 
@@ -355,11 +358,14 @@ class ModuleContext:
         """Resolve a registry ``setup_id`` into a ``ToolModuleInfo`` and cache it.
 
         On-demand loader for a discovered tool. ``registry.get_setup`` always runs
-        first — it is the permission gate, and the tool cache is shared across
-        missions of the same agent setup, so a cache hit must never skip authz.
+        first — it is the permission gate, and the cache's ``declared`` layer is shared
+        across missions of the same agent setup, so a cache hit must never skip authz.
         The cache only short-circuits the module discovery + schema fetch.
         Permission denials propagate so callers can surface them distinctly.
 
+        The result lands in the cache's mission-scoped ``dynamic`` layer. Pair this with
+        :meth:`persist_loaded_tool` to make the load outlive the current turn.
+
         Args:
             setup_id: The registry setup id to load as an invocable tool.
 
@@ -376,7 +382,7 @@ class ModuleContext:
                 "resolve_tool: setup '%s' not found or has no module", setup_id, extra=self.session.current_ids()
             )
             return None
-        cached = self.tool_cache.entries.get(setup_id)
+        cached = self.tool_cache.get(setup_id)
         if cached is not None:
             logger.debug(
                 "resolve_tool: cache hit for setup '%s' (authz re-checked)", setup_id, extra=self.session.current_ids()
@@ -401,7 +407,10 @@ class ModuleContext:
             )
             return None
         tool_info = await ToolModuleInfo.from_module_info(info, setup_id, setup.name, self.communication)
-        self.tool_cache.add(tool_info)
+        # Mission-scoped layer, never ``declared``: the declared layer is the object the
+        # servicer shares with every other mission of this setup, so writing a runtime
+        # load there makes it reappear in unrelated conversations.
+        self.tool_cache.add_dynamic(tool_info)
         logger.info(
             "resolve_tool: resolved setup '%s' -> module '%s' (%d tools), cached",
             setup_id,
@@ -411,6 +420,81 @@ class ModuleContext:
         )
         return tool_info
 
+    async def persist_loaded_tool(self, setup_id: str) -> bool:
+        """Record a runtime-loaded tool so it survives into this mission's next turn.
+
+        Every user message builds a fresh module instance, so the ``dynamic`` cache layer
+        and the agent's tool list are both rebuilt from scratch. Persisting the id is what
+        turns a load into a property of the *conversation* rather than of the turn.
+
+        Args:
+            setup_id: The loaded tool's registry setup id.
+
+        Returns:
+            ``True`` if the id was persisted; ``False`` if the module never registered the
+            ``loaded_tools`` collection, in which case the load lasts only this turn.
+        """
+        return await LoadedToolStore(self.storage).save(setup_id)
+
+    async def rehydrate_loaded_tools(self) -> int:
+        """Re-resolve this mission's previously-loaded tools into the ``dynamic`` layer.
+
+        Called once per turn from ``BaseModule.prepare()``, before ``initialize()`` builds
+        the agent's toolkits. Ids are re-resolved rather than replayed from a snapshot, so
+        each turn re-checks authorization and picks up schema changes; an id that no longer
+        resolves — revoked, deleted — is dropped from the mission so it is not retried on
+        every subsequent message.
+
+        Returns:
+            The number of tools restored into the dynamic layer.
+        """
+        store = LoadedToolStore(self.storage)
+        setup_ids = [sid for sid in await store.list_setup_ids() if sid not in self.tool_cache.dynamic]
+        if not setup_ids:
+            return 0
+
+        # Resolve concurrently: each id costs a get_setup + discover + schema fetch, and this
+        # sits on the critical path of every user message.
+        results = await asyncio.gather(
+            *(self.resolve_tool(setup_id) for setup_id in setup_ids),
+            return_exceptions=True,
+        )
+
+        restored = 0
+        for setup_id, result in zip(setup_ids, results, strict=True):
+            if isinstance(result, PermissionDeniedError):
+                logger.warning(
+                    "rehydrate_loaded_tools: access to '%s' was revoked; dropping it from the mission",
+                    setup_id,
+                    extra=self.session.current_ids(),
+                )
+                await store.forget(setup_id)
+            elif isinstance(result, BaseException):
+                # Transient (registry hiccup): keep the id so a later turn can retry.
+                logger.warning(
+                    "rehydrate_loaded_tools: could not restore '%s': %s",
+                    setup_id,
+                    result,
+                    extra=self.session.current_ids(),
+                )
+            elif result is None:
+                logger.warning(
+                    "rehydrate_loaded_tools: '%s' no longer exists; dropping it from the mission",
+                    setup_id,
+                    extra=self.session.current_ids(),
+                )
+                await store.forget(setup_id)
+            else:
+                restored += 1
+
+        logger.info(
+            "rehydrate_loaded_tools: restored %d/%d loaded tool(s)",
+            restored,
+            len(setup_ids),
+            extra=self.session.current_ids(),
+        )
+        return restored
+
     @staticmethod
     def _create_single_tool_function(
         communication: CommunicationStrategy,

{digitalkin-1.0.3.dev1 → digitalkin-1.0.3.dev2}/src/digitalkin/models/module/tool_cache.py

@@ -186,20 +186,79 @@ class ToolModuleInfo(ModuleInfo):
 
 
 class ToolCache(BaseModel):
-    """Registry cache storing resolved tool references by setup field name."""
+    """Two-layer cache of resolved tool references, keyed by ``setup_id``.
 
-    entries: dict[str, ToolModuleInfo] = Field(default_factory=dict)
+    The layers differ by *lifetime*, which is the whole point of the split:
+
+    - ``declared`` — the tools the setup itself selects, resolved once by
+      ``SetupModel.build_tool_cache``. The servicer keeps this layer alive per
+      ``setup_id`` and hands the same object to every mission of that setup.
+    - ``dynamic`` — tools the agent loaded at runtime via
+      ``ModuleContext.resolve_tool``. This layer is **mission-scoped**: it is
+      rebuilt per mission from the ``loaded_tools`` storage collection, so a load
+      persists across the turns of one conversation and never leaks into another
+      mission of the same setup.
+
+    Never write a runtime resolution into ``declared`` — doing so is what leaked
+    dynamically-loaded tools across missions before the split existed.
+    """
+
+    declared: dict[str, ToolModuleInfo] = Field(
+        default_factory=dict, description="Setup-selected tools; shared across missions of one setup."
+    )
+    dynamic: dict[str, ToolModuleInfo] = Field(
+        default_factory=dict, description="Runtime-loaded tools; scoped to a single mission."
+    )
+
+    @property
+    def entries(self) -> dict[str, ToolModuleInfo]:
+        """Merged read-only view of both layers, ``dynamic`` winning on conflict.
+
+        Returns:
+            A fresh dict — mutating it does not touch either layer (and must not:
+            ``declared`` is shared with every other mission of this setup).
+        """
+        return {**self.declared, **self.dynamic}
+
+    def mission_view(self, dynamic: dict[str, ToolModuleInfo] | None = None) -> "ToolCache":
+        """Build a per-mission view that shares this cache's ``declared`` entries.
+
+        The mapping is shallow-copied so a mission can never mutate the shared
+        declared layer, while the ``ToolModuleInfo`` values are reused as-is
+        (they are treated as immutable, and re-validating them per turn is not free).
+
+        Args:
+            dynamic: Pre-resolved runtime tools to seed the mission layer with.
+
+        Returns:
+            A new ``ToolCache`` whose ``dynamic`` layer is private to this mission.
+        """
+        return ToolCache.model_construct(declared=dict(self.declared), dynamic=dynamic or {})
 
     def add(self, tool_module_info: ToolModuleInfo) -> None:
-        """Add a tool to the cache.
+        """Add a setup-declared tool to the ``declared`` layer.
+
+        Args:
+            tool_module_info: Resolved tool module information.
+        """
+        setup_id = tool_module_info.setup_id
+        self.declared[setup_id] = tool_module_info
+        logger.debug(
+            "Tool cached (declared): module_id=%s",
+            tool_module_info.module_id,
+            extra={"setup_id": setup_id},
+        )
+
+    def add_dynamic(self, tool_module_info: ToolModuleInfo) -> None:
+        """Add a runtime-loaded tool to the mission-scoped ``dynamic`` layer.
 
         Args:
             tool_module_info: Resolved tool module information.
         """
         setup_id = tool_module_info.setup_id
-        self.entries[setup_id] = tool_module_info
+        self.dynamic[setup_id] = tool_module_info
         logger.debug(
-            "Tool cached: module_id=%s",
+            "Tool cached (dynamic): module_id=%s",
             tool_module_info.module_id,
             extra={"setup_id": setup_id},
         )
@@ -208,7 +267,7 @@ class ToolCache(BaseModel):
         self,
         setup_id: str,
     ) -> ToolModuleInfo | None:
-        """Get a tool from cache, optionally querying registry on miss.
+        """Get a tool from either layer, preferring the mission-scoped one.
 
         Args:
             setup_id: Field name to look up.
@@ -216,14 +275,15 @@ class ToolCache(BaseModel):
         Returns:
             ToolModuleInfo if found, None otherwise.
         """
-        return self.entries.get(setup_id)
+        return self.dynamic.get(setup_id) or self.declared.get(setup_id)
 
     def clear(self) -> None:
-        """Clear all cache entries."""
-        self.entries.clear()
+        """Clear both layers."""
+        self.declared.clear()
+        self.dynamic.clear()
 
     def list_tools(self) -> list[str]:
-        """List all cached tool names.
+        """List all cached tool names across both layers.
 
         Returns:
             List of setup field names in cache.

{digitalkin-1.0.3.dev1 → digitalkin-1.0.3.dev2}/src/digitalkin/modules/_base_module.py

@@ -648,9 +648,16 @@ class BaseModule(  # Module SDK base class requires many public methods # noqa:
                 self.context.registry,
                 self.context.communication,
             )
-            if tool_cache.entries:
-                self.context.tool_cache = tool_cache
+            # Installed unconditionally, even when the setup declares no tools: the
+            # mission view owns the ``dynamic`` layer, which is where runtime loads land.
+            # Gating on a non-empty declared layer used to leave the context holding a
+            # throwaway ToolCache, so a setup with no selected tools could never keep one.
+            self.context.tool_cache = tool_cache.mission_view()
             timer.mark("build_tool_cache")
+            # Restore the tools the agent loaded earlier in this mission, before
+            # initialize() builds the toolkits that have to expose them.
+            await self.context.rehydrate_loaded_tools()
+            timer.mark("rehydrate_loaded_tools")
 
         await self.initialize(self.context, setup_data)
         timer.mark("initialize")

{digitalkin-1.0.3.dev1 → digitalkin-1.0.3.dev2}/src/digitalkin.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: digitalkin
-Version: 1.0.3.dev1
+Version: 1.0.3.dev2
 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.3.dev1 → digitalkin-1.0.3.dev2}/src/digitalkin.egg-info/SOURCES.txt

@@ -148,6 +148,7 @@ src/digitalkin/models/grpc_servers/types.py
 src/digitalkin/models/module/__init__.py
 src/digitalkin/models/module/ag_ui.py
 src/digitalkin/models/module/base_types.py
+src/digitalkin/models/module/loaded_tools.py
 src/digitalkin/models/module/module.py
 src/digitalkin/models/module/module_context.py
 src/digitalkin/models/module/module_types.py