digitalkin 0.3.5.dev9__tar.gz → 0.3.5.dev11__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: digitalkin
-Version: 0.3.5.dev9
+Version: 0.3.5.dev11
 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.5.dev9 → digitalkin-0.3.5.dev11}/pyproject.toml

@@ -35,7 +35,7 @@
         "grpcio-status==1.78.0",
         "pydantic==2.12.5",
 ]
-    version = "0.3.5.dev9"
+    version = "0.3.5.dev11"
 
     [project.optional-dependencies]
         profiling = [

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

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

{digitalkin-0.3.5.dev9 → digitalkin-0.3.5.dev11}/src/digitalkin/community/agno/agno_adapter.py

@@ -2,11 +2,16 @@
 
 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.
 """
 
 from __future__ import annotations
 
 import logging
+import uuid
 from typing import Any
 
 from digitalkin.models.events import (
@@ -20,6 +25,8 @@ from digitalkin.models.events import (
     RunContentEvent,
     RunErrorEvent,
     RunStartedEvent,
+    TextMessageCompletedEvent,
+    TextMessageStartedEvent,
     ToolCallCompletedEvent,
     ToolCallErrorEvent,
     ToolCallStartedEvent,
@@ -32,9 +39,9 @@ logger = logging.getLogger(__name__)
 class AgnoStreamAdapter:
     """Stateful converter: Agno streaming events -> DigitalKin events.
 
-    Tracks reasoning state so that ``reasoning_content`` arriving on
-    ``RunEvent.run_content`` events is automatically wrapped in proper
-    ReasoningStarted / ReasoningContentDelta / ReasoningCompleted 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).
 
     Usage::
 
@@ -47,14 +54,16 @@ class AgnoStreamAdapter:
     """
 
     def __init__(self) -> None:
-        """Initialize the AgnoStreamAdapter.
-
-        This adapter tracks reasoning state to properly handle reasoning_content
-        that arrives on RunEvent.run_content events.
-        """
+        """Initialize the AgnoStreamAdapter."""
         self._reasoning_active: bool = False
+        self._current_reasoning_id: str | None = None
+
+        self._content_active: bool = False
+        self._current_message_id: str | None = None
 
-    def to_digitalkin_events(self, agno_event: Any) -> list[BaseAgentRunEvent]:  # noqa: C901, PLR0911, PLR0912
+        self._closed_tool_call_ids: set[str] = set()
+
+    def to_digitalkin_events(self, agno_event: Any) -> list[BaseAgentRunEvent]:  # noqa: C901, PLR0911, PLR0912, PLR0915
         """Convert one Agno event into one or more DigitalKin events.
 
         Args:
@@ -73,10 +82,8 @@ class AgnoStreamAdapter:
             raise ImportError(message) from exc
 
         event_type = agno_event.event
-        event_types = getattr(agno_event, "events", None)
 
         logger.info("[DK STREAM-DEBUG => agno_adapter] Converting Agno event type: %s", event_type)
-        logger.info("[DK STREAM-DEBUG => agno_adapter event_types] Converting Agno event types: %s", event_types)
 
         timestamp = getattr(agno_event, "timestamp", None)
 
@@ -97,7 +104,15 @@ class AgnoStreamAdapter:
             return self._handle_run_content(agno_event, timestamp)
 
         if event_type == RunEvent.run_completed:
-            return [
+            events: list[BaseAgentRunEvent] = []
+
+            # Close any open sequences before completing the run
+            if self._content_active:
+                events.extend(self._close_content(timestamp))
+            if self._reasoning_active:
+                events.extend(self._close_reasoning(timestamp))
+
+            events.append(
                 RunCompletedEvent(
                     event=AgentRunEvent.RUN_COMPLETED,
                     run_id=getattr(agno_event, "run_id", None),
@@ -106,7 +121,8 @@ class AgnoStreamAdapter:
                     timestamp=timestamp,
                     metadata=None,
                 )
-            ]
+            )
+            return events
 
         if event_type == RunEvent.run_error:
             return [
@@ -123,15 +139,27 @@ class AgnoStreamAdapter:
         # ── Explicit Reasoning Events (native Agno reasoning models) ────
 
         if event_type == RunEvent.reasoning_started:
+            events = []
+
+            # Close content if active
+            if self._content_active:
+                events.extend(self._close_content(timestamp))
+
+            self._current_reasoning_id = str(uuid.uuid4())
             self._reasoning_active = True
-            logger.info("[DK STREAM-DEBUG => agno_adapter] Reasoning started (explicit)")
-            return [
+            logger.info(
+                "[DK STREAM-DEBUG => agno_adapter] Reasoning started (explicit), id=%s",
+                self._current_reasoning_id,
+            )
+            events.append(
                 ReasoningStartedEvent(
                     event=AgentRunEvent.REASONING_STARTED,
+                    reasoning_id=self._current_reasoning_id,
                     timestamp=timestamp,
                     metadata=None,
                 )
-            ]
+            )
+            return events
 
         if event_type == RunEvent.reasoning_content_delta:
             reasoning_content = getattr(agno_event, "reasoning_content", "")
@@ -139,6 +167,7 @@ class AgnoStreamAdapter:
                 ReasoningContentDeltaEvent(
                     event=AgentRunEvent.REASONING_CONTENT_DELTA,
                     delta=reasoning_content,
+                    reasoning_id=self._current_reasoning_id,
                     timestamp=timestamp,
                     metadata=None,
                 )
@@ -150,38 +179,27 @@ class AgnoStreamAdapter:
                 ReasoningStepEvent(
                     event=AgentRunEvent.REASONING_STEP,
                     delta=reasoning_content,
+                    reasoning_id=self._current_reasoning_id,
                     timestamp=timestamp,
                     metadata=None,
                 )
             ]
 
         if event_type == RunEvent.reasoning_completed:
-            self._reasoning_active = False
             logger.info("[DK STREAM-DEBUG => agno_adapter] Reasoning completed (explicit)")
-            return [
-                ReasoningCompletedEvent(
-                    event=AgentRunEvent.REASONING_COMPLETED,
-                    timestamp=timestamp,
-                    metadata=None,
-                )
-            ]
+            return self._close_reasoning(timestamp)
 
         # ── Tool Call Events ─────────────────────────────────────────────
 
         if event_type == RunEvent.tool_call_started:
-            events: list[BaseAgentRunEvent] = []
+            events = []
 
-            # Auto-close reasoning before tool calls
+            # Close both reasoning and content before tool calls
             if self._reasoning_active:
                 logger.info("[DK STREAM-DEBUG => agno_adapter] Reasoning auto-completed (tool call started)")
-                events.append(
-                    ReasoningCompletedEvent(
-                        event=AgentRunEvent.REASONING_COMPLETED,
-                        timestamp=timestamp,
-                        metadata=None,
-                    )
-                )
-                self._reasoning_active = False
+                events.extend(self._close_reasoning(timestamp))
+            if self._content_active:
+                events.extend(self._close_content(timestamp))
 
             tool = getattr(agno_event, "tool", None)
             tool_info = None
@@ -205,13 +223,20 @@ class AgnoStreamAdapter:
         if event_type == RunEvent.tool_call_completed:
             tool = getattr(agno_event, "tool", None)
             tool_info = None
+            tool_call_id = None
             if tool:
+                tool_call_id = getattr(tool, "tool_call_id", None)
                 tool_info = ToolInfo(
-                    tool_call_id=getattr(tool, "tool_call_id", None),
+                    tool_call_id=tool_call_id,
                     tool_name=getattr(tool, "tool_name", None),
                     tool_args=getattr(tool, "tool_args", None),
                     result=getattr(tool, "result", None),
                 )
+
+            # Track closed tool call to prevent duplicate end from ToolCallError
+            if tool_call_id:
+                self._closed_tool_call_ids.add(tool_call_id)
+
             return [
                 ToolCallCompletedEvent(
                     event=AgentRunEvent.TOOL_CALL_COMPLETED,
@@ -224,14 +249,28 @@ class AgnoStreamAdapter:
 
         if event_type == RunEvent.tool_call_error:
             tool = getattr(agno_event, "tool", None)
+            tool_call_id = getattr(tool, "tool_call_id", None) if tool else None
+
+            # Skip if already closed by ToolCallCompleted (Agno emits both for the same tool_call_id)
+            if tool_call_id and tool_call_id in self._closed_tool_call_ids:
+                logger.info(
+                    "[DK STREAM-DEBUG => agno_adapter] Skipping duplicate ToolCallError for already-closed tool %s",
+                    tool_call_id,
+                )
+                return []
+
             tool_info = None
             if tool:
                 tool_info = ToolInfo(
-                    tool_call_id=getattr(tool, "tool_call_id", None),
+                    tool_call_id=tool_call_id,
                     tool_name=getattr(tool, "tool_name", None),
                     tool_args=None,
                     result=None,
                 )
+
+            if tool_call_id:
+                self._closed_tool_call_ids.add(tool_call_id)
+
             return [
                 ToolCallErrorEvent(
                     event=AgentRunEvent.TOOL_CALL_ERROR,
@@ -247,99 +286,189 @@ class AgnoStreamAdapter:
         return []
 
     def flush(self) -> list[BaseAgentRunEvent]:
-        """Emit closing events if reasoning is still active at end of stream.
+        """Emit closing events for any active sequences at end of stream.
 
         Returns:
-            List of closing events (empty if no active reasoning).
+            List of closing events (empty if nothing is active).
         """
         events: list[BaseAgentRunEvent] = []
+        if self._content_active:
+            logger.info("[DK STREAM-DEBUG => agno_adapter] Flushing: closing active content")
+            events.extend(self._close_content(None))
         if self._reasoning_active:
             logger.info("[DK STREAM-DEBUG => agno_adapter] Flushing: closing active reasoning")
-            events.append(
-                ReasoningCompletedEvent(
-                    event=AgentRunEvent.REASONING_COMPLETED,
-                    timestamp=None,
-                    metadata=None,
-                )
-            )
-            self._reasoning_active = False
+            events.extend(self._close_reasoning(None))
         return events
 
     # ── Private Helpers ──────────────────────────────────────────────────
 
-    def _handle_run_content(self, agno_event: Any, timestamp: Any) -> list[BaseAgentRunEvent]:
-        """Handle RunEvent.run_content with reasoning_content awareness.
+    def _close_reasoning(self, timestamp: Any) -> list[BaseAgentRunEvent]:
+        """Close active reasoning sequence.
 
-        When reasoning_content is present on a run_content event (native model
-        reasoning via LiteLLM/proxy), this method emits proper reasoning
-        lifecycle events instead of plain RunContentEvent.
+        Returns:
+            List of closing events (empty if reasoning is not active).
+        """
+        if not self._reasoning_active:
+            return []
+
+        events: list[BaseAgentRunEvent] = [
+            ReasoningCompletedEvent(
+                event=AgentRunEvent.REASONING_COMPLETED,
+                reasoning_id=self._current_reasoning_id,
+                timestamp=timestamp,
+                metadata=None,
+            )
+        ]
+        self._reasoning_active = False
+        self._current_reasoning_id = None
+        return events
 
-        Args:
-            agno_event: The Agno run_content event.
-            timestamp: The timestamp for the event.
+    def _close_content(self, timestamp: Any) -> list[BaseAgentRunEvent]:
+        """Close active text message sequence.
 
         Returns:
-            List of DigitalKin events (reasoning events or run content event).
+            List of closing events (empty if content is not active).
+        """
+        if not self._content_active:
+            return []
+
+        events: list[BaseAgentRunEvent] = [
+            TextMessageCompletedEvent(
+                event=AgentRunEvent.TEXT_MESSAGE_COMPLETED,
+                message_id=self._current_message_id or "",
+                timestamp=timestamp,
+                metadata=None,
+            )
+        ]
+        self._content_active = False
+        self._current_message_id = None
+        return events
+
+    def _handle_run_content(self, agno_event: Any, timestamp: Any) -> list[BaseAgentRunEvent]:
+        """Handle RunEvent.run_content — the core state machine.
+
+        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
+
+        Returns:
+            List of DigitalKin events for this run_content chunk.
         """
         events: list[BaseAgentRunEvent] = []
 
         reasoning_content = getattr(agno_event, "reasoning_content", None)
         content = agno_event.content
 
-        # ── Reasoning content present ────────────────────────────────
-        if reasoning_content:
-            # Auto-open reasoning sequence on first reasoning chunk
-            if not self._reasoning_active:
-                logger.info("[DK STREAM-DEBUG => agno_adapter] Reasoning auto-started from run_content")
-                events.append(
-                    ReasoningStartedEvent(
-                        event=AgentRunEvent.REASONING_STARTED,
-                        timestamp=timestamp,
-                        metadata=None,
-                    )
-                )
-                self._reasoning_active = True
+        # ── 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("[DK STREAM-DEBUG => agno_adapter] run_content with no content, skipping")
+
+        return events
+
+    def _process_reasoning_content(self, reasoning_content: str, timestamp: Any) -> list[BaseAgentRunEvent]:
+        """Process reasoning_content from a run_content event.
+
+        Returns:
+            List of reasoning lifecycle and content events.
+        """
+        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.info(
-                "[DK STREAM-DEBUG => agno_adapter] Reasoning content delta (len=%d)",
-                len(reasoning_content),
+                "[DK STREAM-DEBUG => agno_adapter] Reasoning auto-started from run_content, id=%s",
+                self._current_reasoning_id,
             )
             events.append(
-                ReasoningContentDeltaEvent(
-                    event=AgentRunEvent.REASONING_CONTENT_DELTA,
-                    delta=reasoning_content,
+                ReasoningStartedEvent(
+                    event=AgentRunEvent.REASONING_STARTED,
+                    reasoning_id=self._current_reasoning_id,
                     timestamp=timestamp,
                     metadata=None,
                 )
             )
+            self._reasoning_active = True
+
+        logger.info(
+            "[DK STREAM-DEBUG => agno_adapter] Reasoning content delta (len=%d)",
+            len(reasoning_content),
+        )
+        events.append(
+            ReasoningContentDeltaEvent(
+                event=AgentRunEvent.REASONING_CONTENT_DELTA,
+                delta=reasoning_content,
+                reasoning_id=self._current_reasoning_id,
+                timestamp=timestamp,
+                metadata=None,
+            )
+        )
+        return events
 
-        # ── Text content present ─────────────────────────────────────
-        if content:
-            # Auto-close reasoning when text content starts
-            if self._reasoning_active:
-                logger.info("[DK STREAM-DEBUG => agno_adapter] Reasoning auto-completed (text content arrived)")
-                events.append(
-                    ReasoningCompletedEvent(
-                        event=AgentRunEvent.REASONING_COMPLETED,
-                        timestamp=timestamp,
-                        metadata=None,
-                    )
-                )
-                self._reasoning_active = False
+    def _process_text_content(self, content: str, timestamp: Any) -> list[BaseAgentRunEvent]:
+        """Process text content from a run_content event.
+
+        Returns:
+            List of text message lifecycle and content events.
+        """
+        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.info("[DK STREAM-DEBUG => agno_adapter] 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(
-                RunContentEvent(
-                    event=AgentRunEvent.RUN_CONTENT,
-                    content=str(content),
-                    reasoning_content=None,
-                    content_type=None,
+                TextMessageStartedEvent(
+                    event=AgentRunEvent.TEXT_MESSAGE_STARTED,
+                    message_id=self._current_message_id,
                     timestamp=timestamp,
                     metadata=None,
                 )
             )
-
-        # Edge case: neither reasoning_content nor content
-        if not reasoning_content and not content:
-            logger.debug("[DK STREAM-DEBUG => agno_adapter] run_content with no content, skipping")
-
+            self._content_active = True
+
+        events.append(
+            RunContentEvent(
+                event=AgentRunEvent.RUN_CONTENT,
+                content=str(content),
+                message_id=self._current_message_id,
+                reasoning_content=None,
+                content_type=None,
+                timestamp=timestamp,
+                metadata=None,
+            )
+        )
         return events