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

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

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "bazaar-compute-node"
-version = "0.1.25"
+version = "0.1.26"
 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.26}/src/bazaar_compute_node/app/agent.py

@@ -279,8 +279,7 @@ 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:
         if not self._started:
@@ -323,8 +322,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 +368,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.26}/src/bazaar_compute_node/app/command.py

@@ -25,17 +25,54 @@ from ..core.command import (
     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_inbound(message: InboundMessage) -> dict[str, object]:
+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_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
@@ -44,25 +81,21 @@ def serialize_inbound(message: InboundMessage) -> dict[str, object]:
         ),
         "sender_kind": message.sender_kind.value,
         "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 +437,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 +469,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,
@@ -470,17 +503,19 @@ class CommandDispatcher:
                     "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 +525,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 +539,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 +563,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 +582,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,25 +605,26 @@ 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()}"
+        f"type={sender_kind} mentioned={str(message['mentions_agent']).lower()}"
     )
     reply_to_message_id = message["reply_to_message_id"]
     if reply_to_message_id is not None:
@@ -599,14 +641,14 @@ 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()}",
     ]
@@ -620,9 +662,9 @@ def format_read_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

{bazaar_compute_node-0.1.25 → bazaar_compute_node-0.1.26}/src/bazaar_compute_node/contrib/lark/channel.py

@@ -23,7 +23,8 @@ from ...core.models import (
     ApprovalResult,
     ChannelTargetKind,
     InboundAttachment,
-    InboundMessage,
+    Message,
+    MessageDirection,
     RuntimeEvent,
     RuntimeEventState,
     SenderIdentity,
@@ -90,7 +91,7 @@ class LarkChannel(IChannel):
         self._region = region
         self._base_url = base_url
         self._timer_wheel = timer_wheel
-        self._inbound: asyncio.Queue[InboundMessage | object] = asyncio.Queue()
+        self._inbound: asyncio.Queue[Message | object] = asyncio.Queue()
         self._lifecycle_lock = asyncio.Lock()
         self._session: aiohttp.ClientSession | None = None
         self._api: LarkApi | None = None
@@ -279,13 +280,13 @@ class LarkChannel(IChannel):
                 self._inbound.put_nowait(_STOP)
                 self._stop_sent = True
 
-    async def receive(self) -> AsyncIterator[InboundMessage]:
+    async def receive(self) -> AsyncIterator[Message]:
         inbound = self._inbound
         while True:
             item = await inbound.get()
             if item is _STOP:
                 return
-            if not isinstance(item, InboundMessage):
+            if not isinstance(item, Message):
                 raise TypeError("Lark inbound queue contained an invalid message")
             yield item
 
@@ -388,7 +389,7 @@ class LarkChannel(IChannel):
         if root_id is not None:
             metadata["lark_root_id"] = root_id
 
-        quoted: InboundMessage | None = None
+        quoted: Message | None = None
         if parent_id is not None:
             parent, failure = await self._fetch_parent(
                 parent_id,
@@ -458,7 +459,7 @@ class LarkChannel(IChannel):
         received_at_ms: int,
         reply_to_message_id: str | None = None,
         provider_payload_metadata: Mapping[str, object] | None = None,
-    ) -> InboundMessage:
+    ) -> Message:
         provider_message_id = _provider_text(message.get("message_id"))
         raw_message_type = _provider_text(message.get("message_type"))
         if provider_message_id is None or raw_message_type is None:
@@ -496,7 +497,8 @@ class LarkChannel(IChannel):
         metadata.setdefault("sender_kind", sender_kind.value)
         if projection.content_error:
             metadata["content_parse_failed"] = True
-        return InboundMessage(
+        return Message(
+            direction=MessageDirection.INBOUND,
             seq=0,
             message_id=thread_identity.message_id(provider_message_id),
             session_id=thread_identity.session_id,
@@ -507,7 +509,7 @@ class LarkChannel(IChannel):
             received_at_ms=received_at_ms,
             sender=sender,
             message_type=projection.message_type,
-            canonical_target=f"{target_kind.value}:{thread_identity.channel_session_id}",
+            target=f"{target_kind.value}:{thread_identity.channel_session_id}",
             body=projection.body,
             target_kind=target_kind,
             mentions_agent=mentions_agent,