digitalkin 0.3.1.dev0__tar.gz → 0.3.1.dev2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: digitalkin
-Version: 0.3.1.dev0
+Version: 0.3.1.dev2
 Summary: SDK to build kin used in DigitalKin
 Author-email: "DigitalKin.ai" <contact@digitalkin.ai>
 License: Attribution-NonCommercial-ShareAlike 4.0 International
@@ -452,17 +452,17 @@ Classifier: License :: Other/Proprietary License
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: digitalkin-proto>=0.2.0.dev4
+Requires-Dist: digitalkin-proto==0.2.0.dev5
 Requires-Dist: grpcio-health-checking>=1.76.0
 Requires-Dist: grpcio-reflection>=1.76.0
 Requires-Dist: grpcio-status>=1.76.0
-Requires-Dist: pydantic>=2.12.4
+Requires-Dist: pydantic>=2.12.5
 Requires-Dist: surrealdb>=1.0.6
 Provides-Extra: taskiq
 Requires-Dist: rstream>=0.40.0; extra == "taskiq"
-Requires-Dist: taskiq-aio-pika>=0.4.4; extra == "taskiq"
+Requires-Dist: taskiq-aio-pika>=0.5.0; extra == "taskiq"
 Requires-Dist: taskiq-redis>=1.1.2; extra == "taskiq"
-Requires-Dist: taskiq[reload]>=0.11.20; extra == "taskiq"
+Requires-Dist: taskiq[reload]>=0.12.0; extra == "taskiq"
 Dynamic: license-file
 
 # DigitalKin Python SDK

digitalkin-0.3.1.dev2/examples/modules/dynamic_setup_module.py

@@ -0,0 +1,362 @@
+"""Example module demonstrating dynamic schema fields in SetupModel.
+
+This example shows how to use the Dynamic metadata class with async fetchers
+to populate field schemas (like enums) at runtime. This is useful when the
+available options come from external sources like databases or APIs.
+
+Usage:
+    # Start the module server
+    python examples/modules/dynamic_setup_module.py
+
+    # Or import and use in your own code
+    from examples.modules.dynamic_setup_module import DynamicSetupModule
+"""
+
+import asyncio
+import logging
+from typing import Annotated, Any, ClassVar
+
+from pydantic import BaseModel, Field
+
+from digitalkin.models.module.module_context import ModuleContext
+from digitalkin.models.module.module_types import DataModel, DataTrigger, SetupModel
+from digitalkin.modules._base_module import BaseModule
+from digitalkin.services.services_models import ServicesStrategy
+from digitalkin.utils import Dynamic
+
+# Configure logging
+logging.basicConfig(
+    level=logging.DEBUG,
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+)
+logger = logging.getLogger(__name__)
+
+
+# =============================================================================
+# Simulated External Services (replace with real implementations)
+# =============================================================================
+
+
+class MockModelRegistry:
+    """Simulates an external model registry service.
+
+    In a real application, this would be a connection to a database,
+    API service, or configuration management system.
+    """
+
+    _models: ClassVar[list[str]] = ["gpt-4", "gpt-4-turbo", "gpt-3.5-turbo"]
+    _languages: ClassVar[list[str]] = ["en", "fr", "de", "es", "it", "pt"]
+
+    @classmethod
+    async def fetch_available_models(cls) -> list[str]:
+        """Fetch available models from the registry.
+
+        Simulates an async API call with a small delay.
+        """
+        await asyncio.sleep(0.1)  # Simulate network latency
+        logger.info("Fetched %d models from registry", len(cls._models))
+        return cls._models.copy()
+
+    @classmethod
+    async def fetch_supported_languages(cls) -> list[str]:
+        """Fetch supported languages from the registry."""
+        await asyncio.sleep(0.05)  # Simulate network latency
+        logger.info("Fetched %d languages from registry", len(cls._languages))
+        return cls._languages.copy()
+
+    @classmethod
+    def get_default_model(cls) -> str:
+        """Get the default model (sync fetcher example)."""
+        return cls._models[0] if cls._models else "gpt-4"
+
+
+# =============================================================================
+# Dynamic Fetcher Functions
+# =============================================================================
+
+
+async def fetch_models() -> list[str]:
+    """Async fetcher for available model names.
+
+    This function is called when SetupModel.get_clean_model(force=True)
+    is invoked, typically during module initialization or schema refresh.
+    """
+    return await MockModelRegistry.fetch_available_models()
+
+
+async def fetch_languages() -> list[str]:
+    """Async fetcher for supported languages."""
+    return await MockModelRegistry.fetch_supported_languages()
+
+
+def get_temperature_range() -> dict[str, float]:
+    """Sync fetcher example returning min/max for temperature.
+
+    Demonstrates that fetchers can return any JSON-serializable value,
+    not just lists for enums.
+    """
+    return {"minimum": 0.0, "maximum": 2.0}
+
+
+# =============================================================================
+# Setup Model with Dynamic Fields
+# =============================================================================
+
+
+class DynamicAgentSetup(SetupModel):
+    """Setup model demonstrating dynamic schema fields.
+
+    Fields marked with Dynamic(...) will have their schema values
+    refreshed at runtime when get_clean_model(force=True) is called.
+
+    Attributes:
+        model_name: The LLM model to use. Enum values fetched from registry.
+        language: Output language. Enum values fetched dynamically.
+        temperature: Sampling temperature. Static field for comparison.
+        max_tokens: Maximum tokens to generate.
+        system_prompt: The system prompt for the model.
+    """
+
+    # Dynamic field: enum values fetched asynchronously from model registry
+    model_name: Annotated[str, Dynamic(enum=fetch_models)] = Field(
+        default="gpt-4",
+        title="Model Name",
+        description="The LLM model to use for generation.",
+        json_schema_extra={
+            "config": True,  # Shown in initial configuration
+            "ui:widget": "select",
+        },
+    )
+
+    # Dynamic field: language options fetched asynchronously
+    language: Annotated[str, Dynamic(enum=fetch_languages)] = Field(
+        default="en",
+        title="Output Language",
+        description="The language for generated responses.",
+        json_schema_extra={
+            "config": True,
+            "ui:widget": "select",
+        },
+    )
+
+    # Static field: no dynamic fetcher, values defined at class time
+    temperature: float = Field(
+        default=0.7,
+        ge=0.0,
+        le=2.0,
+        title="Temperature",
+        description="Controls randomness. Higher values = more creative.",
+        json_schema_extra={"config": True},
+    )
+
+    # Static field with hidden flag (runtime-only, not in initial config)
+    max_tokens: int = Field(
+        default=1024,
+        ge=1,
+        le=4096,
+        title="Max Tokens",
+        description="Maximum tokens in the response.",
+        json_schema_extra={"hidden": True},
+    )
+
+    # Static field without any special flags
+    system_prompt: str = Field(
+        default="You are a helpful assistant.",
+        title="System Prompt",
+        description="The system prompt defining assistant behavior.",
+    )
+
+
+# =============================================================================
+# Input/Output Models (Using DataModel/DataTrigger pattern)
+# =============================================================================
+
+
+class MessageInputTrigger(DataTrigger):
+    """Message input trigger following DigitalKin DataTrigger pattern.
+
+    The protocol field determines which trigger handler processes this input.
+    """
+
+    protocol: str = "message"
+    content: str = Field(default="", description="The user message content.")
+
+
+class DynamicModuleInput(DataModel[MessageInputTrigger]):
+    """Input model following DigitalKin DataModel pattern.
+
+    Wraps the trigger in a root field with optional annotations.
+    """
+
+    root: MessageInputTrigger = Field(default_factory=MessageInputTrigger)
+
+
+class MessageOutputTrigger(DataTrigger):
+    """Message output trigger following DigitalKin DataTrigger pattern."""
+
+    protocol: str = "message"
+    content: str = Field(default="", description="The generated response.")
+    model_used: str = Field(default="", description="The model that generated this response.")
+    language: str = Field(default="", description="The output language.")
+
+
+class DynamicModuleOutput(DataModel[MessageOutputTrigger]):
+    """Output model following DigitalKin DataModel pattern."""
+
+    root: MessageOutputTrigger = Field(default_factory=MessageOutputTrigger)
+
+
+class DynamicModuleSecret(BaseModel):
+    """Secret model (empty for this example)."""
+
+    pass
+
+
+# =============================================================================
+# Module Implementation
+# =============================================================================
+
+
+class DynamicSetupModule(
+    BaseModule[
+        DynamicModuleInput,
+        DynamicModuleOutput,
+        DynamicAgentSetup,
+        DynamicModuleSecret,
+    ]
+):
+    """Example module demonstrating dynamic schema in SetupModel.
+
+    This module shows how to:
+    1. Define setup fields with Dynamic() metadata for runtime enum fetching
+    2. Mix static and dynamic fields in the same SetupModel
+    3. Use async fetchers that simulate external service calls
+    4. Follow DigitalKin's DataModel/DataTrigger pattern for I/O
+
+    The key integration point is in the gRPC servicer, which calls
+    SetupModel.get_clean_model(force=True) to refresh dynamic values
+    before returning schema information to clients.
+    """
+
+    name = "DynamicSetupModule"
+    description = "Demonstrates dynamic schema fields in module setup"
+
+    # Schema format definitions
+    input_format = DynamicModuleInput
+    output_format = DynamicModuleOutput
+    setup_format = DynamicAgentSetup
+    secret_format = DynamicModuleSecret
+
+    # Module metadata
+    metadata: ClassVar[dict[str, Any]] = {
+        "name": "DynamicSetupModule",
+        "description": "Example module with dynamic setup schema",
+        "version": "1.0.0",
+        "tags": ["example", "dynamic-schema"],
+    }
+
+    # Services configuration (empty for this example)
+    services_config_strategies: ClassVar[dict[str, ServicesStrategy | None]] = {}
+    services_config_params: ClassVar[dict[str, dict[str, Any | None] | None]] = {}
+
+    async def initialize(self, context: ModuleContext, setup_data: DynamicAgentSetup) -> None:
+        """Initialize the module with setup data.
+
+        Args:
+            context: The module context with services and session info.
+            setup_data: The validated setup configuration.
+        """
+        logger.info(
+            "Initializing DynamicSetupModule with model=%s, language=%s",
+            setup_data.model_name,
+            setup_data.language,
+        )
+        self.setup = setup_data
+
+    async def cleanup(self) -> None:
+        """Clean up resources."""
+        logger.info("Cleaning up DynamicSetupModule")
+
+
+# =============================================================================
+# Demonstration Script
+# =============================================================================
+
+
+async def demonstrate_dynamic_schema() -> None:
+    """Demonstrate the dynamic schema functionality."""
+    print("=" * 60)
+    print("Dynamic Schema Demonstration")
+    print("=" * 60)
+
+    # 1. Show schema WITHOUT force (dynamic fields not resolved)
+    print("\n1. Schema without force=True (fetchers NOT called):")
+    print("-" * 40)
+
+    model_no_force = await DynamicAgentSetup.get_clean_model(
+        config_fields=True,
+        hidden_fields=False,
+        force=False,
+    )
+    schema_no_force = model_no_force.model_json_schema()
+
+    # Check if enum is present
+    model_name_schema = schema_no_force.get("properties", {}).get("model_name", {})
+    print(f"model_name has enum: {'enum' in model_name_schema}")
+    if "enum" in model_name_schema:
+        print(f"  enum values: {model_name_schema['enum']}")
+
+    # 2. Show schema WITH force (dynamic fields resolved)
+    print("\n2. Schema with force=True (fetchers called):")
+    print("-" * 40)
+
+    model_with_force = await DynamicAgentSetup.get_clean_model(
+        config_fields=True,
+        hidden_fields=False,
+        force=True,
+    )
+    schema_with_force = model_with_force.model_json_schema()
+
+    # Check enum values after force
+    model_name_schema = schema_with_force.get("properties", {}).get("model_name", {})
+    print(f"model_name has enum: {'enum' in model_name_schema}")
+    if "enum" in model_name_schema:
+        print(f"  enum values: {model_name_schema['enum']}")
+
+    language_schema = schema_with_force.get("properties", {}).get("language", {})
+    print(f"language has enum: {'enum' in language_schema}")
+    if "enum" in language_schema:
+        print(f"  enum values: {language_schema['enum']}")
+
+    # 3. Show that static json_schema_extra is preserved
+    print("\n3. Static json_schema_extra preserved:")
+    print("-" * 40)
+    print(f"model_name ui:widget: {model_name_schema.get('ui:widget', 'NOT FOUND')}")
+
+    # 4. Show field filtering
+    print("\n4. Field filtering demonstration:")
+    print("-" * 40)
+
+    # Config fields only (hidden excluded)
+    config_model = await DynamicAgentSetup.get_clean_model(
+        config_fields=True,
+        hidden_fields=False,
+        force=False,
+    )
+    print(f"Config fields (hidden=False): {list(config_model.model_fields.keys())}")
+
+    # All fields including hidden
+    all_model = await DynamicAgentSetup.get_clean_model(
+        config_fields=True,
+        hidden_fields=True,
+        force=False,
+    )
+    print(f"All fields (hidden=True): {list(all_model.model_fields.keys())}")
+
+    print("\n" + "=" * 60)
+    print("Demonstration complete!")
+    print("=" * 60)
+
+
+if __name__ == "__main__":
+    asyncio.run(demonstrate_dynamic_schema())

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

@@ -12,7 +12,7 @@
 
     keywords = [ "digitalkin", "kin", "agent", "gprc", "sdk" ]
 
-    version = "0.3.1.dev0"
+    version = "0.3.1.dev2"
     classifiers = [
         "Development Status :: 3 - Alpha",
         "Intended Audience :: Developers",
@@ -28,20 +28,20 @@
     ]
 
     dependencies = [
-        "digitalkin-proto>=0.2.0.dev4",
+        "digitalkin-proto==0.2.0.dev5",
         "grpcio-health-checking>=1.76.0",
         "grpcio-reflection>=1.76.0",
         "grpcio-status>=1.76.0",
-        "pydantic>=2.12.4",
+        "pydantic>=2.12.5",
         "surrealdb>=1.0.6",
     ]
 
     [project.optional-dependencies]
         taskiq = [
             "rstream>=0.40.0",
-            "taskiq-aio-pika>=0.4.4",
+            "taskiq-aio-pika>=0.5.0",
             "taskiq-redis>=1.1.2",
-            "taskiq[reload]>=0.11.20",
+            "taskiq[reload]>=0.12.0",
         ]
 
     [project.urls]
@@ -55,18 +55,18 @@
 
 [dependency-groups]
     dev = [
-        "typos>=1.39.2",
-        "ruff>=0.14.5",
-        "mypy>=1.18.2",
+        "typos>=1.40.0",
+        "ruff>=0.14.7",
+        "mypy>=1.19.0",
         "pyright>=1.1.407",
-        "pre-commit>=4.4.0",
+        "pre-commit>=4.5.0",
         "bump-my-version>=1.2.4",
         "build>=1.3.0",
         "twine>=6.2.0",
         "cryptography>=46.0.3",
     ]
     tests = [
-        "freezegun>=1.5.3",
+        "freezegun>=1.5.5",
         "hdrhistogram>=0.10.3",
         "grpcio-testing>=1.76.0",
         "psutil>=7.1.3",
@@ -75,17 +75,17 @@
         "pytest-cov>=7.0.0",
         "pytest-html==4.1.1",
         "pytest-json-report==1.5.0",
-        "pytest-timeout>=2.3.1",
+        "pytest-timeout>=2.4.0",
     ]
     docs = [
         "mike>=2.1.3",
-        "markdown-callouts>=0.4",
+        "markdown-callouts>=0.4.0",
         "markdown-exec>=1.12.1",
-        "mkdocs>=1.6",
+        "mkdocs>=1.6.1",
         "mkdocs-coverage>=2.0.0",
-        "mkdocs-llmstxt>=0.2",
-        "mkdocs-redirects>=1.2",
-        "mkdocstrings>=0.29",
+        "mkdocs-llmstxt>=0.5.0",
+        "mkdocs-redirects>=1.2.2",
+        "mkdocstrings>=1.0.0",
         "griffe-inherited-docstrings>=1.1.2",
         "mkdocs-autorefs>=1.4.3",
         "mkdocs-awesome-pages-plugin>=2.10.1",
@@ -97,8 +97,7 @@
         "mkdocs-material[imaging]>=9.7.0",
         "mkdocs-minify-plugin>=0.8.0",
         "mkdocs-section-index>=0.3.10",
-        "mkdocstrings>=0.30.1",
-        "mkdocstrings-python>=1.19.0",
+        "mkdocstrings-python>=2.0.0",
         "mkdocs-open-in-new-tab>=1.0.8",
         "tomli>=2.3.0",
     ]

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

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

{digitalkin-0.3.1.dev0 → digitalkin-0.3.1.dev2}/src/digitalkin/core/job_manager/taskiq_broker.py

@@ -208,7 +208,7 @@ async def run_start_module(
         # Reconstruct Pydantic models from dicts for type safety
         try:
             input_model = module_class.create_input_model(input_data)
-            setup_model = module_class.create_setup_model(setup_data)
+            setup_model = await module_class.create_setup_model(setup_data)
         except Exception as e:
             logger.error("Failed to reconstruct models for job %s: %s", job_id, e, exc_info=True)
             raise

{digitalkin-0.3.1.dev0 → digitalkin-0.3.1.dev2}/src/digitalkin/core/job_manager/taskiq_job_manager.py

@@ -140,7 +140,7 @@ class TaskiqJobManager(BaseJobManager[InputModelT, OutputModelT, SetupModelT]):
         services_mode: ServicesMode,
         default_timeout: float = 10.0,
         max_concurrent_tasks: int = 100,
-        stream_timeout: float = 15.0,
+        stream_timeout: float = 30.0,
     ) -> None:
         """Initialize the Taskiq job manager.
 
@@ -298,7 +298,6 @@ class TaskiqJobManager(BaseJobManager[InputModelT, OutputModelT, SetupModelT]):
             while True:
                 try:
                     # Block for first item with timeout to allow termination checks
-                    # Configurable timeout (default 15s) to account for distributed system latencies
                     item = await asyncio.wait_for(queue.get(), timeout=self.stream_timeout)
                     queue.task_done()
                     yield item

{digitalkin-0.3.1.dev0 → digitalkin-0.3.1.dev2}/src/digitalkin/core/task_manager/base_task_manager.py

@@ -11,6 +11,7 @@ from typing import Any
 from digitalkin.core.task_manager.surrealdb_repository import SurrealDBConnection
 from digitalkin.core.task_manager.task_session import TaskSession
 from digitalkin.logger import logger
+from digitalkin.models.core.task_monitor import CancellationReason
 from digitalkin.modules._base_module import BaseModule
 
 
@@ -84,13 +85,32 @@ class BaseTaskManager(ABC):
             task_id: The ID of the task to clean up
             mission_id: The ID of the mission associated with the task
         """
+        session = self.tasks_sessions.get(task_id)
+        cancellation_reason = session.cancellation_reason.value if session else "no_session"
+        final_status = session.status.value if session else "unknown"
+
         logger.debug(
-            "Cleaning up resources for task: '%s'", task_id, extra={"mission_id": mission_id, "task_id": task_id}
+            "Cleaning up resources",
+            extra={
+                "mission_id": mission_id,
+                "task_id": task_id,
+                "final_status": final_status,
+                "cancellation_reason": cancellation_reason,
+            },
         )
-        if task_id in self.tasks_sessions:
-            session = self.tasks_sessions[task_id]
+
+        if session:
             await session.cleanup()
             self.tasks_sessions.pop(task_id, None)
+            logger.debug(
+                "Task session cleanup completed",
+                extra={
+                    "mission_id": mission_id,
+                    "task_id": task_id,
+                    "final_status": final_status,
+                    "cancellation_reason": cancellation_reason,
+                },
+            )
 
         self.tasks.pop(task_id, None)
 
@@ -261,10 +281,21 @@ class BaseTaskManager(ABC):
             )
 
         except asyncio.TimeoutError:
+            # Set timeout as cancellation reason
+            if task_id in self.tasks_sessions:
+                session = self.tasks_sessions[task_id]
+                if session.cancellation_reason == CancellationReason.UNKNOWN:
+                    session.cancellation_reason = CancellationReason.TIMEOUT
+
             logger.warning(
                 "Graceful cancellation timed out for task: '%s', forcing cancellation",
                 task_id,
-                extra={"mission_id": mission_id, "task_id": task_id, "timeout": timeout},
+                extra={
+                    "mission_id": mission_id,
+                    "task_id": task_id,
+                    "timeout": timeout,
+                    "cancellation_reason": CancellationReason.TIMEOUT.value,
+                },
             )
 
             # Phase 2: Force cancellation
@@ -272,8 +303,16 @@ class BaseTaskManager(ABC):
             with contextlib.suppress(asyncio.CancelledError):
                 await task
 
-            logger.warning("Task force-cancelled: '%s'", task_id, extra={"mission_id": mission_id, "task_id": task_id})
-            await self._cleanup_task(task_id, mission_id)
+            logger.warning(
+                "Task force-cancelled: '%s', reason: %s",
+                task_id,
+                CancellationReason.TIMEOUT.value,
+                extra={
+                    "mission_id": mission_id,
+                    "task_id": task_id,
+                    "cancellation_reason": CancellationReason.TIMEOUT.value,
+                },
+            )
             return True
 
         except Exception as e:
@@ -283,10 +322,9 @@ class BaseTaskManager(ABC):
                 extra={"mission_id": mission_id, "task_id": task_id, "error": str(e)},
                 exc_info=True,
             )
-            await self._cleanup_task(task_id, mission_id)
             return False
-
-        await self._cleanup_task(task_id, mission_id)
+        finally:
+            await self._cleanup_task(task_id, mission_id)
         return True
 
     async def clean_session(self, task_id: str, mission_id: str) -> bool:
@@ -382,7 +420,16 @@ class BaseTaskManager(ABC):
         results: dict[str, bool | BaseException] = {}
         for task_id, result in zip(task_ids, results_list):
             if isinstance(result, Exception):
-                logger.error("Exception cancelling task %s: %s", task_id, result)
+                logger.error(
+                    "Exception cancelling task: '%s', error: %s",
+                    task_id,
+                    result,
+                    extra={
+                        "mission_id": mission_id,
+                        "task_id": task_id,
+                        "error": str(result),
+                    },
+                )
                 results[task_id] = False
             else:
                 results[task_id] = result
@@ -403,6 +450,21 @@ class BaseTaskManager(ABC):
         )
 
         self._shutdown_event.set()
+
+        # Mark all sessions with shutdown reason before cancellation
+        for task_id, session in self.tasks_sessions.items():
+            if session.cancellation_reason == CancellationReason.UNKNOWN:
+                session.cancellation_reason = CancellationReason.SHUTDOWN
+                logger.debug(
+                    "Marking task for shutdown: '%s'",
+                    task_id,
+                    extra={
+                        "mission_id": mission_id,
+                        "task_id": task_id,
+                        "cancellation_reason": CancellationReason.SHUTDOWN.value,
+                    },
+                )
+
         results = await self.cancel_all_tasks(mission_id, timeout)
 
         failed_tasks = [task_id for task_id, success in results.items() if not success]
@@ -411,13 +473,26 @@ class BaseTaskManager(ABC):
                 "Failed to cancel %d tasks during shutdown: %s",
                 len(failed_tasks),
                 failed_tasks,
-                extra={"mission_id": mission_id, "failed_tasks": failed_tasks, "failed_count": len(failed_tasks)},
+                extra={
+                    "mission_id": mission_id,
+                    "failed_tasks": failed_tasks,
+                    "failed_count": len(failed_tasks),
+                    "cancellation_reason": CancellationReason.SHUTDOWN.value,
+                },
             )
 
         # Clean up any remaining sessions (in case cancellation didn't clean them)
         remaining_sessions = list(self.tasks_sessions.keys())
         if remaining_sessions:
-            logger.info("Cleaning up %d remaining task sessions", len(remaining_sessions))
+            logger.info(
+                "Cleaning up %d remaining task sessions after shutdown",
+                len(remaining_sessions),
+                extra={
+                    "mission_id": mission_id,
+                    "remaining_sessions": remaining_sessions,
+                    "remaining_count": len(remaining_sessions),
+                },
+            )
             cleanup_coros = [self._cleanup_task(task_id, mission_id) for task_id in remaining_sessions]
             await asyncio.gather(*cleanup_coros, return_exceptions=True)