digitalkin 0.4.1.dev2__tar.gz → 0.4.1.dev4__tar.gz

{digitalkin-0.4.1.dev2 → digitalkin-0.4.1.dev4}/PKG-INFO

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

{digitalkin-0.4.1.dev2 → digitalkin-0.4.1.dev4}/pyproject.toml

@@ -35,7 +35,7 @@
         "grpcio-status==1.78.0",
         "pydantic==2.12.5",
     ]
-    version = "0.4.1.dev2"
+    version = "0.4.1.dev4"
 
     [project.optional-dependencies]
         profiling = [

{digitalkin-0.4.1.dev2 → digitalkin-0.4.1.dev4}/src/digitalkin/__version__.py

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

{digitalkin-0.4.1.dev2 → digitalkin-0.4.1.dev4}/src/digitalkin/community/agno/agno_adapter.py

@@ -263,20 +263,60 @@ class AgnoStreamAdapter:
         ]
 
     def _handle_reasoning_step(self, agno_event: Any, timestamp: Any) -> list[BaseAgentRunEvent]:
-        """Handle RunEvent.reasoning_step.
+        """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()``.
 
         Returns:
-            List containing a ReasoningStepEvent.
+            List of events: optionally a ``ReasoningStartedEvent`` (if
+            auto-opened), followed by the ``ReasoningStepEvent``.
         """
-        return [
+        events: list[BaseAgentRunEvent] = []
+
+        content = getattr(agno_event, "reasoning_content", "")
+        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
+            logger.debug("Reasoning auto-started (from reasoning_step), id=%s", self._current_reasoning_id)
+            events.append(
+                ReasoningStartedEvent(
+                    event=AgentRunEvent.REASONING_STARTED,
+                    reasoning_id=self._current_reasoning_id,
+                    timestamp=timestamp,
+                    metadata=None,
+                )
+            )
+
+        events.append(
             ReasoningStepEvent(
                 event=AgentRunEvent.REASONING_STEP,
-                delta=getattr(agno_event, "reasoning_content", ""),
+                delta=content,
                 reasoning_id=self._current_reasoning_id,
                 timestamp=timestamp,
                 metadata=None,
             )
-        ]
+        )
+        return events
 
     def _handle_reasoning_completed(self, agno_event: Any, timestamp: Any) -> list[BaseAgentRunEvent]:
         """Handle RunEvent.reasoning_completed.
@@ -397,8 +437,19 @@ 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.
+        seen_ids: set[str] = set()
         for tool_exec in tools:
+            if not getattr(tool_exec, "external_execution_required", False):
+                continue
             tool_call_id = getattr(tool_exec, "tool_call_id", None)
+            if not tool_call_id or tool_call_id in seen_ids:
+                continue
+            seen_ids.add(tool_call_id)
             tool_info = ToolInfo(
                 tool_call_id=tool_call_id,
                 tool_name=getattr(tool_exec, "tool_name", None),
@@ -425,8 +476,7 @@ class AgnoStreamAdapter:
                     metadata=None,
                 ),
             ))
-            if tool_call_id:
-                self._closed_tool_call_ids.add(tool_call_id)
+            self._closed_tool_call_ids.add(tool_call_id)
 
         return events
 

{digitalkin-0.4.1.dev2 → digitalkin-0.4.1.dev4}/src/digitalkin/community/agno/hitl.py

@@ -184,11 +184,20 @@ class PausedRunStore:
         Returns:
             A :class:`PauseInfo` describing what was persisted.
         """
-        pending = [
-            req.tool_execution.tool_call_id
-            for req in (run_output.requirements or [])
-            if getattr(req, "needs_external_execution", False) and req.tool_execution is not None
-        ]
+        # Extract pending tool_call_ids from run_output.tools (not requirements).
+        # Agno's requirements list may be incomplete: it only appends a
+        # RunRequirement for the LAST tool in each paused batch
+        # (tool_executions_list[-1] in _response.py), so when N external tools
+        # pause in the same turn, only the last one gets a requirement.
+        # run_output.tools contains ALL tools (server-side + external), so we
+        # filter by external_execution_required and deduplicate.
+        seen: set[str] = set()
+        pending: list[str] = []
+        for tool in run_output.tools or []:
+            tid = getattr(tool, "tool_call_id", None)
+            if tid and tid not in seen and getattr(tool, "external_execution_required", False):
+                seen.add(tid)
+                pending.append(tid)
         record = PausedRunRecord(
             thread_id=thread_id,
             run_id=run_output.run_id or "",

{digitalkin-0.4.1.dev2 → digitalkin-0.4.1.dev4}/src/digitalkin.egg-info/PKG-INFO

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