quelware-client 0.2.0__tar.gz → 0.3.0__tar.gz

{quelware_client-0.2.0 → quelware_client-0.3.0}/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 ## [Unreleased]
 
+## [0.3.0] - 2026-06-09
+
+### Added
+
+- `Session.trigger` now routes through the manager by default (single round-trip, shorter lead).
+- `ServiceUnavailableError` exception for catching cases where the server-side service is not available.
+
+### Changed
+
+- `Session.trigger` default `wait_ms` changed from `400` to `None`.
+- `Session.trigger` returns the scheduled clock count (`int`).
+- Default multi-unit trigger offset is 0 ticks (was 16).
+
+### Removed
+
+- `agent.instrument(unit).get_clock_snapshot()` — use `agent.worker(unit).get_clock_snapshot()`.
+
 ## [0.2.0] - 2026-05-28
 
 ### Changed

{quelware_client-0.2.0 → quelware_client-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quelware-client
-Version: 0.2.0
+Version: 0.3.0
 Project-URL: Repository, https://github.com/quel-inc/quelware-client
 Project-URL: Documentation, https://quel-inc.github.io/quelware-client/
 Project-URL: Changelog, https://github.com/quel-inc/quelware-client/blob/main/quelware-client/CHANGELOG.md
@@ -10,7 +10,7 @@ License-File: LICENSE
 Requires-Python: >=3.10
 Requires-Dist: betterproto2>=0.9.1
 Requires-Dist: grpclib>=0.4.8
-Requires-Dist: quelware-core>=0.1.4
+Requires-Dist: quelware-core>=0.2.0
 Requires-Dist: typer>=0.21.1
 Requires-Dist: typing-extensions>=4.1.0
 Provides-Extra: plot

{quelware_client-0.2.0 → quelware_client-0.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "quelware-client"
-version = "0.2.0"
+version = "0.3.0"
 description = ""
 readme = "README.md"
 authors = [
@@ -9,7 +9,7 @@ authors = [
 requires-python = ">=3.10"
 dependencies = [
     "betterproto2>=0.9.1",
-    "quelware-core>=0.1.4",
+    "quelware-core>=0.2.0",
     "grpclib>=0.4.8",
     "typer>=0.21.1",
     "typing_extensions>=4.1.0"

{quelware_client-0.2.0 → quelware_client-0.3.0}/src/quelware_client/client/_grpc.py

@@ -13,6 +13,7 @@ from quelware_client.core.interfaces.session_agent import SessionAgent
 from quelware_client.core.interfaces.system_configuration_agent import (
     SystemConfigurationAgent,
 )
+from quelware_client.core.interfaces.worker_agent import WorkerAgent
 from quelware_client.infra.diagnostics_agent_grpc import DiagnosticsAgentGrpc
 from quelware_client.infra.health_agent_grpc import HealthAgentGrpc
 from quelware_client.infra.instrument_agent_grpc import InstrumentAgentGrpc
@@ -24,6 +25,8 @@ from quelware_client.infra.session_agent_grpc import SessionAgentGrpc
 from quelware_client.infra.system_configuration_agent_grpc import (
     SystemConfigurationAgentGrpc,
 )
+from quelware_client.infra.trigger_agent_grpc import TriggerAgentGrpc
+from quelware_client.infra.worker_agent_grpc import WorkerAgentGrpc
 
 logger = logging.getLogger(__name__)
 
@@ -64,6 +67,13 @@ def _create_default_diagnostics_agent_factory(channel, pat: str):
     return _default_diagnostics_agent_factory
 
 
+def _create_default_worker_agent_factory(channel):
+    def _default_worker_agent_factory(ul: UnitLabel):
+        return WorkerAgentGrpc(channel, metadata={"x-unit-label": str(ul)})
+
+    return _default_worker_agent_factory
+
+
 _CENTRAL_SERVER_METADATA_BASE = {"x-unit-label": "central-server"}
 
 
@@ -76,6 +86,7 @@ def create_quelware_client(  # noqa: PLR0913
     resource_agent_factory: AgentFactory[ResourceAgent] | None = None,
     instrument_agent_factory: AgentFactory[InstrumentAgent] | None = None,
     diagnostics_agent_factory: AgentFactory[DiagnosticsAgent] | None = None,
+    worker_agent_factory: AgentFactory[WorkerAgent] | None = None,
     pat: PatProvider | str | None = None,
 ):
     channel = Channel(endpoint, port)
@@ -105,6 +116,9 @@ def create_quelware_client(  # noqa: PLR0913
             channel, _pat
         )
 
+    if worker_agent_factory is None:
+        worker_agent_factory = _create_default_worker_agent_factory(channel)
+
     central_server_metadata = _CENTRAL_SERVER_METADATA_BASE | {"x-pat": _pat}
 
     agent_container = AgentContainer()
@@ -116,11 +130,15 @@ def create_quelware_client(  # noqa: PLR0913
         agent_container.system_configuration = SystemConfigurationAgentGrpc(
             channel, metadata=central_server_metadata
         )
+    agent_container.trigger = TriggerAgentGrpc(
+        channel, metadata=central_server_metadata
+    )
     return QuelwareClient(
         agent=agent_container,
         health_agent_factory=health_agent_factory,
         resource_agent_factory=resource_agent_factory,
         instrument_agent_factory=instrument_agent_factory,
         diagnostics_agent_factory=diagnostics_agent_factory,
+        worker_agent_factory=worker_agent_factory,
         close_handlers=[channel.close],
     )

{quelware_client-0.2.0 → quelware_client-0.3.0}/src/quelware_client/client/_standalone_grpc.py

@@ -9,6 +9,8 @@ from quelware_client.infra.diagnostics_agent_grpc import DiagnosticsAgentGrpc
 from quelware_client.infra.instrument_agent_grpc import InstrumentAgentGrpc
 from quelware_client.infra.pat_provider_file import pat_provider_from_config
 from quelware_client.infra.resource_agent_grpc import ResourceAgentGrpc
+from quelware_client.infra.trigger_agent_grpc import TriggerAgentGrpc
+from quelware_client.infra.worker_agent_grpc import WorkerAgentGrpc
 from quelware_client.testing.session_agent_mock import SessionAgentMock
 from quelware_client.testing.system_configuration_agent_mock import (
     SystemConfigurationAgentMock,
@@ -59,9 +61,13 @@ def create_standalone_client(
             channel, metadata={"x-unit-label": str(ul), "x-pat": _pat}
         )
 
+    def worker_agent_factory(ul: UnitLabel):
+        return WorkerAgentGrpc(channel, metadata={"x-unit-label": str(ul)})
+
     agent_container = AgentContainer()
     agent_container.session = session_agent
     agent_container.system_configuration = conf_agent
+    agent_container.trigger = TriggerAgentGrpc(channel)
 
     logger.warning("NOTE: Standalone client is for testing purposes.")
 
@@ -70,6 +76,7 @@ def create_standalone_client(
         resource_agent_factory=resource_agent_factory,
         instrument_agent_factory=instrument_agent_factory,
         diagnostics_agent_factory=diagnostics_agent_factory,
+        worker_agent_factory=worker_agent_factory,
         close_handlers=[channel.close],
         skip_lock_check=skip_lock_check,
     )

{quelware_client-0.2.0 → quelware_client-0.3.0}/src/quelware_client/core/_agent_container.py

@@ -10,6 +10,8 @@ from quelware_client.core.interfaces.session_agent import SessionAgent
 from quelware_client.core.interfaces.system_configuration_agent import (
     SystemConfigurationAgent,
 )
+from quelware_client.core.interfaces.trigger_agent import TriggerAgent
+from quelware_client.core.interfaces.worker_agent import WorkerAgent
 
 logger = logging.getLogger(__name__)
 
@@ -18,10 +20,12 @@ class AgentContainer:
     def __init__(self):
         self._session: SessionAgent | None = None
         self._conf: SystemConfigurationAgent | None = None
+        self._trigger: TriggerAgent | None = None
         self._health: dict[UnitLabel, HealthAgent] = {}
         self._rsrc: dict[UnitLabel, ResourceAgent] = {}
         self._inst: dict[UnitLabel, InstrumentAgent] = {}
         self._diag: dict[UnitLabel, DiagnosticsAgent] = {}
+        self._worker: dict[UnitLabel, WorkerAgent] = {}
 
     def update_health_agent(self, unit_label: UnitLabel, agent: HealthAgent | None):
         if agent is None:
@@ -67,6 +71,15 @@ class AgentContainer:
         else:
             self._diag[unit_label] = agent
 
+    def update_worker_agent(self, unit_label: UnitLabel, agent: WorkerAgent | None):
+        if agent is None:
+            if unit_label in self._worker:
+                self._worker[unit_label]
+            else:
+                logger.warning(f"WorkerAgent for '{unit_label}' not found. Continue.")
+        else:
+            self._worker[unit_label] = agent
+
     @property
     def session(self) -> SessionAgent:
         if self._session is None:
@@ -87,6 +100,16 @@ class AgentContainer:
     def system_configuration(self, val: SystemConfigurationAgent):
         self._conf = val
 
+    @property
+    def trigger(self) -> TriggerAgent:
+        if self._trigger is None:
+            raise ValueError("TriggerAgent not set.")
+        return self._trigger
+
+    @trigger.setter
+    def trigger(self, val: TriggerAgent):
+        self._trigger = val
+
     def health(self, unit_label: UnitLabel) -> HealthAgent:
         if unit_label not in self._health:
             raise ValueError(f"HealthAgent for '{unit_label}' not set.")
@@ -106,3 +129,8 @@ class AgentContainer:
         if unit_label not in self._diag:
             raise ValueError(f"DiagnosticsAgent for '{unit_label}' not set.")
         return self._diag[unit_label]
+
+    def worker(self, unit_label: UnitLabel) -> WorkerAgent:
+        if unit_label not in self._worker:
+            raise ValueError(f"WorkerAgent for '{unit_label}' not set.")
+        return self._worker[unit_label]

{quelware_client-0.2.0 → quelware_client-0.3.0}/src/quelware_client/core/_client.py

@@ -16,6 +16,7 @@ from quelware_client.core._agent_container import AgentContainer
 from quelware_client.core.interfaces.diagnostics_agent import DiagnosticsAgent
 from quelware_client.core.interfaces.health_agent import HealthAgent
 from quelware_client.core.interfaces.instrument_agent import InstrumentAgent
+from quelware_client.core.interfaces.worker_agent import WorkerAgent
 
 from ._session import Session
 from .interfaces.resource_agent import ResourceAgent
@@ -35,6 +36,7 @@ class QuelwareClient:
         resource_agent_factory: AgentFactory[ResourceAgent] | None = None,
         instrument_agent_factory: AgentFactory[InstrumentAgent] | None = None,
         diagnostics_agent_factory: AgentFactory[DiagnosticsAgent] | None = None,
+        worker_agent_factory: AgentFactory[WorkerAgent] | None = None,
         close_handlers: list[Callable[[], None]] | None = None,
         skip_lock_check: bool = False,
     ):
@@ -43,6 +45,7 @@ class QuelwareClient:
         self._rsrc_agent_factory = resource_agent_factory
         self._inst_agent_factory = instrument_agent_factory
         self._diag_agent_factory = diagnostics_agent_factory
+        self._worker_agent_factory = worker_agent_factory
         self._unit_labels: list[UnitLabel] = []
         self._close_handlers = close_handlers or []
         self._skip_lock_check = skip_lock_check
@@ -91,6 +94,8 @@ class QuelwareClient:
                 self._agent.update_instrument_agent(ul, self._inst_agent_factory(ul))
             if self._diag_agent_factory:
                 self._agent.update_diagnostics_agent(ul, self._diag_agent_factory(ul))
+            if self._worker_agent_factory:
+                self._agent.update_worker_agent(ul, self._worker_agent_factory(ul))
         self._unit_labels = healthy_labels
 
     def list_unit_labels(self) -> list[UnitLabel]:

{quelware_client-0.2.0 → quelware_client-0.3.0}/src/quelware_client/core/_session.py

@@ -14,6 +14,7 @@ from quelware_core.entities.session import SessionToken
 from quelware_core.entities.unit import UnitLabel
 
 from quelware_client.core import AgentContainer
+from quelware_client.core.exceptions import ServiceUnavailableError
 from quelware_client.core.trigger_count_proposer import (
     FixedOffsetTriggerCountProposer,
     TriggerCountProposer,
@@ -23,8 +24,9 @@ from ._utils import create_unit_to_ids_map
 
 logger = logging.getLogger(__name__)
 
-_default_count_proposer = FixedOffsetTriggerCountProposer(grid_step=32, offset=16)
+_default_count_proposer = FixedOffsetTriggerCountProposer(grid_step=32, offset=0)
 _CLOCK_FREQUENCY_HZ = 312_500_000
+_FALLBACK_MIN_WAIT_MS = 500
 
 
 class Session:
@@ -143,7 +145,11 @@ class Session:
         )
         return insts
 
-    async def trigger(self, instrument_ids: Collection[ResourceId], wait_ms=400):
+    async def trigger(
+        self,
+        instrument_ids: Collection[ResourceId],
+        wait_ms: int | None = None,
+    ) -> int:
         unit_to_ids = create_unit_to_ids_map(instrument_ids)
 
         logger.info(f"starting application (token= {self.token} )")
@@ -154,27 +160,47 @@ class Session:
         await asyncio.gather(*apply_coros)
         logger.info(f"finished application (token= {self.token} )")
 
+        try:
+            scheduled = await self._agent.trigger.trigger(
+                self.token,
+                list(instrument_ids),
+                requested_min_wait_ms=wait_ms,
+            )
+            logger.info(f"trigger scheduled via manager at clock_count={scheduled}")
+            return scheduled
+        except ServiceUnavailableError:
+            fallback_wait_ms = max(wait_ms or 0, _FALLBACK_MIN_WAIT_MS)
+            logger.warning(
+                f"Manager-side TriggerService unavailable; falling back to "
+                f"client-side trigger (wait_ms={fallback_wait_ms})."
+            )
+
+        return await self._client_side_trigger_fallback(unit_to_ids, fallback_wait_ms)
+
+    async def _client_side_trigger_fallback(
+        self,
+        unit_to_ids: dict[UnitLabel, list[ResourceId]],
+        wait_ms: int,
+    ) -> int:
         if len(unit_to_ids) == 1:
             unit_label = next(iter(unit_to_ids))
-            logger.info(f"trigger via self-timed path (unit={unit_label})")
+            logger.info(f"fallback: self-timed trigger (unit={unit_label})")
             scheduled = await self._agent.instrument(unit_label).trigger_now(self.token)
             logger.info(f"trigger scheduled at clock_count={scheduled}")
-        else:
-            logger.info(
-                f"trigger via multi-unit sync path "
-                f"(n_units={len(unit_to_ids)}, wait_ms={wait_ms})"
-            )
-            reference_unit = next(iter(unit_to_ids))
-            cur, ref = await self._agent.instrument(reference_unit).get_clock_snapshot()
-            wait_count = math.ceil(wait_ms * _CLOCK_FREQUENCY_HZ / 1000)
-            target_time = self._trigger_count_proposer.propose_count(
-                cur, ref, wait_count
-            )
-            trigger_coros = [
-                self._agent.instrument(unit_label).schedule_trigger(
-                    self.token, target_time
-                )
-                for unit_label in unit_to_ids
-            ]
-            await asyncio.gather(*trigger_coros)
-            logger.info(f"trigger scheduled at clock_count={target_time}")
+            return scheduled
+
+        logger.info(
+            f"fallback: multi-unit sync trigger "
+            f"(n_units={len(unit_to_ids)}, wait_ms={wait_ms})"
+        )
+        reference_unit = next(iter(unit_to_ids))
+        cur, ref = await self._agent.worker(reference_unit).get_clock_snapshot()
+        wait_count = math.ceil(wait_ms * _CLOCK_FREQUENCY_HZ / 1000)
+        target_time = self._trigger_count_proposer.propose_count(cur, ref, wait_count)
+        trigger_coros = [
+            self._agent.instrument(unit_label).schedule_trigger(self.token, target_time)
+            for unit_label in unit_to_ids
+        ]
+        await asyncio.gather(*trigger_coros)
+        logger.info(f"trigger scheduled at clock_count={target_time}")
+        return target_time

{quelware_client-0.2.0 → quelware_client-0.3.0}/src/quelware_client/core/exceptions/__init__.py

@@ -72,3 +72,7 @@ class UnitNotFoundError(_ErrorWithUnitLabelsMixin, QuelwareClientError): ...
 
 
 class InvalidUnitStatusError(_ErrorWithUnitLabelsMixin, QuelwareClientError): ...
+
+
+class ServiceUnavailableError(QuelwareClientError):
+    DEFAULT_MESSAGE = "The requested service is not available on the server."

{quelware_client-0.2.0 → quelware_client-0.3.0}/src/quelware_client/core/interfaces/instrument_agent/__init__.py

@@ -1,7 +1,6 @@
 from collections.abc import Collection, Sequence
 from typing import Protocol
 
-from quelware_core.entities.clock import CurrentCount, ReferenceCount
 from quelware_core.entities.directives import Directive
 from quelware_core.entities.instrument import InstrumentStatus
 from quelware_core.entities.resource import ResourceId
@@ -35,10 +34,6 @@ class InstrumentAgent(Protocol):
         resource_ids: Collection[ResourceId],
     ) -> bool: ...
 
-    async def get_clock_snapshot(
-        self,
-    ) -> tuple[CurrentCount, ReferenceCount]: ...
-
     async def schedule_trigger(
         self,
         token: SessionToken,

quelware_client-0.3.0/src/quelware_client/core/interfaces/trigger_agent/__init__.py

@@ -0,0 +1,18 @@
+from abc import ABC, abstractmethod
+from collections.abc import Collection
+
+from quelware_core.entities.resource import ResourceId
+from quelware_core.entities.session import SessionToken
+
+
+class TriggerAgent(ABC):
+    @abstractmethod
+    async def trigger(
+        self,
+        token: SessionToken,
+        instrument_ids: Collection[ResourceId],
+        requested_min_wait_ms: int | None,
+    ) -> int: ...
+
+
+__all__ = ["TriggerAgent"]

quelware_client-0.3.0/src/quelware_client/core/interfaces/worker_agent/__init__.py

@@ -0,0 +1,7 @@
+from typing import Protocol
+
+from quelware_core.entities.clock import CurrentCount, ReferenceCount
+
+
+class WorkerAgent(Protocol):
+    async def get_clock_snapshot(self) -> tuple[CurrentCount, ReferenceCount]: ...

{quelware_client-0.2.0 → quelware_client-0.3.0}/src/quelware_client/infra/instrument_agent_grpc/__init__.py

@@ -3,7 +3,6 @@ from collections.abc import Collection, Sequence
 import quelware_core.pb.quelware.instrument.v1 as pb_inst
 from grpclib.client import Channel
 from quelware_core.entities import directives
-from quelware_core.entities.clock import CurrentCount, ReferenceCount
 from quelware_core.entities.instrument import InstrumentStatus
 from quelware_core.entities.resource import ResourceId
 from quelware_core.entities.session import SessionToken
@@ -79,16 +78,6 @@ class InstrumentAgentGrpc(InstrumentAgent):
         await call_with_retry(lambda: self._service.apply(req, metadata=metadata))
         return True
 
-    @override
-    async def get_clock_snapshot(
-        self,
-    ) -> tuple[CurrentCount, ReferenceCount]:
-        req = pb_inst.GetClockSnapshotRequest()
-        resp = await call_with_retry(
-            lambda: self._service.get_clock_snapshot(req), idempotent=True
-        )
-        return (resp.current_count, resp.reference_count)
-
     @override
     async def schedule_trigger(
         self,

quelware_client-0.3.0/src/quelware_client/infra/trigger_agent_grpc/__init__.py

@@ -0,0 +1,52 @@
+from collections.abc import Collection
+
+import quelware_core.pb.quelware.trigger.v1 as pb_trigger
+from betterproto2.grpclib.grpclib_client import MetadataLike
+from grpclib import GRPCError
+from grpclib.client import Channel
+from grpclib.const import Status
+from quelware_core.entities.resource import ResourceId
+from quelware_core.entities.session import SessionToken
+
+from quelware_client.core.exceptions import ServiceUnavailableError
+from quelware_client.core.interfaces.trigger_agent import TriggerAgent
+from quelware_client.infra._grpc_retry import call_with_retry
+
+
+class TriggerAgentGrpc(TriggerAgent):
+    def __init__(self, grpc_channel: Channel, metadata: MetadataLike | None = None):
+        self._channel = grpc_channel
+        self._service = pb_trigger.TriggerServiceStub(self._channel, metadata=metadata)
+
+    async def trigger(
+        self,
+        token: SessionToken,
+        instrument_ids: Collection[ResourceId],
+        requested_min_wait_ms: int | None,
+    ) -> int:
+        req = pb_trigger.TriggerRequest(
+            instrument_ids=[str(r) for r in instrument_ids],
+            requested_min_wait_ms=requested_min_wait_ms,
+        )
+        metadata = dict(self._service.metadata or {})
+        metadata["x-session-token"] = str(token)
+        try:
+            resp = await call_with_retry(
+                lambda: self._service.trigger(req, metadata=metadata)
+            )
+        except GRPCError as e:
+            if e.status is Status.UNIMPLEMENTED:
+                raise ServiceUnavailableError(
+                    f"TriggerService is not available: {e.message}"
+                ) from e
+            # Some gRPC proxies surface upstream missing-route as UNKNOWN + content-type
+            # error.
+            if e.status is Status.UNKNOWN and e.message and "content-type" in e.message:
+                raise ServiceUnavailableError(
+                    f"TriggerService route not reachable via proxy: {e.message}"
+                ) from e
+            raise
+        return resp.scheduled_clock_count
+
+
+__all__ = ["TriggerAgentGrpc"]

quelware_client-0.3.0/src/quelware_client/infra/worker_agent_grpc/__init__.py

@@ -0,0 +1,24 @@
+import quelware_core.pb.quelware.worker.v1 as pb_worker
+from grpclib.client import Channel
+from quelware_core.entities.clock import CurrentCount, ReferenceCount
+from typing_extensions import override
+
+from quelware_client.core.interfaces.worker_agent import WorkerAgent
+from quelware_client.infra._grpc_retry import call_with_retry
+
+
+class WorkerAgentGrpc(WorkerAgent):
+    def __init__(self, grpc_channel: Channel, metadata=None):
+        self._channel = grpc_channel
+        self._service = pb_worker.WorkerServiceStub(self._channel, metadata=metadata)
+
+    @override
+    async def get_clock_snapshot(self) -> tuple[CurrentCount, ReferenceCount]:
+        req = pb_worker.GetClockSnapshotRequest()
+        resp = await call_with_retry(
+            lambda: self._service.get_clock_snapshot(req), idempotent=True
+        )
+        return (resp.current_count, resp.reference_count)
+
+
+__all__ = ["WorkerAgentGrpc"]

{quelware_client-0.2.0 → quelware_client-0.3.0}/src/quelware_client/testing/instrument_agent_mock/__init__.py

@@ -1,6 +1,5 @@
 from collections.abc import Collection, Sequence
 
-from quelware_core.entities.clock import CurrentCount, ReferenceCount
 from quelware_core.entities.directives import Directive
 from quelware_core.entities.instrument import InstrumentStatus
 from quelware_core.entities.resource import ResourceId
@@ -41,11 +40,6 @@ class InstrumentAgentMock(InstrumentAgent):
     ) -> bool:
         return True
 
-    async def get_clock_snapshot(
-        self,
-    ) -> tuple[CurrentCount, ReferenceCount]:
-        return 1234, 1000
-
     async def schedule_trigger(
         self,
         token: SessionToken,

{quelware_client-0.2.0 → quelware_client-0.3.0}/src/quelware_client/testing/mock_client.py

@@ -8,6 +8,8 @@ from quelware_client.testing.session_agent_mock import SessionAgentMock
 from quelware_client.testing.system_configuration_agent_mock import (
     SystemConfigurationAgentMock,
 )
+from quelware_client.testing.trigger_agent_mock import TriggerAgentMock
+from quelware_client.testing.worker_agent_mock import WorkerAgentMock
 
 
 def create_mock_quelware_client(
@@ -19,6 +21,7 @@ def create_mock_quelware_client(
     agent_container.system_configuration = SystemConfigurationAgentMock(unit_to_status)
 
     agent_container.session = SessionAgentMock()
+    agent_container.trigger = TriggerAgentMock()
 
     def resource_agent_factory(ul: UnitLabel) -> ResourceAgentMock:
         rinfos = unit_to_resources.get(ul, [])
@@ -27,8 +30,12 @@ def create_mock_quelware_client(
     def instrument_agent_factory(ul: UnitLabel) -> InstrumentAgentMock:
         return InstrumentAgentMock()
 
+    def worker_agent_factory(ul: UnitLabel) -> WorkerAgentMock:
+        return WorkerAgentMock()
+
     return QuelwareClient(
         agent=agent_container,
         resource_agent_factory=resource_agent_factory,
         instrument_agent_factory=instrument_agent_factory,
+        worker_agent_factory=worker_agent_factory,
     )

quelware_client-0.3.0/src/quelware_client/testing/trigger_agent_mock/__init__.py

@@ -0,0 +1,24 @@
+from collections.abc import Collection
+
+from quelware_core.entities.resource import ResourceId
+from quelware_core.entities.session import SessionToken
+
+from quelware_client.core.interfaces.trigger_agent import TriggerAgent
+
+
+class TriggerAgentMock(TriggerAgent):
+    def __init__(self, scheduled_clock_count: int = 1234):
+        self._scheduled = scheduled_clock_count
+        self.calls: list[tuple[SessionToken, list[ResourceId], int | None]] = []
+
+    async def trigger(
+        self,
+        token: SessionToken,
+        instrument_ids: Collection[ResourceId],
+        requested_min_wait_ms: int | None,
+    ) -> int:
+        self.calls.append((token, list(instrument_ids), requested_min_wait_ms))
+        return self._scheduled
+
+
+__all__ = ["TriggerAgentMock"]

quelware_client-0.3.0/src/quelware_client/testing/worker_agent_mock/__init__.py

@@ -0,0 +1,12 @@
+from quelware_core.entities.clock import CurrentCount, ReferenceCount
+
+from quelware_client.core.interfaces.worker_agent import WorkerAgent
+
+
+class WorkerAgentMock(WorkerAgent):
+    def __init__(self, current_count: int = 1234, reference_count: int = 1000):
+        self._current_count = current_count
+        self._reference_count = reference_count
+
+    async def get_clock_snapshot(self) -> tuple[CurrentCount, ReferenceCount]:
+        return self._current_count, self._reference_count

quelware_client-0.3.0/tests/core/session/test_trigger.py

@@ -0,0 +1,38 @@
+import pytest
+from quelware_core.entities.resource import ResourceId
+from quelware_core.entities.session import SessionToken
+from quelware_core.entities.unit import UnitLabel
+
+from quelware_client.core import AgentContainer, Session
+from quelware_client.testing.instrument_agent_mock import InstrumentAgentMock
+from quelware_client.testing.trigger_agent_mock import TriggerAgentMock
+from quelware_client.testing.worker_agent_mock import WorkerAgentMock
+
+
+def _build_agents(
+    units: list[UnitLabel], trigger_agent: TriggerAgentMock
+) -> AgentContainer:
+    agents = AgentContainer()
+    agents.trigger = trigger_agent
+    for u in units:
+        agents.update_instrument_agent(u, InstrumentAgentMock())
+        agents.update_worker_agent(u, WorkerAgentMock())
+    return agents
+
+
+@pytest.mark.asyncio
+async def test_trigger_goes_through_manager_with_requested_wait_ms():
+    trig = TriggerAgentMock(scheduled_clock_count=42_000)
+    units = [UnitLabel("unit-a"), UnitLabel("unit-b")]
+    agents = _build_agents(units, trig)
+    rids = [ResourceId(f"{u}:i1") for u in units]
+    session = Session(rids, agents, token=SessionToken("tok"))
+
+    scheduled = await session.trigger(rids, wait_ms=200)
+
+    assert scheduled == 42_000
+    assert len(trig.calls) == 1
+    token, sent_ids, wait_ms = trig.calls[0]
+    assert token == SessionToken("tok")
+    assert set(sent_ids) == set(rids)
+    assert wait_ms == 200

{quelware_client-0.2.0 → quelware_client-0.3.0}/uv.lock

@@ -940,7 +940,7 @@ wheels = [
 
 [[package]]
 name = "quelware-client"
-version = "0.2.0"
+version = "0.3.0"
 source = { editable = "." }
 dependencies = [
     { name = "betterproto2" },
@@ -984,7 +984,7 @@ dev = [
 
 [[package]]
 name = "quelware-core"
-version = "0.1.4"
+version = "0.2.0"
 source = { editable = "../quelware-core/python" }
 dependencies = [
     { name = "betterproto2" },