digitalkin 1.0.5.dev0__tar.gz → 1.0.5.dev2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: digitalkin
-Version: 1.0.5.dev0
+Version: 1.0.5.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.3.dev0
+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.5.dev0 → digitalkin-1.0.5.dev2}/examples/redis_demo/client.py

@@ -2,10 +2,11 @@
 """Demo client for the Gateway gRPC service with per-endpoint testing.
 
 Subcommands:
-    full      Full pipeline: StartStream → Stream → SendSignal
+    full      Full pipeline: StartStream → ConsumeStream → SendSignal
     start     StartStream only (unary)
-    consume   Stream on existing task (requires --task-id)
-    signal    SendSignal(cancel) on existing task (requires --task-id)
+    consume   ConsumeStream on existing task (requires --task-id)
+    produce   StartStream + ProduceStream (act as Module A)
+    signal    SendSignal on existing task (requires --task-id)
     inspect   Dump Redis keys for a task (no gRPC)
 
 Usage:
@@ -13,7 +14,8 @@ 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 signal --task-id <uuid>
+    python client.py produce --task-id <uuid> --chunks 3
+    python client.py signal --task-id <uuid> --action cancel
     python client.py inspect --task-id <uuid>
 """
 
@@ -32,7 +34,7 @@ import grpc
 import redis.asyncio as aioredis
 from google.protobuf import json_format, struct_pb2
 
-from agentic_mesh_protocol.gateway.v1 import gateway_dto_pb2, gateway_messages_pb2, gateway_service_pb2_grpc
+from agentic_mesh_protocol.gateway.v1 import gateway_pb2, gateway_service_pb2_grpc
 
 # ── ANSI colors ─────────────────────────────────────────────────────
 
@@ -289,18 +291,29 @@ 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_dto_pb2.StartStreamRequest(
+        gateway_pb2.StartStreamRequest(
             task_id=task_id,
-            setup_id="setups:demo",
-            mission_id="missions:demo",
+            input=input_struct,
+            setup_id="demo-setup",
+            mission_id="demo-mission",
         ),
     )
     elapsed = (time.monotonic() - t0) * 1000
@@ -314,58 +327,112 @@ 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]]:
-    """Stream — send the query, then read module output until ``stream.end``.
+    """ConsumeStream — read module output from Redis.
 
     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_messages_pb2.StreamRequest(task_id=task_id, from_seq=0, data=query_struct)
+        yield gateway_pb2.ConsumeStreamRequest(
+            init=gateway_pb2.ConsumeStreamInit(task_id=task_id, from_seq=0),
+        )
 
     t0 = time.monotonic()
-    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
+    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
-        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
+
+        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
+            break
+
+        elif payload_type == "heartbeat":
+            if verbose:
+                print(f"  {DIM}heartbeat{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 — cancel a running task.
+    """SendSignal — send a control signal.
 
     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_dto_pb2.SendSignalRequest(cancel=gateway_messages_pb2.CancelSignal(task_id=task_id)),
+        gateway_pb2.ClientSignalRequest(task_id=task_id, action=action_enum),
     )
     elapsed = (time.monotonic() - t0) * 1000
 
@@ -380,7 +447,7 @@ async def cmd_signal(
 
 
 async def run_full(args: argparse.Namespace) -> None:
-    """Full pipeline: StartStream → Stream → SendSignal."""
+    """Full pipeline: StartStream → ConsumeStream → 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
@@ -400,7 +467,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)
+            accepted = await cmd_start(stub, task_id, args.prompt, setup)
             if not accepted:
                 print(f"  {RED}Server rejected the task — aborting.{RESET}")  # noqa: T201
                 return
@@ -409,17 +476,18 @@ async def run_full(args: argparse.Namespace) -> None:
                 await asyncio.sleep(0.1)
                 await tracker.snapshot("StartStream", task_id)
 
-            # 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)
+            # 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)
 
             if tracker:
                 await asyncio.sleep(0.1)
-                await tracker.snapshot("Stream", task_id)
+                await tracker.snapshot("ConsumeStream", task_id)
 
             # 3. SendSignal
             print(f"\n{BOLD}[3] SendSignal (cancel){RESET}")  # noqa: T201
-            await cmd_signal(stub, task_id)
+            await cmd_signal(stub, task_id, "cancel")
 
             if tracker:
                 await asyncio.sleep(0.1)
@@ -445,39 +513,61 @@ 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)
+        await cmd_start(stub, task_id, args.prompt, setup)
 
 
 async def run_consume(args: argparse.Namespace) -> None:
-    """Stream on existing task."""
+    """ConsumeStream 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}[Stream]{RESET}  gateway={args.gateway}  task_id={args.task_id}")  # noqa: T201
+
+    print(f"\n{BOLD}[Produce]{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_consume(stub, args.task_id, args.prompt, setup, args.verbose)
+
+        # 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)
 
 
 async def run_signal(args: argparse.Namespace) -> None:
-    """SendSignal(cancel) on existing task."""
+    """SendSignal 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}  signal=cancel")  # noqa: T201
+    print(f"\n{BOLD}[SendSignal]{RESET}  gateway={args.gateway}  task_id={args.task_id}  action={args.action}")  # 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)
+        await cmd_signal(stub, args.task_id, args.action)
 
 
 async def run_inspect(args: argparse.Namespace) -> None:
@@ -523,7 +613,8 @@ examples:
   %(prog)s full --prompt "Test" --setup '{"uppercase": true, "repeat": 5}'
   %(prog)s start --prompt "Hello"
   %(prog)s consume --task-id <uuid>
-  %(prog)s signal --task-id <uuid>
+  %(prog)s produce --chunks 5 --prompt "Manual"
+  %(prog)s signal --task-id <uuid> --action cancel
   %(prog)s inspect --task-id <uuid>
 """,
     )
@@ -540,16 +631,21 @@ examples:
     sub = p.add_subparsers(dest="command", help="Endpoint to test")
 
     # full (default)
-    sub.add_parser("full", help="Full pipeline: StartStream -> Stream -> SendSignal")
+    sub.add_parser("full", help="Full pipeline: StartStream -> ConsumeStream -> SendSignal")
 
     # start
     sub.add_parser("start", help="StartStream only (unary)")
 
     # consume
-    sub.add_parser("consume", help="Stream on existing task (requires --task-id)")
+    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)")
 
     # signal
-    sub.add_parser("signal", help="SendSignal(cancel) on existing task (requires --task-id)")
+    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)")
 
     # inspect
     sub.add_parser("inspect", help="Dump Redis keys for a task (no gRPC)")
@@ -566,10 +662,17 @@ 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.dev0 → digitalkin-1.0.5.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.3.dev0",
+        "agentic-mesh-protocol==1.0.1",
         "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.dev0"
+    version = "1.0.5.dev2"
 
     [project.optional-dependencies]
         agno = [ "agno>=2.6" ]

{digitalkin-1.0.5.dev0 → digitalkin-1.0.5.dev2}/src/digitalkin/__version__.py

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

{digitalkin-1.0.5.dev0 → digitalkin-1.0.5.dev2}/src/digitalkin/community/agno/agno_adapter.py

@@ -7,6 +7,8 @@ import logging
 import uuid
 from typing import TYPE_CHECKING, Any, TypeAlias
 
+from pydantic import ValidationError
+
 if TYPE_CHECKING:
     from collections.abc import Callable
 
@@ -54,6 +56,7 @@ if TYPE_CHECKING:
 from digitalkin.models.events import (
     AgentRunEvent,
     BaseAgentRunEvent,
+    CustomEvent,
     ReasoningCompletedEvent,
     ReasoningContentDeltaEvent,
     ReasoningStartedEvent,
@@ -62,6 +65,8 @@ from digitalkin.models.events import (
     RunContentEvent,
     RunErrorEvent,
     RunStartedEvent,
+    SourceCitation,
+    SourceCitationEvent,
     SubagentErrorEvent,
     SubagentFinishedEvent,
     SubagentStartedEvent,
@@ -80,7 +85,9 @@ class AgnoStreamAdapter:
     """Stateful Agno→DigitalKin event converter.
 
     Auto-wraps ``run_content`` deltas in TextMessage/Reasoning lifecycle
-    events and tracks HITL pause state.
+    events and tracks HITL pause state. One adapter serves one stream: its
+    dedup state (citations, closed tool calls, completed runs) is reset on each
+    top-level ``run_started``, so it must not be shared across concurrent streams.
     """
 
     def __init__(self) -> None:
@@ -94,6 +101,8 @@ class AgnoStreamAdapter:
         self._reasonings: dict[str, tuple[str, dict[str, Any] | None]] = {}
 
         self._closed_tool_call_ids: set[str] = set()
+        # Providers repeat the same citations on every delta and again on completion.
+        self._cited_urls: set[str] = set()
 
         self._active_run_id: str | None = None
         self._completed_run_ids: set[str] = set()
@@ -206,6 +215,7 @@ class AgnoStreamAdapter:
             "tool_call_started": self._handle_tool_call_started,
             "tool_call_completed": self._handle_tool_call_completed,
             "tool_call_error": self._handle_tool_call_error,
+            "custom_event": self._handle_custom_event,
         }
         dispatch = {
             enum_cls[name]: handler
@@ -313,6 +323,17 @@ class AgnoStreamAdapter:
             self._active_run_id,
             self._last_metadata,
         )
+        # TODO(validate): ADAPTER-RESET per-run dedup state resets on each new top-level run
+        logger.info(
+            "[VALIDATE ADAPTER-RESET] run_id=%s clearing cited_urls=%d closed_tool_calls=%d completed_runs=%d",
+            run_id,
+            len(self._cited_urls),
+            len(self._closed_tool_call_ids),
+            len(self._completed_run_ids),
+        )
+        self._cited_urls.clear()
+        self._closed_tool_call_ids.clear()
+        self._completed_run_ids.clear()
         self._active_run_id = run_id
         return [
             RunStartedEvent(
@@ -337,11 +358,13 @@ class AgnoStreamAdapter:
         """
         parent_run_id = getattr(agno_event, "parent_run_id", None)
         run_id = agno_event.run_id
+        citations = self._citations(agno_event, timestamp)
 
         if parent_run_id:
             # Close this member's own text/reasoning bubble, then the matching step. Siblings
             # still streaming keep theirs open.
-            events: list[BaseAgentRunEvent] = self._close_content(self._run_key, timestamp)
+            events: list[BaseAgentRunEvent] = citations
+            events.extend(self._close_content(self._run_key, timestamp))
             events.extend(self._close_reasoning(self._run_key, timestamp))
 
             subagent = self._subagents.pop(run_id, None) if run_id else None
@@ -377,7 +400,8 @@ class AgnoStreamAdapter:
 
         # AG-UI refuses RUN_FINISHED while any message, reasoning or step is still open, so
         # everything still running when the top-level run ends is force-closed here.
-        events = self._close_all_content(timestamp)
+        events = citations
+        events.extend(self._close_all_content(timestamp))
         events.extend(self._close_all_reasoning(timestamp))
         events.extend(self._close_subagents(timestamp))
 
@@ -884,6 +908,80 @@ class AgnoStreamAdapter:
             event for run_key in reversed(list(self._messages)) for event in self._close_content(run_key, timestamp)
         ]
 
+    def _source_event(self, payload: Any, timestamp: Any) -> SourceCitationEvent | None:
+        """Validate one source payload into a ``source_citation`` event.
+
+        Args:
+            payload: ``{url, title?, description?}`` as received.
+            timestamp: Event timestamp.
+
+        Returns:
+            The event, or None when the payload is invalid (logged and dropped).
+        """
+        try:
+            citation = SourceCitation.model_validate(payload)
+        except ValidationError as exc:
+            logger.warning("Dropped source citation %r: %s", payload, exc)
+            return None
+        return SourceCitationEvent(
+            event=AgentRunEvent.CUSTOM,
+            name="source_citation",
+            value=citation,
+            subagent_run_id=self._subagent_of(self._run_key),
+            timestamp=timestamp,
+            metadata=self._last_metadata,
+        )
+
+    def _citations(
+        self, agno_event: AgnoRunContentEvent | AgnoRunCompletedEvent, timestamp: Any
+    ) -> list[BaseAgentRunEvent]:
+        """Convert the model-native ``citations.urls`` not yet emitted in this run.
+
+        Returns:
+            One SourceCitationEvent per new URL.
+        """
+        citations = agno_event.citations
+        if citations is None or not citations.urls:
+            return []
+        events: list[BaseAgentRunEvent] = []
+        for cite in citations.urls:
+            if not cite.url:
+                logger.warning("Dropped source citation without url: title=%r", cite.title)
+                continue
+            if cite.url in self._cited_urls:
+                continue
+            self._cited_urls.add(cite.url)
+            event = self._source_event({"url": cite.url, "title": cite.title}, timestamp)
+            if event is not None:
+                events.append(event)
+        return events
+
+    def _handle_custom_event(self, agno_event: AgnoRunEvent, timestamp: Any) -> list[BaseAgentRunEvent]:
+        """Handle RunEvent.custom_event — agno stores the tool's kwargs as attributes.
+
+        Returns:
+            A SourceCitationEvent for ``source_citation``, a generic CustomEvent otherwise,
+            or empty when the event is unnamed or its source is invalid.
+        """
+        data = agno_event.__dict__
+        name = data.get("name")
+        if not name:
+            logger.debug("Skipping unnamed agno custom event: %r", data)
+            return []
+        if name == "source_citation":
+            event = self._source_event(data.get("value"), timestamp)
+            return [event] if event is not None else []
+        return [
+            CustomEvent(
+                event=AgentRunEvent.CUSTOM,
+                name=name,
+                value=data.get("value"),
+                subagent_run_id=self._subagent_of(self._run_key),
+                timestamp=timestamp,
+                metadata=self._last_metadata,
+            )
+        ]
+
     def _handle_run_content(self, agno_event: AgnoRunContentEvent, timestamp: Any) -> list[BaseAgentRunEvent]:
         """Handle RunEvent.run_content — the core state machine.
 
@@ -892,7 +990,7 @@ class AgnoStreamAdapter:
         Returns:
             DigitalKin events for this chunk.
         """
-        events: list[BaseAgentRunEvent] = []
+        events = self._citations(agno_event, timestamp)
 
         reasoning_content = agno_event.reasoning_content
         content = agno_event.content

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

@@ -85,11 +85,26 @@ class PausedRunStore:
             if tid and tid not in seen and tool.external_execution_required and tool.result is None:
                 seen.add(tid)
                 pending.append(tid)
+        payload = run_output.to_dict()
+        # History messages are re-fetched from the session by continue_run; events are not replayed.
+        messages = payload.get("messages") or []
+        history = [m for m in messages if m.get("from_history")]
+        if history:
+            payload["messages"] = [m for m in messages if not m.get("from_history")]
+        events = payload.pop("events", None) or []
+        # TODO(validate): HITL-TRIM paused runs stored without history messages/events still resume
+        logger.info(
+            "[VALIDATE HITL-TRIM] thread_id=%s dropped %d history message(s) %s and %d event(s)",
+            thread_id,
+            len(history),
+            [(m.get("id"), m.get("role")) for m in history],
+            len(events),
+        )
         record = PausedRunRecord(
             thread_id=thread_id,
             run_id=run_output.run_id or "",
             pending_tool_call_ids=pending,
-            payload=run_output.to_dict(),
+            payload=payload,
         )
         await self._storage.upsert(
             collection=self.COLLECTION,