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

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

@@ -1,12 +1,13 @@
 Metadata-Version: 2.4
 Name: bazaar-compute-node
-Version: 0.1.26
+Version: 0.1.28
 Summary: Runtime-agnostic computer node daemon for agents and channels.
 License-Expression: AGPL-3.0-only
 License-File: LICENSE
 Requires-Dist: aiohttp>=3.12.0
 Requires-Dist: aiosqlite>=0.20.0
 Requires-Dist: cryptography>=45.0.0
+Requires-Dist: jinja2>=3.1.6
 Requires-Dist: pydantic>=2.0.0
 Requires-Dist: protobug==1.0.0
 Requires-Dist: tzdata>=2024.1 ; sys_platform == 'win32'

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

@@ -1,6 +1,6 @@
 [project]
 name = "bazaar-compute-node"
-version = "0.1.26"
+version = "0.1.28"
 description = "Runtime-agnostic computer node daemon for agents and channels."
 readme = "README.md"
 license = "AGPL-3.0-only"
@@ -10,6 +10,7 @@ dependencies = [
     "aiohttp>=3.12.0",
     "aiosqlite>=0.20.0",
     "cryptography>=45.0.0",
+    "jinja2>=3.1.6",
     "pydantic>=2.0.0",
     "protobug==1.0.0",
     "tzdata>=2024.1; sys_platform == 'win32'",

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

@@ -1,6 +1,6 @@
 [project]
 name = "bazaar-compute-node"
-version = "0.1.26"
+version = "0.1.28"
 description = "Runtime-agnostic computer node daemon for agents and channels."
 readme = "README.md"
 license = "AGPL-3.0-only"
@@ -10,6 +10,7 @@ dependencies = [
     "aiohttp>=3.12.0",
     "aiosqlite>=0.20.0",
     "cryptography>=45.0.0",
+    "jinja2>=3.1.6",
     "pydantic>=2.0.0",
     "protobug==1.0.0",
     "tzdata>=2024.1; sys_platform == 'win32'",

{bazaar_compute_node-0.1.26 → bazaar_compute_node-0.1.28}/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.28}/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.28}/src/bazaar_compute_node/app/command.py

@@ -21,8 +21,9 @@ from ..core.command import (
     ICommandService,
     InboxListResult,
     MessageSendFreshnessHold,
-    MessageSendHandoffRequired,
+    MessageSendSuccess,
     SessionNotFoundError,
+    TargetProjection,
 )
 from ..core.lifecycle import TimeoutBudget
 from ..core.models import (
@@ -63,7 +64,14 @@ def _serialize_attachment(
     }
 
 
-def serialize_message(message: Message) -> dict[str, object]:
+def serialize_message(
+    message: Message,
+    target_projections: tuple[TargetProjection, ...] = (),
+) -> dict[str, object]:
+    targets = {
+        projection.canonical_target: projection.display_target
+        for projection in target_projections
+    }
     return {
         "seq": message.seq,
         "message_id": message.message_id,
@@ -80,7 +88,24 @@ 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": (
+            targets.get(source_target, source_target)
+            if isinstance(
+                source_target := message.metadata.get("system_message_source_target"),
+                str,
+            )
+            else None
+        ),
+        "system_message_source_message_id": message.metadata.get(
+            "system_message_source_message_id"
+        ),
         "message_type": message.message_type,
+        "target": targets.get(message.target, message.target),
         "canonical_target": message.target,
         "target_kind": message.target_kind.value,
         "mentions_agent": message.mentions_agent,
@@ -437,10 +462,11 @@ class CommandDispatcher:
                 "ok": True,
                 "result": {
                     "messages": [
-                        serialize_message(message) for message in result.messages
+                        serialize_message(message, result.target_projections)
+                        for message in result.messages
                     ],
                     "referenced_messages": [
-                        serialize_message(message)
+                        serialize_message(message, result.target_projections)
                         for message in result.referenced_messages
                     ],
                     "snapshot_seq": result.snapshot_seq,
@@ -461,7 +487,7 @@ class CommandDispatcher:
             request = cast(_MessageReadRequest, request)
             result = await self._service.read(
                 session_id,
-                target=request.target,
+                raw_target=request.target,
                 around_message_id=request.around_message_id,
                 limit=request.limit,
             )
@@ -469,10 +495,11 @@ class CommandDispatcher:
                 "ok": True,
                 "result": {
                     "messages": [
-                        serialize_message(message) for message in result.messages
+                        serialize_message(message, result.target_projections)
+                        for message in result.messages
                     ],
                     "referenced_messages": [
-                        serialize_message(message)
+                        serialize_message(message, result.target_projections)
                         for message in result.referenced_messages
                     ],
                     "snapshot_seq": result.snapshot_seq,
@@ -486,7 +513,7 @@ class CommandDispatcher:
             result = await self._service.send(
                 session_id=session_id,
                 command_id=request.command_id,
-                target=request.target,
+                raw_target=request.target,
                 body=request.body,
                 created_at_ms=request.created_at_ms,
                 attachment_paths=tuple(request.attachment_paths),
@@ -498,27 +525,25 @@ 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 not isinstance(result, MessageSendSuccess):
+                raise AssertionError("message send returned an unsupported result")
+            message = result.message
+            delivery_state = message.delivery_state
             if delivery_state is None:
                 raise RuntimeError("outbound message has no delivery state")
             if delivery_state is OutboundDeliveryState.SENT:
                 text = (
-                    f"Message sent to {result.target}. Message ID: {result.message_id}"
+                    f"Message sent to {result.target}. Message ID: {message.message_id}"
                 )
             elif delivery_state is OutboundDeliveryState.QUEUED:
                 text = (
                     f"Message queued to {result.target}. "
-                    f"Message ID: {result.message_id}"
+                    f"Message ID: {message.message_id}"
                 )
             elif delivery_state is OutboundDeliveryState.PARTIAL:
                 raise CommandDispatchError(
                     "SEND_PARTIAL",
-                    result.error_message
+                    message.error_message
                     or "Message delivery was only partially confirmed.",
                     next_action=(
                         "Do not retry the complete message automatically; reconcile "
@@ -528,13 +553,13 @@ class CommandDispatcher:
             elif delivery_state is OutboundDeliveryState.UNKNOWN:
                 raise CommandDispatchError(
                     "SEND_UNKNOWN",
-                    result.error_message or "Message delivery outcome is unknown.",
+                    message.error_message or "Message delivery outcome is unknown.",
                     next_action="Reconcile channel delivery before retrying.",
                 )
             elif delivery_state is OutboundDeliveryState.FAILED:
                 raise CommandDispatchError(
                     "SEND_FAILED",
-                    result.error_message or "Message delivery failed.",
+                    message.error_message or "Message delivery failed.",
                     next_action="Fix the provider error before retrying.",
                 )
             else:
@@ -548,8 +573,14 @@ class CommandDispatcher:
 
         if resource == "thread" and command == "unfollow":
             request = cast(_ThreadUnfollowRequest, request)
-            changed = await self._service.unfollow(session_id, target=request.target)
-            return {"ok": True, "result": {"changed": changed}}
+            result = await self._service.unfollow(
+                session_id,
+                raw_target=request.target,
+            )
+            return {
+                "ok": True,
+                "result": {"target": result.target, "changed": result.changed},
+            }
 
         raise AssertionError("validated command route has no handler")
 
@@ -573,7 +604,7 @@ def _message_timestamp(message: Mapping[str, object]) -> int:
 def _message_header_fields(
     message: Mapping[str, object],
 ) -> tuple[str, str, str, str, str | None, str]:
-    target = cast(str, message["canonical_target"])
+    target = cast(str, message["target"])
     message_id = cast(str, message["message_id"])
     sender_kind = cast(str, message["sender_kind"])
     sender_value = message["sender"]
@@ -622,17 +653,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,21 +709,24 @@ 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)
 
 
 def format_freshness_hold(result: MessageSendFreshnessHold) -> str:
-    messages = [serialize_message(message) for message in result.messages]
+    messages = [
+        serialize_message(message, result.target_projections)
+        for message in result.messages
+    ]
     referenced_messages = [
-        serialize_message(message) for message in result.referenced_messages
+        serialize_message(message, result.target_projections)
+        for message in result.referenced_messages
     ]
     shown = len(messages)
     total = result.newer_message_total
@@ -718,23 +780,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.",
-        )
-    )