digitalkin 0.3.5.dev12__tar.gz → 0.4.0.dev1__tar.gz

{digitalkin-0.3.5.dev12 → digitalkin-0.4.0.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: digitalkin
-Version: 0.3.5.dev12
+Version: 0.4.0.dev1
 Summary: SDK to build kin used in DigitalKin
 Author-email: "DigitalKin.ai" <contact@digitalkin.ai>
 License: Attribution-NonCommercial-ShareAlike 4.0 International
@@ -454,7 +454,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: ag-ui-protocol>=0.1.14
 Requires-Dist: agentic-mesh-protocol==0.2.3
-Requires-Dist: anyio==4.12.1
+Requires-Dist: anyio==4.13.0
 Requires-Dist: grpcio-health-checking==1.78.0
 Requires-Dist: grpcio-reflection==1.78.0
 Requires-Dist: grpcio-status==1.78.0
@@ -463,7 +463,7 @@ Provides-Extra: profiling
 Requires-Dist: asyncio-inspector==0.1.0; extra == "profiling"
 Requires-Dist: pyinstrument==5.1.2; extra == "profiling"
 Requires-Dist: viztracer==1.1.1; extra == "profiling"
-Requires-Dist: yappi==1.7.3; extra == "profiling"
+Requires-Dist: yappi==1.7.6; extra == "profiling"
 Provides-Extra: taskiq
 Requires-Dist: rstream==1.0.0; extra == "taskiq"
 Requires-Dist: taskiq-aio-pika==0.6.0; extra == "taskiq"

{digitalkin-0.3.5.dev12 → digitalkin-0.4.0.dev1}/examples/modules/archetype_with_tools_module.py

@@ -5,10 +5,11 @@ from typing import Any, ClassVar, Literal
 
 from pydantic import BaseModel, Field
 
-from digitalkin.models.grpc_servers.models import ClientConfig, SecurityMode, ServerMode
+from digitalkin.models.grpc_servers.models import ClientConfig
 from digitalkin.models.module.module_context import ModuleContext
 from digitalkin.models.module.setup_types import SetupModel
 from digitalkin.models.module.tool_reference import ToolReference
+from digitalkin.models.settings.utils.channel import ControlFlow, SecurityMode
 from digitalkin.modules._base_module import BaseModule  # noqa: PLC2701
 from digitalkin.services.services_models import ServicesStrategy
 
@@ -98,7 +99,7 @@ class ArchetypeSecret(BaseModel):
 client_config = ClientConfig(
     host="[::]",
     port=50152,
-    mode=ServerMode.ASYNC,
+    mode=ControlFlow.ASYNC,
     security=SecurityMode.INSECURE,
     credentials=None,
 )

{digitalkin-0.3.5.dev12 → digitalkin-0.4.0.dev1}/pyproject.toml

@@ -29,20 +29,20 @@
     dependencies = [
         "ag-ui-protocol>=0.1.14",
         "agentic-mesh-protocol==0.2.3",
-        "anyio==4.12.1",
+        "anyio==4.13.0",
         "grpcio-health-checking==1.78.0",
         "grpcio-reflection==1.78.0",
         "grpcio-status==1.78.0",
         "pydantic==2.12.5",
-]
-    version = "0.3.5.dev12"
+    ]
+    version = "0.4.0.dev1"
 
     [project.optional-dependencies]
         profiling = [
             "asyncio-inspector==0.1.0",
             "pyinstrument==5.1.2",
             "viztracer==1.1.1",
-            "yappi==1.7.3",
+            "yappi==1.7.6",
         ]
         taskiq = [
             "rstream==1.0.0",
@@ -61,13 +61,13 @@
 
 [dependency-groups]
     dev = [
-        "build==1.4.0",
+        "build==1.4.2",
         "bump-my-version==1.2.7",
-        "cryptography==46.0.5",
+        "cryptography==46.0.6",
         "mypy==1.19.1",
         "pre-commit==4.5.1",
         "pyright==1.1.408",
-        "ruff==0.15.5",
+        "ruff==0.15.8",
         "twine==6.2.0",
         "types-grpcio-health-checking==1.0.0.20250506",
         "types-grpcio-reflection==1.0.0.20250506",
@@ -87,17 +87,17 @@
         "mkdocs-git-revision-date-localized-plugin==1.5.1",
         "mkdocs-glightbox==0.5.2",
         "mkdocs-include-markdown-plugin==7.2.1",
-        "mkdocs-literate-nav==0.6.2",
+        "mkdocs-literate-nav==0.6.3",
         "mkdocs-llmstxt==0.5.0",
-        "mkdocs-material[imaging]==9.7.5",
+        "mkdocs-material[imaging]==9.7.6",
         "mkdocs-minify-plugin==0.8.0",
         "mkdocs-open-in-new-tab==1.0.8",
         "mkdocs-redirects==1.2.2",
-        "mkdocs-section-index==0.3.10",
+        "mkdocs-section-index==0.3.11",
         "mkdocs==1.6.1",
         "mkdocstrings-python==2.0.3",
         "mkdocstrings==1.0.3",
-        "tomli==2.4.0",
+        "tomli==2.4.1",
     ]
     tests = [
         "freezegun==1.5.5",
@@ -105,7 +105,7 @@
         "hdrhistogram==0.10.3",
         "psutil==7.2.2",
         "pytest-asyncio==1.3.0",
-        "pytest-cov==7.0.0",
+        "pytest-cov==7.1.0",
         "pytest-html==4.2.0",
         "pytest-json-report==1.5.0",
         "pytest-timeout==2.4.0",

{digitalkin-0.3.5.dev12 → digitalkin-0.4.0.dev1}/src/digitalkin/__version__.py

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

digitalkin-0.4.0.dev1/src/digitalkin/community/agno/agno_adapter.py

@@ -0,0 +1,548 @@
+"""Adapter to convert Agno events to DigitalKin framework-agnostic events.
+
+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 TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+from digitalkin.models.events import (
+    AgentRunEvent,
+    BaseAgentRunEvent,
+    ReasoningCompletedEvent,
+    ReasoningContentDeltaEvent,
+    ReasoningStartedEvent,
+    ReasoningStepEvent,
+    RunCompletedEvent,
+    RunContentEvent,
+    RunErrorEvent,
+    RunStartedEvent,
+    TextMessageCompletedEvent,
+    TextMessageStartedEvent,
+    ToolCallCompletedEvent,
+    ToolCallErrorEvent,
+    ToolCallStartedEvent,
+    ToolInfo,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class AgnoStreamAdapter:
+    """Stateful converter: Agno streaming events -> DigitalKin 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::
+
+        adapter = AgnoStreamAdapter()
+        async for raw_event in agent.arun(..., stream=True, stream_events=True):
+            for event in adapter.to_digitalkin_events(raw_event):
+                await send(event)
+        for event in adapter.flush():
+            await send(event)
+    """
+
+    def __init__(self) -> None:
+        """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
+
+        self._closed_tool_call_ids: set[str] = set()
+
+        self._active_run_id: str | None = None
+        self._completed_run_ids: set[str] = set()
+
+        self._dispatch: dict[Any, Callable[[Any, Any], list[BaseAgentRunEvent]]] | None = None
+
+    def to_digitalkin_events(self, agno_event: Any) -> list[BaseAgentRunEvent]:
+        """Convert one Agno event into one or more DigitalKin events.
+
+        Args:
+            agno_event: Event from Agno's streaming API.
+
+        Returns:
+            List of corresponding DigitalKin events (may be empty).
+
+        Raises:
+            ImportError: If the optional 'agno' dependency is not installed.
+        """
+        if self._dispatch is None:
+            try:
+                from agno.run.agent import RunEvent  # pylint: disable=C0415 # pyright: ignore[reportMissingImports]
+            except ImportError as exc:
+                message = "The 'agno' package is required to use AgnoStreamAdapter. Install it with: pip install agno"
+                raise ImportError(message) from exc
+
+            self._dispatch = {
+                RunEvent.run_started: self._handle_run_started,
+                RunEvent.run_content: self._handle_run_content,
+                RunEvent.run_completed: self._handle_run_completed,
+                RunEvent.run_error: self._handle_run_error,
+                RunEvent.reasoning_started: self._handle_reasoning_started,
+                RunEvent.reasoning_content_delta: self._handle_reasoning_content_delta,
+                RunEvent.reasoning_step: self._handle_reasoning_step,
+                RunEvent.reasoning_completed: self._handle_reasoning_completed,
+                RunEvent.tool_call_started: self._handle_tool_call_started,
+                RunEvent.tool_call_completed: self._handle_tool_call_completed,
+                RunEvent.tool_call_error: self._handle_tool_call_error,
+            }
+
+        event_type = agno_event.event
+        logger.debug("Converting Agno event: %s", event_type)
+
+        handler = self._dispatch.get(event_type)
+        if handler is None:
+            logger.debug("Skipping unhandled Agno event type: %s", event_type)
+            return []
+
+        return handler(agno_event, getattr(agno_event, "timestamp", None))
+
+    # ── Run Lifecycle Handlers ───────────────────────────────────────────
+
+    def _handle_run_started(self, agno_event: Any, timestamp: Any) -> list[BaseAgentRunEvent]:
+        """Handle RunEvent.run_started.
+
+        Returns:
+            List containing a RunStartedEvent, or empty for duplicates.
+        """
+        run_id = getattr(agno_event, "run_id", None)
+
+        if run_id and run_id == self._active_run_id:
+            logger.debug("Skipping duplicate RunStarted for run_id=%s", run_id)
+            return []
+
+        self._active_run_id = run_id
+        return [
+            RunStartedEvent(
+                event=AgentRunEvent.RUN_STARTED,
+                run_id=run_id,
+                thread_id=getattr(agno_event, "thread_id", None),
+                timestamp=timestamp,
+                metadata=None,
+            )
+        ]
+
+    def _handle_run_completed(self, agno_event: Any, timestamp: Any) -> list[BaseAgentRunEvent]:
+        """Handle RunEvent.run_completed.
+
+        Returns:
+            List of closing events followed by a RunCompletedEvent.
+        """
+        run_id = getattr(agno_event, "run_id", None)
+
+        if run_id and run_id in self._completed_run_ids and run_id != self._active_run_id:
+            logger.debug("Skipping duplicate RunCompleted for run_id=%s", run_id)
+            return []
+
+        events: list[BaseAgentRunEvent] = []
+
+        if self._content_active:
+            events.extend(self._close_content(timestamp))
+        if self._reasoning_active:
+            events.extend(self._close_reasoning(timestamp))
+
+        if run_id:
+            self._completed_run_ids.add(run_id)
+        self._active_run_id = None
+
+        events.append(
+            RunCompletedEvent(
+                event=AgentRunEvent.RUN_COMPLETED,
+                run_id=run_id,
+                final_content=str(agno_event.content) if getattr(agno_event, "content", None) else None,
+                usage=None,
+                message_id=None,
+                timestamp=timestamp,
+                metadata=None,
+            )
+        )
+        return events
+
+    def _handle_run_error(  # noqa: PLR6301
+        self,
+        agno_event: Any,
+        timestamp: Any,
+    ) -> list[BaseAgentRunEvent]:
+        """Handle RunEvent.run_error.
+
+        Returns:
+            List containing a RunErrorEvent.
+        """
+        return [
+            RunErrorEvent(
+                event=AgentRunEvent.RUN_ERROR,
+                error_type=getattr(agno_event, "error_type", None),
+                content=str(agno_event.content) if getattr(agno_event, "content", None) else None,
+                error_details=None,
+                timestamp=timestamp,
+                metadata=None,
+            )
+        ]
+
+    # ── Reasoning Handlers (native Agno reasoning models) ───────────────
+
+    def _handle_reasoning_started(self, agno_event: Any, timestamp: Any) -> list[BaseAgentRunEvent]:
+        """Handle RunEvent.reasoning_started.
+
+        Returns:
+            List with an optional TextMessageCompletedEvent and a ReasoningStartedEvent.
+        """
+        _ = agno_event
+        events: list[BaseAgentRunEvent] = []
+
+        if self._content_active:
+            events.extend(self._close_content(timestamp))
+
+        self._current_reasoning_id = str(uuid.uuid4())
+        self._reasoning_active = True
+        logger.debug("Reasoning started, 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
+
+    def _handle_reasoning_content_delta(self, agno_event: Any, timestamp: Any) -> list[BaseAgentRunEvent]:
+        """Handle RunEvent.reasoning_content_delta.
+
+        Returns:
+            List containing a ReasoningContentDeltaEvent.
+        """
+        return [
+            ReasoningContentDeltaEvent(
+                event=AgentRunEvent.REASONING_CONTENT_DELTA,
+                delta=getattr(agno_event, "reasoning_content", ""),
+                reasoning_id=self._current_reasoning_id,
+                timestamp=timestamp,
+                metadata=None,
+            )
+        ]
+
+    def _handle_reasoning_step(self, agno_event: Any, timestamp: Any) -> list[BaseAgentRunEvent]:
+        """Handle RunEvent.reasoning_step.
+
+        Returns:
+            List containing a ReasoningStepEvent.
+        """
+        return [
+            ReasoningStepEvent(
+                event=AgentRunEvent.REASONING_STEP,
+                delta=getattr(agno_event, "reasoning_content", ""),
+                reasoning_id=self._current_reasoning_id,
+                timestamp=timestamp,
+                metadata=None,
+            )
+        ]
+
+    def _handle_reasoning_completed(self, agno_event: Any, timestamp: Any) -> list[BaseAgentRunEvent]:
+        """Handle RunEvent.reasoning_completed.
+
+        Returns:
+            List containing a ReasoningCompletedEvent if reasoning was active.
+        """
+        _ = agno_event
+        logger.debug("Reasoning completed")
+        return self._close_reasoning(timestamp)
+
+    # ── Tool Call Handlers ──────────────────────────────────────────────
+
+    def _handle_tool_call_started(self, agno_event: Any, timestamp: Any) -> list[BaseAgentRunEvent]:
+        """Handle RunEvent.tool_call_started.
+
+        Returns:
+            List of any needed closing events and a ToolCallStartedEvent.
+        """
+        events: list[BaseAgentRunEvent] = []
+
+        if self._reasoning_active:
+            logger.debug("Reasoning auto-completed (tool call started)")
+            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
+        if tool:
+            tool_info = ToolInfo(
+                tool_call_id=getattr(tool, "tool_call_id", None),
+                tool_name=getattr(tool, "tool_name", None),
+                tool_args=getattr(tool, "tool_args", None),
+                result=None,
+            )
+        events.append(
+            ToolCallStartedEvent(
+                event=AgentRunEvent.TOOL_CALL_STARTED,
+                tool=tool_info,
+                timestamp=timestamp,
+                metadata=None,
+            )
+        )
+        return events
+
+    def _handle_tool_call_completed(self, agno_event: Any, timestamp: Any) -> list[BaseAgentRunEvent]:
+        """Handle RunEvent.tool_call_completed.
+
+        Returns:
+            List containing a ToolCallCompletedEvent.
+        """
+        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=tool_call_id,
+                tool_name=getattr(tool, "tool_name", None),
+                tool_args=getattr(tool, "tool_args", None),
+                result=getattr(tool, "result", None),
+            )
+
+        if tool_call_id:
+            self._closed_tool_call_ids.add(tool_call_id)
+
+        return [
+            ToolCallCompletedEvent(
+                event=AgentRunEvent.TOOL_CALL_COMPLETED,
+                tool=tool_info,
+                content=str(agno_event.content) if getattr(agno_event, "content", None) else None,
+                timestamp=timestamp,
+                metadata=None,
+            )
+        ]
+
+    def _handle_tool_call_error(self, agno_event: Any, timestamp: Any) -> list[BaseAgentRunEvent]:
+        """Handle RunEvent.tool_call_error.
+
+        Returns:
+            List containing a ToolCallErrorEvent, or empty if already closed.
+        """
+        tool = getattr(agno_event, "tool", None)
+        tool_call_id = getattr(tool, "tool_call_id", None) if tool else None
+
+        if tool_call_id and tool_call_id in self._closed_tool_call_ids:
+            logger.debug("Skipping duplicate ToolCallError for tool %s", tool_call_id)
+            return []
+
+        tool_info = None
+        if tool:
+            tool_info = ToolInfo(
+                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,
+                tool=tool_info,
+                error_message=str(agno_event.content) if getattr(agno_event, "content", None) else None,
+                timestamp=timestamp,
+                metadata=None,
+            )
+        ]
+
+    def flush(self) -> list[BaseAgentRunEvent]:
+        """Emit closing events for any active sequences at end of stream.
+
+        Returns:
+            List of closing events (empty if nothing is active).
+        """
+        events: list[BaseAgentRunEvent] = []
+        if self._content_active:
+            logger.debug("Flushing active content sequence")
+            events.extend(self._close_content(None))
+        if self._reasoning_active:
+            logger.debug("Flushing active reasoning sequence")
+            events.extend(self._close_reasoning(None))
+        return events
+
+    # ── Private Helpers ──────────────────────────────────────────────────
+
+    def _close_reasoning(self, timestamp: Any) -> list[BaseAgentRunEvent]:
+        """Close active reasoning sequence.
+
+        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
+
+    def _close_content(self, timestamp: Any) -> list[BaseAgentRunEvent]:
+        """Close active text message sequence.
+
+        Returns:
+            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 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("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.debug("Reasoning auto-started, id=%s", self._current_reasoning_id)
+            events.append(
+                ReasoningStartedEvent(
+                    event=AgentRunEvent.REASONING_STARTED,
+                    reasoning_id=self._current_reasoning_id,
+                    timestamp=timestamp,
+                    metadata=None,
+                )
+            )
+            self._reasoning_active = True
+
+        events.append(
+            ReasoningContentDeltaEvent(
+                event=AgentRunEvent.REASONING_CONTENT_DELTA,
+                delta=reasoning_content,
+                reasoning_id=self._current_reasoning_id,
+                timestamp=timestamp,
+                metadata=None,
+            )
+        )
+        return events
+
+    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.debug("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(
+                TextMessageStartedEvent(
+                    event=AgentRunEvent.TEXT_MESSAGE_STARTED,
+                    message_id=self._current_message_id,
+                    timestamp=timestamp,
+                    metadata=None,
+                )
+            )
+            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

{digitalkin-0.3.5.dev12 → digitalkin-0.4.0.dev1}/src/digitalkin/core/job_manager/base_job_manager.py

@@ -130,6 +130,12 @@ class BaseJobManager(abc.ABC, Generic[InputModelT, OutputModelT, SetupModelT]):
         required for the job manager to function.
         """
 
+    async def stop(self) -> None:
+        """Stop the job manager and clean up resources.
+
+        Default no-op. Subclasses with external connections override.
+        """
+
     @staticmethod
     async def job_specific_callback(
         callback: Callable[[str, DataModel | ModuleCodeModel], Coroutine[Any, Any, None]],