bazaar-compute-node 0.1.32__tar.gz → 0.1.33__tar.gz

{bazaar_compute_node-0.1.32 → bazaar_compute_node-0.1.33}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bazaar-compute-node
-Version: 0.1.32
+Version: 0.1.33
 Summary: Runtime-agnostic computer node daemon for agents and channels.
 License-Expression: AGPL-3.0-only
 License-File: LICENSE

{bazaar_compute_node-0.1.32 → bazaar_compute_node-0.1.33}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "bazaar-compute-node"
-version = "0.1.32"
+version = "0.1.33"
 description = "Runtime-agnostic computer node daemon for agents and channels."
 readme = "README.md"
 license = "AGPL-3.0-only"

{bazaar_compute_node-0.1.32 → bazaar_compute_node-0.1.33}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "bazaar-compute-node"
-version = "0.1.32"
+version = "0.1.33"
 description = "Runtime-agnostic computer node daemon for agents and channels."
 readme = "README.md"
 license = "AGPL-3.0-only"

{bazaar_compute_node-0.1.32 → bazaar_compute_node-0.1.33}/src/bazaar_compute_node/contrib/sqlite/repository/reminders.py

@@ -10,10 +10,8 @@ from ....core.models import (
     OwnedReminder,
     Reminder,
     ReminderState,
-    SenderKind,
-    SystemMessageKind,
 )
-from ....core.reminder import canonical_id_reference, render_reminder_fire_body
+from ....core.reminder import canonical_id_reference
 from ..codec import (
     _required_text,
 )
@@ -196,6 +194,49 @@ class ReminderOperations(RepositoryBase):
         await self._update_reminder(reminder)
         return reminder
 
+    async def save_owned_reminder_transition(
+        self,
+        expected_revision: int,
+        reminder: OwnedReminder,
+    ) -> Reminder | None:
+        """Retire one Reminder, or report that its state moved before the write."""
+
+        incoming = reminder.reminder
+        existing_owned = await self.get_owned_reminder(
+            reminder.agent_id,
+            incoming.owner_session_id,
+            incoming.reminder_id,
+        )
+        if existing_owned is None:
+            return None
+        existing = existing_owned.reminder
+        if existing.revision != expected_revision:
+            return None
+        if existing.state is ReminderState.CANCELED:
+            return None
+        await self.execute(
+            "UPDATE reminders SET title = ?, state = ?, next_fire_at_ms = ?, "
+            "repeat_rule = ?, timezone = ?, revision = ?, last_occurrence_no = ?, "
+            "updated_at_ms = ?, last_fired_at_ms = ?, canceled_at_ms = ? "
+            "WHERE agent_id = ? AND reminder_id = ? AND owner_session_id = ?",
+            (
+                incoming.title,
+                incoming.state.value,
+                incoming.next_fire_at_ms,
+                incoming.repeat_rule,
+                incoming.timezone,
+                incoming.revision,
+                incoming.last_occurrence_no,
+                incoming.updated_at_ms,
+                incoming.last_fired_at_ms,
+                incoming.canceled_at_ms,
+                reminder.agent_id,
+                incoming.reminder_id,
+                incoming.owner_session_id,
+            ),
+        )
+        return incoming
+
     async def get_owned_reminder(
         self,
         agent_id: str,
@@ -214,7 +255,7 @@ class ReminderOperations(RepositoryBase):
         return self._owned_reminder_from_row(row) if row is not None else None
 
     async def get_next_scheduled_owned_reminder(self) -> OwnedReminder | None:
-        predicates = ["state = ?"]
+        predicates = ["state = ?", "next_fire_at_ms IS NOT NULL"]
         parameters: list[object] = [ReminderState.SCHEDULED.value]
         bound_agent_id = self._bound_agent_id()
         if bound_agent_id is not None:
@@ -253,7 +294,9 @@ class ReminderOperations(RepositoryBase):
         expected_revision: int,
         reminder: OwnedReminder,
         system_message: Message[InboundAttachment],
-    ) -> Message[InboundAttachment]:
+    ) -> Message[InboundAttachment] | None:
+        """Fire one Reminder, or report that its state moved before the write."""
+
         incoming = reminder.reminder
         existing_owned = await self.get_owned_reminder(
             reminder.agent_id,
@@ -261,48 +304,16 @@ class ReminderOperations(RepositoryBase):
             incoming.reminder_id,
         )
         if existing_owned is None:
-            raise ValueError("reminder not found")
+            return None
         existing = existing_owned.reminder
-        self._validate_expected_revision(existing, expected_revision)
-        self._validate_reminder_identity(existing, incoming)
+        if existing.revision != expected_revision:
+            return None
         if existing.state is not ReminderState.SCHEDULED:
-            raise ValueError("only a scheduled reminder can fire")
-        if incoming.revision != expected_revision + 1:
-            raise ValueError("reminder revision must advance by exactly one")
-        if incoming.last_occurrence_no != existing.last_occurrence_no + 1:
-            raise ValueError("reminder occurrence number must advance by exactly one")
-        if incoming.last_fired_at_ms is None:
-            raise ValueError("fired reminder requires a fire time")
-        scheduled_for_ms = existing.next_fire_at_ms
-        if scheduled_for_ms is None:
-            raise RuntimeError("scheduled reminder has no next fire time")
-        if incoming.last_fired_at_ms < scheduled_for_ms:
-            raise ValueError("reminder fire time precedes its scheduled slot")
-        if (
-            incoming.repeat_rule is not None
-            and incoming.next_fire_at_ms is not None
-            and incoming.next_fire_at_ms <= scheduled_for_ms
-        ):
-            raise ValueError("recurring next fire must follow the scheduled slot")
-        if incoming.updated_at_ms != incoming.last_fired_at_ms:
-            raise ValueError("reminder update time does not match fire time")
-        if incoming.title != existing.title:
-            raise ValueError("fire cannot change reminder title")
-        if incoming.repeat_rule != existing.repeat_rule:
-            raise ValueError("fire cannot change reminder cadence")
-        if system_message.sender_kind is not SenderKind.SYSTEM:
-            raise ValueError("reminder fire requires a system message")
-        if system_message.system_message_kind is not SystemMessageKind.REMINDER:
-            raise ValueError("reminder fire requires reminder system metadata")
-        if system_message.session_id != incoming.owner_session_id:
-            raise ValueError("system message owner binding does not match reminder")
-        if system_message.received_at_ms != incoming.last_fired_at_ms:
-            raise ValueError("system message time does not match reminder fire")
+            return None
         anchor = await self.fetchone(
             "SELECT channel_session_id, channel, provider_thread_id, target, "
             "target_kind FROM messages WHERE agent_id = ? AND session_id = ? "
-            "AND message_id = ? AND direction = 'inbound' "
-            "AND provider_message_id IS NOT NULL",
+            "AND message_id = ? AND direction = 'inbound'",
             (
                 reminder.agent_id,
                 incoming.owner_session_id,
@@ -310,22 +321,7 @@ class ReminderOperations(RepositoryBase):
             ),
         )
         if anchor is None:
-            raise ValueError("reminder anchor message is missing")
-        if (
-            system_message.channel_session_id != anchor["channel_session_id"]
-            or system_message.channel != anchor["channel"]
-            or system_message.provider_thread_id != anchor["provider_thread_id"]
-            or system_message.target != anchor["target"]
-            or system_message.target_kind.value != anchor["target_kind"]
-        ):
-            raise ValueError("system message binding does not match reminder anchor")
-        expected_body = render_reminder_fire_body(
-            incoming,
-            system_message.target,
-            incoming.next_fire_at_ms,
-        )
-        if system_message.body != expected_body:
-            raise ValueError("system message body does not match reminder fire")
+            return None
 
         await self.execute(
             "UPDATE reminders SET title = ?, state = ?, next_fire_at_ms = ?, "

{bazaar_compute_node-0.1.32 → bazaar_compute_node-0.1.33}/src/bazaar_compute_node/core/orchestration/reminder.py

@@ -13,6 +13,7 @@ from ..models import (
     Message,
     MessageDirection,
     OwnedReminder,
+    Reminder,
     ReminderState,
     SenderIdentity,
     SenderKind,
@@ -28,6 +29,7 @@ from ..timerwheel import (
 )
 
 _WALL_CLOCK_RECHECK_MS = 60_000
+_CYCLE_RETRY_MS = 5_000
 _DUE_BATCH_SIZE = 100
 
 
@@ -123,8 +125,8 @@ class ReminderScheduler(IAsyncLifecycle):
         await self._failure.wait()
 
     async def _run(self) -> None:
-        try:
-            while not self._stopping:
+        while not self._stopping:
+            try:
                 await self._materialize_due_batches()
                 if self._stopping:
                     return
@@ -135,9 +137,9 @@ class ReminderScheduler(IAsyncLifecycle):
                     continue
                 next_fire_at_ms = frontier.reminder.next_fire_at_ms
                 if next_fire_at_ms is None:
-                    raise RuntimeError(
-                        "scheduled reminder frontier has no next fire time"
-                    )
+                    await self._poke.wait()
+                    self._poke.clear()
+                    continue
                 remaining_ms = next_fire_at_ms - self._clock()
                 if remaining_ms <= 0:
                     await asyncio.sleep(0)
@@ -148,11 +150,18 @@ class ReminderScheduler(IAsyncLifecycle):
                     _WALL_CLOCK_RECHECK_MS,
                 )
                 await self._wait_for_frontier(delay_ms)
-        except asyncio.CancelledError:
-            raise
-        except Exception:
-            self._logger.exception("reminder scheduler failed")
-            raise
+            except asyncio.CancelledError:
+                raise
+            except Exception:
+                self._logger.exception("reminder cycle failed; retrying")
+                try:
+                    await asyncio.wait_for(
+                        self._poke.wait(),
+                        _CYCLE_RETRY_MS / 1_000,
+                    )
+                except TimeoutError:
+                    pass
+                self._poke.clear()
 
     async def _wait_for_frontier(self, delay_ms: int) -> None:
         timer = self._timer_wheel.create(delay_ms)
@@ -234,7 +243,7 @@ class ReminderScheduler(IAsyncLifecycle):
                 return None
             scheduled_for_ms = current.next_fire_at_ms
             if scheduled_for_ms is None:
-                raise RuntimeError("scheduled reminder has no next fire time")
+                return None
             fired_at_ms = self._clock()
             if fired_at_ms < scheduled_for_ms:
                 return None
@@ -250,21 +259,13 @@ class ReminderScheduler(IAsyncLifecycle):
                 )
             except asyncio.CancelledError:
                 raise
-            except Exception as error:
-                canceled = current.cancel(at_ms=fired_at_ms)
-                await self._storage.save_reminder_transition(
-                    current.revision,
-                    canceled,
-                )
-                self._logger.error(
-                    "reminder recurrence is invalid; reminder canceled",
-                    extra={
-                        "agent_id": owner.agent_id,
-                        "owner_session_id": current.owner_session_id,
-                        "reminder_id": current.reminder_id,
-                        "error_type": type(error).__name__,
-                    },
-                    exc_info=(type(error), error, error.__traceback__),
+            except Exception as error:  # noqa: BLE001
+                await self._cancel_unusable_reminder(
+                    owner.agent_id,
+                    current,
+                    "reminder recurrence is invalid",
+                    at_ms=fired_at_ms,
+                    error=error,
                 )
                 return None
             fired = current.record_fire(
@@ -279,19 +280,11 @@ class ReminderScheduler(IAsyncLifecycle):
                 direction=MessageDirection.INBOUND,
             )
             if anchor is None:
-                canceled = current.cancel(at_ms=fired_at_ms)
-                await self._storage.save_reminder_transition(
-                    current.revision,
-                    canceled,
-                )
-                self._logger.error(
-                    "reminder anchor is missing; reminder canceled",
-                    extra={
-                        "agent_id": owner.agent_id,
-                        "owner_session_id": current.owner_session_id,
-                        "reminder_id": current.reminder_id,
-                        "anchor_message_id": current.anchor_message_id,
-                    },
+                await self._cancel_unusable_reminder(
+                    owner.agent_id,
+                    current,
+                    "reminder anchor is missing",
+                    at_ms=fired_at_ms,
                 )
                 return None
             system_message = Message[InboundAttachment](
@@ -326,8 +319,42 @@ class ReminderScheduler(IAsyncLifecycle):
                 OwnedReminder(owner.agent_id, fired),
                 system_message,
             )
+            if materialized is None:
+                return None
             return owner.agent_id, materialized
 
+    async def _cancel_unusable_reminder(
+        self,
+        agent_id: str,
+        reminder: Reminder,
+        reason: str,
+        *,
+        at_ms: int | None = None,
+        error: BaseException | None = None,
+    ) -> None:
+        """Retire one Reminder that can never fire, so the frontier keeps moving."""
+
+        canceled = reminder.cancel(at_ms=at_ms if at_ms is not None else self._clock())
+        retired = await self._storage.save_owned_reminder_transition(
+            reminder.revision,
+            OwnedReminder(agent_id, canceled),
+        )
+        if retired is None:
+            return
+        self._logger.error(
+            "%s; reminder canceled",
+            reason,
+            extra={
+                "agent_id": agent_id,
+                "owner_session_id": reminder.owner_session_id,
+                "reminder_id": reminder.reminder_id,
+                "anchor_message_id": reminder.anchor_message_id,
+            },
+            exc_info=(
+                (type(error), error, error.__traceback__) if error is not None else None
+            ),
+        )
+
     async def _publish_message(
         self,
         agent_id: str,

{bazaar_compute_node-0.1.32 → bazaar_compute_node-0.1.33}/src/bazaar_compute_node/core/storage.py

@@ -384,11 +384,8 @@ class StorageOperationMixin:
                 payload.reply_to_message_id,
                 delivery_states=_HISTORY_DELIVERY_STATES,
             )
-            if reply_message is None or reply_message.target != payload.target:
-                raise ValueError(
-                    "reply target does not belong to the target conversation"
-                )
-            reply_to_provider_message_id = reply_message.provider_message_id
+            if reply_message is not None and reply_message.target == payload.target:
+                reply_to_provider_message_id = reply_message.provider_message_id
         cross_session = source_target_id != target_id
         metadata: dict[str, object] = {}
         if cross_session:
@@ -730,12 +727,18 @@ class _StorageOperations(Protocol):
         limit: int,
     ) -> tuple[OwnedReminder, ...]: ...
 
+    async def save_owned_reminder_transition(
+        self,
+        expected_revision: int,
+        reminder: OwnedReminder,
+    ) -> Reminder | None: ...
+
     async def materialize_owned_reminder_message(
         self,
         expected_revision: int,
         reminder: OwnedReminder,
         system_message: Message[InboundAttachment],
-    ) -> Message[InboundAttachment]: ...
+    ) -> Message[InboundAttachment] | None: ...
 
     async def list_unread_message_owners(self) -> tuple[UnreadMessageOwner, ...]: ...