digitalkin 1.0.0.dev0__tar.gz → 1.0.0.dev2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: digitalkin
-Version: 1.0.0.dev0
+Version: 1.0.0.dev2
 Summary: SDK to build kin used in DigitalKin
 Author-email: "DigitalKin.ai" <contact@digitalkin.ai>
 License: Attribution-NonCommercial-ShareAlike 4.0 International

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

@@ -37,7 +37,7 @@
         "pydantic-settings>=2.14.0",
         "redis[hiredis]>=7.4.0,<8",
     ]
-    version = "1.0.0.dev0"
+    version = "1.0.0.dev2"
 
     [project.optional-dependencies]
         performance = [ "uvloop>=0.21" ]

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

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

digitalkin-1.0.0.dev2/src/digitalkin/core/task_manager/module_runner.py

@@ -0,0 +1,170 @@
+"""Module runner — invoked by the dial-back orchestrator.
+
+Receives the consumer's first input Struct (the query), resolves the
+setup, builds the input/setup models, looks up the tool cache, and
+starts the module via the job manager. Each module output goes to the
+task's Redis Stream via the ``_on_output`` callback so the gateway's
+``_consume_from_redis`` can drain it back to the consumer.
+
+This used to live inline in ``TaskDispatcher._handle_dispatch``. The
+dispatcher (separate XADD/XREAD bus) is gone in embedded mode — the
+dial-back BiDi handler is the sole orchestrator and calls into here
+directly when the consumer's first reply lands.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import time
+from typing import TYPE_CHECKING, Any
+
+from google.protobuf import json_format, struct_pb2
+
+from digitalkin.core.profiling.step_timer import StepTimer
+from digitalkin.core.profiling.task_profiler import ProfilerMode, TaskProfiler
+from digitalkin.grpc_servers.stream_error_codes import StreamErrorCode
+from digitalkin.logger import logger
+from digitalkin.models.settings.profiling import ProfilingSettings
+
+# Singleton — read profiler env once at import.
+_PROFILING = ProfilingSettings()
+
+if TYPE_CHECKING:
+    from collections.abc import Awaitable, Callable
+
+    from digitalkin.core.task_manager.redis.redis_client import RedisClient
+    from digitalkin.grpc_servers.module_servicer import ModuleServicer
+
+
+class ModuleRunner:
+    """Run one task end-to-end: setup → module instance → output drain.
+
+    Stateless aside from the injected ``servicer`` and ``redis_client``;
+    one instance is shared per ``GatewayServicer`` (created in
+    ``module_server._register_gateway_servicer`` and passed to the
+    gateway).
+    """
+
+    _redis_client: RedisClient
+    _servicer: ModuleServicer
+
+    def __init__(self, redis_client: RedisClient, servicer: ModuleServicer) -> None:
+        """Initialize the runner.
+
+        Args:
+            redis_client: Redis used to write module outputs to the task stream.
+            servicer: ModuleServicer for setup resolution and job management.
+        """
+        self._redis_client = redis_client
+        self._servicer = servicer
+
+    async def run(
+        self,
+        query: struct_pb2.Struct,
+        *,
+        task_id: str,
+        setup_id: str,
+        mission_id: str,
+        on_fatal: Callable[[str, str], Awaitable[None]],
+    ) -> None:
+        """Execute one module task to completion.
+
+        Args:
+            query: The first input Struct received from the consumer
+                (delivered via the dial-back BiDi).
+            task_id: Task identifier; output stream is ``task:{task_id}:stream``.
+            setup_id: Setup identifier (used for setup resolution + tool cache).
+            mission_id: Mission identifier (carried for logging context).
+            on_fatal: Async callback invoked on any unhandled exception
+                with ``(StreamErrorCode value, message)``. The caller is
+                responsible for emitting the corresponding ``stream.error``
+                + EOS to the task's Redis stream.
+        """
+        log_extra = {"task_id": task_id, "setup_id": setup_id, "mission_id": mission_id}
+        stream_key = f"task:{task_id}:stream"
+        timer = StepTimer()
+
+        # Per-task profiler — zero-cost when DIGITALKIN_PROFILER=none.
+        # Runs over the whole module lifecycle so the saved profile shows
+        # setup/init/run/output broken down with line-level resolution.
+        profiler_mode = ProfilerMode(_PROFILING.profiler) if _PROFILING.profiler in {p.value for p in ProfilerMode} else ProfilerMode.NONE
+        profiler = TaskProfiler(task_id=task_id, mode=profiler_mode, output_dir=_PROFILING.profile_output_dir)
+        profiler.start()
+
+        # Fire the (async) setup resolve immediately so it overlaps with
+        # the (sync) input parsing below. Cold-cache _resolve_setup is a
+        # gRPC call (50-200ms); the input work below is sub-ms.
+        setup_version_task = asyncio.create_task(
+            self._servicer._resolve_setup(setup_id, mission_id),  # noqa: SLF001
+            name=f"resolve_setup_{task_id}",
+        )
+
+        try:
+            timer.mark("entry")
+
+            input_dict = json_format.MessageToDict(query)
+            timer.mark("struct_to_dict")
+
+            input_data = self._servicer.module_class.create_input_model(input_dict)
+            timer.mark("pydantic_input")
+
+            setup_version = await setup_version_task
+            timer.mark("setup_resolve")
+
+            setup_data = await self._servicer.module_class.create_setup_model(setup_version.content)
+            timer.mark("setup_model")
+
+            tool_cache = self._servicer.get_tool_cache(setup_version.setup_id)
+            timer.mark("tool_cache_lookup")
+
+            # L8: measure latency from runner entry to first producer output.
+            runner_start_ns = time.perf_counter_ns()
+            first_logged = False
+
+            async def _on_output(output_data: Any) -> None:
+                nonlocal first_logged
+                data = output_data.model_dump(mode="json")
+                if not first_logged:
+                    elapsed_ms = (time.perf_counter_ns() - runner_start_ns) / 1e6
+                    logger.info(
+                        "[lat-audit] producer_first_byte_to_redis: %.1fms task_id=%s",
+                        elapsed_ms, task_id, extra=log_extra,
+                    )
+                    first_logged = True
+                if data.get("root", {}).get("protocol") == "stream.end":
+                    await self._redis_client.xadd(stream_key, {"eos": b"true"})
+                    await self._redis_client.expire(stream_key, 60)
+                    return
+                s = struct_pb2.Struct()
+                s.update(data)
+                await self._redis_client.xadd(stream_key, {"pb": s.SerializeToString()})
+
+            await self._servicer.job_manager.create_module_instance_job(
+                input_data,
+                setup_data,
+                mission_id=mission_id,
+                setup_id=setup_version.setup_id,
+                setup_version_id=setup_version.id,
+                request_metadata={"x-task-id": task_id},
+                job_id=task_id,
+                tool_cache=tool_cache,
+                callback=_on_output,
+            )
+            timer.mark("create_job")
+            timer.log("ModuleRunner", task_id)
+
+        except Exception as exc:
+            logger.exception("ModuleRunner: module job failed", extra=log_extra)
+            await on_fatal(
+                StreamErrorCode.MODULE_RUNTIME_ERROR.value,
+                f"module execution failed: {type(exc).__name__}: {exc}",
+            )
+            # Cancel the resolve task if it's still in flight (sync work
+            # raised before we could await it).
+            if not setup_version_task.done():
+                setup_version_task.cancel()
+                with contextlib.suppress(asyncio.CancelledError, Exception):
+                    await setup_version_task
+        finally:
+            profiler.stop()

{digitalkin-1.0.0.dev0 → digitalkin-1.0.0.dev2}/src/digitalkin/grpc_servers/gateway_constants.py

@@ -64,7 +64,8 @@ BACKPRESSURE_TIMEOUT_S = _gw.backpressure.backpressure_timeout_s
 DEFAULT_OUTPUT_QUEUE_SIZE = _gw.queue.output_queue_size
 DEFAULT_INPUT_QUEUE_SIZE = _gw.queue.input_queue_size
 ENQUEUE_TIMEOUT_S = _gw.queue.enqueue_timeout_s
-INPUT_WAIT_TIMEOUT_S = _gw.queue.dispatcher_input_wait_s
+INPUT_WAIT_TIMEOUT_S = _gw.queue.dispatcher_input_wait_s  # retired in 2.B; see GatewayQueueSettings
+TOOLKIT_CACHE_TTL_S = _gw.queue.toolkit_cache_ttl_s
 REDIS_HEALTH_CHECK_TIMEOUT_S = _gw.redis_health_timeout
 
 # ══════════════════════════════════════════════════════════════════

{digitalkin-1.0.0.dev0 → digitalkin-1.0.0.dev2}/src/digitalkin/grpc_servers/gateway_servicer.py

@@ -25,7 +25,6 @@ from __future__ import annotations
 import asyncio
 import contextlib
 import json
-import time
 from datetime import datetime, timezone
 from typing import TYPE_CHECKING, Any
 
@@ -53,6 +52,7 @@ from digitalkin.services.communication.grpc_communication import (
 if TYPE_CHECKING:
     from collections.abc import AsyncGenerator, AsyncIterator
 
+    from digitalkin.core.task_manager.module_runner import ModuleRunner
     from digitalkin.core.task_manager.redis.redis_client import RedisClient
     from digitalkin.grpc_servers.utils.circuit_breaker import CircuitBreaker
 
@@ -67,7 +67,6 @@ class GatewayServicer:
     _registry: StreamRegistry
     _redis_client: RedisClient
     _circuit_breaker: CircuitBreaker | None
-    _dispatch_key: str
 
     @staticmethod
     def _sentinel(seq: int, task_id: str, protocol: str, **fields: Any) -> Any:
@@ -117,27 +116,30 @@ class GatewayServicer:
         redis_client: RedisClient,
         max_streams: int = MAX_STREAMS,
         circuit_breaker: CircuitBreaker | None = None,
-        dispatch_key: str = "dispatch:module",
         cache_handler: Any = None,
         client_config: Any = None,
+        module_runner: ModuleRunner | None = None,
     ) -> None:
         """Initialize the gateway servicer.
 
         Args:
-            redis_client: Redis for stream persistence, dispatch, and signals.
+            redis_client: Redis for stream persistence and signals.
             max_streams: Maximum concurrent sessions (cluster-wide with Redis).
             circuit_breaker: Optional circuit breaker for recording success/failure.
-            dispatch_key: Redis Stream key for task dispatch to the module.
             cache_handler: Async callback for cache invalidation signals (from ModuleServer).
             client_config: ClientConfig for outbound dial-back to consumers
-                (used by the ``_dial_consumer`` callback flow).
+                (used by ``_dial_consumer``).
+            module_runner: Orchestrator invoked by ``_dial_consumer`` after the
+                consumer's first reply lands. Required in embedded mode; the
+                dial-back is the sole entry point for module execution and
+                cannot proceed without it.
         """
         self._registry = StreamRegistry(redis_client, max_streams=max_streams)
         self._circuit_breaker = circuit_breaker
         self._redis_client = redis_client
-        self._dispatch_key = dispatch_key
         self._cache_handler = cache_handler
         self._client_config = client_config
+        self._module_runner = module_runner
 
     async def start(self) -> None:
         """Start the registry reaper."""
@@ -233,15 +235,11 @@ class GatewayServicer:
         )
         timer.mark("xadd_stream_start")
 
-        # Start module in background
-        session._forward_task = asyncio.create_task(  # noqa: SLF001
-            self._start_module(session, request),
-            name=f"start_module_{task_id}",
-        )
-        timer.mark("schedule_start_module")
-
         # Server-initiated dial-back to consumer (mandatory; address
-        # validated at the top of this method).
+        # validated at the top of this method). The dial-back IS the
+        # dispatcher: it opens the BiDi, receives the consumer's first
+        # reply (the query), and runs the module via ``ModuleRunner.run``.
+        # No second background task — there is no separate dispatch flow.
         logger.info("→ Dial-back scheduled to consumer %s", client_address, extra=log_extra)
         # F1.7 (deferred): track this task in a servicer-level set with
         # add_done_callback so it survives strong-reference GC and
@@ -330,47 +328,6 @@ class GatewayServicer:
                 extra=log_extra,
             )
 
-    async def _start_module(self, session: StreamSession, request: Any) -> None:
-        """Dispatch module execution via Redis.
-
-        XADDs task spec to the dispatch stream. The TaskDispatcher picks
-        it up, runs the module, and writes output to the proto stream.
-        Gateway reads output via ProtoStreamReader in Stream.
-
-        Module input arrives via upstream ``StreamClient.data`` messages
-        (handled by ``_read_consumer_upstream``), not from the dispatch entry.
-
-        Args:
-            session: The stream session.
-            request: The StartStreamRequest.
-        """
-        log_extra = {
-            "task_id": session.task_id,
-            "setup_id": request.setup_id,
-            "mission_id": request.mission_id,
-        }
-        try:
-            await self._redis_client.xadd(
-                self._dispatch_key,
-                {
-                    "task_id": session.task_id,
-                    "ts_ns": str(time.perf_counter_ns()),
-                    "setup_id": request.setup_id,
-                    "mission_id": request.mission_id,
-                },
-            )
-            self._cb_success()
-            logger.debug("Task dispatched to Redis", extra=log_extra)
-        except RedisError as exc:
-            self._cb_failure()
-            logger.exception("Task dispatch XADD failed", extra=log_extra)
-            await self._emit_fatal_to_redis(
-                session.task_id,
-                code=StreamErrorCode.DISPATCH_UNAVAILABLE.value,
-                message=f"failed to dispatch task: {type(exc).__name__}",
-                log_extra=log_extra,
-            )
-
     async def Stream(  # noqa: C901, PLR0912
         self,
         request_iterator: AsyncIterator,
@@ -704,6 +661,9 @@ class GatewayServicer:
                     data=srv_msg.data,
                 )
 
+        async def _runner_fatal(code: str, message: str) -> None:
+            await self._emit_fatal_to_redis(task_id, code=code, message=message, log_extra=log_extra)
+
         try:
             logger.info(
                 "→ Opening BiDi to consumer %s (sending stream.init)",
@@ -715,14 +675,36 @@ class GatewayServicer:
             async for upstream in responses:
                 if not (upstream.data and len(upstream.data.fields) > 0):
                     continue
-                await session.enqueue_input({"_proto": upstream.data})
                 if first:
                     logger.info(
-                        "← First consumer reply received — query enqueued, output drain unblocked",
+                        "← First consumer reply received — starting module runner",
                         extra=log_extra,
                     )
+                    if self._module_runner is None:
+                        await self._emit_fatal_to_redis(
+                            task_id,
+                            code=StreamErrorCode.DIAL_BACK_INTERNAL.value,
+                            message="gateway has no ModuleRunner configured",
+                            log_extra=log_extra,
+                        )
+                        output_started.set()
+                        return
+                    asyncio.create_task(  # noqa: RUF006 — runner runs to completion in background; tracked via stream.end EOS
+                        self._module_runner.run(
+                            upstream.data,
+                            task_id=task_id,
+                            setup_id=setup_id,
+                            mission_id=mission_id,
+                            on_fatal=_runner_fatal,
+                        ),
+                        name=f"module_runner_{task_id}",
+                    )
                     output_started.set()
                     first = False
+                    continue
+                # Follow-up multi-turn input: enqueue for any module that
+                # consumes session.input_queue mid-run.
+                await session.enqueue_input({"_proto": upstream.data})
         except grpc.aio.AioRpcError as exc:
             code_name = exc.code().name
             details = exc.details() or ""

{digitalkin-1.0.0.dev0 → digitalkin-1.0.0.dev2}/src/digitalkin/grpc_servers/module_server.py

@@ -62,7 +62,6 @@ class ModuleServer(BaseServer):
         self.registry: RegistryStrategy | None = None
         self.module_servicer: ModuleServicer | None = None
         self._gateway_servicer: GatewayServicer | None = None
-        self._task_dispatcher: Any = None
 
         self._prepare_registry_config()
 
@@ -95,10 +94,12 @@ class ModuleServer(BaseServer):
         self._register_gateway_servicer()
 
     def _register_gateway_servicer(self) -> None:
-        """Register the embedded GatewayServicer and TaskDispatcher.
+        """Register the embedded GatewayServicer.
 
-        Gateway dispatches tasks via Redis XADD. TaskDispatcher picks them
-        up via XREAD and runs modules through ModuleServicer's job manager.
+        The dial-back is the sole orchestrator: when a consumer dials in
+        and sends its first reply, the gateway's ``_dial_consumer`` calls
+        the injected ``ModuleRunner`` directly. There is no separate
+        dispatcher process, queue, or Redis stream for dispatch.
 
         Raises:
             RuntimeError: If DIGITALKIN_REDIS_URL is not set.
@@ -109,43 +110,26 @@ class ModuleServer(BaseServer):
             raise RuntimeError(msg)
 
         redis_client = RedisClient(redis_url)
-        module_id = self.module_class.get_module_id()
-        dispatch_key = f"dispatch:{module_id}"
+
+        from digitalkin.core.task_manager.module_runner import ModuleRunner
+
+        module_runner = ModuleRunner(redis_client=redis_client, servicer=self.module_servicer)
 
         self._gateway_servicer = GatewayServicer(
             redis_client=redis_client,
             circuit_breaker=self._gateway_circuit_breaker,
-            dispatch_key=dispatch_key,
             cache_handler=self._handle_cache_invalidation,
-            # Used by `_dial_consumer` to dial back to consumer-side
-            # GatewayService.Stream when the client opts in via
-            # `x-client-address` metadata.
             client_config=self.client_config,
+            module_runner=module_runner,
         )
 
         self.register_servicer(
             self._gateway_servicer,
             gateway_service_pb2_grpc.add_GatewayServiceServicer_to_server,
-            # Pass DESCRIPTOR (not just names) so gateway_service_pb2 is
-            # registered into Default() pool — required for reflection
-            # describe of this service's symbols.
             service_descriptor=gateway_service_pb2.DESCRIPTOR,
         )
 
-        # TaskDispatcher reads from the same dispatch stream
-        from digitalkin.core.task_manager.task_dispatcher import TaskDispatcher
-
-        self._task_dispatcher = TaskDispatcher(
-            redis_client=redis_client,
-            servicer=self.module_servicer,
-            dispatch_key=dispatch_key,
-            # Registry lookup lets the dispatcher pull the first module
-            # input from session.input_queue (fed by the client's first
-            # StreamClient.data) instead of from the dispatch entry.
-            registry=self._gateway_servicer._registry,  # noqa: SLF001
-        )
-
-        logger.info("GatewayServicer + TaskDispatcher registered (Redis: %s, dispatch: %s)", redis_url, dispatch_key)
+        logger.info("GatewayServicer + ModuleRunner registered (Redis: %s)", redis_url)
 
     async def _handle_cache_invalidation(self, action: str) -> None:
         """Dispatch cache invalidation by action name. Isolated from module lifecycle.
@@ -284,9 +268,6 @@ class ModuleServer(BaseServer):
         if self._gateway_servicer is not None:
             await self._gateway_servicer.start()
 
-        if self._task_dispatcher is not None:
-            await self._task_dispatcher.start()
-
         if self.client_config is not None:
             await self._init_and_register()
 
@@ -327,12 +308,6 @@ class ModuleServer(BaseServer):
             except Exception:
                 logger.exception("Failed to close registry")
 
-        if self._task_dispatcher is not None:
-            try:
-                await self._task_dispatcher.stop()
-            except Exception:
-                logger.exception("Failed to stop task dispatcher")
-
         if self._gateway_servicer is not None:
             try:
                 await self._gateway_servicer.stop()

{digitalkin-1.0.0.dev0 → digitalkin-1.0.0.dev2}/src/digitalkin/grpc_servers/module_servicer.py

@@ -2,6 +2,7 @@
 
 import asyncio
 import os
+import time
 from argparse import ArgumentParser, Namespace
 from collections.abc import AsyncGenerator
 from typing import Any, cast
@@ -18,6 +19,7 @@ from pydantic import ValidationError
 
 from digitalkin.core.job_manager.base_job_manager import BaseJobManager
 from digitalkin.core.job_manager.single_job_manager import SingleJobManager
+from digitalkin.grpc_servers.gateway_constants import TOOLKIT_CACHE_TTL_S
 from digitalkin.grpc_servers.utils.exceptions import ServerError, ServicerError
 from digitalkin.logger import logger
 from digitalkin.models.module.module import ModuleCodeModel, ModuleStatus
@@ -46,7 +48,11 @@ class ModuleServicer(module_service_pb2_grpc.ModuleServiceServicer, ArgParser):
     setup: SetupStrategy
     job_manager: BaseJobManager
     _registry_cache: RegistryStrategy | None
-    _tool_cache_by_setup: dict[str, Any]
+    # Maps setup_id -> (tool_cache, expires_at_perf_counter_ns).
+    # TTL'd so a slow-changing tool definition still gets refreshed
+    # without a SendSignal/INVALIDATE_TOOLS in the loop. The signal
+    # path (`invalidate_tool_cache`) bypasses TTL with a full clear.
+    _tool_cache_by_setup: dict[str, tuple[Any, float]]
     _communication_cache: Any
 
     def _add_parser_args(self, parser: ArgumentParser) -> None:
@@ -123,6 +129,37 @@ class ModuleServicer(module_service_pb2_grpc.ModuleServiceServicer, ArgParser):
         """Clear tool cache. Next request re-resolves tool definitions."""
         self._tool_cache_by_setup.clear()
 
+    def get_tool_cache(self, setup_id: str) -> Any | None:
+        """TTL'd lookup. Returns None if missing or expired (the caller
+        is expected to recompute and call ``set_tool_cache``).
+
+        Args:
+            setup_id: Setup identifier.
+
+        Returns:
+            Cached tool definition object, or None on miss/expiry.
+        """
+        entry = self._tool_cache_by_setup.get(setup_id)
+        if entry is None:
+            return None
+        value, expires_at = entry
+        if time.monotonic() >= expires_at:
+            self._tool_cache_by_setup.pop(setup_id, None)
+            return None
+        return value
+
+    def set_tool_cache(self, setup_id: str, value: Any) -> None:
+        """Insert ``value`` with TTL ``TOOLKIT_CACHE_TTL_S``.
+
+        Args:
+            setup_id: Setup identifier.
+            value: Tool definition object to cache.
+        """
+        if len(self._tool_cache_by_setup) >= self._setup_cache_max:
+            oldest_key = next(iter(self._tool_cache_by_setup))
+            del self._tool_cache_by_setup[oldest_key]
+        self._tool_cache_by_setup[setup_id] = (value, time.monotonic() + TOOLKIT_CACHE_TTL_S)
+
     def _get_registry(self) -> RegistryStrategy | None:
         """Get a cached registry instance if configured.
 
@@ -516,14 +553,11 @@ class ModuleServicer(module_service_pb2_grpc.ModuleServiceServicer, ArgParser):
             str(k): str(v) for k, v in cast("list[tuple[str, str]]", context.invocation_metadata() or ())
         }
 
-        # Resolve tool cache (shared across requests with same setup_id)
-        tool_cache = self._tool_cache_by_setup.get(setup_version.setup_id)
+        # Resolve tool cache (shared across requests with same setup_id, TTL'd)
+        tool_cache = self.get_tool_cache(setup_version.setup_id)
         if tool_cache is None and isinstance(setup_data, SetupModel):
             tool_cache = await setup_data.build_tool_cache(self._get_registry(), self._get_communication())
-            if len(self._tool_cache_by_setup) >= self._setup_cache_max:
-                oldest_key = next(iter(self._tool_cache_by_setup))
-                del self._tool_cache_by_setup[oldest_key]
-            self._tool_cache_by_setup[setup_version.setup_id] = tool_cache
+            self.set_tool_cache(setup_version.setup_id, tool_cache)
 
         # create a task to run the module in background
         logger.debug(

{digitalkin-1.0.0.dev0 → digitalkin-1.0.0.dev2}/src/digitalkin/models/settings/gateway.py

@@ -39,10 +39,17 @@ class GatewayQueueSettings(BaseSettings):
     dispatcher_input_wait_s: float = Field(
         default=60.0,
         description=(
-            "Max seconds the dispatcher waits for the consumer's first input "
-            "(via session.input_queue) before emitting INPUT_WAIT_TIMEOUT. "
-            "Must stay below the dial-back BiDi ceiling (300s) so the dispatcher "
-            "times out first with a meaningful error code."
+            "Retired in Phase 2.B (the dial-back is the orchestrator). "
+            "Kept for forward-compat / external readers. No effect."
+        ),
+    )
+    toolkit_cache_ttl_s: float = Field(
+        default=600.0,
+        description=(
+            "TTL for the per-setup tool cache "
+            "(``ModuleServicer._tool_cache_by_setup``). Entries older than "
+            "this are recomputed on next lookup. The INVALIDATE_TOOLS "
+            "SendSignal flushes the whole cache regardless of TTL."
         ),
     )
 

{digitalkin-1.0.0.dev0 → digitalkin-1.0.0.dev2}/src/digitalkin/services/communication/gateway_consumer.py

@@ -35,9 +35,13 @@ from digitalkin.logger import logger
 from digitalkin.models.settings.consumer import ConsumerSettings
 from digitalkin.models.settings.server.grpc import GrpcServerSettings
 
-# Singleton — read env vars once at import. Field defaults below pull
-# from this so any caller building ConsumerConfig() picks up env overrides.
+# Singletons — read env vars once at import. Field defaults below pull
+# from `_CONSUMER_DEFAULTS` so any caller building `ConsumerConfig()`
+# picks up env overrides; `_GRPC_SERVER_OPTIONS` is reused by every
+# `GatewayConsumer` instance so we don't re-instantiate the settings
+# on every consumer build (L5).
 _CONSUMER_DEFAULTS = ConsumerSettings()
+_GRPC_SERVER_OPTIONS = GrpcServerSettings().options
 
 if TYPE_CHECKING:
     from collections.abc import AsyncGenerator, AsyncIterator
@@ -179,7 +183,7 @@ class GatewayConsumer:
         self._stub: gateway_service_pb2_grpc.GatewayServiceStub | None = None
         self._server: grpc.aio.Server | None = host_server
         self._registry: dict[str, _TaskHandle] = {}
-        self._grpc_options = GrpcServerSettings().options
+        self._grpc_options = _GRPC_SERVER_OPTIONS
 
     @classmethod
     def standalone(cls, config: ConsumerConfig) -> GatewayConsumer:

{digitalkin-1.0.0.dev0 → digitalkin-1.0.0.dev2}/src/digitalkin/services/registry/grpc_registry.py

@@ -6,12 +6,14 @@ the Service Provider's Registry service.
 
 from typing import Any
 
+import grpc
 from agentic_mesh_protocol.registry.v1 import (
     registry_enums_pb2,
     registry_models_pb2,
     registry_requests_pb2,
     registry_service_pb2_grpc,
 )
+from grpc_health.v1 import health_pb2, health_pb2_grpc
 
 from digitalkin.grpc_servers.utils.exceptions import ServerError
 from digitalkin.grpc_servers.utils.grpc_client_wrapper import GrpcClientWrapper
@@ -59,27 +61,23 @@ class GrpcRegistry(RegistryStrategy, GrpcClientWrapper, GrpcErrorHandlerMixin):
         logger.debug("Channel client 'Registry' initialized successfully")
 
     async def wait_for_ready(self, timeout: float = 1.0) -> bool:
-        """Ping the registry by issuing a real GetModule RPC.
-
-        Any gRPC response (including NOT_FOUND) means the server is alive.
-        Only connection failure (UNAVAILABLE/DEADLINE_EXCEEDED after retries)
-        returns False.
+        """Probe the registry via the standard gRPC Health Check service.
 
         Args:
             timeout: Max seconds for the round-trip.
 
         Returns:
-            True if the server responded, False if unreachable.
+            True if the server responded SERVING, False otherwise.
         """
+        health_stub = health_pb2_grpc.HealthStub(self._channel)
         try:
-            await self.exec_grpc_query(
-                "GetModule",
-                registry_requests_pb2.GetModuleRequest(module_id="__ping__"),
+            response = await health_stub.Check(
+                health_pb2.HealthCheckRequest(service=""),
                 timeout=timeout,
             )
-        except ServerError as e:
-            return "UNAVAILABLE" not in str(e) and "DEADLINE_EXCEEDED" not in str(e)
-        return True
+        except grpc.aio.AioRpcError:
+            return False
+        return response.status == health_pb2.HealthCheckResponse.SERVING
 
     @staticmethod
     def _proto_to_module_info(

{digitalkin-1.0.0.dev0 → digitalkin-1.0.0.dev2}/src/digitalkin.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: digitalkin
-Version: 1.0.0.dev0
+Version: 1.0.0.dev2
 Summary: SDK to build kin used in DigitalKin
 Author-email: "DigitalKin.ai" <contact@digitalkin.ai>
 License: Attribution-NonCommercial-ShareAlike 4.0 International