digitalkin 1.0.0.dev5__tar.gz → 1.0.0.dev7__tar.gz

{digitalkin-1.0.0.dev5 → digitalkin-1.0.0.dev7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: digitalkin
-Version: 1.0.0.dev5
+Version: 1.0.0.dev7
 Summary: SDK to build kin used in DigitalKin
 Author-email: "DigitalKin.ai" <contact@digitalkin.ai>
 License: Attribution-NonCommercial-ShareAlike 4.0 International
@@ -453,13 +453,13 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: ag-ui-protocol>=0.1.18
-Requires-Dist: agentic-mesh-protocol==1.0.0.dev1
+Requires-Dist: agentic-mesh-protocol==1.0.0.dev2
 Requires-Dist: anyio>=4.13.0
 Requires-Dist: grpcio-health-checking==1.80.0
 Requires-Dist: grpcio-reflection==1.80.0
 Requires-Dist: grpcio-status==1.80.0
 Requires-Dist: pydantic>=2.12.4
-Requires-Dist: pydantic-settings>=2.14.0
+Requires-Dist: pydantic-settings>=2.14.1
 Requires-Dist: redis[hiredis]<8,>=7.4.0
 Provides-Extra: performance
 Requires-Dist: uvloop>=0.21; extra == "performance"

{digitalkin-1.0.0.dev5 → digitalkin-1.0.0.dev7}/pyproject.toml

@@ -28,16 +28,16 @@
 
     dependencies = [
         "ag-ui-protocol>=0.1.18",
-        "agentic-mesh-protocol==1.0.0.dev1",
+        "agentic-mesh-protocol==1.0.0.dev2",
         "anyio>=4.13.0",
         "grpcio-health-checking==1.80.0",
         "grpcio-reflection==1.80.0",
         "grpcio-status==1.80.0",
         "pydantic>=2.12.4",
-        "pydantic-settings>=2.14.0",
+        "pydantic-settings>=2.14.1",
         "redis[hiredis]>=7.4.0,<8",
     ]
-    version = "1.0.0.dev5"
+    version = "1.0.0.dev7"
 
     [project.optional-dependencies]
         performance = [ "uvloop>=0.21" ]
@@ -60,16 +60,16 @@
         "build>=1.5.0",
         "bump-my-version>=1.3.0",
         "cryptography>=48.0.0",
-        "mypy>=2.0.0",
+        "mypy>=2.1.0",
         "pre-commit>=4.6.0",
         "pyright>=1.1.409",
-        "ruff>=0.15.12",
+        "ruff>=0.15.13",
         "twine>=6.2.0",
-        "types-grpcio-health-checking>=1.0.0.20260408",
-        "types-grpcio-reflection>=1.0.0.20260408",
-        "types-grpcio>=1.0.0.20260408",
-        "types-protobuf>=7.34.1.20260503",
-        "typos>=1.46.0",
+        "types-grpcio-health-checking>=1.0.0.20260518",
+        "types-grpcio-reflection>=1.0.0.20260508",
+        "types-grpcio>=1.0.0.20260518",
+        "types-protobuf>=7.34.1.20260518",
+        "typos>=1.46.2",
     ]
     docs = [
         "griffe-inherited-docstrings>=1.1.3",
@@ -80,9 +80,9 @@
         "mkdocs-awesome-pages-plugin>=2.10.1",
         "mkdocs-coverage>=2.0.0",
         "mkdocs-git-committers-plugin-2>=2.5.0",
-        "mkdocs-git-revision-date-localized-plugin>=1.5.1",
+        "mkdocs-git-revision-date-localized-plugin>=1.5.2",
         "mkdocs-glightbox>=0.5.2",
-        "mkdocs-include-markdown-plugin>=7.2.2",
+        "mkdocs-include-markdown-plugin>=7.3.0",
         "mkdocs-literate-nav>=0.6.3",
         "mkdocs-llmstxt>=0.5.0",
         "mkdocs-material[imaging]>=9.7.6",
@@ -100,7 +100,7 @@
         "freezegun>=1.5.5",
         "grpcio-testing>=1.80.0",
         "hdrhistogram>=0.10.3",
-        "hypothesis>=6.152.4",
+        "hypothesis>=6.152.8",
         "objgraph>=3.6",
         "psutil>=7.2.2",
         "pytest-asyncio>=1.3.0",

{digitalkin-1.0.0.dev5 → digitalkin-1.0.0.dev7}/src/digitalkin/__init__.py

@@ -10,24 +10,22 @@ from digitalkin.modules.archetype_module import ArchetypeModule
 from digitalkin.modules.tool_module import ToolModule
 from digitalkin.modules.trigger_handler import TriggerHandler
 from digitalkin.services.communication import (
-    ConsumerConfig,
-    GatewayConsumer,
-    GatewayConsumerError,
-    StartStreamRejected,
-    StartStreamRpcError,
+    GrpcCommunication,
+    M2MAtCapacityError,
+    M2MCallTimeout,
+    M2MTargetUnavailable,
 )
 from digitalkin.services.services_config import ServicesConfig
 
 __all__ = [
     "ArchetypeModule",
-    "ConsumerConfig",
-    "GatewayConsumer",
-    "GatewayConsumerError",
+    "GrpcCommunication",
+    "M2MAtCapacityError",
+    "M2MCallTimeout",
+    "M2MTargetUnavailable",
     "ModuleContext",
     "ModuleStatus",
     "ServicesConfig",
-    "StartStreamRejected",
-    "StartStreamRpcError",
     "ToolModule",
     "TriggerHandler",
     "__version__",

{digitalkin-1.0.0.dev5 → digitalkin-1.0.0.dev7}/src/digitalkin/__version__.py

@@ -5,4 +5,4 @@ from importlib.metadata import PackageNotFoundError, version
 try:
     __version__ = version("digitalkin")
 except PackageNotFoundError:
-    __version__ = "1.0.0.dev5"
+    __version__ = "1.0.0.dev7"

{digitalkin-1.0.0.dev5 → digitalkin-1.0.0.dev7}/src/digitalkin/community/agno/__init__.py

@@ -24,10 +24,10 @@ from digitalkin.community.agno.hitl import (
     AgnoHitlRunner,
     PausedRunRecord,
     PausedRunStore,
-    PauseInfo,
     emit_awaiting_tool_result,
     emit_messages_snapshot,
 )
+from digitalkin.community.agno.models import PauseInfo
 
 __all__ = [
     "HITL_STORAGE_CONFIG",

{digitalkin-1.0.0.dev5 → digitalkin-1.0.0.dev7}/src/digitalkin/community/agno/hitl.py

@@ -66,11 +66,12 @@ from __future__ import annotations
 
 import json
 import logging
-from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any, ClassVar
 
 from pydantic import BaseModel, ConfigDict, Field
 
+from digitalkin.community.agno.models import PauseInfo
+
 if TYPE_CHECKING:
     from collections.abc import Callable, Coroutine
 
@@ -123,34 +124,6 @@ Example::
 """
 
 
-# ── Return type ─────────────────────────────────────────────────────────────
-
-
-@dataclass
-class PauseInfo:
-    """Summary of a paused Agno run.
-
-    Returned by :meth:`AgnoHitlRunner.run` and related methods whenever
-    the run paused on one or more external tool calls. Callers typically
-    use it to emit the AG-UI awaiting-tool-result event to the front.
-
-    ``new_messages`` carries the AG-UI messages generated by Agno during
-    the paused run (user echoes, the assistant message with ``tool_calls``,
-    and any tool results emitted before the pause). It's provided because
-    Agno does not emit stream events from which the front can reconstruct
-    the assistant-with-tool-calls message — in particular, when the LLM
-    goes straight from reasoning to a frontend tool call without emitting
-    any text. Consumers typically push these messages to the front via a
-    :class:`~ag_ui.core.events.MessagesSnapshotEvent` so the client has an
-    authoritative view of the conversation.
-    """
-
-    thread_id: str
-    run_id: str
-    pending_tool_call_ids: list[str]
-    new_messages: list[AgUiMessage] = field(default_factory=list)
-
-
 # ── Storage wrapper ─────────────────────────────────────────────────────────
 
 

digitalkin-1.0.0.dev7/src/digitalkin/community/agno/models.py

@@ -0,0 +1,28 @@
+"""Models for the Agno community integration."""
+
+from ag_ui.core.types import Message as AgUiMessage
+from pydantic import BaseModel, Field
+
+
+class PauseInfo(BaseModel):
+    """Summary of a paused Agno run.
+
+    Returned by :meth:`AgnoHitlRunner.run` and related methods whenever
+    the run paused on one or more external tool calls. Callers typically
+    use it to emit the AG-UI awaiting-tool-result event to the front.
+
+    ``new_messages`` carries the AG-UI messages generated by Agno during
+    the paused run (user echoes, the assistant message with ``tool_calls``,
+    and any tool results emitted before the pause). It's provided because
+    Agno does not emit stream events from which the front can reconstruct
+    the assistant-with-tool-calls message — in particular, when the LLM
+    goes straight from reasoning to a frontend tool call without emitting
+    any text. Consumers typically push these messages to the front via a
+    :class:`~ag_ui.core.events.MessagesSnapshotEvent` so the client has an
+    authoritative view of the conversation.
+    """
+
+    thread_id: str
+    run_id: str
+    pending_tool_call_ids: list[str]
+    new_messages: list[AgUiMessage] = Field(default_factory=list)

{digitalkin-1.0.0.dev5 → digitalkin-1.0.0.dev7}/src/digitalkin/core/common/factories.py

@@ -6,6 +6,7 @@ import asyncio
 from typing import TYPE_CHECKING
 
 from digitalkin.logger import logger
+from digitalkin.models.settings.queue import QueueSettings
 
 if TYPE_CHECKING:
     from digitalkin.models.module.tool_cache import ToolCache
@@ -88,15 +89,13 @@ class ModuleFactory:
 class QueueFactory:
     """Factory for creating asyncio queues with consistent configuration."""
 
-    # Default max queue size to prevent unbounded memory growth
-    DEFAULT_MAX_QUEUE_SIZE = 1000
-
     @staticmethod
-    def create_bounded_queue(maxsize: int = DEFAULT_MAX_QUEUE_SIZE) -> asyncio.Queue:
+    def create_bounded_queue(maxsize: int | None = None) -> asyncio.Queue:
         """Create a bounded asyncio queue with standard configuration.
 
         Args:
-            maxsize: Maximum queue size (default 1000, 0 means unlimited)
+            maxsize: Maximum queue size. ``None`` uses QueueSettings.max_size
+                (default 1000); 0 means unlimited.
 
         Returns:
             Bounded asyncio.Queue instance
@@ -111,6 +110,8 @@ class QueueFactory:
             # unlimited queue
             queue = QueueFactory.create_bounded_queue(maxsize=0)
         """
+        if maxsize is None:
+            maxsize = QueueSettings().max_size
         if maxsize < 0:
             msg = "maxsize must be >= 0"
             raise ValueError(msg)

digitalkin-1.0.0.dev7/src/digitalkin/core/exceptions.py

@@ -0,0 +1,16 @@
+"""Exceptions for the DigitalKin core package."""
+
+
+class BackpressureTimeoutError(Exception):
+    """Producer's XADD throttled past the backpressure timeout.
+
+    Throttled past :data:`GatewayBackpressureSettings.backpressure_timeout_s`.
+    Caller (typically the module's ``_on_output`` callback) must surface
+    this as ``stream.error(code=BACKPRESSURE_TIMEOUT)`` via the
+    ``_emit_fatal_to_redis`` path so the consumer sees a typed sentinel
+    instead of a silent stall.
+    """
+
+
+class BulkheadFullError(Exception):
+    """Raised when a bulkhead semaphore cannot be acquired within timeout."""

{digitalkin-1.0.0.dev5 → digitalkin-1.0.0.dev7}/src/digitalkin/core/job_manager/base_job_manager.py

@@ -8,9 +8,9 @@ from digitalkin.core.task_manager.base_task_manager import BaseTaskManager
 from digitalkin.core.task_manager.task_session import TaskSession
 from digitalkin.models.module.module import ModuleCodeModel
 from digitalkin.models.module.module_types import DataModel, InputModelT, OutputModelT, SetupModelT
+from digitalkin.models.services.services import ServicesMode
 from digitalkin.modules._base_module import BaseModule
 from digitalkin.services.services_config import ServicesConfig
-from digitalkin.services.services_models import ServicesMode
 
 
 class BaseJobManager(abc.ABC, Generic[InputModelT, OutputModelT, SetupModelT]):
@@ -58,7 +58,6 @@ class BaseJobManager(abc.ABC, Generic[InputModelT, OutputModelT, SetupModelT]):
         """Get tasks from the task manager."""
         return self._task_manager.tasks
 
-    # Delegate task lifecycle methods to task manager
     async def create_task(
         self,
         task_id: str,
@@ -69,6 +68,8 @@ class BaseJobManager(abc.ABC, Generic[InputModelT, OutputModelT, SetupModelT]):
     ) -> None:
         """Create a task using the task manager.
 
+        Delegate task lifecycle methods to task manager
+
         Args:
             task_id: Unique identifier for the task
             mission_id: Mission identifier

{digitalkin-1.0.0.dev5 → digitalkin-1.0.0.dev7}/src/digitalkin/core/job_manager/single_job_manager.py

@@ -9,7 +9,6 @@ the in-memory queue (for local consumers) and a Redis Stream
 from __future__ import annotations
 
 import asyncio
-import os
 import uuid
 from typing import TYPE_CHECKING, Any
 
@@ -17,20 +16,23 @@ import grpc
 
 from digitalkin.core.common import ModuleFactory
 from digitalkin.core.job_manager.base_job_manager import BaseJobManager
+from digitalkin.core.profiling.step_timer import StepTimer
 from digitalkin.core.task_manager.local_task_manager import LocalTaskManager
+from digitalkin.core.task_manager.redis.redis_streams import RedisStreamWriter
 from digitalkin.core.task_manager.task_session import TaskSession
 from digitalkin.logger import logger
 from digitalkin.models.core.job_manager_models import BackpressureStrategy
 from digitalkin.models.module.base_types import DataModel, InputModelT, OutputModelT, SetupModelT
 from digitalkin.models.module.module import ModuleCodeModel
+from digitalkin.models.settings.task_manager import JobManagerSettings
+from digitalkin.services.task_manager.redis_task_manager import RedisTaskManager
 
 if TYPE_CHECKING:
     from collections.abc import Callable
 
     from digitalkin.core.task_manager.redis.redis_client import RedisClient
-    from digitalkin.core.task_manager.redis.redis_streams import RedisStreamWriter
+    from digitalkin.models.services.services import ServicesMode
     from digitalkin.modules._base_module import BaseModule
-    from digitalkin.services.services_models import ServicesMode
 
 
 class SingleJobManager(BaseJobManager[InputModelT, OutputModelT, SetupModelT]):
@@ -54,7 +56,7 @@ class SingleJobManager(BaseJobManager[InputModelT, OutputModelT, SetupModelT]):
         services_mode: ServicesMode,
         redis_client: RedisClient,
         default_timeout: float = 300.0,
-        max_concurrent_tasks: int = int(os.environ.get("DIGITALKIN_MAX_CONCURRENT_TASKS", "100")),
+        max_concurrent_tasks: int | None = None,
     ) -> None:
         """Initialize the job manager.
 
@@ -62,22 +64,25 @@ class SingleJobManager(BaseJobManager[InputModelT, OutputModelT, SetupModelT]):
             module_class: The class of the module to be managed.
             services_mode: The mode of operation for the services (e.g., ASYNC or SYNC).
             default_timeout: Default timeout for task operations
-            max_concurrent_tasks: Maximum number of concurrent tasks
+            max_concurrent_tasks: Maximum number of concurrent tasks. ``None`` keeps
+                the task manager's TaskManagerSettings-derived limit.
             redis_client: Redis client for signal delivery and stream persistence.
         """
         # Create local task manager for same-process execution
         task_manager = LocalTaskManager(default_timeout)
-        task_manager.max_concurrent_tasks = max_concurrent_tasks
+        if max_concurrent_tasks is not None:
+            task_manager.max_concurrent_tasks = max_concurrent_tasks
 
         # Initialize base job manager with task manager
         super().__init__(module_class, services_mode, task_manager)
 
+        jm_settings = JobManagerSettings()
         self._lock = asyncio.Lock()
-        self._config_setup_timeout = float(os.environ.get("DIGITALKIN_CONFIG_SETUP_TIMEOUT", "30.0"))
+        self._config_setup_timeout = jm_settings.config_setup_timeout
 
         # Backpressure configuration
-        self._backpressure_strategy = BackpressureStrategy(os.environ.get("DIGITALKIN_BACKPRESSURE_STRATEGY", "block"))
-        self._backpressure_timeout = float(os.environ.get("DIGITALKIN_BACKPRESSURE_TIMEOUT", "300.0"))
+        self._backpressure_strategy = jm_settings.backpressure_strategy
+        self._backpressure_timeout = jm_settings.backpressure_timeout
 
         # Redis for signal delivery and durable output persistence
         self._redis_client = redis_client
@@ -86,8 +91,6 @@ class SingleJobManager(BaseJobManager[InputModelT, OutputModelT, SetupModelT]):
         # Pool one RedisTaskManager across all preload_instance calls.
         # The class is task-id-stateless; its `_listener` is already a
         # process-wide singleton via SharedRedisListener.get_or_create.
-        from digitalkin.services.task_manager.redis_task_manager import RedisTaskManager
-
         self._task_manager_strategy = RedisTaskManager(self._redis_client)
 
     async def start(self) -> None:
@@ -198,7 +201,8 @@ class SingleJobManager(BaseJobManager[InputModelT, OutputModelT, SetupModelT]):
             logger.debug("Queue write rejected - session not found", extra={"job_id": job_id})
             return
 
-        # Serialize outside the lock — pure computation, no contention
+        # Serialize outside the lock — pure computation, no contention.
+        # Redis stores only bytes/strings, so a JSON-compatible dump is required.
         data = output_data.model_dump(mode="json")
 
         # P1: Redis write outside lock — XADD is idempotent, safe without serialization.
@@ -256,7 +260,7 @@ class SingleJobManager(BaseJobManager[InputModelT, OutputModelT, SetupModelT]):
         tool_cache: Any = None,
         callback: Callable | None = None,
     ) -> tuple[Any, str, Callable]:
-        """Phase 3.A: Build + warm a module instance without input.
+        """Build + warm a module instance without input.
 
         Calls the factory, wires the redis task manager + callback, and
         runs the module's ``prepare()`` (which is idempotent — the later
@@ -279,8 +283,6 @@ class SingleJobManager(BaseJobManager[InputModelT, OutputModelT, SetupModelT]):
         Returns:
             ``(module, job_id, callback)`` — pass to ``run_preloaded``.
         """
-        from digitalkin.core.profiling.step_timer import StepTimer
-
         timer = StepTimer()
         job_id = job_id or str(uuid.uuid4())
         module = ModuleFactory.create_module_instance(
@@ -299,8 +301,6 @@ class SingleJobManager(BaseJobManager[InputModelT, OutputModelT, SetupModelT]):
         timer.mark("redis_task_manager")
 
         if callback is None:
-            from digitalkin.core.task_manager.redis.redis_streams import RedisStreamWriter
-
             self._stream_writers[job_id] = RedisStreamWriter(job_id, self._redis_client)
             callback = await self.job_specific_callback(self.add_to_queue, job_id)
             timer.mark("default_callback")
@@ -319,7 +319,7 @@ class SingleJobManager(BaseJobManager[InputModelT, OutputModelT, SetupModelT]):
         setup_data: SetupModelT,
         callback: Callable,
     ) -> str:
-        """Phase 3.A: Run a pre-prepared module instance with input.
+        """Run a pre-prepared module instance with input.
 
         ``module`` must come from :meth:`preload_instance`. Schedules
         the run in the task manager and returns the job_id.
@@ -335,8 +335,6 @@ class SingleJobManager(BaseJobManager[InputModelT, OutputModelT, SetupModelT]):
         Returns:
             The ``job_id`` (echoed for caller convenience).
         """
-        from digitalkin.core.profiling.step_timer import StepTimer
-
         timer = StepTimer()
         await self.create_task(
             job_id,

digitalkin-1.0.0.dev7/src/digitalkin/core/profiling/__init__.py

@@ -0,0 +1,6 @@
+"""Profiling and monitoring tools for DigitalKin tasks and servers."""
+
+from digitalkin.core.profiling.task_profiler import TaskProfiler
+from digitalkin.models.settings.profiling import ProfilerMode
+
+__all__ = ["ProfilerMode", "TaskProfiler"]

{digitalkin-1.0.0.dev5 → digitalkin-1.0.0.dev7}/src/digitalkin/core/profiling/step_timer.py

@@ -33,6 +33,7 @@ class StepTimer:
     __slots__ = ("_last", "_steps", "_t0")
 
     def __init__(self) -> None:
+        """Init start time."""
         now = time.perf_counter_ns()
         self._t0 = now
         self._last = now
@@ -55,5 +56,9 @@ class StepTimer:
             logger.info("[lat-audit] %s: %s", prefix, " ".join(parts))
 
     def total_ms(self) -> float:
-        """Total elapsed time across all marks in milliseconds."""
+        """Total elapsed time across all marks in milliseconds.
+
+        Returns:
+            float: time elapsed in ms
+        """
         return (self._last - self._t0) / 1e6

{digitalkin-1.0.0.dev5 → digitalkin-1.0.0.dev7}/src/digitalkin/core/profiling/task_profiler.py

@@ -2,51 +2,12 @@
 
 import datetime
 import io
-import logging
 import os
-from enum import Enum
 from pathlib import Path
-from typing import Any
+from typing import Any, ClassVar
 
 from digitalkin.logger import logger
-
-# Phase 7.C: rotate per-task profile files to avoid unbounded growth.
-# Default keeps the most recent N profiles by mtime; configure via
-# ``DIGITALKIN_PROFILER_KEEP_N``.
-PROFILER_KEEP_N = int(os.environ.get("DIGITALKIN_PROFILER_KEEP_N", "100"))
-
-
-def _rotate_profiles(output_dir: str, keep_n: int, suffixes: tuple[str, ...]) -> None:
-    """Trim ``output_dir`` to the most recent ``keep_n`` files by mtime.
-
-    Args:
-        output_dir: Directory containing profile files.
-        keep_n: Number of files to keep. ``<= 0`` disables rotation.
-        suffixes: File extensions to include in rotation (e.g. ``(".html",)``).
-    """
-    if keep_n <= 0:
-        return
-    try:
-        candidates = [p for p in Path(output_dir).iterdir() if p.is_file() and p.suffix in suffixes]
-    except OSError:
-        return
-    if len(candidates) <= keep_n:
-        return
-    candidates.sort(key=lambda p: p.stat().st_mtime, reverse=True)
-    for stale in candidates[keep_n:]:
-        try:
-            stale.unlink()
-        except OSError:
-            logger.debug("Profiler rotation: could not delete %s", stale)
-
-
-class ProfilerMode(str, Enum):
-    """Profiler backend selection."""
-
-    NONE = "none"
-    VIZTRACER = "viztracer"
-    YAPPI = "yappi"
-    PYINSTRUMENT = "pyinstrument"
+from digitalkin.models.settings.profiling import ProfilerMode, ProfilingSettings
 
 
 class TaskProfiler:
@@ -59,6 +20,8 @@ class TaskProfiler:
     run concurrently, yappi stats reflect all of them.
     """
 
+    _settings: ClassVar[ProfilingSettings] = ProfilingSettings()
+
     def __init__(self, task_id: str, mode: ProfilerMode, output_dir: str) -> None:
         """Initialize the task profiler.
 
@@ -73,6 +36,30 @@ class TaskProfiler:
         self._profiler: Any = None
         self._yappi_started: bool = False
 
+    @staticmethod
+    def _rotate_profiles(output_dir: str, keep_n: int, suffixes: tuple[str, ...]) -> None:
+        """Trim ``output_dir`` to the most recent ``keep_n`` files by mtime.
+
+        Args:
+            output_dir: Directory containing profile files.
+            keep_n: Number of files to keep. ``<= 0`` disables rotation.
+            suffixes: File extensions to include in rotation (e.g. ``(".html",)``).
+        """
+        if keep_n <= 0:
+            return
+        try:
+            candidates = [p for p in Path(output_dir).iterdir() if p.is_file() and p.suffix in suffixes]
+        except OSError:
+            return
+        if len(candidates) <= keep_n:
+            return
+        candidates.sort(key=lambda p: p.stat().st_mtime, reverse=True)
+        for stale in candidates[keep_n:]:
+            try:
+                stale.unlink()
+            except OSError:  # noqa: PERF203
+                logger.debug("Profiler rotation: could not delete %s", stale)
+
     def start(self) -> None:
         """Start the profiler. No-op when mode is NONE."""
         if self._mode == ProfilerMode.NONE:
@@ -150,40 +137,10 @@ class TaskProfiler:
                 Path(path).write_text(self._profiler.output_html(), encoding="utf-8")
                 logger.info("Pyinstrument profile saved: %s", path)
                 logger.info("Pyinstrument summary:\n%s", self._profiler.output_text())
-                _rotate_profiles(self._output_dir, PROFILER_KEEP_N, (".html",))
+                self._rotate_profiles(self._output_dir, self._settings.profiler_keep_n, (".html",))
 
         except Exception:
             logger.exception("Failed to stop/save profiler %s for task %s", self._mode.value, self._task_id)
         finally:
             self._profiler = None
             self._yappi_started = False
-
-
-class _LogWriter:
-    """Adapter to redirect yappi print_all output to a logger."""
-
-    def __init__(self, target_logger: logging.Logger, level: int) -> None:
-        """Initialize the log writer.
-
-        Args:
-            target_logger: Logger to write to.
-            level: Logging level for output.
-        """
-        self._logger = target_logger
-        self._level = level
-        self._buffer: list[str] = []
-
-    def write(self, text: str) -> None:
-        """Buffer text lines for logging.
-
-        Args:
-            text: Text to write.
-        """
-        if text and text.strip():
-            self._buffer.append(text.rstrip())
-
-    def flush(self) -> None:
-        """Flush buffered lines to the logger."""
-        if self._buffer:
-            self._logger.log(self._level, "Yappi top functions:\n%s", "\n".join(self._buffer))
-            self._buffer.clear()

{digitalkin-1.0.0.dev5 → digitalkin-1.0.0.dev7}/src/digitalkin/core/resilience/__init__.py

@@ -7,7 +7,8 @@
 - ``StartupRestorer``: Redis checkpoint restore on startup.
 """
 
-from digitalkin.core.resilience.bulkhead import Bulkhead, BulkheadFullError
+from digitalkin.core.exceptions import BulkheadFullError
+from digitalkin.core.resilience.bulkhead import Bulkhead
 from digitalkin.core.resilience.graceful_shutdown import GracefulShutdownHandler, StartupRestorer
 from digitalkin.core.resilience.session_reaper import SessionReaper
 from digitalkin.core.resilience.watchdog import WatchdogThread

{digitalkin-1.0.0.dev5 → digitalkin-1.0.0.dev7}/src/digitalkin/core/resilience/bulkhead.py

@@ -20,11 +20,8 @@ from typing import ClassVar
 
 from typing_extensions import Self
 
-from digitalkin.logger import logger
-
-
-class BulkheadFullError(Exception):
-    """Raised when a bulkhead semaphore cannot be acquired within timeout."""
+from digitalkin.core.exceptions import BulkheadFullError
+from digitalkin.models.settings.resilience import BulkheadSettings
 
 
 class Bulkhead:
@@ -69,9 +66,12 @@ class Bulkhead:
             oldest = next(iter(cls._instances))
             del cls._instances[oldest]
 
-        env_key = f"DIGITALKIN_BULKHEAD_{service_id.upper()}_MAX"
-        default_max = int(os.environ.get(env_key, os.environ.get("DIGITALKIN_BULKHEAD_DEFAULT_MAX", "50")))
-        default_timeout = float(os.environ.get("DIGITALKIN_BULKHEAD_TIMEOUT", "2.0"))
+        settings = BulkheadSettings()
+        # Per-service override has a dynamic env-var suffix, so it cannot be a
+        # static settings field — read it directly, falling back to the setting.
+        env_max = os.environ.get(f"DIGITALKIN_BULKHEAD_{service_id.upper()}_MAX")
+        default_max = int(env_max) if env_max is not None else settings.default_max
+        default_timeout = settings.timeout
 
         inst = cls(
             service_id=service_id,