digitalkin 0.3.1.dev0__py3-none-any.whl → 0.3.1.dev1__py3-none-any.whl

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/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/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/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/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/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/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.dist-info → digitalkin-0.3.1.dev1.dist-info}/METADATA

@@ -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.dist-info → digitalkin-0.3.1.dev1.dist-info}/RECORD

@@ -7,7 +7,7 @@ base_server/mock/__init__.py,sha256=YZFT-F1l_TpvJYuIPX-7kTeE1CfOjhx9YmNRXVoi-jQ,
 base_server/mock/mock_pb2.py,sha256=sETakcS3PAAm4E-hTCV1jIVaQTPEAIoVVHupB8Z_k7Y,1843
 base_server/mock/mock_pb2_grpc.py,sha256=BbOT70H6q3laKgkHfOx1QdfmCS_HxCY4wCOX84YAdG4,3180
 digitalkin/__init__.py,sha256=7LLBAba0th-3SGqcpqFO-lopWdUkVLKzLZiMtB-mW3M,162
-digitalkin/__version__.py,sha256=Q0IBkIes3oz9LCKqzDtGa5rK6FC1xTmf-s6rHrrfiuQ,195
+digitalkin/__version__.py,sha256=IXDN38pf9GYznzUOcCygvxQc4p61JPJp3xDMpPowM8o,195
 digitalkin/logger.py,sha256=8ze_tjt2G6mDTuQcsf7-UTXWP3UHZ7LZVSs_iqF4rX4,4685
 digitalkin/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 digitalkin/core/__init__.py,sha256=FJRcJ-B1Viyn-38L8XpOpZ8KOnf1I7PCDOAmKXLQhqc,71
@@ -17,18 +17,18 @@ digitalkin/core/job_manager/__init__.py,sha256=gGtgQpE6vbBHxAj1SYMbcpj45Q6x8Icsq
 digitalkin/core/job_manager/base_job_manager.py,sha256=yVaakJNIEPWc6ND1bWrUgBA-8r1yEEQZ_iNP1RnK0jY,10076
 digitalkin/core/job_manager/single_job_manager.py,sha256=7MkttI7pP0aZUHgz8apQf3kXHNI3Mbh8F5LfKwLhRpo,13789
 digitalkin/core/job_manager/taskiq_broker.py,sha256=4BbuvKZNWIVbAHmle8XdpPolHhiOv9XgCWR1VGAFg8E,11400
-digitalkin/core/job_manager/taskiq_job_manager.py,sha256=04DDMhik09368aCGxmrqR011VOEDgmpFVxC_ugN6Fzs,21352
+digitalkin/core/job_manager/taskiq_job_manager.py,sha256=IQ2g34mA_AsbIHNiSpzxxT6KzoOEUVb_67659LgBT_4,21251
 digitalkin/core/task_manager/__init__.py,sha256=k9i-qIoee_1yXogyQolaVFDUQBIZU3ENbYKtjrCNmTQ,31
-digitalkin/core/task_manager/base_task_manager.py,sha256=CCAltJul85WMVEaJMsNHO58QSIirRrOcVZj7cQud-v8,16751
+digitalkin/core/task_manager/base_task_manager.py,sha256=ahkflSul07hMAWRX22CoJf9FxpQhWzi_oKZz3YAN6lc,19416
 digitalkin/core/task_manager/local_task_manager.py,sha256=Z1gv4dCGD32LBSfMZJ4dGyYDe80lZRAyowTgGC6E4Vk,3534
 digitalkin/core/task_manager/remote_task_manager.py,sha256=zgccmnwwtB0nyeIZlL5Ji8SY1J89z_vjA4JD9ur7HzY,3082
 digitalkin/core/task_manager/surrealdb_repository.py,sha256=eNOVrYhTiIM0jd8j46fsKDr_THbGdK3xrog2jeqSQyA,9671
-digitalkin/core/task_manager/task_executor.py,sha256=EN8aIXZFh01dMcMw01u5QEKw3mz1IAkIWpe4l3zssc0,7373
-digitalkin/core/task_manager/task_session.py,sha256=OT0jV_xYCAEyB3krSaGMqHUiGEOinu2h7Y-3kIu3Zx8,11525
+digitalkin/core/task_manager/task_executor.py,sha256=8xh5_1zuRAaGZIH_gWyNsA4T7YYaF0sl51dLS8a6aAk,10981
+digitalkin/core/task_manager/task_session.py,sha256=0p8jPsPhtD0TgBNaE4AdU_0QLLHERhD5s2eV5HBLbU0,13307
 digitalkin/grpc_servers/__init__.py,sha256=ZIRMJ1Lcas8yQ106GCup6hn2UBOsx1sNk8ap0lpEDnY,72
 digitalkin/grpc_servers/_base_server.py,sha256=ZVeCDwI7w7fFbPTXPkeJb_SOuLfd2T7za3T4oCu2UWY,18680
 digitalkin/grpc_servers/module_server.py,sha256=fJncoCQ-nHK4rs1PFM99Ds0U1Axjxj1X4ILeud96AvM,10235
-digitalkin/grpc_servers/module_servicer.py,sha256=JxZwoMNi1nkMOW7qCQrvV5fJd5y-PWU-bq-EAgwtLHc,19404
+digitalkin/grpc_servers/module_servicer.py,sha256=8enBRV5EArfZ9g4ak9fIC4PDk4IRNoHm4e3_B-Mx6VI,19614
 digitalkin/grpc_servers/registry_server.py,sha256=v4pFpkcnWHL3Sm4CHw8wTKbSAvppEYgg_ikgdirmazc,2235
 digitalkin/grpc_servers/registry_servicer.py,sha256=5AaGacM875fHCiOmMRuqx4Q3ZsR5yvdfjuRsV4xhRcA,16485
 digitalkin/grpc_servers/utils/__init__.py,sha256=ZnAIb_F8z4NhtPypqkdmzgRSzolKnJTk3oZx5GfWH5Y,38
@@ -47,7 +47,7 @@ digitalkin/mixins/storage_mixin.py,sha256=ptZ4a2bydIa48q0V9e395vWHTu7yw4A6rI4jwK
 digitalkin/models/__init__.py,sha256=hDHtUfswaNh8wo4NZaBItg9JqC0uNSRqXArNWSrGynY,163
 digitalkin/models/core/__init__.py,sha256=jOMDmPX0uSfGA9zUi0u_kOvYJ46VdIssoIhVYvNSeew,19
 digitalkin/models/core/job_manager_models.py,sha256=RCrW20HCTQ7l2D1JtNgEKefZpMzoN-uAXK8bPorIqqA,1120
-digitalkin/models/core/task_monitor.py,sha256=JBMzqaKLrsxb0QZYM1BlvCxxkbqD_YKgsWob7bsmBeE,1626
+digitalkin/models/core/task_monitor.py,sha256=XNYCxhN9QqJZhuO2LoiWEHZwhA35dsupyfYvek_pgE8,2295
 digitalkin/models/grpc_servers/__init__.py,sha256=0tA71nPSXgRrh9DoLvx-TSwZXdYIRUEItoadpTL1cTo,42
 digitalkin/models/grpc_servers/models.py,sha256=ZQ1Gk4zmLRX_ueuwFOwXgtyG9OEPSzFa_91I_CXZmZ0,8957
 digitalkin/models/grpc_servers/types.py,sha256=rQ78s4nAet2jy-NIDj_PUWriT0kuGHr_w6ELjmjgBao,539
@@ -104,14 +104,14 @@ digitalkin/utils/arg_parser.py,sha256=wzscRlE1Qp1gGl-lAJlkkwnbU1O2oezj6BwK_BZFBI
 digitalkin/utils/development_mode_action.py,sha256=2hznh0ajW_4ZTysfoc0Y49161f_PQPATRgNk8NAn1_o,1623
 digitalkin/utils/llm_ready_schema.py,sha256=JjMug_lrQllqFoanaC091VgOqwAd-_YzcpqFlS7p778,2375
 digitalkin/utils/package_discover.py,sha256=sa6Zp5Kape1Zr4iYiNrnZxiHDnqM06ODk6yfWHom53w,13465
-digitalkin-0.3.1.dev0.dist-info/licenses/LICENSE,sha256=Ies4HFv2r2hzDRakJYxk3Y60uDFLiG-orIgeTpstnIo,20327
+digitalkin-0.3.1.dev1.dist-info/licenses/LICENSE,sha256=Ies4HFv2r2hzDRakJYxk3Y60uDFLiG-orIgeTpstnIo,20327
 modules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 modules/cpu_intensive_module.py,sha256=ejB9XPnFfA0uCuFUQbM3fy5UYfqqAlF36rv_P5Ri8ho,8363
 modules/minimal_llm_module.py,sha256=Ijld__ZnhzfLwpXD1XVkLZ7jyKZKyOFZczOpiPttJZc,11216
 modules/text_transform_module.py,sha256=bwPSnEUthZQyfLwcTLo52iAxItAoknkLh8Y3m5aywaY,7251
 services/filesystem_module.py,sha256=71Mcja8jCQqiqFHPdsIXplFIHTvgkxRhp0TRXuCfgkk,7430
 services/storage_module.py,sha256=ybTMqmvGaTrR8PqJ4FU0cwxaDjT36TskVrGoetTGmno,6955
-digitalkin-0.3.1.dev0.dist-info/METADATA,sha256=orxFRM6GJLgC6DrDpmpzlrtK17hop_3x3rqagEEWu_k,29720
-digitalkin-0.3.1.dev0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-digitalkin-0.3.1.dev0.dist-info/top_level.txt,sha256=gcjqlyrZuLjIyxrOIavCQM_olpr6ND5kPKkZd2j0xGo,40
-digitalkin-0.3.1.dev0.dist-info/RECORD,,
+digitalkin-0.3.1.dev1.dist-info/METADATA,sha256=Aw7Z4ekcYlhBCCGu7x1gut_2YhOaOvxCoWlNPNBgAOU,29720
+digitalkin-0.3.1.dev1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+digitalkin-0.3.1.dev1.dist-info/top_level.txt,sha256=gcjqlyrZuLjIyxrOIavCQM_olpr6ND5kPKkZd2j0xGo,40
+digitalkin-0.3.1.dev1.dist-info/RECORD,,