bazaar-compute-node 0.2.1rc15__py3-none-any.whl → 0.2.2__py3-none-any.whl

bazaar_compute_node/app/attachments.py

@@ -21,12 +21,10 @@ class AttachmentMaterializer:
         referenced_paths: Callable[[], Awaitable[set[str]]],
         *,
         max_file_bytes: int = 25 * 1024 * 1024,
-        max_workspace_bytes: int = 1024 * 1024 * 1024,
     ) -> None:
         self._workspace = workspace
         self._referenced_paths = referenced_paths
         self._max_file_bytes = max_file_bytes
-        self._max_workspace_bytes = max_workspace_bytes
         self._lock = asyncio.Lock()
 
     async def reconcile(self) -> None:
@@ -66,11 +64,9 @@ class AttachmentMaterializer:
         source: bytes | AsyncIterable[bytes],
         temporary: Path,
         destination: Path,
-        root: Path,
     ) -> int:
         """Write an attachment aside, then move it into place once it is whole."""
 
-        current_size = await asyncio.to_thread(self._stored_size, root)
         descriptor: int | None = None
         try:
             descriptor = await asyncio.to_thread(
@@ -80,7 +76,7 @@ class AttachmentMaterializer:
                 0o600,
             )
             try:
-                size = await self._write(descriptor, source, current_size)
+                size = await self._write(descriptor, source)
                 await asyncio.to_thread(os.fsync, descriptor)
                 stored = await asyncio.to_thread(os.fstat, descriptor)
                 if stored.st_size != size:
@@ -107,12 +103,12 @@ class AttachmentMaterializer:
         self,
         descriptor: int,
         source: bytes | AsyncIterable[bytes],
-        current_size: int,
     ) -> int:
         """Write the source through, refusing it the moment it goes over a limit."""
 
         if isinstance(source, bytes):
-            self._check_room(len(source), current_size)
+            if len(source) > self._max_file_bytes:
+                raise ValueError("attachment exceeds the per-file size limit")
             await asyncio.to_thread(_write_all, descriptor, source)
             return len(source)
         size = 0
@@ -120,16 +116,11 @@ class AttachmentMaterializer:
             if not isinstance(chunk, bytes):
                 raise TypeError("attachment stream must yield bytes")
             size += len(chunk)
-            self._check_room(size, current_size)
+            if size > self._max_file_bytes:
+                raise ValueError("attachment exceeds the per-file size limit")
             await asyncio.to_thread(_write_all, descriptor, chunk)
         return size
 
-    def _check_room(self, size: int, current_size: int) -> None:
-        if size > self._max_file_bytes:
-            raise ValueError("attachment exceeds the per-file size limit")
-        if current_size + size > self._max_workspace_bytes:
-            raise ValueError("attachment workspace quota exceeded")
-
     async def materialize(
         self,
         source: bytes | AsyncIterable[bytes],
@@ -153,7 +144,7 @@ class AttachmentMaterializer:
             await asyncio.to_thread(
                 staging.mkdir, parents=True, exist_ok=True, mode=0o700
             )
-            size = await self._stage(source, temporary, destination, root)
+            size = await self._stage(source, temporary, destination)
         return InboundAttachment(
             attachment_id=attachment_id,
             name=Path(name).name,
@@ -181,17 +172,6 @@ class AttachmentMaterializer:
             error=error,
         )
 
-    @staticmethod
-    def _stored_size(root: Path) -> int:
-        if not root.exists():
-            return 0
-        return sum(
-            path.stat().st_size
-            for pattern in ("*/content", "*/content.*")
-            for path in root.glob(pattern)
-            if path.is_file() and not path.is_symlink()
-        )
-
 
 def _write_all(descriptor: int, payload: bytes) -> None:
     view = memoryview(payload)

bazaar_compute_node/contrib/lark/channel.py

@@ -437,6 +437,7 @@ class LarkChannel(IChannel):
 
         quoted: Message | None = None
         if parent_id is not None:
+            metadata["provider_reply_to_message_id"] = parent_id
             quoted, failure = await self._quoted_message(
                 parent_id,
                 chat_id=fields.chat_id,
@@ -462,7 +463,6 @@ class LarkChannel(IChannel):
             mentions_agent=target_kind is ChannelTargetKind.GROUP,
             notifies_runtime=True,
             received_at_ms=received_at_ms,
-            reply_to_message_id=quoted.message_id if quoted is not None else None,
             provider_payload_metadata=metadata,
         )
         await self._queue_inbound(
@@ -485,7 +485,6 @@ class LarkChannel(IChannel):
         mentions_agent: bool,
         notifies_runtime: bool,
         received_at_ms: int,
-        reply_to_message_id: str | None = None,
         provider_payload_metadata: Mapping[str, object] | None = None,
     ) -> Message:
         provider_message_id = _provider_text(message.get("message_id"))
@@ -546,7 +545,6 @@ class LarkChannel(IChannel):
             notifies_runtime=notifies_runtime,
             attachments=attachments,
             provider_time_ms=_provider_time_ms(message.get("create_time")),
-            reply_to_message_id=reply_to_message_id,
             metadata=metadata,
         )
 

bazaar_compute_node/contrib/telegram/channel.py

@@ -779,9 +779,9 @@ class TelegramChannel(IChannel):
         reply = message.get("reply_to_message")
 
         received_at_ms = time_ns() // 1_000_000
-        reply_to_message_id: str | None = None
+        reference: str | None = None
         if isinstance(reply, Mapping):
-            reply_to_message_id = await self._queue_reply_backfill(
+            reference = await self._queue_reply_backfill(
                 reply,
                 update_id=update_id,
                 identity=identity,
@@ -818,8 +818,8 @@ class TelegramChannel(IChannel):
                 notifies_runtime=activation.notifies_runtime,
                 attachments=update.content.attachments,
                 provider_time_ms=update.provider_time_s * 1_000,
-                reply_to_message_id=reply_to_message_id,
                 metadata={
+                    "provider_reply_to_message_id": reference,
                     "telegram_update_id": update_id,
                     "telegram_chat_id": update.chat_id,
                     "telegram_message_thread_id": update.topic_id,
@@ -866,20 +866,20 @@ class TelegramChannel(IChannel):
         bot_username = self._bot_username or ""
         if bot_id is None:
             raise RuntimeError("Telegram bot identity is not initialized")
-        # what the bot itself said is on record as sent; quoted back, it is
-        # not heard a second time as if someone else had said it
         quoted_sender = reply.get("from")
-        if isinstance(quoted_sender, Mapping) and quoted_sender.get("id") == bot_id:
-            return None
         content = await self._content(
             reply,
             bot_id=bot_id,
             bot_username=bot_username,
         )
         if content is None:
-            return None
+            return str(provider_message_id)
 
-        sender = self._sender(reply)
+        sender = (
+            None
+            if isinstance(quoted_sender, Mapping) and quoted_sender.get("id") == bot_id
+            else self._sender(reply)
+        )
         provider_time_s = reply.get("date")
         provider_time_ms: int | None = None
         historical: bool | None = None
@@ -892,12 +892,11 @@ class TelegramChannel(IChannel):
             historical = provider_time_s < self._started_at_s
 
         channel_session_id = identity.channel_session_id
-        message_id = identity.message_id(provider_message_id)
         await self._inbound.put(
             Message(
                 direction=MessageDirection.INBOUND,
                 seq=0,
-                message_id=message_id,
+                message_id=identity.message_id(provider_message_id),
                 thread_id=identity.session_id,
                 channel_session_id=channel_session_id,
                 channel="telegram",
@@ -935,7 +934,7 @@ class TelegramChannel(IChannel):
         )
         self._messages_queued += 1
         self._quoted_messages_queued += 1
-        return message_id
+        return str(provider_message_id)
 
     async def _content(
         self,

bazaar_compute_node/contrib/wecom/channel.py

@@ -43,7 +43,7 @@ from ...core.timerwheel import TimerWheel
 from ...core.utils.clock import remaining
 from ...core.utils.markdown import split_markdown, utf8_bytes
 from ...i18n import ENGLISH, Translator, create_translator
-from .identity import conversation_thread_id, parse_provider_thread_id
+from .identity import TopicAddress, conversation_thread_id, parse_provider_thread_id
 from .outbound import (
     AttachmentReader,
     PreparedAttachment,
@@ -52,6 +52,7 @@ from .outbound import (
     prepare_attachments,
     visible_message_body,
 )
+from .topic import TopicConversations
 
 _STOP = object()
 _MAX_MEDIA_BYTES = 25 * 1024 * 1024
@@ -198,6 +199,13 @@ class WeComChannel(IChannel):
             self._logger.addHandler(logging.StreamHandler())
         self._logger.setLevel(logging.INFO)
         self._logger.propagate = False
+        self._topics = TopicConversations(
+            context,
+            bot_id=bot_id,
+            secret=secret,
+            emit=self._inbound.put,
+            logger=self._logger,
+        )
 
     @property
     def name(self) -> str:
@@ -241,6 +249,7 @@ class WeComChannel(IChannel):
         self._startup_finished.clear()
         self._startup_error = None
         self._state = "connecting"
+        self._topics.start()
         self._runner = asyncio.create_task(self._run(), name="bcn-wecom-channel")
         try:
             await asyncio.wait_for(self._startup_finished.wait(), timeout=timeout)
@@ -249,46 +258,57 @@ class WeComChannel(IChannel):
             self._runner.cancel()
             await asyncio.gather(self._runner, return_exceptions=True)
             self._runner = None
+            await self._topics.stop(timeout=timeout)
             self._state = "stopped"
             raise
         if self._startup_error is not None:
+            await self._topics.stop(timeout=timeout)
             raise self._startup_error
 
     async def stop(self, *, timeout: float) -> None:
         self._stopping.set()
-        decided_at_ms = time_ns() // 1_000_000
-        for pending in tuple(self._pending_approvals.values()):
-            if not pending.future.done():
-                pending.future.set_result(
-                    ApprovalResult(
-                        request_id=pending.request.approval.request_id,
-                        decision=ApprovalDecision.REJECTED,
-                        decided_at_ms=decided_at_ms,
-                        reason="channel_stopped",
-                    )
-                )
-        self._pending_approvals.clear()
-        self._approval_task_ids_by_request.clear()
-        await self._cancel_approval_card_updates()
+        deadline = asyncio.get_running_loop().time() + timeout
+        shutdown = asyncio.create_task(
+            self._topics.stop(timeout=timeout), name="bcn-wecom-topics-stop"
+        )
         try:
-            await asyncio.wait_for(self._send_lock.acquire(), timeout=timeout)
-        except TimeoutError:
-            pass
-        else:
-            self._send_lock.release()
-        connection = self._connection
-        if connection is not None:
-            await connection.close()
-        runner = self._runner
-        if runner is not None:
+            decided_at_ms = time_ns() // 1_000_000
+            for pending in tuple(self._pending_approvals.values()):
+                if not pending.future.done():
+                    pending.future.set_result(
+                        ApprovalResult(
+                            request_id=pending.request.approval.request_id,
+                            decision=ApprovalDecision.REJECTED,
+                            decided_at_ms=decided_at_ms,
+                            reason="channel_stopped",
+                        )
+                    )
+            self._pending_approvals.clear()
+            self._approval_task_ids_by_request.clear()
+            await self._cancel_approval_card_updates()
             try:
-                await asyncio.wait_for(runner, timeout=timeout)
+                await asyncio.wait_for(
+                    self._send_lock.acquire(), timeout=remaining(deadline)
+                )
             except TimeoutError:
-                runner.cancel()
-                await asyncio.gather(runner, return_exceptions=True)
-        self._runner = None
-        self._state = "stopped"
-        await self._inbound.put(_STOP)
+                pass
+            else:
+                self._send_lock.release()
+            connection = self._connection
+            if connection is not None:
+                await connection.close()
+            runner = self._runner
+            if runner is not None:
+                try:
+                    await asyncio.wait_for(runner, timeout=remaining(deadline))
+                except TimeoutError:
+                    runner.cancel()
+                    await asyncio.gather(runner, return_exceptions=True)
+        finally:
+            self._runner = None
+            await shutdown
+            self._state = "stopped"
+            await self._inbound.put(_STOP)
 
     async def receive(self) -> AsyncIterator[Message]:
         while True:
@@ -510,6 +530,24 @@ class WeComChannel(IChannel):
     async def send(
         self, request: ChannelSendRequest, *, timeout: float
     ) -> ProviderCallResult[ChannelDeliveryReceipt]:
+        try:
+            address = TopicAddress.parse(request.provider_thread_id)
+            if address is not None and address.bot_id != self._bot_id:
+                raise ValueError("WeCom topic belongs to another bot")
+        except ValueError as error:
+            return ProviderCallResult(
+                status=ProviderCallStatus.FAILED,
+                error_kind="invalid_topic_target",
+                error_message=str(error),
+            )
+        if address is not None:
+            if self._stopping.is_set():
+                return ProviderCallResult(
+                    status=ProviderCallStatus.FAILED,
+                    error_kind="channel_stopped",
+                    error_message="WeCom channel is stopping",
+                )
+            return await self._topics.send(request, address, timeout=timeout)
         _, target_id = parse_provider_thread_id(request.provider_thread_id)
         try:
             batches = (
@@ -945,6 +983,13 @@ class WeComChannel(IChannel):
     async def request_approval(
         self, request: ChannelApprovalRequest, *, timeout: float
     ) -> ApprovalResult:
+        if TopicAddress.parse(request.provider_thread_id) is not None:
+            return ApprovalResult(
+                request_id=request.approval.request_id,
+                decision=ApprovalDecision.REJECTED,
+                decided_at_ms=time_ns() // 1_000_000,
+                reason="WeCom native topics do not support approval cards",
+            )
         request_id = request.approval.request_id
         if timeout <= 0:
             raise TimeoutError("WeCom approval card delivery timed out")
@@ -1247,7 +1292,7 @@ class WeComChannel(IChannel):
             )
             return None
         quote_content = await self._content(quote, quote_type)
-        reply_to_message_id = str(
+        message_id = str(
             uuid5(
                 NAMESPACE_URL,
                 f"bcn:wecom:{self._bot_id}:quoted-message:{conversation}:"
@@ -1258,7 +1303,7 @@ class WeComChannel(IChannel):
             Message(
                 direction=MessageDirection.INBOUND,
                 seq=0,
-                message_id=reply_to_message_id,
+                message_id=message_id,
                 thread_id=session_id,
                 channel_session_id=channel_session_id,
                 channel=self.name,
@@ -1277,7 +1322,7 @@ class WeComChannel(IChannel):
                 metadata={"sender_kind": SenderKind.HUMAN.value},
             )
         )
-        return reply_to_message_id
+        return quote_content.fingerprint
 
     def _update_approval_card(
         self,
@@ -1375,7 +1420,7 @@ class WeComChannel(IChannel):
         return False
 
     async def _receive_event(self, frame: Mapping[str, object]) -> None:
-        """Take in a bot event frame, which is only ever an approval decision."""
+        """Route native topic events and ordinary chat approval decisions."""
 
         body = frame.get("body")
         event = body.get("event") if isinstance(body, dict) else None
@@ -1387,6 +1432,8 @@ class WeComChannel(IChannel):
             "wecom.event.received",
             event_type=self._last_event_type,
         )
+        if isinstance(body, dict) and self._topics.receive(body):
+            return
         if (
             self._last_event_type == "template_card_event"
             and isinstance(event, dict)
@@ -1408,6 +1455,10 @@ class WeComChannel(IChannel):
         if not isinstance(body, dict):
             self._filter_message("invalid_body")
             return
+        compatibility = body.get("compat_info")
+        if isinstance(compatibility, dict) and compatibility.get("source") == "channel":
+            self._filter_message("native_topic_projection")
+            return
         route = self._route(body)
         if route is None:
             return
@@ -1428,7 +1479,7 @@ class WeComChannel(IChannel):
         create_time = body.get("create_time")
         if isinstance(create_time, int) and not isinstance(create_time, bool):
             metadata["provider_create_time"] = create_time
-        reply_to_message_id = await self._queue_quoted_message(
+        reference = await self._queue_quoted_message(
             body.get("quote"),
             provider_message_id=provider_message_id,
             conversation=conversation,
@@ -1438,6 +1489,8 @@ class WeComChannel(IChannel):
             target_kind=target_kind,
             received_at_ms=received_at_ms,
         )
+        if reference is not None:
+            metadata["provider_reply_to_message_id"] = reference
         await self._inbound.put(
             Message(
                 direction=MessageDirection.INBOUND,
@@ -1462,7 +1515,6 @@ class WeComChannel(IChannel):
                 target_kind=target_kind,
                 mentions_agent=mentions_agent,
                 attachments=content.attachments,
-                reply_to_message_id=reply_to_message_id,
                 metadata=metadata,
             )
         )
@@ -1476,7 +1528,7 @@ class WeComChannel(IChannel):
             session_id=session_id,
             target_kind=target_kind.value,
             message_type=message_type,
-            referenced=reply_to_message_id is not None,
+            referenced=reference is not None,
         )
 
     async def _send_approval_card_update(

bazaar_compute_node/contrib/wecom/identity.py

@@ -1,5 +1,8 @@
 from __future__ import annotations
 
+from dataclasses import dataclass
+from urllib.parse import quote, unquote
+
 _PROVIDER_PREFIX = "wecom"
 
 
@@ -20,4 +23,49 @@ def parse_provider_thread_id(value: str) -> tuple[str, str]:
     return parts[1], parts[2]
 
 
-__all__ = ["conversation_thread_id", "parse_provider_thread_id"]
+@dataclass(frozen=True, slots=True)
+class TopicAddress:
+    bot_id: str
+    topic_id: str
+    post_id: str | None = None
+
+    @property
+    def provider_thread_id(self) -> str:
+        value = (
+            f"wecom:{quote(self.bot_id, safe='')}:topic:{quote(self.topic_id, safe='')}"
+        )
+        if self.post_id is not None:
+            value += f":post:{quote(self.post_id, safe='')}"
+        return value
+
+    @classmethod
+    def parse(cls, value: str) -> TopicAddress | None:
+        parts = value.split(":")
+        if len(parts) not in {4, 6} or parts[0] != "wecom" or parts[2] != "topic":
+            return None
+        if not parts[1] or not parts[3]:
+            raise ValueError("WeCom topic address requires a bot and channel")
+        if len(parts) == 6 and (parts[4] != "post" or not parts[5]):
+            raise ValueError("WeCom topic address requires a post id")
+        return cls(
+            unquote(parts[1]),
+            unquote(parts[3]),
+            unquote(parts[5]) if len(parts) == 6 else None,
+        )
+
+
+def post_message_id(post_id: str) -> str:
+    return "post:" + quote(post_id, safe="")
+
+
+def reply_message_id(post_id: str, reply_id: str) -> str:
+    return "reply:" + quote(post_id, safe="") + ":" + quote(reply_id, safe="")
+
+
+__all__ = [
+    "TopicAddress",
+    "conversation_thread_id",
+    "parse_provider_thread_id",
+    "post_message_id",
+    "reply_message_id",
+]