bazaar-compute-node 0.2.0rc2__tar.gz → 0.2.0rc3__tar.gz

{bazaar_compute_node-0.2.0rc2 → bazaar_compute_node-0.2.0rc3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bazaar-compute-node
-Version: 0.2.0rc2
+Version: 0.2.0rc3
 Summary: Runtime-agnostic computer node daemon for agents and channels.
 License-Expression: AGPL-3.0-only
 License-File: LICENSE

{bazaar_compute_node-0.2.0rc2 → bazaar_compute_node-0.2.0rc3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "bazaar-compute-node"
-version = "0.2.0rc2"
+version = "0.2.0rc3"
 description = "Runtime-agnostic computer node daemon for agents and channels."
 readme = "README.md"
 license = "AGPL-3.0-only"

{bazaar_compute_node-0.2.0rc2 → bazaar_compute_node-0.2.0rc3}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "bazaar-compute-node"
-version = "0.2.0rc2"
+version = "0.2.0rc3"
 description = "Runtime-agnostic computer node daemon for agents and channels."
 readme = "README.md"
 license = "AGPL-3.0-only"

{bazaar_compute_node-0.2.0rc2 → bazaar_compute_node-0.2.0rc3}/src/bazaar_compute_node/contrib/lark/api.py

@@ -15,6 +15,15 @@ import aiohttp
 from ...core.timerwheel import TimerWheel
 from ...core.utils.clock import remaining
 
+
+@dataclass(frozen=True, slots=True)
+class LarkSentMessage:
+    """What the provider says about a message it just accepted."""
+
+    message_id: str
+    chat_id: str | None
+
+
 _CONNECT_TIMEOUT_SECONDS = 10.0
 _HTTP_METHODS = frozenset({"GET", "POST", "PUT", "DELETE"})
 _MAX_ERROR_MESSAGE = 256
@@ -412,12 +421,13 @@ class LarkApi:
         content: str,
         uuid: str,
         timeout: float,
-    ) -> str:
+        receive_id_type: str = "chat_id",
+    ) -> LarkSentMessage:
         body = await self._post_json(
             "message_create",
             "/open-apis/im/v1/messages",
             timeout=timeout,
-            params={"receive_id_type": "chat_id"},
+            params={"receive_id_type": receive_id_type},
             json_body={
                 "receive_id": chat_id,
                 "msg_type": message_type,
@@ -425,7 +435,10 @@ class LarkApi:
                 "uuid": uuid,
             },
         )
-        return _response_id(body, "message_create", "message_id")
+        return LarkSentMessage(
+            message_id=_response_id(body, "message_create", "message_id"),
+            chat_id=_optional_response_text(body, "chat_id"),
+        )
 
     async def reply_message(
         self,
@@ -436,7 +449,7 @@ class LarkApi:
         reply_in_thread: bool,
         uuid: str,
         timeout: float,
-    ) -> str:
+    ) -> LarkSentMessage:
         body = await self._post_json(
             "message_reply",
             f"/open-apis/im/v1/messages/{quote(message_id, safe='')}/reply",
@@ -448,7 +461,10 @@ class LarkApi:
                 "uuid": uuid,
             },
         )
-        return _response_id(body, "message_reply", "message_id")
+        return LarkSentMessage(
+            message_id=_response_id(body, "message_reply", "message_id"),
+            chat_id=_optional_response_text(body, "chat_id"),
+        )
 
     async def reply_card(
         self,
@@ -458,7 +474,7 @@ class LarkApi:
         reply_in_thread: bool,
         uuid: str,
         timeout: float,
-    ) -> str:
+    ) -> LarkSentMessage:
         return await self.reply_message(
             message_id=message_id,
             message_type="interactive",
@@ -913,6 +929,17 @@ def _provider_message(value: object) -> str:
     return value[:_MAX_ERROR_MESSAGE]
 
 
+def _optional_response_text(
+    body: Mapping[str, object],
+    field_name: str,
+) -> str | None:
+    data = body.get("data")
+    value = data.get(field_name) if isinstance(data, Mapping) else None
+    if not isinstance(value, str) or not value or "\r" in value or "\n" in value:
+        return None
+    return value
+
+
 def _response_id(
     body: Mapping[str, object],
     method: str,

{bazaar_compute_node-0.2.0rc2 → bazaar_compute_node-0.2.0rc3}/src/bazaar_compute_node/contrib/lark/approval.py

@@ -36,6 +36,7 @@ class _PendingApproval:
     token: str
     thread: LarkThreadIdentity
     expected_sender_id: str
+    callback_chat_id: str
     prompt_message_id: str | None
     future: asyncio.Future[ApprovalResult]
 
@@ -135,6 +136,7 @@ class LarkApprovalChannel(LarkChannel):
             token=secrets.token_urlsafe(18),
             thread=thread,
             expected_sender_id=request.provider_sender_id,
+            callback_chat_id=thread.chat_id,
             prompt_message_id=None,
             future=loop.create_future(),
         )
@@ -154,7 +156,7 @@ class LarkApprovalChannel(LarkChannel):
             )
             budget = remaining(deadline)
             if reply_to_message_id is not None:
-                prompt_message_id = await api.reply_message(
+                sent = await api.reply_message(
                     message_id=reply_to_message_id,
                     message_type="interactive",
                     content=content,
@@ -163,14 +165,22 @@ class LarkApprovalChannel(LarkChannel):
                     timeout=budget,
                 )
             else:
-                prompt_message_id = await api.send_message(
+                sent = await api.send_message(
                     chat_id=thread.chat_id,
+                    # A one-to-one chat is named by the peer, so the id that
+                    # addresses it is an `ou_`; card callbacks report the `oc_`
+                    # the provider gave that chat, which only the send tells us.
+                    receive_id_type=(
+                        "open_id" if thread.chat_id.startswith("ou_") else "chat_id"
+                    ),
                     message_type="interactive",
                     content=content,
                     uuid=uuid4().hex,
                     timeout=budget,
                 )
-            prompt_message_id = _provider_text(prompt_message_id)
+            if sent.chat_id is not None:
+                pending.callback_chat_id = sent.chat_id
+            prompt_message_id = _provider_text(sent.message_id)
             if prompt_message_id is None:
                 raise ValueError("Lark approval prompt has no message_id")
             if (
@@ -237,7 +247,7 @@ class LarkApprovalChannel(LarkChannel):
                     resolved_callback_text(self._translator, state),
                     toast_type="warning",
                 )
-            if chat_id != pending.thread.chat_id or (
+            if chat_id != pending.callback_chat_id or (
                 pending.prompt_message_id is not None
                 and message_id != pending.prompt_message_id
             ):

{bazaar_compute_node-0.2.0rc2 → bazaar_compute_node-0.2.0rc3}/src/bazaar_compute_node/contrib/lark/channel.py

@@ -17,6 +17,7 @@ from ...core.channel import (
     ChannelDeliveryReceipt,
     ChannelIdentity,
     ChannelSendRequest,
+    DmAddress,
     IChannel,
 )
 from ...core.models import (
@@ -414,7 +415,15 @@ class LarkChannel(IChannel):
         )
         thread_identity = LarkThreadIdentity(
             bot_open_id=fields.identity.open_id,
-            chat_id=fields.chat_id,
+            # A one-to-one chat is named by the peer, not by the `oc_` id the
+            # provider gives that chat: the peer is the only part of it we can
+            # know before the chat exists, so a conversation opened from
+            # `dm:@name` and one the peer starts are the same conversation.
+            chat_id=(
+                fields.sender_open_id
+                if target_kind is ChannelTargetKind.DM
+                else fields.chat_id
+            ),
             thread_id=thread_id,
         )
         presentation = None
@@ -954,6 +963,20 @@ class LarkChannel(IChannel):
         except LarkApiError, LarkTransportError, TimeoutError:
             self._typing_failures += 1
 
+    def dm_address(
+        self, sender: SenderIdentity, *, sender_kind: SenderKind
+    ) -> DmAddress | None:
+        del sender_kind
+        identity = self._identity
+        if identity is None or sender.id is None:
+            return None
+        thread = LarkThreadIdentity(bot_open_id=identity.open_id, chat_id=sender.id)
+        return DmAddress(
+            channel_session_id=thread.channel_session_id,
+            thread_id=thread.session_id,
+            provider_thread_id=thread.provider_thread_id,
+        )
+
     async def send(
         self,
         request: ChannelSendRequest,
@@ -1089,6 +1112,7 @@ class _EventFields:
     provider_message_id: str
     chat_id: str
     chat_type: str
+    sender_open_id: str
     sender_type: str
 
 
@@ -1147,6 +1171,7 @@ def _read_event(
         provider_message_id=provider_message_id,
         chat_id=chat_id,
         chat_type=chat_type,
+        sender_open_id=sender_open_id,
         sender_type=sender_type,
     )
 

{bazaar_compute_node-0.2.0rc2 → bazaar_compute_node-0.2.0rc3}/src/bazaar_compute_node/contrib/lark/outbound.py

@@ -375,7 +375,7 @@ async def _send_message_part(
         return None, TimeoutError("Lark delivery deadline expired")
     try:
         if reply_anchor is not None:
-            provider_message_id = await api.reply_message(
+            sent = await api.reply_message(
                 message_id=reply_anchor,
                 message_type=message_type,
                 content=content,
@@ -384,8 +384,12 @@ async def _send_message_part(
                 timeout=timeout,
             )
         else:
-            provider_message_id = await api.send_message(
+            sent = await api.send_message(
                 chat_id=thread.chat_id,
+                # Lark ids carry their kind in the prefix: `ou_` a user, `oc_` a chat.
+                receive_id_type=(
+                    "open_id" if thread.chat_id.startswith("ou_") else "chat_id"
+                ),
                 message_type=message_type,
                 content=content,
                 uuid=str(uuid4()),
@@ -395,7 +399,7 @@ async def _send_message_part(
         raise
     except Exception as error:  # noqa: BLE001
         return None, error
-    return provider_message_id, None
+    return sent.message_id, None
 
 
 def _finish_failure(

{bazaar_compute_node-0.2.0rc2 → bazaar_compute_node-0.2.0rc3}/src/bazaar_compute_node/contrib/sqlite/repository/messages.py

@@ -21,7 +21,9 @@ from ....core.models import (
     SenderKind,
 )
 from ....core.storage import (
+    AmbiguousInboxTargetError,
     InboxTargetResolutionError,
+    KnownSender,
     ResolvedInboxTarget,
     UnreadMessageOwner,
 )
@@ -331,9 +333,13 @@ class MessageOperations(RepositoryBase):
             f"AND ({predicate}) ORDER BY thread.id",
             parameters,
         )
-        if len(rows) != 1:
+        if len(rows) > 1:
+            raise AmbiguousInboxTargetError(
+                "inbox target resolves to more than one owned session"
+            )
+        if not rows:
             raise InboxTargetResolutionError(
-                "inbox target does not resolve to exactly one owned session"
+                "inbox target does not resolve to an owned session"
             )
         target = thread_from_row(rows[0])
         channel_session = cast(
@@ -363,6 +369,54 @@ class MessageOperations(RepositoryBase):
             handle_is_unique=handle_is_unique,
         )
 
+    async def find_known_sender(self, token: str) -> KnownSender | None:
+        """Find a sender this Agent has heard from, by what its `@` renders as.
+
+        `sender` carries the handle when the provider offers one and `sender_id`
+        the provider identity otherwise, which is the same order the `@` position
+        is rendered in. Matching follows that order so the more specific value
+        decides first. The display name is deliberately not a key: it is not
+        unique, and addressing by it would let one name reach several people.
+        """
+
+        for predicate, parameter in (
+            ("LOWER(sender) = LOWER(?)", token),
+            ("sender_id = ?", token),
+        ):
+            row = await self.fetchone(
+                "SELECT sender, sender_id, sender_display_name, channel, "
+                "metadata_json "
+                "FROM messages "
+                "WHERE agent_id = /*agent_id*/? "
+                "AND direction = ? "
+                f"AND {predicate} "
+                "ORDER BY seq DESC LIMIT 1",
+                (MessageDirection.INBOUND.value, parameter),
+            )
+            if row is None:
+                continue
+            sender = cast(str | None, row["sender"])
+            sender_id = cast(str | None, row["sender_id"])
+            if sender is None and sender_id is None:
+                continue
+            metadata_json = cast(str | None, row["metadata_json"])
+            sender_kind = SenderKind.UNKNOWN
+            if metadata_json:
+                stored_kind = json.loads(metadata_json).get(
+                    "sender_kind", SenderKind.UNKNOWN.value
+                )
+                sender_kind = SenderKind(cast(str, stored_kind))
+            return KnownSender(
+                sender=SenderIdentity(
+                    id=sender_id,
+                    name=sender,
+                    display_name=cast(str | None, row["sender_display_name"]),
+                ),
+                channel=cast(str, row["channel"]),
+                sender_kind=sender_kind,
+            )
+        return None
+
     async def find_message(
         self,
         channel: str,

{bazaar_compute_node-0.2.0rc2 → bazaar_compute_node-0.2.0rc3}/src/bazaar_compute_node/contrib/sqlite/storage.py

@@ -13,6 +13,7 @@ _READ_OPERATIONS = frozenset(
         "count_messages",
         "find_thread",
         "find_channel_session",
+        "find_known_sender",
         "find_message",
         "get_thread",
         "get_channel_session",

{bazaar_compute_node-0.2.0rc2 → bazaar_compute_node-0.2.0rc3}/src/bazaar_compute_node/contrib/telegram/api.py

@@ -87,12 +87,15 @@ class TelegramBotApi:
     async def send_chat_action(
         self,
         *,
-        chat_id: int,
+        chat_id: int | str,
         action: str,
         message_thread_id: int | None = None,
         timeout: float,
     ) -> None:
-        if not isinstance(chat_id, int) or isinstance(chat_id, bool) or chat_id == 0:
+        if isinstance(chat_id, str):
+            if not chat_id:
+                raise ValueError("Telegram chat_id text must be non-empty")
+        elif not isinstance(chat_id, int) or isinstance(chat_id, bool) or chat_id == 0:
             raise ValueError("Telegram chat_id must be a non-zero integer")
         if not isinstance(action, str) or not action:
             raise ValueError("Telegram chat action must be non-empty")

{bazaar_compute_node-0.2.0rc2 → bazaar_compute_node-0.2.0rc3}/src/bazaar_compute_node/contrib/telegram/approval.py

@@ -27,7 +27,7 @@ _RESOLVED_TOKEN_LIMIT = 256
 class _PendingApproval:
     request_id: str
     token: str
-    chat_id: int
+    chat_id: int | str
     topic_id: int
     markdown: str
     prompt_message_id: int | None

{bazaar_compute_node-0.2.0rc2 → bazaar_compute_node-0.2.0rc3}/src/bazaar_compute_node/contrib/telegram/channel.py

@@ -15,6 +15,7 @@ from ...core.channel import (
     ChannelDeliveryReceipt,
     ChannelIdentity,
     ChannelSendRequest,
+    DmAddress,
     IChannel,
 )
 from ...core.correlation import CorrelationContext
@@ -441,6 +442,37 @@ class TelegramChannel(IChannel):
             exc_info=(type(error), error, error.__traceback__),
         )
 
+    def dm_address(
+        self, sender: SenderIdentity, *, sender_kind: SenderKind
+    ) -> DmAddress | None:
+        bot_id = self._bot_id
+        if bot_id is None:
+            return None
+        chat_id: int | str
+        # sendMessage accepts an @username only for a bot, supergroup or
+        # channel; a person is still addressable by numeric id alone.
+        if sender_kind is SenderKind.AGENT and sender.name is not None:
+            chat_id = f"@{sender.name}"
+        # A message a channel or an anonymous admin posted to a group carries
+        # that chat's id and no `from`, so its kind is unknown; addressing it
+        # would publish the DM back into the group it came from.
+        elif (
+            sender_kind in {SenderKind.HUMAN, SenderKind.AGENT}
+            and sender.id is not None
+        ):
+            try:
+                chat_id = int(sender.id)
+            except ValueError:
+                return None
+        else:
+            return None
+        identity = TelegramThreadIdentity(bot_id=bot_id, chat_id=chat_id, topic_id=0)
+        return DmAddress(
+            channel_session_id=identity.channel_session_id,
+            thread_id=identity.session_id,
+            provider_thread_id=identity.provider_thread_id,
+        )
+
     async def send(
         self,
         request: ChannelSendRequest,

{bazaar_compute_node-0.2.0rc2 → bazaar_compute_node-0.2.0rc3}/src/bazaar_compute_node/contrib/telegram/identity.py

@@ -8,14 +8,24 @@ _PROVIDER_PREFIX = "telegram"
 
 @dataclass(frozen=True, slots=True)
 class TelegramThreadIdentity:
+    """A Telegram conversation, addressed the way Telegram itself addresses it.
+
+    `chat_id` is the numeric id of a chat this bot has seen, or an `@username`
+    for a peer it has not: Bot API accepts either as `chat_id`, and a username
+    is the only address available before the first message arrives.
+    """
+
     bot_id: int
-    chat_id: int
+    chat_id: int | str
     topic_id: int
 
     def __post_init__(self) -> None:
         if self.bot_id <= 0:
             raise ValueError("Telegram bot_id must be positive")
-        if self.chat_id == 0:
+        if isinstance(self.chat_id, str):
+            if not self.chat_id.startswith("@") or len(self.chat_id) < 2:
+                raise ValueError("Telegram chat_id text must be an @username")
+        elif self.chat_id == 0:
             raise ValueError("Telegram chat_id must be non-zero")
         if self.topic_id < 0:
             raise ValueError("Telegram topic_id must be non-negative")
@@ -56,12 +66,18 @@ def parse_provider_thread_id(value: str) -> TelegramThreadIdentity:
     parts = value.split(":")
     if len(parts) != 4 or parts[0] != _PROVIDER_PREFIX:
         raise ValueError("Telegram provider_thread_id has invalid format")
+    chat_id: int | str = parts[2]
     try:
-        bot_id, chat_id, topic_id = (int(part) for part in parts[1:])
+        bot_id = int(parts[1])
+        topic_id = int(parts[3])
     except ValueError as error:
         raise ValueError(
             "Telegram provider_thread_id contains invalid integers"
         ) from error
+    try:
+        chat_id = int(chat_id)
+    except ValueError:
+        pass
     return TelegramThreadIdentity(bot_id=bot_id, chat_id=chat_id, topic_id=topic_id)
 
 

{bazaar_compute_node-0.2.0rc2 → bazaar_compute_node-0.2.0rc3}/src/bazaar_compute_node/contrib/wecom/channel.py

@@ -24,6 +24,7 @@ from ...core.channel import (
     ChannelDeliveryReceipt,
     ChannelIdentity,
     ChannelSendRequest,
+    DmAddress,
     IChannel,
 )
 from ...core.models import (
@@ -484,6 +485,19 @@ class WeComChannel(IChannel):
             )
         return None
 
+    def dm_address(
+        self, sender: SenderIdentity, *, sender_kind: SenderKind
+    ) -> DmAddress | None:
+        del sender_kind
+        if sender.id is None:
+            return None
+        identity = f"wecom:dm:{sender.id}"
+        return DmAddress(
+            channel_session_id=str(uuid5(NAMESPACE_URL, identity)),
+            thread_id=str(uuid5(NAMESPACE_URL, f"bcn:{identity}")),
+            provider_thread_id=sender.id,
+        )
+
     async def send(
         self, request: ChannelSendRequest, *, timeout: float
     ) -> ProviderCallResult[ChannelDeliveryReceipt]:

{bazaar_compute_node-0.2.0rc2 → bazaar_compute_node-0.2.0rc3}/src/bazaar_compute_node/core/audit.py

@@ -19,7 +19,6 @@ class ErrorKind(StrEnum):
     TIMEOUT = "timeout"
     VALIDATION = "validation"
     SESSION_NOT_FOUND = "session_not_found"
-    TARGET_NOT_REPLYABLE = "target_not_replyable"
     EMPTY_BODY = "empty_body"
     FRESH_CHECK_REQUIRED = "fresh_check_required"
     FRESH_CHECK_FAILED = "fresh_check_failed"

{bazaar_compute_node-0.2.0rc2 → bazaar_compute_node-0.2.0rc3}/src/bazaar_compute_node/core/channel.py

@@ -17,6 +17,8 @@ from .models import (
     Message,
     OutboundAttachment,
     RuntimeOutputEvent,
+    SenderIdentity,
+    SenderKind,
 )
 from .outcomes import ProviderCallResult
 from .timerwheel import TimerWheel
@@ -120,6 +122,20 @@ class IApproval(Protocol):
     ) -> ApprovalResult: ...
 
 
+@dataclass(frozen=True, slots=True)
+class DmAddress:
+    """A DM conversation in one channel's own terms.
+
+    Both ids come from the channel's own identity string rather than from the
+    provider thread id, so a later inbound message from the same peer lands on
+    this conversation instead of creating a second one.
+    """
+
+    channel_session_id: str
+    thread_id: str
+    provider_thread_id: str
+
+
 class IChannel(IAsyncLifecycle, IApproval, Protocol):
     @property
     def name(self) -> str: ...
@@ -146,6 +162,17 @@ class IChannel(IAsyncLifecycle, IApproval, Protocol):
 
         return
 
+    def dm_address(
+        self, sender: SenderIdentity, *, sender_kind: SenderKind
+    ) -> DmAddress | None:
+        """Return where a DM to this sender lives, if this channel has one.
+
+        `None` means the sender cannot be turned into a DM address here, and the
+        caller reports the target as not found.
+        """
+
+        return None
+
     async def send(
         self,
         request: ChannelSendRequest,
@@ -216,6 +243,23 @@ class Channel(IChannel):
             self._provider_session_ids.get(session_id, session_id), anchor
         )
 
+    def dm_address(
+        self, sender: SenderIdentity, *, sender_kind: SenderKind
+    ) -> DmAddress | None:
+        address = self._channel.dm_address(sender, sender_kind=sender_kind)
+        if address is None:
+            return None
+        thread_id = self._local_id("bcn-session", address.thread_id)
+        self._provider_session_ids[thread_id] = address.thread_id
+        return DmAddress(
+            channel_session_id=self._local_id(
+                "channel-session",
+                address.channel_session_id,
+            ),
+            thread_id=thread_id,
+            provider_thread_id=address.provider_thread_id,
+        )
+
     async def send(
         self,
         request: ChannelSendRequest,