digitalkin 1.0.1.dev0__tar.gz → 1.0.2.dev0__tar.gz

{digitalkin-1.0.1.dev0 → digitalkin-1.0.2.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: digitalkin
-Version: 1.0.1.dev0
+Version: 1.0.2.dev0
 Summary: SDK to build kin used in DigitalKin
 Author-email: "DigitalKin.ai" <contact@digitalkin.ai>
 License: Attribution-NonCommercial-ShareAlike 4.0 International
@@ -453,13 +453,13 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: ag-ui-protocol>=0.1.18
-Requires-Dist: agentic-mesh-protocol==1.0.0b0
+Requires-Dist: agentic-mesh-protocol==1.0.1.dev2
 Requires-Dist: anyio>=4.13.0
-Requires-Dist: grpcio-health-checking==1.81.0
-Requires-Dist: grpcio-reflection==1.81.0
-Requires-Dist: grpcio-status==1.81.0
-Requires-Dist: pydantic>=2.12.4
+Requires-Dist: grpcio-health-checking==1.82.1
+Requires-Dist: grpcio-reflection==1.82.1
+Requires-Dist: grpcio-status==1.82.1
 Requires-Dist: pydantic-settings>=2.14.1
+Requires-Dist: pydantic>=2.12.4
 Requires-Dist: redis[hiredis]<9,>=7.4.0
 Provides-Extra: agno
 Requires-Dist: agno>=2.6; extra == "agno"

{digitalkin-1.0.1.dev0 → digitalkin-1.0.2.dev0}/pyproject.toml

@@ -28,19 +28,19 @@
 
     dependencies = [
         "ag-ui-protocol>=0.1.18",
-        "agentic-mesh-protocol==1.0.0b0",
+        "agentic-mesh-protocol==1.0.1.dev2",
         "anyio>=4.13.0",
-        "grpcio-health-checking==1.81.0",
-        "grpcio-reflection==1.81.0",
-        "grpcio-status==1.81.0",
-        "pydantic>=2.12.4",
+        "grpcio-health-checking==1.82.1",
+        "grpcio-reflection==1.82.1",
+        "grpcio-status==1.82.1",
         "pydantic-settings>=2.14.1",
+        "pydantic>=2.12.4",
         "redis[hiredis]>=7.4.0,<9",
     ]
-    version = "1.0.1.dev0"
+    version = "1.0.2.dev0"
 
     [project.optional-dependencies]
-        agno        = [ "agno>=2.6" ]
+        agno = [ "agno>=2.6" ]
         performance = [ "uvloop>=0.21" ]
         profiling = [
             "pyinstrument>=5.1.2",
@@ -57,6 +57,22 @@
         name  = "DigitalKin.ai"
 
 [dependency-groups]
+    tests = [
+        "fakeredis[lua]>=2.35.1",
+        "freezegun>=1.5.5",
+        "grpcio-testing>=1.81.0",
+        "hdrhistogram>=0.10.3",
+        "hypothesis>=6.152.8",
+        "objgraph>=3.6",
+        "psutil>=7.2.2",
+        "pytest-asyncio>=1.3.0",
+        "pytest-benchmark>=5.2.3",
+        "pytest-cov>=7.1.0",
+        "pytest-html>=4.2.0",
+        "pytest-json-report>=1.5.0",
+        "pytest-timeout>=2.4.0",
+        "pytest>=9.0.3",
+    ]
     dev = [
         "build>=1.5.0",
         "bump-my-version>=1.3.0",
@@ -68,7 +84,7 @@
         "twine>=6.2.0",
         "types-grpcio-health-checking>=1.0.0.20260518",
         "types-grpcio-reflection>=1.0.0.20260508",
-        "types-grpcio>=1.0.0.20260518",
+        "types-grpcio>=1.82.1.20260711",
         "types-protobuf>=7.34.1.20260518",
         "typos>=1.48.0",
     ]
@@ -96,23 +112,6 @@
         "mkdocstrings>=1.0.4",
         "tomli>=2.4.1",
     ]
-    tests = [
-        "agno>=2.6",
-        "fakeredis[lua]>=2.35.1",
-        "freezegun>=1.5.5",
-        "grpcio-testing>=1.81.0",
-        "hdrhistogram>=0.10.3",
-        "hypothesis>=6.152.8",
-        "objgraph>=3.6",
-        "psutil>=7.2.2",
-        "pytest-asyncio>=1.3.0",
-        "pytest-benchmark>=4.0",
-        "pytest-cov>=7.1.0",
-        "pytest-html>=4.2.0",
-        "pytest-json-report>=1.5.0",
-        "pytest-timeout>=2.4.0",
-        "pytest>=9.0.3",
-    ]
 [tool.setuptools]
     package-dir = { "" = "src" }
 
@@ -148,12 +147,12 @@
         "buck-out",
         "build",
         "dist",
-        "scripts",
         "docs/*",
         "examples/*",
         "factory.py",
         "generate_certificates.py",
         "node_modules",
+        "scripts",
         "tests/*",
         "venv",
     ]
@@ -270,10 +269,10 @@
         skip-magic-trailing-comma = false
 
 [tool.mypy]
-    exclude                = [ "examples", "tests", "scripts" ]
+    exclude                = [ "examples", "scripts", "tests" ]
     ignore_missing_imports = true
-    warn_unused_ignores    = true
     warn_redundant_casts   = true
+    warn_unused_ignores    = true
 
 [tool.pytest.ini_options]
 

{digitalkin-1.0.1.dev0 → digitalkin-1.0.2.dev0}/src/digitalkin/__version__.py

@@ -5,4 +5,4 @@ from importlib.metadata import PackageNotFoundError, version
 try:
     __version__ = version("digitalkin")
 except PackageNotFoundError:
-    __version__ = "1.0.1.dev0"
+    __version__ = "1.0.2.dev0"

{digitalkin-1.0.1.dev0 → digitalkin-1.0.2.dev0}/src/digitalkin/community/agno/__init__.py

@@ -20,6 +20,11 @@ optional ``agno`` dependency at import time and is therefore NOT exported here;
 import it directly::
 
     from digitalkin.community.agno.module_toolkit import ModuleToolkit
+
+Default agent toolkits (``ChatHistoryTools``, ``UserProfileTools``,
+``RegistryTools``, ``DefaultToolkits``) live in
+:mod:`digitalkin.community.agno.toolkits` — imported separately because they
+require the optional ``agno`` dependency at import time.
 """
 
 from digitalkin.community.agno.agno_adapter import AgnoStreamAdapter

{digitalkin-1.0.1.dev0 → digitalkin-1.0.2.dev0}/src/digitalkin/community/agno/module_toolkit.py

@@ -16,10 +16,10 @@ from typing import Any
 
 from ag_ui.core.events import CustomEvent as AgUiCustomEvent
 from agno.media import Image
-from agno.tools import Toolkit
 from agno.tools.function import Function, ToolResult
 
 from digitalkin.community.agno.models import ToolCallMetadata, ToolOutputMetadata
+from digitalkin.community.agno.toolkits.base import DkToolkit
 from digitalkin.core.profiling.step_timer import StepTimer
 from digitalkin.logger import logger
 from digitalkin.models.module import ModuleContext
@@ -38,7 +38,7 @@ TOOL_CONTENT_PROTOCOL = "tool_content"
 AGUI_CUSTOM_PROTOCOL = "agui_custom"
 
 
-class ModuleToolkit(Toolkit):
+class ModuleToolkit(DkToolkit):
     """Agno Toolkit wrapper for SDK module tools.
 
     Wraps a ToolModuleInfo containing multiple ToolDefinitions into
@@ -170,7 +170,7 @@ class ModuleToolkit(Toolkit):
             or tool_module_info.module_name
             or tool_module_info.slug.replace(":", "_").replace(".", "_")
         )
-        super().__init__(name=f"{toolkit_name}_toolkit", tools=agno_functions)
+        super().__init__(name=f"{toolkit_name}_toolkit", tools=agno_functions, context=self._context)
 
     @property
     def module_id(self) -> str:

digitalkin-1.0.2.dev0/src/digitalkin/community/agno/toolkits/__init__.py

@@ -0,0 +1,20 @@
+"""Default Agno toolkits for DigitalKin modules.
+
+Requires the optional ``agno`` dependency — importing this subpackage without
+``agno`` installed raises ModuleNotFoundError. The parent
+``digitalkin.community.agno`` package stays importable without agno.
+"""
+
+from digitalkin.community.agno.toolkits.base import DkToolkit
+from digitalkin.community.agno.toolkits.chat_history import ChatHistoryTools
+from digitalkin.community.agno.toolkits.defaults import DefaultToolkits
+from digitalkin.community.agno.toolkits.registry import RegistryTools
+from digitalkin.community.agno.toolkits.user_profile import UserProfileTools
+
+__all__ = [
+    "ChatHistoryTools",
+    "DefaultToolkits",
+    "DkToolkit",
+    "RegistryTools",
+    "UserProfileTools",
+]

digitalkin-1.0.2.dev0/src/digitalkin/community/agno/toolkits/base.py

@@ -0,0 +1,91 @@
+"""Shared base for DigitalKin agno toolkits.
+
+Codifies the format/return conventions established by
+:class:`~digitalkin.community.agno.module_toolkit.ModuleToolkit`: a canonical
+``{"output"|"error", "metadata"}`` JSON envelope (:meth:`_ok`/:meth:`_fail`) and
+best-effort AG-UI custom-event notifications on the agent's own stream
+(:meth:`_notify`). Every toolkit returns consistently and never raises into the
+agent loop.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import TYPE_CHECKING, Any
+
+from ag_ui.core.events import CustomEvent as AgUiCustomEvent
+from agno.tools import Toolkit
+
+from digitalkin.logger import logger
+from digitalkin.models.module.ag_ui import AgUiCustomEventOutput, AgUiOutput
+
+if TYPE_CHECKING:
+    from digitalkin.models.module import ModuleContext
+
+
+class DkToolkit(Toolkit):
+    """Base class for DigitalKin agno toolkits.
+
+    Subclasses register bound async tool methods and return via :meth:`_ok`/
+    :meth:`_fail` so the agent always receives the same envelope and the tool
+    never raises. Passing a :class:`ModuleContext` enables :meth:`_notify`,
+    which pushes AG-UI custom events onto the caller's gRPC stream.
+    """
+
+    def __init__(self, name: str, tools: list[Any], context: ModuleContext | None = None) -> None:
+        """Initialize the toolkit.
+
+        Args:
+            name: Toolkit name registered with Agno.
+            tools: Bound tool callables to expose to the agent.
+            context: Module context; when present, :meth:`_notify` can emit AG-UI events.
+        """
+        self._ctx = context
+        super().__init__(name=name, tools=tools)
+
+    @staticmethod
+    def _ok(output: Any, **metadata: Any) -> str:
+        """Build the canonical success envelope.
+
+        Args:
+            output: The tool result payload (JSON-serializable).
+            metadata: Extra metadata fields (e.g. ``tool``).
+
+        Returns:
+            JSON string ``{"output": ..., "metadata": {"success": true, ...}}``.
+        """
+        return json.dumps({"output": output, "metadata": {"success": True, **metadata}}, ensure_ascii=False)
+
+    @staticmethod
+    def _fail(error: str, **metadata: Any) -> str:
+        """Build the canonical error envelope.
+
+        Args:
+            error: Human/LLM-readable error message.
+            metadata: Extra metadata fields (e.g. ``tool``).
+
+        Returns:
+            JSON string ``{"error": ..., "metadata": {"success": false, ...}}``.
+        """
+        return json.dumps({"error": error, "metadata": {"success": False, **metadata}}, ensure_ascii=False)
+
+    async def _notify(self, name: str, value: Any) -> None:
+        """Emit an AG-UI custom event on the agent's output stream (best-effort).
+
+        No-op when there is no context or ``send_message`` is not installed (e.g. outside a
+        running job). Never raises — a notification failure must not fail the tool call.
+
+        Args:
+            name: Custom event name.
+            value: Custom event payload (JSON-serializable).
+        """
+        if self._ctx is None:
+            return
+        # callbacks is a dict-driven SimpleNamespace; send_message is attached during prepare().
+        send_message = vars(self._ctx.callbacks).get("send_message")
+        if send_message is None:
+            return
+        try:
+            await send_message(AgUiOutput(root=AgUiCustomEventOutput(event=AgUiCustomEvent(name=name, value=value))))
+        except Exception:
+            logger.exception("Failed to emit custom event '%s' to the agent stream", name)

digitalkin-1.0.2.dev0/src/digitalkin/community/agno/toolkits/chat_history.py

@@ -0,0 +1,298 @@
+"""Toolkit for progressive chat-history access (outline first, then read by id).
+
+Replaces Agno's built-in ``get_chat_history`` (which dumps every message in full)
+with a two-step, token-cheap surface:
+
+1. ``outline_chat_history`` — a metadata-only index (role, who, size, preview) so the
+   agent can see *what* exists before loading anything.
+2. ``read_chat_messages`` — fetch full content only for the message ids that matter.
+
+The toolkit is leader-only: it is attached to the head agent / team leader and its
+underlying ``aget_session_messages`` call skips team-member sub-conversations.
+
+Note: the tools intentionally take NO ``run_context`` parameter. The session id is
+captured at construction and the runtime Agent/Team is late-bound as ``host`` — so
+every tool parameter is a plain builtin type, which keeps the LLM-facing JSON schema
+correct under ``from __future__ import annotations``.
+"""
+
+from __future__ import annotations
+
+from itertools import starmap
+from typing import TYPE_CHECKING, Any, ClassVar
+
+from digitalkin.community.agno.toolkits.base import DkToolkit
+from digitalkin.logger import logger
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from agno.media import Audio, File, Image, Video
+    from agno.models.message import Message
+
+    from digitalkin.models.module import ModuleContext
+
+
+class ChatHistoryTools(DkToolkit):
+    """Two-tool chat-history surface bound to a constructed Agent or Team.
+
+    ``host`` is late-bound after the agent/team is created (the same pattern Agno uses
+    for its own history tools, which close over the agent + session). Until bound, the
+    tools report that history is unavailable rather than raising.
+    """
+
+    # Agno message roles -> the labels surfaced to the LLM.
+    _ROLE_TO_LABEL: ClassVar[dict[str, str]] = {"user": "human", "assistant": "ai", "tool": "tool", "system": "system"}
+
+    # Requested label -> Agno ``skip_roles`` (which roles to exclude). ``system`` is special-cased.
+    _LABEL_TO_SKIP: ClassVar[dict[str, list[str]]] = {
+        "human": ["system", "assistant", "tool"],
+        "ai": ["system", "user", "tool"],
+        "tool": ["system", "user", "assistant"],
+        "system": [],
+    }
+
+    def __init__(self, session_id: str | None = None, context: ModuleContext | None = None) -> None:
+        """Register the outline + read tools.
+
+        Args:
+            session_id: The session whose history to read. Captured here (it is known at
+                agent-construction time) so the tools need no ``run_context`` parameter.
+            context: Module context; enables AG-UI notifications via the base toolkit.
+        """
+        super().__init__(
+            name="chat_history_tools",
+            tools=[self.outline_chat_history, self.read_chat_messages],
+            context=context,
+        )
+        self._session_id = session_id
+        # Late-bound to the runtime Agent (single mode) or Team (team mode).
+        self.host: Any = None
+
+    @staticmethod
+    def bind_host(tools: list[Any] | Callable[..., list[Any]] | None, host: Any) -> None:
+        """Late-bind the runtime Agent/Team into the ChatHistoryTools instance, if present.
+
+        The toolkit needs a handle to call ``aget_session_messages``, which only exists once
+        the agent/team is constructed. In team mode call this again with the ``Team`` so
+        history reads target the team session rather than the bare head agent.
+
+        Args:
+            tools: The head tools — either the raw list or an
+                :meth:`AguiTools.make_tools_factory` callable (calling it without a
+                RunContext returns the base list). Binds the first ChatHistoryTools
+                found; no-op if absent.
+            host: The constructed Agent or Team to bind as the history source.
+        """
+        if callable(tools) and not isinstance(tools, list):
+            tools = tools(None)
+        if not isinstance(tools, list):
+            return
+        for tool in tools:
+            if isinstance(tool, ChatHistoryTools):
+                tool.host = host
+                return
+
+    async def outline_chat_history(
+        self,
+        role: str | None = None,
+        first: int | None = None,
+        last: int | None = None,
+        offset: int = 0,
+    ) -> str:
+        """List the conversation as a cheap metadata index — call this FIRST.
+
+        Returns one lightweight row per message (role, who, timestamp, size and a short
+        preview) WITHOUT the full content, so it is safe to scan a long thread. Once you
+        know which messages you need, call ``read_chat_messages`` with their ids to get
+        full content. Prefer this over loading everything.
+
+        Args:
+            role: Filter by message type: "human", "ai", "tool", or "system".
+                Omit to get all messages except the system prompt.
+            first: Return only the first N messages (oldest). Use this to reach the start
+                of the conversation, e.g. the user's first request.
+            last: Return only the last N messages (most recent). Mutually exclusive with first.
+            offset: Skip this many messages from the relevant end (for pagination).
+
+        Returns:
+            JSON string: {"total", "returned", "offset", "messages": [{"ord", "id", "role",
+            "ts", "chars", "preview", ...}]}. "total" is the full count after filtering, so
+            an empty "messages" with "total": 0 means the thread is genuinely empty.
+        """
+        if role is not None and role not in self._LABEL_TO_SKIP:
+            msg = f"invalid role '{role}'; use one of: human, ai, tool, system"
+            return self._fail(msg, tool="outline_chat_history")
+
+        skip_roles = self._LABEL_TO_SKIP[role] if role is not None else ["system"]
+        messages = await self._fetch(skip_roles)
+        if messages is None:
+            return self._fail("chat history is not available", tool="outline_chat_history")
+        if role == "system":
+            messages = [m for m in messages if m.role == "system"]
+
+        rows = list(starmap(self._index_row, enumerate(messages)))
+        total = len(rows)
+
+        if first is not None:
+            sliced = rows[offset : offset + max(first, 0)]
+        elif last is not None:
+            end = max(total - offset, 0)
+            start = max(end - max(last, 0), 0)
+            sliced = rows[start:end]
+        else:
+            sliced = rows[offset:]
+
+        return self._ok(
+            {"total": total, "returned": len(sliced), "offset": offset, "messages": sliced},
+            tool="outline_chat_history",
+        )
+
+    async def read_chat_messages(
+        self,
+        ids: list[str],
+        max_content_chars: int = 4000,
+    ) -> str:
+        """Fetch the full content of specific messages by id (from ``outline_chat_history``).
+
+        Use the "id" values returned by ``outline_chat_history`` — they are stable even as
+        the conversation grows (unlike the "ord" position). Long bodies are truncated to
+        ``max_content_chars``; attached media is returned as a reference, never inlined.
+
+        Args:
+            ids: The message ids to read, taken from an earlier ``outline_chat_history`` call.
+            max_content_chars: Truncate each message body to this many characters (default 4000).
+
+        Returns:
+            JSON string: {"messages": [{"id", "role", "ts", "content", ...}], "missing": [...]}.
+            Any requested id that no longer exists is listed under "missing".
+        """
+        if not ids:
+            return self._ok({"messages": [], "missing": []}, tool="read_chat_messages")
+
+        messages = await self._fetch(skip_roles=[])
+        if messages is None:
+            return self._fail("chat history is not available", tool="read_chat_messages")
+
+        by_id = {message.id: message for message in messages}
+        out: list[dict[str, Any]] = []
+        missing: list[str] = []
+        for message_id in ids:
+            message = by_id.get(message_id)
+            if message is None:
+                missing.append(message_id)
+            else:
+                out.append(self._full_row(message, max_content_chars))
+
+        return self._ok({"messages": out, "missing": missing}, tool="read_chat_messages")
+
+    async def _fetch(self, skip_roles: list[str]) -> list[Message] | None:
+        """Load session messages via the bound agent/team, or None if unavailable.
+
+        Args:
+            skip_roles: Roles to exclude (passed to Agno's ``aget_session_messages``).
+
+        Returns:
+            The deduplicated session messages, or None if no host is bound or the call fails.
+        """
+        if self.host is None:
+            logger.warning("ChatHistoryTools called before host was bound")
+            return None
+        try:
+            return await self.host.aget_session_messages(
+                session_id=self._session_id,
+                skip_roles=skip_roles,
+                skip_history_messages=True,
+            )
+        except Exception as error:
+            logger.warning("ChatHistoryTools: failed to load session messages: %s", error)
+            return None
+
+    def _index_row(self, ordinal: int, message: Message) -> dict[str, Any]:
+        """Build a metadata-only index row for one message.
+
+        Args:
+            ordinal: Position of the message in the filtered list (display-only).
+            message: The Agno message.
+
+        Returns:
+            A compact dict with role, id, timestamp, size and a short preview.
+        """
+        content = message.get_content_string() or ""
+        row: dict[str, Any] = {
+            "ord": ordinal,
+            "id": message.id,
+            "role": self._ROLE_TO_LABEL.get(message.role, message.role),
+            "ts": message.created_at,
+            "chars": len(content),
+            "preview": content[:120],
+        }
+        if message.images or message.files or message.videos or message.audio:
+            row["has_media"] = True
+        if message.from_history:
+            row["from_history"] = True
+        if message.role == "tool":
+            row["name"] = message.tool_name
+            if message.tool_call_error:
+                row["error"] = True
+        return row
+
+    def _full_row(self, message: Message, max_content_chars: int) -> dict[str, Any]:
+        """Build a full-content row for one message, truncating the body if needed.
+
+        Args:
+            message: The Agno message.
+            max_content_chars: Maximum body length before truncation.
+
+        Returns:
+            A dict with the (possibly truncated) content plus media references.
+        """
+        content = message.get_content_string() or ""
+        truncated = len(content) > max_content_chars
+        if truncated:
+            content = content[:max_content_chars] + " […truncated]"
+
+        row: dict[str, Any] = {
+            "id": message.id,
+            "role": self._ROLE_TO_LABEL.get(message.role, message.role),
+            "ts": message.created_at,
+            "content": content,
+        }
+        if truncated:
+            row["truncated"] = True
+        if message.role == "tool":
+            row["name"] = message.tool_name
+            if message.tool_call_error:
+                row["error"] = True
+        media = self._media_refs(message)
+        if media:
+            row["media"] = media
+        return row
+
+    @staticmethod
+    def _media_refs(message: Message) -> list[dict[str, Any]]:
+        """Build reference descriptors for attached media — never the raw bytes.
+
+        Args:
+            message: The Agno message.
+
+        Returns:
+            A list of {"kind", "id", "mime_type", "format"} descriptors.
+        """
+        groups: tuple[tuple[str, Any], ...] = (
+            ("image", message.images),
+            ("audio", message.audio),
+            ("video", message.videos),
+            ("file", message.files),
+        )
+        refs: list[dict[str, Any]] = []
+        for kind, items in groups:
+            for item in items or []:
+                media_item: Image | Audio | Video | File = item
+                refs.append({
+                    "kind": kind,
+                    "id": media_item.id,
+                    "mime_type": media_item.mime_type,
+                    "format": media_item.format,
+                })
+        return refs

digitalkin-1.0.2.dev0/src/digitalkin/community/agno/toolkits/defaults.py

@@ -0,0 +1,57 @@
+"""One-call assembler for the default DigitalKin toolkits."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from digitalkin.community.agno.toolkits.chat_history import ChatHistoryTools
+from digitalkin.community.agno.toolkits.registry import RegistryTools
+from digitalkin.community.agno.toolkits.user_profile import UserProfileTools
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from agno.tools import Toolkit
+
+    from digitalkin.models.module.module_context import ModuleContext
+
+
+class DefaultToolkits:
+    """Assemble the default DigitalKin toolkits (chat history, user profile, registry).
+
+    Two-phase usage — ChatHistoryTools needs the constructed Agent/Team::
+
+        tools = DefaultToolkits.build(context, session_id=sid)
+        agent = Agent(tools=AguiTools.make_tools_factory(tools), cache_callables=False, ...)
+        DefaultToolkits.bind_host(tools, agent)
+
+    In team mode call :meth:`bind_host` again with the ``Team`` so history reads
+    target the team session rather than the bare head agent.
+    """
+
+    @staticmethod
+    def build(context: ModuleContext, session_id: str | None = None) -> list[Toolkit]:
+        """Build the default toolkits from a module context.
+
+        Args:
+            context: The module context carrying the user_profile and registry services.
+            session_id: The Agno session whose chat history should be readable.
+
+        Returns:
+            [ChatHistoryTools, UserProfileTools, RegistryTools].
+        """
+        return [
+            ChatHistoryTools(session_id=session_id, context=context),
+            UserProfileTools(context.user_profile, context=context),
+            RegistryTools(context.registry, context=context),
+        ]
+
+    @staticmethod
+    def bind_host(tools: list[Any] | Callable[..., list[Any]] | None, host: Any) -> None:
+        """Late-bind the constructed Agent/Team into ChatHistoryTools (delegates).
+
+        Args:
+            tools: The tools list (or a make_tools_factory callable) containing the toolkits.
+            host: The constructed Agent or Team to bind as the history source.
+        """
+        ChatHistoryTools.bind_host(tools, host)