digitalkin 1.0.5.dev3__tar.gz → 1.0.5.dev5__tar.gz

{digitalkin-1.0.5.dev3 → digitalkin-1.0.5.dev5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: digitalkin
-Version: 1.0.5.dev3
+Version: 1.0.5.dev5
 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.2
+Requires-Dist: agentic-mesh-protocol==1.2.0
 Requires-Dist: agno<3,>=2.8.0
 Requires-Dist: anyio>=4.13.0
 Requires-Dist: grpcio-health-checking==1.82.1

{digitalkin-1.0.5.dev3 → digitalkin-1.0.5.dev5}/examples/redis_demo/client.py

@@ -2,11 +2,10 @@
 """Demo client for the Gateway gRPC service with per-endpoint testing.
 
 Subcommands:
-    full      Full pipeline: StartStream → ConsumeStream → SendSignal
+    full      Full pipeline: StartStream → Stream → SendSignal
     start     StartStream only (unary)
-    consume   ConsumeStream on existing task (requires --task-id)
-    produce   StartStream + ProduceStream (act as Module A)
-    signal    SendSignal on existing task (requires --task-id)
+    consume   Stream on existing task (requires --task-id)
+    signal    SendSignal(cancel) on existing task (requires --task-id)
     inspect   Dump Redis keys for a task (no gRPC)
 
 Usage:
@@ -14,8 +13,7 @@ Usage:
     python client.py full --prompt "Test" --setup '{"uppercase": true, "repeat": 5}'
     python client.py start --prompt "Hello"
     python client.py consume --task-id <uuid>
-    python client.py produce --task-id <uuid> --chunks 3
-    python client.py signal --task-id <uuid> --action cancel
+    python client.py signal --task-id <uuid>
     python client.py inspect --task-id <uuid>
 """
 
@@ -34,7 +32,7 @@ import grpc
 import redis.asyncio as aioredis
 from google.protobuf import json_format, struct_pb2
 
-from agentic_mesh_protocol.gateway.v1 import gateway_pb2, gateway_service_pb2_grpc
+from agentic_mesh_protocol.gateway.v1 import gateway_dto_pb2, gateway_messages_pb2, gateway_service_pb2_grpc
 
 # ── ANSI colors ─────────────────────────────────────────────────────
 
@@ -291,29 +289,18 @@ def _print_diff_report(tracker: RedisTracker, task_id: str) -> None:
 async def cmd_start(
     stub: gateway_service_pb2_grpc.GatewayServiceStub,
     task_id: str,
-    prompt: str,
-    setup: dict[str, Any] | None,
 ) -> bool:
     """StartStream — create a task session.
 
     Returns:
         True if accepted.
     """
-    input_struct = struct_pb2.Struct()
-    payload: dict[str, Any] = {
-        "root": {"protocol": "message", "text": prompt},
-    }
-    if setup:
-        payload["setup"] = setup
-    input_struct.update(payload)
-
     t0 = time.monotonic()
     resp = await stub.StartStream(
-        gateway_pb2.StartStreamRequest(
+        gateway_dto_pb2.StartStreamRequest(
             task_id=task_id,
-            input=input_struct,
-            setup_id="demo-setup",
-            mission_id="demo-mission",
+            setup_id="setups:demo",
+            mission_id="missions:demo",
         ),
     )
     elapsed = (time.monotonic() - t0) * 1000
@@ -327,112 +314,58 @@ async def cmd_start(
 async def cmd_consume(
     stub: gateway_service_pb2_grpc.GatewayServiceStub,
     task_id: str,
+        prompt: str,
+        setup: dict[str, Any] | None,
     verbose: bool,
 ) -> list[dict[str, Any]]:
-    """ConsumeStream — read module output from Redis.
+    """Stream — send the query, then read module output until ``stream.end``.
 
     Returns:
         List of received items.
     """
     received: list[dict[str, Any]] = []
+    query: dict[str, Any] = {"root": {"protocol": "message", "text": prompt}}
+    if setup:
+        query["setup"] = setup
+    query_struct = struct_pb2.Struct()
+    query_struct.update(query)
 
     async def _requests() -> AsyncGenerator:
-        yield gateway_pb2.ConsumeStreamRequest(
-            init=gateway_pb2.ConsumeStreamInit(task_id=task_id, from_seq=0),
-        )
+        yield gateway_messages_pb2.StreamRequest(task_id=task_id, from_seq=0, data=query_struct)
 
     t0 = time.monotonic()
-    resp_stream = stub.ConsumeStream(_requests())
-    async for resp in resp_stream:
-        elapsed = (time.monotonic() - t0) * 1000
-        payload_type = resp.WhichOneof("payload")
-
-        if payload_type == "output":
-            data_dict = json_format.MessageToDict(resp.output.data)
-            text = data_dict.get("root", {}).get("text", data_dict.get("root", {}).get("protocol", ""))
-            received.append({"seq": resp.output.seq, "text": text})
-            print(f"  {GREEN}seq={resp.output.seq:>2}{RESET}  {text}")  # noqa: T201
-            if verbose:
-                print(f"         {DIM}{json.dumps(data_dict, ensure_ascii=False)}{RESET}")  # noqa: T201
-
-        elif payload_type == "status":
-            state_name = gateway_pb2.StreamState.Name(resp.status.state)
-            received.append({"status": state_name})
-            color = GREEN if "COMPLETED" in state_name else YELLOW
-            print(f"  {color}status: {state_name}{RESET}  ({elapsed:.1f}ms total)")  # noqa: T201
-            break
-
-        elif payload_type == "error":
-            received.append({"error": resp.error.message})
-            print(f"  {RED}error: code={resp.error.code} msg={resp.error.message}{RESET}")  # noqa: T201
+    async for resp in stub.Stream(_requests()):
+        root = json_format.MessageToDict(resp.data).get("root", {})
+        protocol = root.get("protocol", "")
+        if protocol == "stream.error":
+            received.append({"seq": resp.seq, "error": root.get("message", "")})
+            print(f"  {RED}error: code={root.get('code')} msg={root.get('message')}{RESET}")  # noqa: T201
+            continue
+        if protocol == "stream.end":
+            received.append({"seq": resp.seq, "status": "stream.end"})
+            print(f"  {GREEN}stream.end{RESET}  ({(time.monotonic() - t0) * 1000:.1f}ms total)")  # noqa: T201
             break
-
-        elif payload_type == "heartbeat":
-            if verbose:
-                print(f"  {DIM}heartbeat{RESET}")  # noqa: T201
+        text = root.get("text", protocol)
+        received.append({"seq": resp.seq, "text": text})
+        print(f"  {GREEN}seq={resp.seq:>2}{RESET}  {text}")  # noqa: T201
+        if verbose:
+            print(f"         {DIM}{json.dumps(root, ensure_ascii=False)}{RESET}")  # noqa: T201
 
     return received
 
 
-async def cmd_produce(
-    stub: gateway_service_pb2_grpc.GatewayServiceStub,
-    task_id: str,
-    prompt: str,
-    num_chunks: int,
-) -> int:
-    """ProduceStream — act as Module A, push output chunks.
-
-    Returns:
-        Number of server responses.
-    """
-    async def _requests() -> AsyncGenerator:
-        yield gateway_pb2.ProduceStreamRequest(
-            init=gateway_pb2.ProduceStreamInit(task_id=task_id),
-        )
-        for i in range(num_chunks):
-            data = struct_pb2.Struct()
-            data.update({
-                "root": {
-                    "protocol": "message",
-                    "text": f"[{i + 1}/{num_chunks}] {prompt}",
-                },
-            })
-            yield gateway_pb2.ProduceStreamRequest(
-                output=gateway_pb2.ProduceStreamOutput(task_id=task_id, data=data),
-            )
-            await asyncio.sleep(0.05)
-
-    t0 = time.monotonic()
-    resp_stream = stub.ProduceStream(_requests())
-    count = 0
-    async for resp in resp_stream:
-        count += 1
-        payload = resp.WhichOneof("payload")
-        print(f"  response #{count}: {payload}")  # noqa: T201
-
-    elapsed = (time.monotonic() - t0) * 1000
-    print(f"  {DIM}stream closed ({count} responses, {elapsed:.1f}ms){RESET}")  # noqa: T201
-    return count
-
-
 async def cmd_signal(
     stub: gateway_service_pb2_grpc.GatewayServiceStub,
     task_id: str,
-    action: str,
 ) -> bool:
-    """SendSignal — send a control signal.
+    """SendSignal — cancel a running task.
 
     Returns:
         True if accepted.
     """
-    action_enum = (
-        gateway_pb2.SIGNAL_ACTION_CANCEL if action == "cancel"
-        else gateway_pb2.SIGNAL_ACTION_PAUSE
-    )
-
     t0 = time.monotonic()
     resp = await stub.SendSignal(
-        gateway_pb2.ClientSignalRequest(task_id=task_id, action=action_enum),
+        gateway_dto_pb2.SendSignalRequest(cancel=gateway_messages_pb2.CancelSignal(task_id=task_id)),
     )
     elapsed = (time.monotonic() - t0) * 1000
 
@@ -447,7 +380,7 @@ async def cmd_signal(
 
 
 async def run_full(args: argparse.Namespace) -> None:
-    """Full pipeline: StartStream → ConsumeStream → SendSignal."""
+    """Full pipeline: StartStream → Stream → SendSignal."""
     task_id = args.task_id or str(uuid.uuid4())
     setup = json.loads(args.setup) if args.setup else None
     tracker = RedisTracker(args.redis) if args.verbose else None
@@ -467,7 +400,7 @@ async def run_full(args: argparse.Namespace) -> None:
 
             # 1. StartStream
             print(f"\n{BOLD}[1] StartStream{RESET}")  # noqa: T201
-            accepted = await cmd_start(stub, task_id, args.prompt, setup)
+            accepted = await cmd_start(stub, task_id)
             if not accepted:
                 print(f"  {RED}Server rejected the task — aborting.{RESET}")  # noqa: T201
                 return
@@ -476,18 +409,17 @@ async def run_full(args: argparse.Namespace) -> None:
                 await asyncio.sleep(0.1)
                 await tracker.snapshot("StartStream", task_id)
 
-            # 2. ConsumeStream — wait for module output
-            print(f"\n{BOLD}[2] ConsumeStream{RESET}")  # noqa: T201
-            await asyncio.sleep(0.2)  # let module start
-            received = await cmd_consume(stub, task_id, args.verbose)
+            # 2. Stream — send the query, read module output
+            print(f"\n{BOLD}[2] Stream{RESET}")  # noqa: T201
+            received = await cmd_consume(stub, task_id, args.prompt, setup, args.verbose)
 
             if tracker:
                 await asyncio.sleep(0.1)
-                await tracker.snapshot("ConsumeStream", task_id)
+                await tracker.snapshot("Stream", task_id)
 
             # 3. SendSignal
             print(f"\n{BOLD}[3] SendSignal (cancel){RESET}")  # noqa: T201
-            await cmd_signal(stub, task_id, "cancel")
+            await cmd_signal(stub, task_id)
 
             if tracker:
                 await asyncio.sleep(0.1)
@@ -513,61 +445,39 @@ async def run_full(args: argparse.Namespace) -> None:
 async def run_start(args: argparse.Namespace) -> None:
     """StartStream only."""
     task_id = args.task_id or str(uuid.uuid4())
-    setup = json.loads(args.setup) if args.setup else None
 
     print(f"\n{BOLD}[StartStream]{RESET}  gateway={args.gateway}  task_id={task_id}")  # noqa: T201
 
     async with grpc.aio.insecure_channel(args.gateway, options=GRPC_OPTIONS) as channel:
         stub = gateway_service_pb2_grpc.GatewayServiceStub(channel)
-        await cmd_start(stub, task_id, args.prompt, setup)
+        await cmd_start(stub, task_id)
 
 
 async def run_consume(args: argparse.Namespace) -> None:
-    """ConsumeStream on existing task."""
+    """Stream on existing task."""
     if not args.task_id:
         print(f"{RED}--task-id is required for consume{RESET}")  # noqa: T201
         sys.exit(1)
 
-    print(f"\n{BOLD}[ConsumeStream]{RESET}  gateway={args.gateway}  task_id={args.task_id}")  # noqa: T201
-
-    async with grpc.aio.insecure_channel(args.gateway, options=GRPC_OPTIONS) as channel:
-        stub = gateway_service_pb2_grpc.GatewayServiceStub(channel)
-        await cmd_consume(stub, args.task_id, args.verbose)
-
-
-async def run_produce(args: argparse.Namespace) -> None:
-    """StartStream + ProduceStream (act as Module A)."""
-    task_id = args.task_id or str(uuid.uuid4())
     setup = json.loads(args.setup) if args.setup else None
-
-    print(f"\n{BOLD}[Produce]{RESET}  gateway={args.gateway}  task_id={task_id}")  # noqa: T201
+    print(f"\n{BOLD}[Stream]{RESET}  gateway={args.gateway}  task_id={args.task_id}")  # noqa: T201
 
     async with grpc.aio.insecure_channel(args.gateway, options=GRPC_OPTIONS) as channel:
         stub = gateway_service_pb2_grpc.GatewayServiceStub(channel)
-
-        # StartStream first (registers the session)
-        print(f"\n  {BOLD}StartStream{RESET}")  # noqa: T201
-        accepted = await cmd_start(stub, task_id, args.prompt, setup)
-        if not accepted:
-            print(f"  {RED}Rejected{RESET}")  # noqa: T201
-            return
-
-        # ProduceStream (act as Module A)
-        print(f"\n  {BOLD}ProduceStream ({args.chunks} chunks){RESET}")  # noqa: T201
-        await cmd_produce(stub, task_id, args.prompt, args.chunks)
+        await cmd_consume(stub, args.task_id, args.prompt, setup, args.verbose)
 
 
 async def run_signal(args: argparse.Namespace) -> None:
-    """SendSignal on existing task."""
+    """SendSignal(cancel) on existing task."""
     if not args.task_id:
         print(f"{RED}--task-id is required for signal{RESET}")  # noqa: T201
         sys.exit(1)
 
-    print(f"\n{BOLD}[SendSignal]{RESET}  gateway={args.gateway}  task_id={args.task_id}  action={args.action}")  # noqa: T201
+    print(f"\n{BOLD}[SendSignal]{RESET}  gateway={args.gateway}  task_id={args.task_id}  signal=cancel")  # noqa: T201
 
     async with grpc.aio.insecure_channel(args.gateway, options=GRPC_OPTIONS) as channel:
         stub = gateway_service_pb2_grpc.GatewayServiceStub(channel)
-        await cmd_signal(stub, args.task_id, args.action)
+        await cmd_signal(stub, args.task_id)
 
 
 async def run_inspect(args: argparse.Namespace) -> None:
@@ -613,8 +523,7 @@ examples:
   %(prog)s full --prompt "Test" --setup '{"uppercase": true, "repeat": 5}'
   %(prog)s start --prompt "Hello"
   %(prog)s consume --task-id <uuid>
-  %(prog)s produce --chunks 5 --prompt "Manual"
-  %(prog)s signal --task-id <uuid> --action cancel
+  %(prog)s signal --task-id <uuid>
   %(prog)s inspect --task-id <uuid>
 """,
     )
@@ -631,21 +540,16 @@ examples:
     sub = p.add_subparsers(dest="command", help="Endpoint to test")
 
     # full (default)
-    sub.add_parser("full", help="Full pipeline: StartStream -> ConsumeStream -> SendSignal")
+    sub.add_parser("full", help="Full pipeline: StartStream -> Stream -> SendSignal")
 
     # start
     sub.add_parser("start", help="StartStream only (unary)")
 
     # consume
-    sub.add_parser("consume", help="ConsumeStream on existing task (requires --task-id)")
-
-    # produce
-    sp_produce = sub.add_parser("produce", help="StartStream + ProduceStream (act as Module A)")
-    sp_produce.add_argument("--chunks", type=int, default=3, help="Number of chunks to produce (default: 3)")
+    sub.add_parser("consume", help="Stream on existing task (requires --task-id)")
 
     # signal
-    sp_signal = sub.add_parser("signal", help="SendSignal on existing task (requires --task-id)")
-    sp_signal.add_argument("--action", choices=["cancel", "pause"], default="cancel", help="Signal action (default: cancel)")
+    sub.add_parser("signal", help="SendSignal(cancel) on existing task (requires --task-id)")
 
     # inspect
     sub.add_parser("inspect", help="Dump Redis keys for a task (no gRPC)")
@@ -662,17 +566,10 @@ async def main() -> None:
     if not args.command:
         args.command = "full"
 
-    # Set defaults for subcommand-specific args
-    if not hasattr(args, "chunks"):
-        args.chunks = 3
-    if not hasattr(args, "action"):
-        args.action = "cancel"
-
     handlers = {
         "full": run_full,
         "start": run_start,
         "consume": run_consume,
-        "produce": run_produce,
         "signal": run_signal,
         "inspect": run_inspect,
     }

{digitalkin-1.0.5.dev3 → digitalkin-1.0.5.dev5}/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.2",
+        "agentic-mesh-protocol==1.2.0",
         "agno>=2.8.0,<3",
         "anyio>=4.13.0",
         "grpcio-health-checking==1.82.1",
@@ -41,7 +41,7 @@
         "pydantic>=2.12.4",
         "redis[hiredis]>=7.4.0,<9",
     ]
-    version = "1.0.5.dev3"
+version = "1.0.5.dev5"
 
     [project.optional-dependencies]
         agno = [ "agno>=2.6" ]

{digitalkin-1.0.5.dev3 → digitalkin-1.0.5.dev5}/src/digitalkin/__version__.py

@@ -5,4 +5,4 @@ from importlib.metadata import PackageNotFoundError, version
 try:
     __version__ = version("digitalkin")
 except PackageNotFoundError:
-    __version__ = "1.0.5.dev3"
+    __version__ = "1.0.5.dev5"

{digitalkin-1.0.5.dev3 → digitalkin-1.0.5.dev5}/src/digitalkin/community/agno/agno_adapter.py

@@ -676,6 +676,26 @@ class AgnoStreamAdapter:
             self._closed_tool_call_ids.add(tool_call_id)
 
         content = agno_event.content
+        if tool is not None and tool.tool_call_error:
+            # Agno flags a raised tool on the completed event, then sends a tool_call_error
+            # that the closed-id check drops — so the failure is surfaced here.
+            # TODO(validate): AGUI-TOOL-FAILED-STATUS a raised tool surfaces as ToolCallError, not success
+            logger.info(
+                "[VALIDATE AGUI-TOOL-FAILED-STATUS] tool %s (id=%s) failed: %s",
+                tool.tool_name,
+                tool_call_id,
+                tool.result,
+            )
+            return [
+                ToolCallErrorEvent(
+                    event=AgentRunEvent.TOOL_CALL_ERROR,
+                    tool=tool_info,
+                    error_message=str(tool.result) if tool.result else None,
+                    subagent_run_id=self._subagent_of(self._run_key),
+                    timestamp=timestamp,
+                    metadata=self._last_metadata,
+                )
+            ]
         return [
             ToolCallCompletedEvent(
                 event=AgentRunEvent.TOOL_CALL_COMPLETED,

{digitalkin-1.0.5.dev3 → digitalkin-1.0.5.dev5}/src/digitalkin/community/agno/hitl.py

@@ -11,6 +11,7 @@ import json
 import logging
 from typing import TYPE_CHECKING, Any, ClassVar
 
+from ag_ui.core.events import Interrupt, RunFinishedInterruptOutcome
 from pydantic import BaseModel, ConfigDict, Field
 
 from digitalkin.community.agno.models import PauseInfo
@@ -268,13 +269,14 @@ class HitlEvents:
         run_id: str,
         pending_tool_call_ids: list[str],
     ) -> None:
-        """Emit an AG-UI ``RunFinished`` with ``status="awaiting_tool_result"``.
+        """Emit an AG-UI ``RunFinished`` with an interrupt outcome.
 
         This is the protocol signal telling the front "the run paused on a
-        client-side tool; execute it and reply with a ``ToolMessage``". It
-        goes out via ``context.callbacks.send_message`` (bypassing the
-        standard :class:`~digitalkin.mixins.agui_mixin.AgUiMixin` event
-        mapping, which has no notion of an "awaiting" status).
+        client-side tool; execute it and reply with a ``ToolMessage``". The
+        standard ``outcome={type: "interrupt"}`` carries one interrupt per pending
+        tool; the legacy ``result.status="awaiting_tool_result"`` is kept for
+        existing clients. When an AG-UI run is open, its state first moves the
+        tools to ``awaiting_input`` and the run to ``interrupted``.
 
         Args:
             context: Current module context.
@@ -291,11 +293,31 @@ class HitlEvents:
             AgUiRunFinishedOutput,
         )
 
+        run = context.agui_run
+        tools = run.state["tools"] if run is not None else {}
+        interrupts = [
+            Interrupt(
+                id=tool_call_id,
+                reason="tool_call",
+                tool_call_id=tool_call_id,
+                message=f"Waiting for the result of {tools.get(tool_call_id, {}).get('name') or 'a frontend tool'}",
+            )
+            for tool_call_id in pending_tool_call_ids
+        ]
+        if run is not None and run.open:
+            run.open = False
+            await run.update(
+                context,
+                *((("tools", tid, "status"), "awaiting_input") for tid in pending_tool_call_ids if tid in tools),
+                (("interrupts",), [i.model_dump(mode="json", by_alias=True, exclude_none=True) for i in interrupts]),
+                (("run", "status"), "interrupted"),
+            )
         output = AgUiOutput(
             root=AgUiRunFinishedOutput(
                 event=AgUiRunFinishedEvent(
                     thread_id=thread_id,
                     run_id=run_id,
+                    outcome=RunFinishedInterruptOutcome(interrupts=interrupts) if interrupts else None,
                     result={
                         "status": _AWAITING_STATUS,
                         "pending_tool_call_ids": pending_tool_call_ids,

{digitalkin-1.0.5.dev3 → digitalkin-1.0.5.dev5}/src/digitalkin/community/agno/module_toolkit.py

@@ -25,6 +25,7 @@ from digitalkin.logger import logger
 from digitalkin.models.module import ModuleContext
 from digitalkin.models.module.ag_ui import AgUiCustomEventOutput, AgUiOutput
 from digitalkin.models.module.tool_cache import ToolDefinition, ToolModuleInfo
+from digitalkin.services.communication.exceptions import ToolCallError
 
 # Default timeout for tool calls in seconds
 DEFAULT_TOOL_TIMEOUT_SECONDS = 300
@@ -265,7 +266,14 @@ class ModuleToolkit(DkToolkit):
         # callbacks is a dict-driven SimpleNamespace (module_context.py:168);
         # send_message may legitimately be absent outside a running job.
         send_message = vars(context.callbacks).get("send_message")
+        value = event.get("value")
+        url = value.get("url") if isinstance(value, dict) else None
         if send_message is None:
+            logger.warning(
+                "Dropped custom event '%s' url=%s: no send_message on the agent context",
+                event["name"],
+                url,
+            )
             return
 
         try:
@@ -275,10 +283,15 @@ class ModuleToolkit(DkToolkit):
             await send_message(
                 AgUiOutput(
                     root=AgUiCustomEventOutput(
-                        event=AgUiCustomEvent(name=event["name"], value=event.get("value")),
+                        event=AgUiCustomEvent(name=event["name"], value=value),
                     )
                 )
             )
+            logger.info(
+                "Relayed custom event '%s' url=%s to the agent stream",
+                event["name"],
+                url,
+            )
         except Exception:
             logger.exception("Failed to relay custom event '%s' to the agent stream", event["name"])
 
@@ -467,6 +480,10 @@ class ModuleToolkit(DkToolkit):
         Wraps the SDK module's async generator function into an async function
         that Agno can consume, with proper error handling and response formatting.
 
+        A failure raises ``ToolCallError`` carrying the same JSON body a success-path caller
+        would have read: Agno hands ``str(exc)`` to the model unchanged and flags the call
+        ``tool_call_error``, which is what marks the tool failed for the front.
+
         Returns:
             Async function that calls the SDK tool and returns a JSON result, or a
             ToolResult when the tool returned images alongside its text output.
@@ -509,14 +526,14 @@ class ModuleToolkit(DkToolkit):
                 duration_ms = round((time.perf_counter() - start_time) * 1000, 2)
                 error_msg = f"Tool '{tool_name}' timed out after {timeout}s"
                 logger.warning("%s task_id=%s", error_msg, task_id)
-                return handle_failure(tool_name, error_msg, duration_ms)
+                raise ToolCallError(handle_failure(tool_name, error_msg, duration_ms))
 
             except Exception as e:
                 outcome = "error"
                 duration_ms = round((time.perf_counter() - start_time) * 1000, 2)
                 error_msg = f"Failed to call tool '{tool_name}': {e!s}"
                 logger.warning("%s task_id=%s", error_msg, task_id, exc_info=True)
-                return handle_failure(tool_name, error_msg, duration_ms)
+                raise ToolCallError(handle_failure(tool_name, error_msg, duration_ms))
 
             else:
                 call_timer.mark("gen_consume")
@@ -536,7 +553,7 @@ class ModuleToolkit(DkToolkit):
 
                 outcome = "no_success"
                 error_msg = ModuleToolkit._extract_error_message(error_frame)
-                return handle_failure(tool_name, error_msg, duration_ms)
+                raise ToolCallError(handle_failure(tool_name, error_msg, duration_ms))
 
             finally:
                 call_timer.mark("respond")

{digitalkin-1.0.5.dev3 → digitalkin-1.0.5.dev5}/src/digitalkin/community/agno/toolkits/registry/action.py

@@ -16,6 +16,7 @@ from pydantic import Field
 from digitalkin.community.agno.toolkits.registry.base import RegistryAction
 from digitalkin.logger import logger
 from digitalkin.models.services.registry import (
+    RegistryModuleType,
     RegistrySetupStatus,
     RegistrySortBy,
     RegistryVisibility,
@@ -36,7 +37,7 @@ class GetAction(RegistryAction):
         """Read the setup (always its current version), refusing a foreign object type.
 
         Returns:
-            The setup with its current version, status and visibility.
+            The setup with its current version, status and visibility, and a service's key map.
         """
         return await ctx.ensure_kind(self.setup_id)
 
@@ -55,7 +56,6 @@ class SearchAction(RegistryAction):
     this manager's own kind. Filters combine with AND; within one filter the values are OR'd.
     """
 
-    _DOC_PREVIEW_CHARS: ClassVar[int] = 300
     # The service ceiling itself (storage and registry both cap a page at 100), so the toolkit
     # no longer imposes a tighter one of its own.
     _MAX_RESULTS: ClassVar[int] = 100
@@ -125,14 +125,16 @@ class SearchAction(RegistryAction):
         # would both contradict ``total_returned`` and, at exactly ``cap`` rows, promise an empty
         # next page.
         truncated = len(usable) > cap
-        rows = [self._row(setup) for setup in usable[:cap]]
+        rows = [self._row(setup, ctx.module_type) for setup in usable[:cap]]
         return {"total_returned": len(rows), "truncated": truncated, "offset": self.offset, "setups": rows}
 
-    def _row(self, setup: SetupSummary) -> dict[str, Any]:
+    @staticmethod
+    def _row(setup: SetupSummary, module_type: RegistryModuleType) -> dict[str, Any]:
         """Trim one search hit to the fields a caller can act on.
 
         Args:
             setup: The summary returned by the registry.
+            module_type: The manager's object type; only services render a structure map.
 
         Returns:
             The rendered row.
@@ -147,11 +149,16 @@ class SearchAction(RegistryAction):
             "tags": setup.tags,
             "visibility": setup.visibility.value if setup.visibility else None,
             "status": setup.status.value if setup.status else None,
-            "description": (setup.documentation or "")[: self._DOC_PREVIEW_CHARS],
+            "documentation": setup.documentation or None,
         }
-        # Only service setups carry a map. Omitting the key rather than rendering an empty
-        # one keeps the feature out of the tools and kins surfaces entirely.
-        if setup.structure:
+        # Only service setups carry a map, so tools and kins rows never show one. A service row
+        # always does, {} included: a caller iterating rows must not meet a missing key.
+        if module_type == RegistryModuleType.SERVICE:
+            if not setup.structure:
+                logger.info(
+                    "[VALIDATE STRUCTROW] service row rendered with an empty structure: setup_id=%s",
+                    setup.setup_id,
+                )  # TODO(validate): remove after prod validation
             row["structure"] = setup.structure
         return row
 
@@ -182,9 +189,10 @@ class UpdateAction(RegistryAction):
     )
     documentation: str | None = Field(
         default=None,
-        description="Free text describing what this instance is for, indexed by ``search``. "
-        "Omit to keep the text the instance already has; pass a string to replace it, or an "
-        "empty string to clear it.",
+        max_length=300,
+        description="Free text describing what this instance is for, indexed by ``search``, at "
+        "most 300 characters. Omit to keep the text the instance already has; pass a string to "
+        "replace it, or an empty string to clear it.",
     )
 
     def _type_payload(self) -> dict[str, Any]:  # ruff: ignore[no-self-use]