digitalkin 1.0.3.dev0__tar.gz → 1.0.3.dev2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: digitalkin
-Version: 1.0.3.dev0
+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
@@ -453,7 +453,7 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: ag-ui-protocol==0.1.21.dev1787220377
-Requires-Dist: agentic-mesh-protocol==1.0.1.dev4
+Requires-Dist: agentic-mesh-protocol==1.0.1
 Requires-Dist: agno<3,>=2.8.0
 Requires-Dist: anyio>=4.13.0
 Requires-Dist: grpcio-health-checking==1.82.1

{digitalkin-1.0.3.dev0 → digitalkin-1.0.3.dev2}/pyproject.toml

@@ -31,7 +31,7 @@
         # which is how a nested run's output is attributed to its author. Pinned exactly
         # because it is a dated prerelease; move to >=0.1.21 once that ships stable.
         "ag-ui-protocol==0.1.21.dev1787220377",
-        "agentic-mesh-protocol==1.0.1.dev4",
+        "agentic-mesh-protocol==1.0.1",
         "agno>=2.8.0,<3",
         "anyio>=4.13.0",
         "grpcio-health-checking==1.82.1",
@@ -40,8 +40,8 @@
         "pydantic-settings>=2.14.1",
         "pydantic>=2.12.4",
         "redis[hiredis]>=7.4.0,<9",
-]
-version = "1.0.3.dev0"
+    ]
+    version = "1.0.3.dev2"
 
     [project.optional-dependencies]
         agno = [ "agno>=2.6" ]
@@ -61,22 +61,6 @@ version = "1.0.3.dev0"
         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",
@@ -116,6 +100,22 @@ version = "1.0.3.dev0"
         "mkdocstrings>=1.0.4",
         "tomli>=2.4.1",
     ]
+    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",
+    ]
 [tool.setuptools]
     package-dir = { "" = "src" }
 

{digitalkin-1.0.3.dev0 → 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.dev0"
+    __version__ = "1.0.3.dev2"

{digitalkin-1.0.3.dev0 → digitalkin-1.0.3.dev2}/src/digitalkin/community/agno/hitl.py

@@ -340,6 +340,40 @@ class AgnoHitlRunner:
         self._store = store
         self._dependency_key = dependency_key
         self._tool_loader = tool_loader
+        # Set while a continue is in flight, so _restore_tools can put the factory back.
+        self._tools_factory: Any = None
+
+    def _resolve_tools_for_continue(self, agui_tools: list[AgUiTool] | None) -> None:
+        """Hand Agno a concrete tool list for the ``acontinue_run`` about to be issued.
+
+        A Team's async ``acontinue_run`` never resolves a callable ``tools`` factory, so the
+        continued leader would run with an empty function map and every call — not just the
+        freshly loaded one — would come back as "the requested tool does not exist".
+
+        Args:
+            agui_tools: Frontend tools to merge in, exactly as the factory would.
+        """
+        from digitalkin.community.agno.agui_tools import AguiTools
+
+        factory = vars(self._agent).get("tools")
+        if not callable(factory) or isinstance(factory, list):
+            return
+        if self._tools_factory is None:
+            self._tools_factory = factory
+        self._agent.tools = [
+            *factory(None),
+            *[AguiTools.agui_tool_to_external_function(tool) for tool in agui_tools or []],
+        ]
+
+    def _restore_tools(self) -> None:
+        """Put the tools factory back after a continue, if one was swapped out.
+
+        The factory is the steady state: it merges each turn's AG-UI frontend tools on the
+        next run, so leaving the resolved list in place would freeze this turn's set.
+        """
+        if self._tools_factory is not None:
+            self._agent.tools = self._tools_factory
+            self._tools_factory = None
 
     @staticmethod
     def _find_loader(tools: Any) -> LoadManager | None:
@@ -675,66 +709,70 @@ class AgnoHitlRunner:
         """
         from digitalkin.community.agno.agno_adapter import AgnoStreamAdapter
 
-        for _ in range(20):
-            adapter = AgnoStreamAdapter()
-            final_run_output: RunOutput | None = None
-
-            async for raw_event in stream:
-                if isinstance(raw_event, run_output_cls):
-                    final_run_output = raw_event
-                    continue
-                for event in adapter.to_digitalkin_events(raw_event):
-                    await send(event)
+        try:
+            for _ in range(20):
+                adapter = AgnoStreamAdapter()
+                final_run_output: RunOutput | None = None
 
-            for event in adapter.flush():
-                await send(event)
+                async for raw_event in stream:
+                    if isinstance(raw_event, run_output_cls):
+                        final_run_output = raw_event
+                        continue
+                    for event in adapter.to_digitalkin_events(raw_event):
+                        await send(event)
 
-            if not (adapter.is_paused and final_run_output is not None and final_run_output.is_paused):
-                return None
+                for event in adapter.flush():
+                    await send(event)
 
-            # Resolve any load_manager calls in-process; if the pause has nothing left for the
-            # front, auto-continue so discover -> load -> use reads as a single turn.
-            if await self._load_paused_tools(final_run_output) and not self._pending_external(final_run_output):
-                # A load appended a ModuleToolkit to the live base_tools list. Agno caches the
-                # tools-factory output per run (``cache_callables`` defaults to True), so
-                # ``acontinue_run`` would re-resolve from the stale pre-load cache and the new tool
-                # would be missing from the model's function map — the LLM then gets "the requested
-                # tool does not exist" when it calls the just-loaded function. Invalidate the
-                # tools cache so the continue re-invokes the factory and registers the loaded tool.
-                from agno.utils.callables import aclear_callable_cache  # pyright: ignore[reportMissingImports]
-
-                await aclear_callable_cache(self._agent, kind="tools")
-                stream = self._agent.acontinue_run(
-                    run_response=final_run_output,
-                    stream=True,
-                    stream_events=True,
-                    yield_run_output=True,
-                    dependencies={self._dependency_key: agui_tools or []},
-                )
-                continue
+                if not (adapter.is_paused and final_run_output is not None and final_run_output.is_paused):
+                    return None
+
+                # Resolve any load_manager calls in-process; if the pause has nothing left for the
+                # front, auto-continue so discover -> load -> use reads as a single turn.
+                if await self._load_paused_tools(final_run_output) and not self._pending_external(final_run_output):
+                    # Agno caches the tools-factory output per run, so a continue would re-resolve
+                    # from the stale pre-load cache and miss the just-loaded tool. Invalidate it.
+                    from agno.utils.callables import aclear_callable_cache  # pyright: ignore[reportMissingImports]
+
+                    await aclear_callable_cache(self._agent, kind="tools")
+                    # ...and hand the continue a resolved list, because a Team never re-invokes the
+                    # factory on acontinue_run at all. See _resolve_tools_for_continue.
+                    self._resolve_tools_for_continue(agui_tools)
+                    stream = self._agent.acontinue_run(
+                        run_response=final_run_output,
+                        stream=True,
+                        stream_events=True,
+                        yield_run_output=True,
+                        dependencies={self._dependency_key: agui_tools or []},
+                    )
+                    continue
 
-            pause_info = await self._store.save(run_output=final_run_output, thread_id=thread_id)
-            # Attach AG-UI-shaped messages so the front can materialise the tool_call.
-            pause_info.new_messages = HitlEvents.agno_messages_to_agui(final_run_output.messages or [])
-            return pause_info
+                pause_info = await self._store.save(run_output=final_run_output, thread_id=thread_id)
+                # Attach AG-UI-shaped messages so the front can materialise the tool_call.
+                pause_info.new_messages = HitlEvents.agno_messages_to_agui(final_run_output.messages or [])
+                return pause_info
 
-        logger.warning("AgnoHitlRunner: auto-continue limit reached for thread_id=%s", thread_id)
-        from digitalkin.models.events import AgentRunEvent, RunErrorEvent
+            logger.warning("AgnoHitlRunner: auto-continue limit reached for thread_id=%s", thread_id)
+            from digitalkin.models.events import AgentRunEvent, RunErrorEvent
 
-        await send(
-            RunErrorEvent(
-                event=AgentRunEvent.RUN_ERROR,
-                error_type="auto_continue_limit",
-                content=(
-                    "The run was stopped after too many consecutive in-process tool "
-                    "loads (load_manager). Send a new message to continue."
-                ),
-                error_details=None,
-                timestamp=None,
-                metadata=None,
+            await send(
+                RunErrorEvent(
+                    event=AgentRunEvent.RUN_ERROR,
+                    error_type="auto_continue_limit",
+                    content=(
+                        "The run was stopped after too many consecutive in-process tool "
+                        "loads (load_manager). Send a new message to continue."
+                    ),
+                    error_details=None,
+                    timestamp=None,
+                    metadata=None,
+                )
             )
-        )
-        return None
+            return None
+        finally:
+            # The swapped-in list is only valid for the continues issued above; the factory is
+            # the steady state every later run resolves from.
+            self._restore_tools()
 
     async def _load_paused_tools(self, run_output: RunOutput) -> bool:
         """Resolve ``load_manager`` calls in a paused run, writing each tool result in place.
@@ -752,10 +790,40 @@ class AgnoHitlRunner:
         loader_tool = self._tool_loader.tool_name
         for tool in run_output.tools or []:
             if tool.external_execution_required and tool.result is None and tool.tool_name == loader_tool:
-                tool.result = await self._tool_loader.run_paused(tool.tool_args or {})
+                result = await self._tool_loader.run_paused(tool.tool_args or {})
+                tool.result = result
+                self._resolve_requirement(run_output, tool.tool_call_id, result)
                 handled = True
         return handled
 
+    @staticmethod
+    def _resolve_requirement(run_output: RunOutput, tool_call_id: str | None, result: str) -> None:
+        """Mark the paused run's requirement for ``tool_call_id`` as externally executed.
+
+        Agno gates ``acontinue_run`` on ``RunRequirement.is_resolved()``, never on
+        ``tools[].result``: ``needs_external_execution`` stays True until the requirement's own
+        ``external_execution_result`` is set. Writing only the tool result therefore leaves the
+        run "still paused" — the continue re-pauses immediately without a model call, the loaded
+        tool is never used, and the turn dead-ends on a pause with nothing left for the front to
+        resolve. The frontend resume path (:meth:`continue_paused_run`) already syncs
+        requirements; the in-process load path must do the same.
+
+        Args:
+            run_output: The paused Agno run whose requirements mirror ``run_output.tools``.
+            tool_call_id: The resolved tool call's id; ``None``/empty matches nothing.
+            result: The tool result to record on the requirement.
+        """
+        if not tool_call_id:
+            return
+        for requirement in run_output.requirements or []:
+            tool_execution = requirement.tool_execution
+            if (
+                tool_execution is not None
+                and tool_execution.tool_call_id == tool_call_id
+                and requirement.needs_external_execution
+            ):
+                requirement.set_external_execution_result(result)
+
     @staticmethod
     def _pending_external(run_output: RunOutput) -> bool:
         """Report whether any external tool in the paused run still needs a result.

{digitalkin-1.0.3.dev0 → digitalkin-1.0.3.dev2}/src/digitalkin/community/agno/toolkits/base.py

@@ -81,6 +81,33 @@ class DkToolkit(Toolkit):
         """
         return json.dumps({"error": error, "metadata": {"success": False, **metadata}}, ensure_ascii=False)
 
+    @staticmethod
+    def _nest_action(action: Any, fields: dict[str, Any]) -> Any:
+        """Normalise the three shapes a model sends a nested ``action`` object in.
+
+        The tool schema declares a single ``action`` property holding a discriminated union, but
+        models routinely flatten it — sending ``{"action": "search", "query": ""}`` instead of
+        ``{"action": {"action": "search", "query": ""}}`` — or serialise the inner object as a
+        JSON string. Both are the model reading a nested union schema the obvious way, not a
+        malformed call, so they are accepted rather than refused.
+
+        Args:
+            action: The ``action`` argument as received: the object, a JSON string of it, or the
+                bare discriminator when the model flattened the call.
+            fields: Any sibling keyword arguments, i.e. the flattened action's own fields.
+
+        Returns:
+            The payload to validate: a JSON string is passed through for ``validate_json``,
+            anything else comes back as a dict.
+        """
+        if isinstance(action, str):
+            # A JSON string is the inner object already; anything else is the bare discriminator,
+            # whose fields were flattened alongside it (empty when the action takes none).
+            return action if action.lstrip().startswith("{") else {"action": action, **fields}
+        if fields and isinstance(action, dict):
+            return {**action, **fields}
+        return fields if action is None and fields else action
+
     async def _notify(self, name: str, value: Any) -> None:
         """Emit an AG-UI custom event on the agent's output stream (best-effort).