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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bazaar-compute-node
-Version: 0.1.25
+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.25 → bazaar_compute_node-0.1.27}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "bazaar-compute-node"
-version = "0.1.25"
+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.25 → bazaar_compute_node-0.1.27}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "bazaar-compute-node"
-version = "0.1.25"
+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.25 → 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
@@ -279,18 +262,12 @@ class AgentApplication:
     async def has_session(self, session_id: str) -> bool:
         if not isinstance(session_id, str) or not session_id:
             return False
-        async with self.storage.transaction() as transaction:
-            return await transaction.get_bcn_session(session_id) is not None
+        return await self.storage.get_bcn_session(session_id) is not None
 
-    async def publish_reminder_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_reminder_wake(session_id)
-
-    async def publish_handoff_wake(self, session_id: str) -> 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 {
@@ -323,8 +300,7 @@ class AgentApplication:
         self._wrapper_path = None
 
     async def _referenced_attachment_paths(self) -> set[str]:
-        async with self.storage.transaction() as transaction:
-            return set(await transaction.list_ready_attachment_paths())
+        return set(await self.storage.list_ready_attachment_paths())
 
     def _adapter_context(self) -> Mapping[str, object]:
         return {
@@ -370,12 +346,11 @@ class AgentApplication:
             )
         runtime_session_id = request.get("runtime_session_id")
         session_capability = request.get("session_capability")
-        async with self.storage.transaction() as transaction:
-            if await transaction.get_bcn_session(session_id) is None:
-                raise CommandDispatchError(
-                    "SESSION_NOT_FOUND",
-                    f"unknown bcn session: {session_id}",
-                )
+        if await self.storage.get_bcn_session(session_id) is None:
+            raise CommandDispatchError(
+                "SESSION_NOT_FOUND",
+                f"unknown bcn session: {session_id}",
+            )
         runtime_session = self.orchestrator.runtime_session(session_id)
         if runtime_session is None or runtime_session_id != runtime_session.id:
             raise CommandDispatchError(

{bazaar_compute_node-0.1.25 → 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.25 → bazaar_compute_node-0.1.27}/src/bazaar_compute_node/app/command.py

@@ -21,21 +21,57 @@ from ..core.command import (
     ICommandService,
     InboxListResult,
     MessageSendFreshnessHold,
-    MessageSendHandoffRequired,
     SessionNotFoundError,
 )
 from ..core.lifecycle import TimeoutBudget
-from ..core.models import InboundMessage, InboxTargetSummary, OutboundDeliveryState
+from ..core.models import (
+    InboundAttachment,
+    InboxTargetSummary,
+    Message,
+    MessageDirection,
+    OutboundAttachment,
+    OutboundDeliveryState,
+)
+
+
+def _serialize_attachment(
+    attachment: InboundAttachment | OutboundAttachment,
+) -> dict[str, object]:
+    if isinstance(attachment, InboundAttachment):
+        return {
+            "attachment_id": attachment.attachment_id,
+            "name": attachment.name,
+            "kind": attachment.kind,
+            "state": attachment.state,
+            "media_type": attachment.media_type,
+            "relative_path": attachment.relative_path,
+            "size_bytes": attachment.size_bytes,
+            "error": attachment.error,
+            "sha256": None,
+        }
+    return {
+        "attachment_id": None,
+        "name": attachment.name,
+        "kind": "file",
+        "state": "ready",
+        "media_type": attachment.media_type,
+        "relative_path": attachment.relative_path,
+        "size_bytes": attachment.size_bytes,
+        "error": None,
+        "sha256": attachment.sha256,
+    }
 
 
-def serialize_inbound(message: InboundMessage) -> dict[str, object]:
+def serialize_message(message: Message) -> dict[str, object]:
     return {
         "seq": message.seq,
         "message_id": message.message_id,
+        "direction": message.direction.value,
         "session_id": message.session_id,
         "channel_session_id": message.channel_session_id,
         "channel": message.channel,
         "received_at_ms": message.received_at_ms,
+        "created_at_ms": message.created_at_ms,
         "provider_time_ms": message.provider_time_ms,
         "sender": (
             None
@@ -43,26 +79,33 @@ def serialize_inbound(message: InboundMessage) -> 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.canonical_target,
+        "canonical_target": message.target,
         "target_kind": message.target_kind.value,
         "mentions_agent": message.mentions_agent,
         "notifies_runtime": message.notifies_runtime,
         "attachments": [
-            {
-                "attachment_id": attachment.attachment_id,
-                "name": attachment.name,
-                "kind": attachment.kind,
-                "state": attachment.state,
-                "media_type": attachment.media_type,
-                "relative_path": attachment.relative_path,
-                "size_bytes": attachment.size_bytes,
-                "error": attachment.error,
-            }
-            for attachment in message.attachments
+            _serialize_attachment(attachment) for attachment in message.attachments
         ],
         "body": message.body,
         "reply_to_message_id": message.reply_to_message_id,
+        "delivery_state": (
+            message.delivery_state.value
+            if message.direction is MessageDirection.OUTBOUND
+            and message.delivery_state is not None
+            else None
+        ),
     }
 
 
@@ -404,10 +447,10 @@ class CommandDispatcher:
                 "ok": True,
                 "result": {
                     "messages": [
-                        serialize_inbound(message) for message in result.messages
+                        serialize_message(message) for message in result.messages
                     ],
                     "referenced_messages": [
-                        serialize_inbound(message)
+                        serialize_message(message)
                         for message in result.referenced_messages
                     ],
                     "snapshot_seq": result.snapshot_seq,
@@ -436,10 +479,10 @@ class CommandDispatcher:
                 "ok": True,
                 "result": {
                     "messages": [
-                        serialize_inbound(message) for message in result.messages
+                        serialize_message(message) for message in result.messages
                     ],
                     "referenced_messages": [
-                        serialize_inbound(message)
+                        serialize_message(message)
                         for message in result.referenced_messages
                     ],
                     "snapshot_seq": result.snapshot_seq,
@@ -465,22 +508,19 @@ 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)},
-                }
-            if result.state is OutboundDeliveryState.SENT:
+            delivery_state = result.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}. "
-                    f"Message ID: {result.outbound_message_id}"
+                    f"Message sent to {result.target}. Message ID: {result.message_id}"
                 )
-            elif result.state is OutboundDeliveryState.QUEUED:
+            elif delivery_state is OutboundDeliveryState.QUEUED:
                 text = (
                     f"Message queued to {result.target}. "
-                    f"Message ID: {result.outbound_message_id}"
+                    f"Message ID: {result.message_id}"
                 )
-            elif result.state is OutboundDeliveryState.PARTIAL:
+            elif delivery_state is OutboundDeliveryState.PARTIAL:
                 raise CommandDispatchError(
                     "SEND_PARTIAL",
                     result.error_message
@@ -490,13 +530,13 @@ class CommandDispatcher:
                         "confirmed delivery first."
                     ),
                 )
-            elif result.state is OutboundDeliveryState.UNKNOWN:
+            elif delivery_state is OutboundDeliveryState.UNKNOWN:
                 raise CommandDispatchError(
                     "SEND_UNKNOWN",
                     result.error_message or "Message delivery outcome is unknown.",
                     next_action="Reconcile channel delivery before retrying.",
                 )
-            elif result.state is OutboundDeliveryState.FAILED:
+            elif delivery_state is OutboundDeliveryState.FAILED:
                 raise CommandDispatchError(
                     "SEND_FAILED",
                     result.error_message or "Message delivery failed.",
@@ -504,7 +544,7 @@ class CommandDispatcher:
                 )
             else:
                 raise AssertionError(
-                    f"message send returned unsupported state: {result.state.value}"
+                    f"message send returned unsupported state: {delivery_state.value}"
                 )
             return {
                 "ok": True,
@@ -528,10 +568,11 @@ def format_message_time(timestamp_ms: int) -> str:
 
 
 def _message_timestamp(message: Mapping[str, object]) -> int:
-    timestamp = message["provider_time_ms"]
-    if timestamp is None:
-        timestamp = message["received_at_ms"]
-    return cast(int, timestamp)
+    for field_name in ("provider_time_ms", "received_at_ms", "created_at_ms"):
+        timestamp = message.get(field_name)
+        if timestamp is not None:
+            return cast(int, timestamp)
+    raise ValueError("message has no display timestamp")
 
 
 def _message_header_fields(
@@ -546,7 +587,12 @@ def _message_header_fields(
         sender_mapping = cast(Mapping[str, object], sender_value)
         sender_id = cast(str | None, sender_mapping.get("id"))
         sender_name = cast(str | None, sender_mapping.get("name"))
-        sender = f"@{sender_id}({sender_name})" if sender_name else f"@{sender_id}"
+        if sender_id is not None and sender_name is not None:
+            sender = f"@{sender_id}({sender_name})"
+        elif sender_name is not None:
+            sender = f"@{sender_name}"
+        elif sender_id is not None:
+            sender = f"@{sender_id}"
     return (
         target,
         message_id,
@@ -564,33 +610,62 @@ def _attachment_suffix(message: Mapping[str, object]) -> str:
     rendered: list[str] = []
     for attachment in attachments:
         name = cast(str, attachment["name"])
-        attachment_id = cast(str, attachment["attachment_id"])
+        attachment_id = cast(str | None, attachment.get("attachment_id"))
         state = cast(str, attachment["state"])
+        identity = f"id:{attachment_id}, " if attachment_id is not None else ""
         if state == "ready":
             path = cast(str, attachment["relative_path"])
-            rendered.append(f"{name} (id:{attachment_id}, path:{path})")
+            rendered.append(f"{name} ({identity}path:{path})")
         else:
             error = cast(str, attachment["error"])
-            rendered.append(f"{name} (id:{attachment_id}, state:failed, error:{error})")
+            rendered.append(f"{name} ({identity}state:failed, error:{error})")
     label = "attachment" if len(rendered) == 1 else "attachments"
     return f" [{len(rendered)} {label}: {', '.join(rendered)}]"
 
 
 def format_check_message(message: Mapping[str, object]) -> str:
-    target, message_id, timestamp, message_type, sender, body = _message_header_fields(
+    target, message_id, timestamp, sender_kind, sender, body = _message_header_fields(
         message
     )
-    line = (
-        f"[target={target} msg={message_id} time={timestamp} "
-        f"type={message_type} 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(
@@ -599,30 +674,29 @@ def format_read_message(
     index: int,
     count: int,
 ) -> str:
-    target, message_id, timestamp, message_type, sender, body = _message_header_fields(
+    target, message_id, timestamp, sender_kind, sender, body = _message_header_fields(
         message
     )
     fields = [
         f"seq={cast(int, message['seq'])}",
         f"msg={message_id}",
         f"time={timestamp}",
-        f"type={message_type}",
+        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_inbound(message) for message in result.messages]
+    messages = [serialize_message(message) for message in result.messages]
     referenced_messages = [
-        serialize_inbound(message) for message in result.referenced_messages
+        serialize_message(message) for message in result.referenced_messages
     ]
     shown = len(messages)
     total = result.newer_message_total
@@ -676,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.",
-        )
-    )