digitalkin 1.0.0.dev6__tar.gz → 1.0.0.dev8__tar.gz

{digitalkin-1.0.0.dev6 → digitalkin-1.0.0.dev8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: digitalkin
-Version: 1.0.0.dev6
+Version: 1.0.0.dev8
 Summary: SDK to build kin used in DigitalKin
 Author-email: "DigitalKin.ai" <contact@digitalkin.ai>
 License: Attribution-NonCommercial-ShareAlike 4.0 International
@@ -459,7 +459,7 @@ Requires-Dist: grpcio-health-checking==1.80.0
 Requires-Dist: grpcio-reflection==1.80.0
 Requires-Dist: grpcio-status==1.80.0
 Requires-Dist: pydantic>=2.12.4
-Requires-Dist: pydantic-settings>=2.14.0
+Requires-Dist: pydantic-settings>=2.14.1
 Requires-Dist: redis[hiredis]<8,>=7.4.0
 Provides-Extra: performance
 Requires-Dist: uvloop>=0.21; extra == "performance"

{digitalkin-1.0.0.dev6 → digitalkin-1.0.0.dev8}/pyproject.toml

@@ -34,10 +34,10 @@
         "grpcio-reflection==1.80.0",
         "grpcio-status==1.80.0",
         "pydantic>=2.12.4",
-        "pydantic-settings>=2.14.0",
+        "pydantic-settings>=2.14.1",
         "redis[hiredis]>=7.4.0,<8",
     ]
-    version = "1.0.0.dev6"
+    version = "1.0.0.dev8"
 
     [project.optional-dependencies]
         performance = [ "uvloop>=0.21" ]
@@ -60,16 +60,16 @@
         "build>=1.5.0",
         "bump-my-version>=1.3.0",
         "cryptography>=48.0.0",
-        "mypy>=2.0.0",
+        "mypy>=2.1.0",
         "pre-commit>=4.6.0",
         "pyright>=1.1.409",
-        "ruff>=0.15.12",
+        "ruff>=0.15.13",
         "twine>=6.2.0",
-        "types-grpcio-health-checking>=1.0.0.20260408",
-        "types-grpcio-reflection>=1.0.0.20260408",
-        "types-grpcio>=1.0.0.20260408",
-        "types-protobuf>=7.34.1.20260503",
-        "typos>=1.46.0",
+        "types-grpcio-health-checking>=1.0.0.20260518",
+        "types-grpcio-reflection>=1.0.0.20260508",
+        "types-grpcio>=1.0.0.20260518",
+        "types-protobuf>=7.34.1.20260518",
+        "typos>=1.46.2",
     ]
     docs = [
         "griffe-inherited-docstrings>=1.1.3",
@@ -80,9 +80,9 @@
         "mkdocs-awesome-pages-plugin>=2.10.1",
         "mkdocs-coverage>=2.0.0",
         "mkdocs-git-committers-plugin-2>=2.5.0",
-        "mkdocs-git-revision-date-localized-plugin>=1.5.1",
+        "mkdocs-git-revision-date-localized-plugin>=1.5.2",
         "mkdocs-glightbox>=0.5.2",
-        "mkdocs-include-markdown-plugin>=7.2.2",
+        "mkdocs-include-markdown-plugin>=7.3.0",
         "mkdocs-literate-nav>=0.6.3",
         "mkdocs-llmstxt>=0.5.0",
         "mkdocs-material[imaging]>=9.7.6",
@@ -100,7 +100,7 @@
         "freezegun>=1.5.5",
         "grpcio-testing>=1.80.0",
         "hdrhistogram>=0.10.3",
-        "hypothesis>=6.152.4",
+        "hypothesis>=6.152.8",
         "objgraph>=3.6",
         "psutil>=7.2.2",
         "pytest-asyncio>=1.3.0",

{digitalkin-1.0.0.dev6 → digitalkin-1.0.0.dev8}/src/digitalkin/__init__.py

@@ -10,24 +10,22 @@ from digitalkin.modules.archetype_module import ArchetypeModule
 from digitalkin.modules.tool_module import ToolModule
 from digitalkin.modules.trigger_handler import TriggerHandler
 from digitalkin.services.communication import (
-    ConsumerConfig,
-    GatewayConsumer,
-    GatewayConsumerError,
-    StartStreamRejected,
-    StartStreamRpcError,
+    GrpcCommunication,
+    M2MAtCapacityError,
+    M2MCallTimeout,
+    M2MTargetUnavailable,
 )
 from digitalkin.services.services_config import ServicesConfig
 
 __all__ = [
     "ArchetypeModule",
-    "ConsumerConfig",
-    "GatewayConsumer",
-    "GatewayConsumerError",
+    "GrpcCommunication",
+    "M2MAtCapacityError",
+    "M2MCallTimeout",
+    "M2MTargetUnavailable",
     "ModuleContext",
     "ModuleStatus",
     "ServicesConfig",
-    "StartStreamRejected",
-    "StartStreamRpcError",
     "ToolModule",
     "TriggerHandler",
     "__version__",

{digitalkin-1.0.0.dev6 → digitalkin-1.0.0.dev8}/src/digitalkin/__version__.py

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

{digitalkin-1.0.0.dev6 → digitalkin-1.0.0.dev8}/src/digitalkin/community/agno/__init__.py

@@ -24,10 +24,10 @@ from digitalkin.community.agno.hitl import (
     AgnoHitlRunner,
     PausedRunRecord,
     PausedRunStore,
-    PauseInfo,
     emit_awaiting_tool_result,
     emit_messages_snapshot,
 )
+from digitalkin.community.agno.models import PauseInfo
 
 __all__ = [
     "HITL_STORAGE_CONFIG",

{digitalkin-1.0.0.dev6 → digitalkin-1.0.0.dev8}/src/digitalkin/community/agno/agno_adapter.py

@@ -1,12 +1,4 @@
-"""Adapter to convert Agno events to DigitalKin framework-agnostic events.
-
-This adapter bridges Agno-specific events to the DigitalKin event model,
-allowing the core DigitalKin SDK to remain independent of Agno.
-
-The adapter owns ALL state management: tracking reasoning/content lifecycle,
-generating message_id and reasoning_id on each phase start, and emitting
-proper start/completed events for text message and reasoning sequences.
-"""
+"""Convert Agno streaming events into framework-agnostic DigitalKin events."""
 
 from __future__ import annotations
 
@@ -40,20 +32,10 @@ logger = logging.getLogger(__name__)
 
 
 class AgnoStreamAdapter:
-    """Stateful converter: Agno streaming events -> DigitalKin events.
-
-    Tracks reasoning and content state so that events arriving on
-    ``RunEvent.run_content`` are automatically wrapped in proper
-    lifecycle events (TextMessageStarted/Completed, ReasoningStarted/Completed).
+    """Stateful Agno→DigitalKin event converter.
 
-    Usage::
-
-        adapter = AgnoStreamAdapter()
-        async for raw_event in agent.arun(..., stream=True, stream_events=True):
-            for event in adapter.to_digitalkin_events(raw_event):
-                await send(event)
-        for event in adapter.flush():
-            await send(event)
+    Auto-wraps ``run_content`` deltas in TextMessage/Reasoning lifecycle
+    events and tracks HITL pause state.
     """
 
     def __init__(self) -> None:
@@ -69,9 +51,6 @@ class AgnoStreamAdapter:
         self._active_run_id: str | None = None
         self._completed_run_ids: set[str] = set()
 
-        # HITL pause state — populated when a RunPausedEvent is seen
-        # (tools with external_execution=True). Callers can inspect these
-        # after streaming to decide whether to persist and resume later.
         self._is_paused: bool = False
         self._paused_tool_executions: list[Any] = []
         self._paused_requirements: list[Any] = []
@@ -94,20 +73,20 @@ class AgnoStreamAdapter:
         return list(self._paused_requirements)
 
     def to_digitalkin_events(self, agno_event: Any) -> list[BaseAgentRunEvent]:
-        """Convert one Agno event into one or more DigitalKin events.
+        """Convert one Agno event into DigitalKin events.
 
         Args:
             agno_event: Event from Agno's streaming API.
 
         Returns:
-            List of corresponding DigitalKin events (may be empty).
+            List of DigitalKin events (may be empty).
 
         Raises:
             ImportError: If the optional 'agno' dependency is not installed.
         """
         if self._dispatch is None:
             try:
-                from agno.run.agent import RunEvent  # pylint: disable=C0415 # pyright: ignore[reportMissingImports]
+                from agno.run.agent import RunEvent  # pyright: ignore[reportMissingImports]
             except ImportError as exc:
                 message = "The 'agno' package is required to use AgnoStreamAdapter. Install it with: pip install agno"
                 raise ImportError(message) from exc
@@ -137,8 +116,6 @@ class AgnoStreamAdapter:
 
         return handler(agno_event, getattr(agno_event, "timestamp", None))
 
-    # ── Run Lifecycle Handlers ───────────────────────────────────────────
-
     def _handle_run_started(self, agno_event: Any, timestamp: Any) -> list[BaseAgentRunEvent]:
         """Handle RunEvent.run_started.
 
@@ -219,8 +196,6 @@ class AgnoStreamAdapter:
             )
         ]
 
-    # ── Reasoning Handlers (native Agno reasoning models) ───────────────
-
     def _handle_reasoning_started(self, agno_event: Any, timestamp: Any) -> list[BaseAgentRunEvent]:
         """Handle RunEvent.reasoning_started.
 
@@ -263,25 +238,11 @@ class AgnoStreamAdapter:
         ]
 
     def _handle_reasoning_step(self, agno_event: Any, timestamp: Any) -> list[BaseAgentRunEvent]:
-        """Handle ``RunEvent.reasoning_step`` — emitted by Agno's ``ReasoningTools``.
-
-        Unlike the native reasoning events (``reasoning_started`` /
-        ``reasoning_content_delta`` / ``reasoning_completed``), a
-        ``reasoning_step`` may arrive without a preceding
-        ``reasoning_started``. This happens when the LLM calls tool-based
-        reasoning (``think`` / ``analyze`` from ``ReasoningTools``) rather
-        than using the model's built-in extended thinking.
-
-        To comply with the AG-UI protocol — which requires every
-        ``REASONING_MESSAGE_CONTENT`` to be wrapped in a
-        ``REASONING_START`` … ``REASONING_END`` lifecycle — we auto-open
-        a reasoning sequence here if none is active. The sequence is
-        auto-closed by the next non-reasoning event (``_handle_run_content``,
-        ``_handle_tool_call_started``, etc.) or by ``flush()``.
+        """Handle ``reasoning_step``; auto-opens a reasoning sequence if needed.
 
         Returns:
-            List of events: optionally a ``ReasoningStartedEvent`` (if
-            auto-opened), followed by the ``ReasoningStepEvent``.
+            Optionally a ``ReasoningStartedEvent`` followed by the
+            ``ReasoningStepEvent``.
         """
         events: list[BaseAgentRunEvent] = []
 
@@ -289,11 +250,9 @@ class AgnoStreamAdapter:
         if not content:
             return events
 
-        # Close active text message if transitioning to reasoning
         if self._content_active:
             events.extend(self._close_content(timestamp))
 
-        # Auto-open reasoning lifecycle if not already active
         if not self._reasoning_active:
             self._current_reasoning_id = str(uuid.uuid4())
             self._reasoning_active = True
@@ -328,8 +287,6 @@ class AgnoStreamAdapter:
         logger.debug("Reasoning completed")
         return self._close_reasoning(timestamp)
 
-    # ── Tool Call Handlers ──────────────────────────────────────────────
-
     def _handle_tool_call_started(self, agno_event: Any, timestamp: Any) -> list[BaseAgentRunEvent]:
         """Handle RunEvent.tool_call_started.
 
@@ -395,33 +352,14 @@ class AgnoStreamAdapter:
         ]
 
     def _handle_run_paused(self, agno_event: Any, timestamp: Any) -> list[BaseAgentRunEvent]:
-        """Handle ``RunEvent.run_paused`` — HITL pause on external tool execution.
-
-        Agno does NOT emit ``tool_call_started`` / ``tool_call_completed`` for
-        tools declared with ``external_execution=True`` (see
-        ``agno/models/base.py`` where the emission is short-circuited). The
-        front therefore never sees the corresponding AG-UI ``ToolCallStart``
-        / ``ToolCallArgs`` / ``ToolCallEnd`` events unless we synthesize them.
-
-        This handler:
-
-        1. Closes any active reasoning / content sequence.
-        2. Iterates ``RunPausedEvent.tools`` and emits one pair of
-           ``ToolCallStartedEvent`` + ``ToolCallCompletedEvent`` per tool.
-           The ``ToolCallCompletedEvent`` carries ``content=None`` and
-           ``tool.result=None`` so the downstream AG-UI bridge emits
-           ``ToolCallEnd`` *without* a ``ToolCallResult`` (guarded by the
-           ``if result_content:`` check in ``AgUiMixin``).
-        3. Records pause state on the adapter (``is_paused``,
-           ``paused_tool_executions``, ``paused_requirements``) so callers
-           can detect the pause after streaming and persist the run for
-           later resumption.
+        """Handle ``run_paused``; synthesize tool-call events for external tools.
+
+        Agno suppresses tool_call_started/completed for tools with
+        ``external_execution=True``; we re-emit them so the front sees
+        the call.
 
         Returns:
-            Synthesized tool-call events for the paused tools. The caller
-            is responsible for subsequently emitting the AG-UI
-            ``RunFinished`` with ``result.status = "awaiting_tool_result"``
-            — this adapter stays protocol-agnostic.
+            Synthesized tool-call events for the paused external tools.
         """
         events: list[BaseAgentRunEvent] = []
 
@@ -437,11 +375,7 @@ class AgnoStreamAdapter:
         self._paused_tool_executions = list(tools)
         self._paused_requirements = list(requirements)
 
-        # RunPausedEvent.tools contains ALL tools from run_response.tools
-        # (both server-side tools already executed and external ones awaiting
-        # client execution). We must only synthesize events for external tools
-        # — the server-side ones (e.g. ReasoningTools' think/analyze) were
-        # already streamed via the normal tool_call_started/completed path.
+        # Only synthesize for external tools; server-side ones already streamed.
         seen_ids: set[str] = set()
         for tool_exec in tools:
             if not getattr(tool_exec, "external_execution_required", False):
@@ -530,8 +464,6 @@ class AgnoStreamAdapter:
             events.extend(self._close_reasoning(None))
         return events
 
-    # ── Private Helpers ──────────────────────────────────────────────────
-
     def _close_reasoning(self, timestamp: Any) -> list[BaseAgentRunEvent]:
         """Close active reasoning sequence.
 
@@ -575,32 +507,24 @@ class AgnoStreamAdapter:
         return events
 
     def _handle_run_content(self, agno_event: Any, timestamp: Any) -> list[BaseAgentRunEvent]:
-        """Handle RunEvent.run_content — the core state machine.
+        """Dispatch a ``run_content`` event between reasoning and text channels.
 
-        Rules:
-        - reasoning_content non-empty: reasoning data (close content if transitioning)
-        - content non-empty: text data (close reasoning if transitioning)
-        - reasoning_content == "": close reasoning if active
-        - content == "": close content if active
-        - None values: ignored
+        Non-empty content opens or extends its sequence; empty strings close it.
 
         Returns:
-            List of DigitalKin events for this run_content chunk.
+            DigitalKin events for this chunk.
         """
         events: list[BaseAgentRunEvent] = []
 
         reasoning_content = getattr(agno_event, "reasoning_content", None)
         content = agno_event.content
 
-        # ── Reasoning content handling ──
         if reasoning_content is not None:
             events.extend(self._process_reasoning_content(reasoning_content, timestamp))
 
-        # ── Text content handling ──
         if content is not None:
             events.extend(self._process_text_content(content, timestamp))
 
-        # Edge case: neither reasoning_content nor content
         if reasoning_content is None and content is None:
             logger.debug("run_content with no content, skipping")
 
@@ -615,17 +539,13 @@ class AgnoStreamAdapter:
         events: list[BaseAgentRunEvent] = []
 
         if not reasoning_content:
-            # Empty string "" → signal to close reasoning
             if self._reasoning_active:
                 events.extend(self._close_reasoning(timestamp))
             return events
 
-        # Non-empty string → reasoning data
-        # Close text message if transitioning from content to reasoning
         if self._content_active:
             events.extend(self._close_content(timestamp))
 
-        # Auto-open reasoning on first chunk
         if not self._reasoning_active:
             self._current_reasoning_id = str(uuid.uuid4())
             logger.debug("Reasoning auto-started, id=%s", self._current_reasoning_id)
@@ -659,18 +579,14 @@ class AgnoStreamAdapter:
         events: list[BaseAgentRunEvent] = []
 
         if not content:
-            # Empty string "" → signal to close text message
             if self._content_active:
                 events.extend(self._close_content(timestamp))
             return events
 
-        # Non-empty string → text data
-        # Close reasoning if transitioning from reasoning to content
         if self._reasoning_active:
             logger.debug("Reasoning auto-completed (text content arrived)")
             events.extend(self._close_reasoning(timestamp))
 
-        # Auto-open text message on first chunk
         if not self._content_active:
             self._current_message_id = str(uuid.uuid4())
             events.append(