bazaar-compute-node 0.1.26__tar.gz → 0.1.27__tar.gz

{bazaar_compute_node-0.1.26 → bazaar_compute_node-0.1.27}/PKG-INFO

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

{bazaar_compute_node-0.1.26 → bazaar_compute_node-0.1.27}/pyproject.toml

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

{bazaar_compute_node-0.1.26 → bazaar_compute_node-0.1.27}/pyproject.toml.orig

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

{bazaar_compute_node-0.1.26 → bazaar_compute_node-0.1.27}/src/bazaar_compute_node/app/agent.py

@@ -10,21 +10,17 @@ import secrets
 from collections.abc import Callable, Mapping, Sequence
 from dataclasses import dataclass
 from pathlib import Path
-from time import time_ns
-from typing import cast
 
 from ..core.channel import AgentScopedChannel, ChannelContext, IChannel
 from ..core.concurrency import ISessionConcurrency, SessionLockRegistry
 from ..core.lifecycle import TimeoutBudget
-from ..core.models import RuntimeSession
+from ..core.models import InboundAttachment, Message, RuntimeSession
 from ..core.observability import IAudit
 from ..core.orchestration import SessionOrchestrator
-from ..core.orchestration.handoff_command import HandoffCommandService
 from ..core.orchestration.reminder_command import ReminderCommandService
-from ..core.orchestration.services import SessionAuditRecorder
 from ..core.paths import resolve_workspace_dir
 from ..core.runtime import IRuntime, RuntimeCommandContext
-from ..core.storage import IHandoffStorageScope, IStorageScope
+from ..core.storage import IStorageScope
 from ..core.timerwheel import TimerWheel
 from ..i18n import Translator
 from .attachments import AttachmentMaterializer
@@ -82,7 +78,6 @@ class AgentApplication:
         self.agent_id = configuration.id
         self.name = configuration.name
         self.storage = storage
-        self._handoff_storage = cast(IHandoffStorageScope, storage)
         self.audit = audit
         self.timer_wheel = timer_wheel
         self.timeout_budget = timeout_budget
@@ -152,7 +147,6 @@ class AgentApplication:
             channel=self.channel,
             runtime=self.runtime,
             storage=self.storage,
-            handoff_storage=self._handoff_storage,
             audit=self.audit,
             timeout_budget=self.timeout_budget,
             timer_wheel=self.timer_wheel,
@@ -167,16 +161,6 @@ class AgentApplication:
             concurrency=reminder_concurrency,
             poke=reminder_poke,
         )
-        self.handoff_service = HandoffCommandService(
-            storage=self._handoff_storage,
-            audit=SessionAuditRecorder(
-                sink=self.audit,
-                timeout_budget=self.timeout_budget,
-                clock=lambda: time_ns() // 1_000_000,
-            ),
-            publish_wake=self.publish_handoff_wake,
-            node_id=lambda: self.agent_id,
-        )
         self._provider_control_handler = (
             factories.control(self._adapter_context())
             if factories.control is not None
@@ -185,7 +169,6 @@ class AgentApplication:
         self.command_dispatcher = CommandDispatcher(
             self.orchestrator.command_service,
             reminder_service=self.reminder_service,
-            handoff_service=self.handoff_service,
             timeout_budget=self.timeout_budget,
             control_handler=(
                 self._handle_control
@@ -281,15 +264,10 @@ class AgentApplication:
             return False
         return await self.storage.get_bcn_session(session_id) is not None
 
-    async def publish_reminder_wake(self, session_id: str) -> None:
-        if not self._started:
-            raise RuntimeError("Agent application is not started")
-        await self.orchestrator.publish_reminder_wake(session_id)
-
-    async def publish_handoff_wake(self, session_id: str) -> None:
+    async def publish_inbox_wake(self, message: Message[InboundAttachment]) -> None:
         if not self._started:
             raise RuntimeError("Agent application is not started")
-        await self.orchestrator.publish_handoff_wake(session_id)
+        await self.orchestrator.publish_inbox_wake(message)
 
     def health_record(self) -> dict[str, object]:
         return {

{bazaar_compute_node-0.1.26 → bazaar_compute_node-0.1.27}/src/bazaar_compute_node/app/application.py

@@ -11,6 +11,7 @@ from pathlib import Path
 
 from ..core.concurrency import SessionLockRegistry
 from ..core.lifecycle import TimeoutBudget
+from ..core.models import InboundAttachment, Message
 from ..core.observability import IAudit
 from ..core.orchestration import ReminderScheduler
 from ..core.paths import resolve_data_dir
@@ -77,7 +78,7 @@ class NodeApplication:
             storage=self.storage,
             timer_wheel=self.timer_wheel,
             concurrency=self._reminder_concurrency,
-            publish_wake=self._publish_reminder_wake,
+            publish_wake=self._publish_inbox_wake,
         )
         self.command_server = LocalCommandServer(
             self._dispatch,
@@ -246,24 +247,28 @@ class NodeApplication:
                 pass
         await self._stopped.wait()
 
-    async def _publish_reminder_wake(self, agent_id: str, session_id: str) -> bool:
+    async def _publish_inbox_wake(
+        self,
+        agent_id: str,
+        message: Message[InboundAttachment],
+    ) -> bool:
         agent = self.agents.get(agent_id)
         if agent is None or not agent.started:
             self._log(
                 "reminder.wake.agent_unavailable",
                 agent_id=agent_id,
-                owner_session_id=session_id,
+                owner_session_id=message.session_id,
             )
             return False
         try:
-            await agent.publish_reminder_wake(session_id)
+            await agent.publish_inbox_wake(message)
         except asyncio.CancelledError:
             raise
         except Exception as error:  # noqa: BLE001
             self._log(
                 "reminder.wake.failed",
                 agent_id=agent_id,
-                owner_session_id=session_id,
+                owner_session_id=message.session_id,
                 error_type=type(error).__name__,
                 error=_safe_error(error),
             )

{bazaar_compute_node-0.1.26 → bazaar_compute_node-0.1.27}/src/bazaar_compute_node/app/command.py

@@ -21,7 +21,6 @@ from ..core.command import (
     ICommandService,
     InboxListResult,
     MessageSendFreshnessHold,
-    MessageSendHandoffRequired,
     SessionNotFoundError,
 )
 from ..core.lifecycle import TimeoutBudget
@@ -80,6 +79,17 @@ def serialize_message(message: Message) -> dict[str, object]:
             else {"id": message.sender.id, "name": message.sender.name}
         ),
         "sender_kind": message.sender_kind.value,
+        "system_message_kind": (
+            None
+            if message.system_message_kind is None
+            else message.system_message_kind.value
+        ),
+        "system_message_source_target": message.metadata.get(
+            "system_message_source_target"
+        ),
+        "system_message_source_message_id": message.metadata.get(
+            "system_message_source_message_id"
+        ),
         "message_type": message.message_type,
         "canonical_target": message.target,
         "target_kind": message.target_kind.value,
@@ -498,11 +508,6 @@ class CommandDispatcher:
                     "ok": True,
                     "result": {"text": format_freshness_hold(result)},
                 }
-            if isinstance(result, MessageSendHandoffRequired):
-                return {
-                    "ok": True,
-                    "result": {"text": format_cross_session_hold(result.target)},
-                }
             delivery_state = result.delivery_state
             if delivery_state is None:
                 raise RuntimeError("outbound message has no delivery state")
@@ -622,17 +627,45 @@ def format_check_message(message: Mapping[str, object]) -> str:
     target, message_id, timestamp, sender_kind, sender, body = _message_header_fields(
         message
     )
-    line = (
-        f"[target={target} msg={message_id} time={timestamp} "
-        f"type={sender_kind} mentioned={str(message['mentions_agent']).lower()}"
-    )
+    line = f"[target={target} msg={message_id} time={timestamp} type={sender_kind}"
     reply_to_message_id = message["reply_to_message_id"]
     if reply_to_message_id is not None:
         line += f" reply_to={cast(str, reply_to_message_id)}"
     line += "] "
     if sender is not None:
-        line += f"{sender} "
-    return line + body + _attachment_suffix(message)
+        line += f"{sender}: "
+    rendered = line + body + _attachment_suffix(message)
+    if message.get("system_message_kind") == "reminder":
+        operation = (
+            "(to snooze/update/cancel: bcc reminder --help)"
+            if "\nNext iteration: " in body
+            else "(to snooze/cancel: bcc reminder --help)"
+        )
+        rendered += (
+            f"\n{operation}"
+            "\nRespond as appropriate. Complete all your work before stopping."
+            "\nReply in the channel or create/reply in a thread as appropriate; "
+            "use each message's `target` and `msg` fields to choose the exact target."
+        )
+    elif message.get("system_message_kind") == "handoff":
+        source_target = cast(str, message["system_message_source_target"])
+        source_message_id = cast(
+            str,
+            message["system_message_source_message_id"],
+        )
+        rendered += (
+            "\nTo understand why this message was sent, inspect the source context:"
+            "\n  bcc message read --target "
+            f"{json.dumps(source_target)} --around {json.dumps(source_message_id)}"
+            "\nIf you have no objection to why the message was sent, do not announce "
+            "or explain the handoff, and do not repeat or respond to the referenced "
+            "message; it has already been delivered. Continue only work already in "
+            "progress in this conversation that is independent of that message; if "
+            "there is none, stop."
+            "\nMention the handoff only when its reason is unclear, conflicts with "
+            "the current conversation, or requires a decision."
+        )
+    return rendered
 
 
 def format_read_message(
@@ -650,14 +683,13 @@ def format_read_message(
         f"time={timestamp}",
         f"type={sender_kind}",
         f"replyTarget={target}",
-        f"mentioned={str(message['mentions_agent']).lower()}",
     ]
     reply_to_message_id = message["reply_to_message_id"]
     if reply_to_message_id is not None:
         fields.append(f"replyTo={cast(str, reply_to_message_id)}")
     line = f"[{index}/{count} {' '.join(fields)}] "
     if sender is not None:
-        line += f"{sender} "
+        line += f"{sender}: "
     return line + body + _attachment_suffix(message)
 
 
@@ -718,23 +750,3 @@ def format_freshness_hold(result: MessageSendFreshnessHold) -> str:
         )
     )
     return "\n".join(lines)
-
-
-def format_cross_session_hold(target: str) -> str:
-    quoted_target = json.dumps(target)
-    return "\n".join(
-        (
-            "Your message was not sent because the target belongs to another conversation.",
-            "",
-            (
-                "To continue this work in the target conversation, send a "
-                "self-contained handoff:"
-            ),
-            f"  bcc handoff send --target {quoted_target} <<'BCCMSG'",
-            "  enough context to understand the background, goal, and next action",
-            "  BCCMSG",
-            "This creates a handoff notice that wakes you in that conversation.",
-            "",
-            "You can also choose not to send anything.",
-        )
-    )

{bazaar_compute_node-0.1.26 → bazaar_compute_node-0.1.27}/src/bazaar_compute_node/app/resource_dispatch.py

@@ -4,22 +4,18 @@ from collections.abc import Mapping
 from time import time_ns
 from typing import Annotated, Literal, cast
 
-from pydantic import Field, StrictBool, StrictInt, StrictStr, field_validator
+from pydantic import Field, StrictBool, StrictInt, StrictStr
 
-from ..core.command import ICommandService, IHandoffService, IReminderService
-from ..core.handoff import HandoffCheckRequest, HandoffSendRequest
+from ..core.command import ICommandService, IReminderService
 from ..core.lifecycle import TimeoutBudget
-from ..core.models import Handoff, Reminder, ReminderOccurrence, ReminderState
-from ..core.orchestration.handoff_command import HandoffCommandFailure
+from ..core.models import Reminder, ReminderState
 from ..core.orchestration.reminder_command import ReminderCommandFailure
 from ..core.reminder import (
     ReminderCancelRequest,
-    ReminderCheckRequest,
     ReminderListRequest,
     ReminderScheduleRequest,
     ReminderSnoozeRequest,
     ReminderUpdateRequest,
-    canonical_id_reference,
 )
 from .command import CommandDispatcher as _MessageCommandDispatcher
 from .command import (
@@ -50,45 +46,8 @@ def serialize_reminder(reminder: Reminder) -> dict[str, object]:
     }
 
 
-def serialize_reminder_occurrence(
-    occurrence: ReminderOccurrence,
-) -> dict[str, object]:
-    return {
-        "occurrence_id": occurrence.occurrence_id,
-        "reminder_id": occurrence.reminder_id,
-        "owner_session_id": occurrence.owner_session_id,
-        "occurrence_no": occurrence.occurrence_no,
-        "anchor_message_id": occurrence.anchor_message_id,
-        "scheduled_for_ms": occurrence.scheduled_for_ms,
-        "fired_at_ms": occurrence.fired_at_ms,
-        "next_fire_at_ms": occurrence.next_fire_at_ms,
-        "overdue": occurrence.overdue,
-        "read_at_ms": occurrence.read_at_ms,
-        "created_at_ms": occurrence.created_at_ms,
-    }
-
-
-def serialize_handoff(handoff: Handoff) -> dict[str, object]:
-    return {
-        "handoff_id": handoff.handoff_id,
-        "command_id": handoff.command_id,
-        "source_session_id": handoff.source_session_id,
-        "target_session_id": handoff.target_session_id,
-        "source_message_id": handoff.source_message_id,
-        "body": handoff.body,
-        "created_at_ms": handoff.created_at_ms,
-        "read_at_ms": handoff.read_at_ms,
-    }
-
-
 NonEmptyText = Annotated[StrictStr, Field(min_length=1)]
 PositiveInt = Annotated[StrictInt, Field(gt=0)]
-NonNegativeInt = Annotated[StrictInt, Field(ge=0)]
-
-
-class _ReminderCheckRequest(_CommandRequest):
-    resource: Literal["reminder"]
-    command: Literal["check"]
 
 
 class _ReminderScheduleRequest(_CommandRequest):
@@ -132,39 +91,9 @@ class _ReminderCancelRequest(_CommandRequest):
     reminder_id: NonEmptyText
 
 
-class _HandoffSendRequest(_CommandRequest):
-    resource: Literal["handoff"]
-    command: Literal["send"]
-    target: NonEmptyText
-    body: StrictStr
-    command_id: NonEmptyText
-    source_message_id: NonEmptyText | None = None
-    created_at_ms: NonNegativeInt = Field(
-        default_factory=lambda: time_ns() // 1_000_000
-    )
-
-    @field_validator("body")
-    @classmethod
-    def _require_body(cls, value: str) -> str:
-        if not value.strip():
-            raise ValueError("handoff body must contain non-whitespace text")
-        return value
-
-    @field_validator("source_message_id")
-    @classmethod
-    def _require_source_message_id(cls, value: str | None) -> str | None:
-        return None if value is None else canonical_id_reference(value)
-
-
-class _HandoffCheckRequest(_CommandRequest):
-    resource: Literal["handoff"]
-    command: Literal["check"]
-
-
 _REMINDER_REQUESTS: dict[
     str, tuple[type[_CommandRequest], Mapping[str, tuple[str, str]]]
 ] = {
-    "check": (_ReminderCheckRequest, {}),
     "schedule": (
         _ReminderScheduleRequest,
         {
@@ -246,37 +175,6 @@ _REMINDER_REQUESTS: dict[
     ),
 }
 
-_HANDOFF_REQUESTS: dict[
-    str, tuple[type[_CommandRequest], Mapping[str, tuple[str, str]]]
-] = {
-    "send": (
-        _HandoffSendRequest,
-        {
-            "target": (
-                "HANDOFF_TARGET_REQUIRED",
-                "Handoff --target is required.",
-            ),
-            "body": (
-                "HANDOFF_BODY_REQUIRED",
-                "Handoff body must be non-empty text read from stdin.",
-            ),
-            "command_id": (
-                "COMMAND_ID_REQUIRED",
-                "command_id must be a non-empty string",
-            ),
-            "source_message_id": (
-                "HANDOFF_SOURCE_INVALID",
-                "Handoff --message-id must be a full UUID.",
-            ),
-            "created_at_ms": (
-                "INVALID_CREATED_AT",
-                "created_at_ms must be non-negative",
-            ),
-        },
-    ),
-    "check": (_HandoffCheckRequest, {}),
-}
-
 
 class CommandDispatcher(_MessageCommandDispatcher):
     """Resource-aware dispatcher for all local Agent commands."""
@@ -286,7 +184,6 @@ class CommandDispatcher(_MessageCommandDispatcher):
         service: ICommandService,
         *,
         reminder_service: IReminderService,
-        handoff_service: IHandoffService,
         timeout_budget: TimeoutBudget,
         control_handler: ControlHandler | None = None,
         session_binding_validator: SessionBindingValidator | None = None,
@@ -298,7 +195,6 @@ class CommandDispatcher(_MessageCommandDispatcher):
             session_binding_validator=session_binding_validator,
         )
         self._reminder_service = reminder_service
-        self._handoff_service = handoff_service
 
     async def _dispatch_command(
         self,
@@ -333,8 +229,6 @@ class CommandDispatcher(_MessageCommandDispatcher):
             return await super()._dispatch_command(raw_request)
         if resource == "inbox":
             return await super()._dispatch_command(raw_request)
-        if resource == "handoff":
-            return await self._dispatch_handoff(raw_request, command)
         if resource != "reminder":
             raise CommandDispatchError(
                 "UNKNOWN_RESOURCE",
@@ -366,71 +260,6 @@ class CommandDispatcher(_MessageCommandDispatcher):
                 next_action=error.next_action,
             ) from error
 
-    async def _dispatch_handoff(
-        self,
-        raw_request: Mapping[str, object],
-        command: str,
-    ) -> Mapping[str, object]:
-        request_spec = _HANDOFF_REQUESTS.get(command)
-        if request_spec is None:
-            raise CommandDispatchError(
-                "UNKNOWN_COMMAND",
-                f"unsupported handoff command: {command}",
-            )
-        request_model, request_errors = request_spec
-        request = _parse_command_request(
-            raw_request,
-            request_model,
-            errors=request_errors,
-        )
-        session_id = request.session_id
-        if self._session_binding_validator is not None:
-            await self._session_binding_validator(session_id, raw_request)
-        try:
-            if command == "send":
-                values = cast(_HandoffSendRequest, request)
-                result = await self._handoff_service.send(
-                    session_id,
-                    HandoffSendRequest(
-                        target=values.target,
-                        body=values.body,
-                        command_id=values.command_id,
-                        created_at_ms=values.created_at_ms,
-                        source_message_id=values.source_message_id,
-                    ),
-                )
-                return {
-                    "ok": True,
-                    "result": {
-                        "handoff": serialize_handoff(result.handoff),
-                        "target": result.target,
-                    },
-                }
-
-            result = await self._handoff_service.check(
-                session_id,
-                HandoffCheckRequest(),
-            )
-            return {
-                "ok": True,
-                "result": {
-                    "items": [
-                        {
-                            "handoff": serialize_handoff(item.handoff),
-                            "source_target": item.source_target,
-                        }
-                        for item in result.items
-                    ],
-                    "has_more": result.has_more,
-                },
-            }
-        except HandoffCommandFailure as error:
-            raise CommandDispatchError(
-                error.code,
-                error.message,
-                next_action=error.next_action,
-            ) from error
-
     async def _dispatch_reminder(
         self,
         session_id: str,
@@ -486,28 +315,6 @@ class CommandDispatcher(_MessageCommandDispatcher):
                 "result": {"reminder": serialize_reminder(result.reminder)},
             }
 
-        if command == "check":
-            result = await self._reminder_service.check(
-                session_id,
-                ReminderCheckRequest(),
-            )
-            return {
-                "ok": True,
-                "result": {
-                    "items": [
-                        {
-                            "occurrence": serialize_reminder_occurrence(
-                                item.occurrence
-                            ),
-                            "title": item.title,
-                            "canonical_target": item.canonical_target,
-                        }
-                        for item in result.items
-                    ],
-                    "has_more": result.has_more,
-                },
-            }
-
         if command == "list":
             request_values = cast(_ReminderListRequest, parsed_request)
             all_statuses = request_values.all
@@ -626,5 +433,4 @@ class CommandDispatcher(_MessageCommandDispatcher):
 __all__ = [
     "CommandDispatcher",
     "serialize_reminder",
-    "serialize_reminder_occurrence",
 ]