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

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

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "bazaar-compute-node"
-version = "0.1.27"
+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.27 → bazaar_compute_node-0.1.28}/src/bazaar_compute_node/app/command.py

@@ -21,7 +21,9 @@ from ..core.command import (
     ICommandService,
     InboxListResult,
     MessageSendFreshnessHold,
+    MessageSendSuccess,
     SessionNotFoundError,
+    TargetProjection,
 )
 from ..core.lifecycle import TimeoutBudget
 from ..core.models import (
@@ -62,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,
@@ -84,13 +93,19 @@ def serialize_message(message: Message) -> dict[str, object]:
             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_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,
@@ -447,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,
@@ -471,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,
             )
@@ -479,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,
@@ -496,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),
@@ -508,22 +525,25 @@ class CommandDispatcher:
                     "ok": True,
                     "result": {"text": format_freshness_hold(result)},
                 }
-            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 "
@@ -533,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:
@@ -553,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")
 
@@ -578,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"]
@@ -694,9 +720,13 @@ def format_read_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

{bazaar_compute_node-0.1.27 → bazaar_compute_node-0.1.28}/src/bazaar_compute_node/bcc.py

@@ -578,6 +578,13 @@ def serialize_send(result: Mapping[str, object]) -> str:
         ) from error
 
 
+def serialize_unfollow(result: Mapping[str, object]) -> str:
+    target = cast(str, result["target"])
+    if cast(bool, result["changed"]):
+        return f"Thread unfollowed: {target}"
+    return f"Thread was already unfollowed: {target}"
+
+
 def _reminder(result: Mapping[str, object]) -> Mapping[str, object]:
     return cast(Mapping[str, object], result["reminder"])
 
@@ -694,6 +701,8 @@ async def async_main(argv: Sequence[str] | None = None) -> int:
             "cancel": serialize_reminder_cancel,
         }[args.command]
         print(serializer(result))
+    elif args.resource == "thread" and args.command == "unfollow":
+        print(serialize_unfollow(result))
     return 0
 
 

{bazaar_compute_node-0.1.27 → bazaar_compute_node-0.1.28}/src/bazaar_compute_node/contrib/lark/api.py

@@ -378,6 +378,18 @@ class LarkApi:
             params={"user_id_type": "open_id"},
         )
 
+    async def get_chat(
+        self,
+        chat_id: str,
+        *,
+        timeout: float,
+    ) -> Mapping[str, object]:
+        return await self._get_json(
+            "chat_get",
+            f"/open-apis/im/v1/chats/{quote(chat_id, safe='')}",
+            timeout=timeout,
+        )
+
     async def get_message(
         self,
         message_id: str,

{bazaar_compute_node-0.1.27 → bazaar_compute_node-0.1.28}/src/bazaar_compute_node/contrib/lark/approval.py

@@ -442,9 +442,13 @@ def _approval_card_content(
         if action_key is not None
         else request.approval.action.replace("_", " ")
     )
-    markdown = translator.text("approval.prompt.action", {"action": action})
-    if request.approval.description:
-        markdown = f"{markdown}\n\n{request.approval.description}"
+    markdown = translator.text(
+        "approval.prompt.lark",
+        {
+            "action": action,
+            "description": request.approval.description,
+        },
+    )
     elements: list[dict[str, object]] = [{"tag": "markdown", "content": markdown}]
     if decision is None:
         elements.append(

{bazaar_compute_node-0.1.27 → bazaar_compute_node-0.1.28}/src/bazaar_compute_node/contrib/lark/channel.py

@@ -7,6 +7,7 @@ from collections import OrderedDict
 from collections.abc import AsyncIterator, Mapping
 from dataclasses import dataclass
 from time import monotonic, time_ns
+from unicodedata import category
 
 import aiohttp
 
@@ -22,6 +23,7 @@ from ...core.models import (
     ApprovalDecision,
     ApprovalResult,
     ChannelTargetKind,
+    ChannelTargetPresentation,
     InboundAttachment,
     Message,
     MessageDirection,
@@ -47,9 +49,14 @@ from .transport import LarkTransport
 
 _STOP = object()
 _EVENT_TYPE = "im.message.receive_v1"
-_CONTACT_CACHE_TTL_SECONDS = 5 * 60
+_CONTACT_CACHE_TTL_SECONDS = 24 * 60 * 60
+_CONTACT_FAILURE_CACHE_TTL_SECONDS = 5 * 60
 _CONTACT_CACHE_MAX_ENTRIES = 256
 _CONTACT_TIMEOUT_SECONDS = 5.0
+_CHAT_CACHE_TTL_SECONDS = 24 * 60 * 60
+_CHAT_FAILURE_CACHE_TTL_SECONDS = 5 * 60
+_CHAT_CACHE_MAX_ENTRIES = 256
+_CHAT_TIMEOUT_SECONDS = 5.0
 _PARENT_TIMEOUT_SECONDS = 10.0
 _RESOURCE_TIMEOUT_SECONDS = 60.0
 _TYPING_TIMEOUT_SECONDS = 3.0
@@ -113,6 +120,14 @@ class LarkChannel(IChannel):
         self._contact_lookup_requests = 0
         self._contact_lookup_failures = 0
         self._contact_cache_hits = 0
+        self._chat_cache: OrderedDict[
+            tuple[str, str, str], tuple[float, str | None]
+        ] = OrderedDict()
+        self._chat_inflight: dict[tuple[str, str, str], asyncio.Task[str | None]] = {}
+        self._chat_lock = asyncio.Lock()
+        self._chat_lookup_requests = 0
+        self._chat_lookup_failures = 0
+        self._chat_cache_hits = 0
         self._resource_cache = LarkResourceCache(context.attachments)
         self._resources_materialized = 0
         self._resource_failures = 0
@@ -162,6 +177,9 @@ class LarkChannel(IChannel):
             "contact_lookup_requests": self._contact_lookup_requests,
             "contact_lookup_failures": self._contact_lookup_failures,
             "contact_cache_hits": self._contact_cache_hits,
+            "chat_lookup_requests": self._chat_lookup_requests,
+            "chat_lookup_failures": self._chat_lookup_failures,
+            "chat_cache_hits": self._chat_cache_hits,
             "resources_materialized": self._resources_materialized,
             "resource_failures": self._resource_failures,
             "last_resource_disposition": self._last_resource_disposition,
@@ -265,6 +283,7 @@ class LarkChannel(IChannel):
             await self._stop_typing(timeout=timeout)
             await self._resource_cache.close()
             await self._close_contact_cache()
+            await self._close_chat_cache()
             if api is not None:
                 self._token_refresh_failures = api.token_refresh_failures
                 await api.stop()
@@ -376,6 +395,14 @@ class LarkChannel(IChannel):
             chat_id=chat_id,
             thread_id=thread_id,
         )
+        presentation = None
+        if target_kind is ChannelTargetKind.GROUP:
+            name = await self._chat_name(
+                tenant_key=tenant_key,
+                chat_id=chat_id,
+            )
+            if name is not None:
+                presentation = ChannelTargetPresentation(display_name=name)
         received_at_ms = time_ns() // 1_000_000
         metadata = {
             "lark_event_type": _EVENT_TYPE,
@@ -402,6 +429,7 @@ class LarkChannel(IChannel):
                         parent,
                         thread_identity=thread_identity,
                         target_kind=target_kind,
+                        presentation=presentation,
                         sender_payload=_message_sender(parent),
                         tenant_key=tenant_key,
                         mentions_agent=False,
@@ -426,6 +454,7 @@ class LarkChannel(IChannel):
             message,
             thread_identity=thread_identity,
             target_kind=target_kind,
+            presentation=presentation,
             sender_payload=sender,
             tenant_key=tenant_key,
             mentions_agent=target_kind is ChannelTargetKind.GROUP,
@@ -454,6 +483,7 @@ class LarkChannel(IChannel):
         *,
         thread_identity: LarkThreadIdentity,
         target_kind: ChannelTargetKind,
+        presentation: ChannelTargetPresentation | None,
         sender_payload: Mapping[str, object] | None,
         tenant_key: str,
         mentions_agent: bool,
@@ -514,6 +544,7 @@ class LarkChannel(IChannel):
             target=f"{target_kind.value}:{thread_identity.channel_session_id}",
             body=projection.body,
             target_kind=target_kind,
+            target_presentation=presentation,
             mentions_agent=mentions_agent,
             notifies_runtime=notifies_runtime,
             attachments=attachments,
@@ -637,7 +668,12 @@ class LarkChannel(IChannel):
                 self._contact_inflight.pop(key, None)
                 if completed:
                     self._contact_cache[key] = (
-                        monotonic() + _CONTACT_CACHE_TTL_SECONDS,
+                        monotonic()
+                        + (
+                            _CONTACT_CACHE_TTL_SECONDS
+                            if name is not None
+                            else _CONTACT_FAILURE_CACHE_TTL_SECONDS
+                        ),
                         name,
                     )
                     self._contact_cache.move_to_end(key)
@@ -654,6 +690,95 @@ class LarkChannel(IChannel):
         if tasks:
             await asyncio.gather(*tasks, return_exceptions=True)
 
+    async def _chat_name(self, *, tenant_key: str, chat_id: str) -> str | None:
+        key = (self._app_id, tenant_key, chat_id)
+        now = monotonic()
+        async with self._chat_lock:
+            cached = self._chat_cache.get(key)
+            if cached is not None:
+                expires_at, name = cached
+                if expires_at > now:
+                    self._chat_cache_hits += 1
+                    self._chat_cache.move_to_end(key)
+                    return name
+                self._chat_cache.pop(key, None)
+            task = self._chat_inflight.get(key)
+            if task is None:
+                task = asyncio.create_task(
+                    self._load_chat_name(key, chat_id),
+                    name="bcn-lark-chat",
+                )
+                self._chat_inflight[key] = task
+        return await asyncio.shield(task)
+
+    async def _load_chat_name(
+        self,
+        key: tuple[str, str, str],
+        chat_id: str,
+    ) -> str | None:
+        name: str | None = None
+        completed = False
+        try:
+            api = self._api
+            if api is None:
+                completed = True
+                return None
+            self._chat_lookup_requests += 1
+            response = await api.get_chat(chat_id, timeout=_CHAT_TIMEOUT_SECONDS)
+            data = response.get("data")
+            raw_name = data.get("name") if isinstance(data, Mapping) else None
+            if (
+                isinstance(raw_name, str)
+                and raw_name.strip()
+                and "]" not in raw_name
+                and not any(category(character) == "Cc" for character in raw_name)
+            ):
+                name = raw_name
+            else:
+                self._chat_lookup_failures += 1
+                self._observe(
+                    "lark.chat.lookup_failed",
+                    error_kind="invalid_name",
+                )
+            completed = True
+            return name
+        except asyncio.CancelledError:
+            raise
+        except Exception as error:  # noqa: BLE001
+            self._chat_lookup_failures += 1
+            self._observe(
+                "lark.chat.lookup_failed",
+                error_kind=type(error).__name__,
+            )
+            completed = True
+            return None
+        finally:
+            async with self._chat_lock:
+                self._chat_inflight.pop(key, None)
+                if completed:
+                    self._chat_cache[key] = (
+                        monotonic()
+                        + (
+                            _CHAT_CACHE_TTL_SECONDS
+                            if name is not None
+                            else _CHAT_FAILURE_CACHE_TTL_SECONDS
+                        ),
+                        name,
+                    )
+                    self._chat_cache.move_to_end(key)
+                    while len(self._chat_cache) > _CHAT_CACHE_MAX_ENTRIES:
+                        self._chat_cache.popitem(last=False)
+
+    async def _close_chat_cache(self) -> None:
+        async with self._chat_lock:
+            tasks = tuple(self._chat_inflight.values())
+            self._chat_inflight.clear()
+            self._chat_cache.clear()
+        for task in tasks:
+            task.cancel()
+        if tasks:
+            await asyncio.gather(*tasks, return_exceptions=True)
+
     async def _materialize_resources(
         self,
         provider_message_id: str,

{bazaar_compute_node-0.1.27 → bazaar_compute_node-0.1.28}/src/bazaar_compute_node/contrib/sqlite/codec.py

@@ -45,6 +45,11 @@ def channel_session_from_row(row: aiosqlite.Row) -> ChannelSession:
         following=bool(following),
         last_inbound_at_ms=cast(int | None, row["last_inbound_at_ms"]),
         last_outbound_at_ms=cast(int | None, row["last_outbound_at_ms"]),
+        target_display_name=_optional_text(
+            row["target_display_name"], "target_display_name"
+        ),
+        target_handle=_optional_text(row["target_handle"], "target_handle"),
+        target_handle_key=_optional_text(row["target_handle_key"], "target_handle_key"),
         metadata=_decode_metadata(
             row["provider_identity_ref_json"], "provider_identity_ref_json"
         ),
@@ -439,6 +444,9 @@ def validate_channel_session_update(
         following=incoming.following,
         last_inbound_at_ms=incoming.last_inbound_at_ms,
         last_outbound_at_ms=incoming.last_outbound_at_ms,
+        target_display_name=incoming.target_display_name,
+        target_handle=incoming.target_handle,
+        target_handle_key=incoming.target_handle_key,
         metadata=incoming.metadata,
     )
 

{bazaar_compute_node-0.1.27 → bazaar_compute_node-0.1.28}/src/bazaar_compute_node/contrib/sqlite/migrations/registry.py

@@ -32,6 +32,7 @@ from .v20_remove_freshness_persistence import (
     FRESHNESS_PERSISTENCE_REMOVAL_MIGRATION,
 )
 from .v21_remove_handoffs import HANDOFF_REMOVAL_MIGRATION
+from .v22_readable_targets import READABLE_TARGET_MIGRATION
 
 if TYPE_CHECKING:
     from ..executor import SqliteSession
@@ -78,6 +79,7 @@ MIGRATIONS = _migration_ledger(
     REMINDER_SYSTEM_MESSAGE_MIGRATION,
     FRESHNESS_PERSISTENCE_REMOVAL_MIGRATION,
     HANDOFF_REMOVAL_MIGRATION,
+    READABLE_TARGET_MIGRATION,
 )
 
 

bazaar_compute_node-0.1.28/src/bazaar_compute_node/contrib/sqlite/migrations/v22_readable_targets.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from .model import Migration
+
+READABLE_TARGET_MIGRATION = Migration(
+    version=22,
+    name="readable_targets",
+    statements=(
+        "ALTER TABLE channel_sessions ADD COLUMN target_display_name TEXT",
+        "ALTER TABLE channel_sessions ADD COLUMN target_handle TEXT",
+        "ALTER TABLE channel_sessions ADD COLUMN target_handle_key TEXT",
+        """
+        CREATE INDEX idx_channel_sessions_target_handle
+            ON channel_sessions (agent_id, target_kind, target_handle_key)
+            WHERE target_handle_key IS NOT NULL
+        """,
+    ),
+)
+
+__all__ = ["READABLE_TARGET_MIGRATION"]

{bazaar_compute_node-0.1.27 → bazaar_compute_node-0.1.28}/src/bazaar_compute_node/contrib/sqlite/repository/facade.py

@@ -63,18 +63,24 @@ class SqliteRepository(
                     or message.mentions_agent
                 ),
             )
+            if message.target_presentation is not None:
+                channel_session = channel_session.with_target_presentation(
+                    message.target_presentation,
+                    updated_at_ms=now_ms,
+                )
             await self.save_channel_session(channel_session)
-        elif (
-            existing_message is None
-            and message.mentions_agent
-            and not channel_session.following
-        ):
-            channel_session = replace(
-                channel_session,
-                following=True,
-                updated_at_ms=now_ms,
-            )
-            await self.save_channel_session(channel_session)
+        elif existing_message is None:
+            if message.target_presentation is not None:
+                channel_session = channel_session.with_target_presentation(
+                    message.target_presentation,
+                    updated_at_ms=now_ms,
+                )
+            if message.mentions_agent and not channel_session.following:
+                channel_session = replace(
+                    channel_session,
+                    following=True,
+                    updated_at_ms=now_ms,
+                )
 
         bcn_session = await self.find_bcn_session(channel_session.id)
         bcn_session_created = bcn_session is None
@@ -94,16 +100,12 @@ class SqliteRepository(
                 or channel_session.following
                 or message.mentions_agent
             )
-            canonical_target = message.target
-            if channel_session.id != message.channel_session_id:
-                canonical_target = (
-                    f"{channel_session.target_kind.value}:{channel_session.id}"
-                )
             message = replace(
                 message,
                 session_id=bcn_session.id,
                 channel_session_id=channel_session.id,
-                target=canonical_target,
+                target=channel_session.canonical_target,
+                target_presentation=None,
                 notifies_runtime=notifies_runtime,
             )