digitalkin 0.3.1.dev0__tar.gz → 0.3.1.dev1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: digitalkin
-Version: 0.3.1.dev0
+Version: 0.3.1.dev1
 Summary: SDK to build kin used in DigitalKin
 Author-email: "DigitalKin.ai" <contact@digitalkin.ai>
 License: Attribution-NonCommercial-ShareAlike 4.0 International
@@ -452,7 +452,7 @@ 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.dev4
 Requires-Dist: grpcio-health-checking>=1.76.0
 Requires-Dist: grpcio-reflection>=1.76.0
 Requires-Dist: grpcio-status>=1.76.0
@@ -460,7 +460,7 @@ Requires-Dist: pydantic>=2.12.4
 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"
 Dynamic: license-file

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

@@ -12,7 +12,7 @@
 
     keywords = [ "digitalkin", "kin", "agent", "gprc", "sdk" ]
 
-    version = "0.3.1.dev0"
+    version = "0.3.1.dev1"
     classifiers = [
         "Development Status :: 3 - Alpha",
         "Intended Audience :: Developers",
@@ -28,7 +28,7 @@
     ]
 
     dependencies = [
-        "digitalkin-proto>=0.2.0.dev4",
+        "digitalkin-proto==0.2.0.dev4",
         "grpcio-health-checking>=1.76.0",
         "grpcio-reflection>=1.76.0",
         "grpcio-status>=1.76.0",
@@ -39,7 +39,7 @@
     [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",
         ]
@@ -56,10 +56,10 @@
 [dependency-groups]
     dev = [
         "typos>=1.39.2",
-        "ruff>=0.14.5",
+        "ruff>=0.14.6",
         "mypy>=1.18.2",
         "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",
@@ -83,7 +83,7 @@
         "markdown-exec>=1.12.1",
         "mkdocs>=1.6",
         "mkdocs-coverage>=2.0.0",
-        "mkdocs-llmstxt>=0.2",
+        "mkdocs-llmstxt>=0.5.0",
         "mkdocs-redirects>=1.2",
         "mkdocstrings>=0.29",
         "griffe-inherited-docstrings>=1.1.2",

{digitalkin-0.3.1.dev0 → digitalkin-0.3.1.dev1}/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.dev1"

{digitalkin-0.3.1.dev0 → digitalkin-0.3.1.dev1}/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.dev1}/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)
 

{digitalkin-0.3.1.dev0 → digitalkin-0.3.1.dev1}/src/digitalkin/core/task_manager/task_executor.py

@@ -8,7 +8,12 @@ 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 SignalMessage, SignalType, TaskStatus
+from digitalkin.models.core.task_monitor import (
+    CancellationReason,
+    SignalMessage,
+    SignalType,
+    TaskStatus,
+)
 
 
 class TaskExecutor:
@@ -82,7 +87,7 @@ class TaskExecutor:
             finally:
                 logger.info("Heartbeat task ended", extra={"mission_id": mission_id, "task_id": task_id})
 
-        async def supervisor() -> None:
+        async def supervisor() -> None:  # noqa: C901, PLR0912, PLR0915
             """Supervise the three concurrent tasks and handle outcomes.
 
             Raises:
@@ -96,6 +101,7 @@ class TaskExecutor:
             main_task = None
             hb_task = None
             sig_task = None
+            cleanup_reason = CancellationReason.UNKNOWN
 
             try:
                 main_task = asyncio.create_task(coro, name=f"{task_id}_main")
@@ -106,12 +112,37 @@ class TaskExecutor:
                     return_when=asyncio.FIRST_COMPLETED,
                 )
 
-                # One task completed -> cancel the others
-                for t in pending:
-                    t.cancel()
+                # Determine cleanup reason based on which task completed first
+                completed = next(iter(done))
+
+                if completed is main_task:
+                    # Main task finished - cleanup is due to success
+                    cleanup_reason = CancellationReason.SUCCESS_CLEANUP
+                elif completed is sig_task or (completed is hb_task and sig_task.done()):
+                    # Signal task finished - external cancellation
+                    cleanup_reason = CancellationReason.SIGNAL
+                elif completed is hb_task:
+                    # Heartbeat stopped - failure cleanup
+                    cleanup_reason = CancellationReason.FAILURE_CLEANUP
+
+                # Cancel pending tasks with proper reason logging
+                if pending:
+                    pending_names = [t.get_name() for t in pending]
+                    logger.debug(
+                        "Cancelling pending tasks: %s, reason: %s",
+                        pending_names,
+                        cleanup_reason.value,
+                        extra={
+                            "mission_id": mission_id,
+                            "task_id": task_id,
+                            "pending_tasks": pending_names,
+                            "cancellation_reason": cleanup_reason.value,
+                        },
+                    )
+                    for t in pending:
+                        t.cancel()
 
                 # Propagate exception/result from the finished task
-                completed = next(iter(done))
                 await completed
 
                 # Determine final status based on which task completed
@@ -122,50 +153,95 @@ class TaskExecutor:
                         extra={"mission_id": mission_id, "task_id": task_id},
                     )
                 elif completed is sig_task or (completed is hb_task and sig_task.done()):
-                    logger.debug(
-                        f"Task cancelled due to signal {sig_task=}",
-                        extra={"mission_id": mission_id, "task_id": task_id},
-                    )
                     session.status = TaskStatus.CANCELLED
+                    session.cancellation_reason = CancellationReason.SIGNAL
+                    logger.info(
+                        "Task cancelled via external signal",
+                        extra={
+                            "mission_id": mission_id,
+                            "task_id": task_id,
+                            "cancellation_reason": CancellationReason.SIGNAL.value,
+                        },
+                    )
                 elif completed is hb_task:
                     session.status = TaskStatus.FAILED
+                    session.cancellation_reason = CancellationReason.HEARTBEAT_FAILURE
                     logger.error(
-                        f"Heartbeat stopped for {task_id}",
-                        extra={"mission_id": mission_id, "task_id": task_id},
+                        "Heartbeat stopped unexpectedly for task: '%s'",
+                        task_id,
+                        extra={
+                            "mission_id": mission_id,
+                            "task_id": task_id,
+                            "cancellation_reason": CancellationReason.HEARTBEAT_FAILURE.value,
+                        },
                     )
                     msg = f"Heartbeat stopped for {task_id}"
                     raise RuntimeError(msg)  # noqa: TRY301
 
             except asyncio.CancelledError:
                 session.status = TaskStatus.CANCELLED
-                logger.info("Task cancelled", extra={"mission_id": mission_id, "task_id": task_id})
+                # Only set reason if not already set (preserve original reason)
+                logger.info(
+                    "Task cancelled externally: '%s', reason: %s",
+                    task_id,
+                    session.cancellation_reason.value,
+                    extra={
+                        "mission_id": mission_id,
+                        "task_id": task_id,
+                        "cancellation_reason": session.cancellation_reason.value,
+                    },
+                )
+                cleanup_reason = CancellationReason.FAILURE_CLEANUP
                 raise
             except Exception:
                 session.status = TaskStatus.FAILED
-                logger.exception("Task failed", extra={"mission_id": mission_id, "task_id": task_id})
+                cleanup_reason = CancellationReason.FAILURE_CLEANUP
+                logger.exception(
+                    "Task failed with exception: '%s'",
+                    task_id,
+                    extra={"mission_id": mission_id, "task_id": task_id},
+                )
                 raise
             finally:
                 session.completed_at = datetime.datetime.now(datetime.timezone.utc)
-                # Ensure all tasks are cleaned up
-                tasks_to_cleanup = [t for t in [main_task, hb_task, sig_task] if t is not None]
-                for t in tasks_to_cleanup:
-                    if not t.done():
-                        t.cancel()
+                # Ensure all tasks are cleaned up with proper reason
+                tasks_to_cleanup = [t for t in [main_task, hb_task, sig_task] if t is not None and not t.done()]
                 if tasks_to_cleanup:
+                    cleanup_names = [t.get_name() for t in tasks_to_cleanup]
+                    logger.debug(
+                        "Final cleanup of %d remaining tasks: %s, reason: %s",
+                        len(tasks_to_cleanup),
+                        cleanup_names,
+                        cleanup_reason.value,
+                        extra={
+                            "mission_id": mission_id,
+                            "task_id": task_id,
+                            "cleanup_count": len(tasks_to_cleanup),
+                            "cleanup_tasks": cleanup_names,
+                            "cancellation_reason": cleanup_reason.value,
+                        },
+                    )
+                    for t in tasks_to_cleanup:
+                        t.cancel()
                     await asyncio.gather(*tasks_to_cleanup, return_exceptions=True)
 
+                duration = (
+                    (session.completed_at - session.started_at).total_seconds()
+                    if session.started_at and session.completed_at
+                    else None
+                )
                 logger.info(
-                    "Task execution completed with status: %s",
-                    session.status,
+                    "Task execution completed: '%s', status: %s, reason: %s, duration: %.2fs",
+                    task_id,
+                    session.status.value,
+                    session.cancellation_reason.value if session.status == TaskStatus.CANCELLED else "n/a",
+                    duration or 0,
                     extra={
                         "mission_id": mission_id,
                         "task_id": task_id,
-                        "status": session.status,
-                        "duration": (
-                            (session.completed_at - session.started_at).total_seconds()
-                            if session.started_at and session.completed_at
-                            else None
-                        ),
+                        "status": session.status.value,
+                        "cancellation_reason": session.cancellation_reason.value,
+                        "duration": duration,
                     },
                 )
 

{digitalkin-0.3.1.dev0 → digitalkin-0.3.1.dev1}/src/digitalkin/core/task_manager/task_session.py

@@ -6,7 +6,13 @@ from collections.abc import AsyncGenerator
 
 from digitalkin.core.task_manager.surrealdb_repository import SurrealDBConnection
 from digitalkin.logger import logger
-from digitalkin.models.core.task_monitor import HeartbeatMessage, SignalMessage, SignalType, TaskStatus
+from digitalkin.models.core.task_monitor import (
+    CancellationReason,
+    HeartbeatMessage,
+    SignalMessage,
+    SignalType,
+    TaskStatus,
+)
 from digitalkin.modules._base_module import BaseModule
 
 
@@ -31,6 +37,7 @@ class TaskSession:
     completed_at: datetime.datetime | None
 
     is_cancelled: asyncio.Event
+    cancellation_reason: CancellationReason
     _paused: asyncio.Event
     _heartbeat_interval: datetime.timedelta
     _last_heartbeat: datetime.datetime
@@ -62,6 +69,7 @@ class TaskSession:
         self.heartbeat_record_id = None
 
         self.is_cancelled = asyncio.Event()
+        self.cancellation_reason = CancellationReason.UNKNOWN
         self._paused = asyncio.Event()
         self._heartbeat_interval = heartbeat_interval
 
@@ -143,17 +151,26 @@ class TaskSession:
 
     async def generate_heartbeats(self) -> None:
         """Periodic heartbeat generator with cancellation support."""
-        logger.debug("Heartbeat started")
+        logger.debug(
+            "Heartbeat generator started for task: '%s'",
+            self.task_id,
+            extra={"task_id": self.task_id, "mission_id": self.mission_id},
+        )
         while not self.cancelled:
-            logger.debug(f"Heartbeat tick for task: '{self.task_id}' | {self.cancelled=}")
+            logger.debug(
+                "Heartbeat tick for task: '%s', cancelled=%s",
+                self.task_id,
+                self.cancelled,
+                extra={"task_id": self.task_id, "mission_id": self.mission_id},
+            )
             success = await self.send_heartbeat()
             if not success:
                 logger.error(
                     "Heartbeat failed, cancelling task: '%s'",
                     self.task_id,
-                    extra={"task_id": self.task_id},
+                    extra={"task_id": self.task_id, "mission_id": self.mission_id},
                 )
-                await self._handle_cancel()
+                await self._handle_cancel(CancellationReason.HEARTBEAT_FAILURE)
                 break
             await asyncio.sleep(self._heartbeat_interval.total_seconds())
 
@@ -192,7 +209,7 @@ class TaskSession:
                     continue
 
                 if signal["action"] == "cancel":
-                    await self._handle_cancel()
+                    await self._handle_cancel(CancellationReason.SIGNAL)
                 elif signal["action"] == "pause":
                     await self._handle_pause()
                 elif signal["action"] == "resume":
@@ -222,26 +239,55 @@ class TaskSession:
                 extra={"task_id": self.task_id},
             )
 
-    async def _handle_cancel(self) -> None:
-        """Idempotent cancellation with acknowledgment."""
-        logger.debug("Handle cancel called")
+    async def _handle_cancel(self, reason: CancellationReason = CancellationReason.UNKNOWN) -> None:
+        """Idempotent cancellation with acknowledgment and reason tracking.
+
+        Args:
+            reason: The reason for cancellation (signal, heartbeat failure, cleanup, etc.)
+        """
         if self.is_cancelled.is_set():
             logger.debug(
-                "Cancel signal ignored - task already cancelled: '%s'",
+                "Cancel ignored - task already cancelled: '%s' (existing reason: %s, new reason: %s)",
                 self.task_id,
-                extra={"task_id": self.task_id},
+                self.cancellation_reason.value,
+                reason.value,
+                extra={
+                    "task_id": self.task_id,
+                    "mission_id": self.mission_id,
+                    "existing_reason": self.cancellation_reason.value,
+                    "new_reason": reason.value,
+                },
             )
             return
 
-        logger.info(
-            "Cancelling task: '%s'",
-            self.task_id,
-            extra={"task_id": self.task_id},
-        )
-
+        self.cancellation_reason = reason
         self.status = TaskStatus.CANCELLED
         self.is_cancelled.set()
 
+        # Log with appropriate level based on reason
+        if reason in {CancellationReason.SUCCESS_CLEANUP, CancellationReason.FAILURE_CLEANUP}:
+            logger.debug(
+                "Task cancelled (cleanup): '%s', reason: %s",
+                self.task_id,
+                reason.value,
+                extra={
+                    "task_id": self.task_id,
+                    "mission_id": self.mission_id,
+                    "cancellation_reason": reason.value,
+                },
+            )
+        else:
+            logger.info(
+                "Task cancelled: '%s', reason: %s",
+                self.task_id,
+                reason.value,
+                extra={
+                    "task_id": self.task_id,
+                    "mission_id": self.mission_id,
+                    "cancellation_reason": reason.value,
+                },
+            )
+
         # Resume if paused so cancellation can proceed
         if self._paused.is_set():
             self._paused.set()

{digitalkin-0.3.1.dev0 → digitalkin-0.3.1.dev1}/src/digitalkin/grpc_servers/module_servicer.py

@@ -220,9 +220,13 @@ class ModuleServicer(module_service_pb2_grpc.ModuleServiceServicer, ArgParser):
                         break
 
                     if message.get("code", None) is not None and message.get("code") == "__END_OF_STREAM__":
-                        yield lifecycle_pb2.StartModuleResponse(success=True, job_id=job_id)
+                        logger.info(
+                            "End of stream via __END_OF_STREAM__",
+                            extra={"job_id": job_id, "mission_id": request.mission_id},
+                        )
                         break
 
+                    logger.info("Yielding message from job %s: %s", job_id, message)
                     proto = json_format.ParseDict(message, struct_pb2.Struct(), ignore_unknown_fields=True)
                     yield lifecycle_pb2.StartModuleResponse(success=True, output=proto, job_id=job_id)
         finally:

{digitalkin-0.3.1.dev0 → digitalkin-0.3.1.dev1}/src/digitalkin/models/core/task_monitor.py

@@ -17,6 +17,23 @@ class TaskStatus(Enum):
     FAILED = "failed"
 
 
+class CancellationReason(Enum):
+    """Reason for task cancellation - helps distinguish cleanup vs real cancellation."""
+
+    # Cleanup cancellations (not errors)
+    SUCCESS_CLEANUP = "success_cleanup"  # Main task completed, cleaning up helper tasks
+    FAILURE_CLEANUP = "failure_cleanup"  # Main task failed, cleaning up helper tasks
+
+    # Real cancellations
+    SIGNAL = "signal"  # External signal requested cancellation
+    HEARTBEAT_FAILURE = "heartbeat_failure"  # Heartbeat stopped working
+    TIMEOUT = "timeout"  # Task timed out
+    SHUTDOWN = "shutdown"  # Manager is shutting down
+
+    # Unknown/unset
+    UNKNOWN = "unknown"  # Reason not determined
+
+
 class SignalType(Enum):
     """Signal type enumeration."""
 

{digitalkin-0.3.1.dev0 → digitalkin-0.3.1.dev1}/src/digitalkin.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: digitalkin
-Version: 0.3.1.dev0
+Version: 0.3.1.dev1
 Summary: SDK to build kin used in DigitalKin
 Author-email: "DigitalKin.ai" <contact@digitalkin.ai>
 License: Attribution-NonCommercial-ShareAlike 4.0 International
@@ -452,7 +452,7 @@ 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.dev4
 Requires-Dist: grpcio-health-checking>=1.76.0
 Requires-Dist: grpcio-reflection>=1.76.0
 Requires-Dist: grpcio-status>=1.76.0
@@ -460,7 +460,7 @@ Requires-Dist: pydantic>=2.12.4
 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"
 Dynamic: license-file

{digitalkin-0.3.1.dev0 → digitalkin-0.3.1.dev1}/src/digitalkin.egg-info/requires.txt

@@ -1,4 +1,4 @@
-digitalkin-proto>=0.2.0.dev4
+digitalkin-proto==0.2.0.dev4
 grpcio-health-checking>=1.76.0
 grpcio-reflection>=1.76.0
 grpcio-status>=1.76.0
@@ -7,6 +7,6 @@ surrealdb>=1.0.6
 
 [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