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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bazaar-compute-node
-Version: 0.2.0rc1
+Version: 0.2.0rc3
 Summary: Runtime-agnostic computer node daemon for agents and channels.
 License-Expression: AGPL-3.0-only
 License-File: LICENSE
@@ -51,11 +51,14 @@ bcn --version
 uv tool upgrade bazaar-compute-node
 
 # Add an Agent / 添加 Agent
+# allowed_sender_ids holds the Telegram user ids allowed to open a private chat
+# allowed_sender_ids 是允许与其私聊的 Telegram 用户 id
 bcn agent add \
   --name Tifa \
   --channel telegram \
   --runtime codex \
-  --set channel.token_env=BCN_TELEGRAM_TIFA_TOKEN
+  --set channel.token_env=BCN_TELEGRAM_TIFA_TOKEN \
+  --set channel.allowed_sender_ids=[123456789]
 
 # Configure the runtime environment / 配置运行时环境
 # Example file content / 示例文件内容:

{bazaar_compute_node-0.2.0rc1 → bazaar_compute_node-0.2.0rc3}/README.md

@@ -32,11 +32,14 @@ bcn --version
 uv tool upgrade bazaar-compute-node
 
 # Add an Agent / 添加 Agent
+# allowed_sender_ids holds the Telegram user ids allowed to open a private chat
+# allowed_sender_ids 是允许与其私聊的 Telegram 用户 id
 bcn agent add \
   --name Tifa \
   --channel telegram \
   --runtime codex \
-  --set channel.token_env=BCN_TELEGRAM_TIFA_TOKEN
+  --set channel.token_env=BCN_TELEGRAM_TIFA_TOKEN \
+  --set channel.allowed_sender_ids=[123456789]
 
 # Configure the runtime environment / 配置运行时环境
 # Example file content / 示例文件内容:

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "bazaar-compute-node"
-version = "0.2.0rc1"
+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.0rc1 → bazaar_compute_node-0.2.0rc3}/src/bazaar_compute_node/app/agent.py

@@ -13,6 +13,7 @@ from functools import partial
 from pathlib import Path
 
 from ..core.actor import Actor, Actors, Agent, Thread
+from ..core.audit import AuditRecorder
 from ..core.channel import Channel, ChannelContext, IChannel
 from ..core.concurrency import IThreadConcurrency, ThreadLockRegistry
 from ..core.lifecycle import TimeoutBudget
@@ -28,6 +29,7 @@ from ..core.paths import resolve_workspace_dir
 from ..core.runtime import IRuntime, RuntimeCommandContext
 from ..core.storage import IStorageScope
 from ..core.timerwheel import TimerWheel
+from ..core.utils.clock import now_ms
 from ..i18n import Translator
 from .attachments import AttachmentMaterializer
 from .command import CommandDispatchError
@@ -104,6 +106,11 @@ class AgentApplication:
             self.workspace_path,
             self._referenced_attachment_paths,
         )
+        self._audit_recorder = AuditRecorder(
+            sink=audit,
+            timeout_budget=timeout_budget,
+            clock=now_ms,
+        )
         provider_channel = factories.channel.build(
             ChannelContext(
                 agent_id=self.agent_id,
@@ -112,6 +119,7 @@ class AgentApplication:
                 workspace=self.workspace_path,
                 translator=self.translator,
                 timer_wheel=self.timer_wheel,
+                audit=self._audit_recorder,
             )
         )
         self.channel: IChannel = Channel(self.agent_id, provider_channel)
@@ -163,7 +171,7 @@ class AgentApplication:
             channel=self.channel,
             runtimes=self.runtimes,
             storage=self.storage,
-            audit=self.audit,
+            audit=self._audit_recorder,
             timeout_budget=self.timeout_budget,
             timer_wheel=self.timer_wheel,
             runtime_idle_timeout_ms=(

{bazaar_compute_node-0.2.0rc1 → 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.0rc1 → 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.0rc1 → 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.0rc1 → 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.0rc1 → 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.0rc1 → 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.0rc1 → 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.0rc1 → 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
@@ -36,8 +36,14 @@ class _PendingApproval:
 
 
 class TelegramApprovalChannel(TelegramChannel):
-    def __init__(self, context: ChannelContext, *, token: str) -> None:
-        super().__init__(context, token=token)
+    def __init__(
+        self,
+        context: ChannelContext,
+        *,
+        token: str,
+        allowed_sender_ids: frozenset[int],
+    ) -> None:
+        super().__init__(context, token=token, allowed_sender_ids=allowed_sender_ids)
         self._translator: Translator = context.translator or create_translator(ENGLISH)
         self._pending_approvals: dict[str, _PendingApproval] = {}
         self._approval_tokens_by_request: dict[str, str] = {}

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

@@ -15,8 +15,10 @@ from ...core.channel import (
     ChannelDeliveryReceipt,
     ChannelIdentity,
     ChannelSendRequest,
+    DmAddress,
     IChannel,
 )
+from ...core.correlation import CorrelationContext
 from ...core.models import (
     ApprovalDecision,
     ApprovalResult,
@@ -28,6 +30,7 @@ from ...core.models import (
     InboundAttachment,
     Message,
     MessageDirection,
+    RuntimeEventState,
     RuntimeOutputEvent,
     SenderIdentity,
     SenderKind,
@@ -44,6 +47,7 @@ from ...core.models import (
     TurnUnknown,
     UsageUpdated,
 )
+from ...core.observability import LogLevel
 from ...core.outcomes import ProviderCallResult, ProviderCallStatus
 from ...core.timerwheel import TimerWheel
 from .api import TelegramApiError, TelegramBotApi, TelegramTransportError
@@ -95,9 +99,16 @@ class _InboundUpdate:
 
 
 class TelegramChannel(IChannel):
-    def __init__(self, context: ChannelContext, *, token: str) -> None:
+    def __init__(
+        self,
+        context: ChannelContext,
+        *,
+        token: str,
+        allowed_sender_ids: frozenset[int],
+    ) -> None:
         self._context = context
         self._token = token
+        self._allowed_sender_ids = allowed_sender_ids
         self._timer_wheel: TimerWheel | None = context.timer_wheel
         self._started_at_s = time_ns() // 1_000_000_000
         self._inbound: asyncio.Queue[Message | object] = asyncio.Queue()
@@ -431,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,
@@ -653,6 +695,31 @@ class TelegramChannel(IChannel):
         chat_type = chat.get("type")
         if chat_type not in {"private", "group", "supergroup"}:
             return "unsupported_chat_type"
+        # Anyone on Telegram can open a private chat with a bot. A group has to
+        # be joined, so only the private case is closed here.
+        if chat_type == "private" and not (
+            isinstance(provider_sender, Mapping)
+            and provider_sender.get("id") in self._allowed_sender_ids
+        ):
+            audit = self._context.audit
+            if audit is not None:
+                await audit.append(
+                    event_name="channel.inbound.rejected",
+                    state=RuntimeEventState.COMPLETED,
+                    correlation=CorrelationContext(
+                        node_id=self._context.agent_id,
+                        channel=self.name,
+                    ),
+                    level=LogLevel.WARNING,
+                    metadata={
+                        "reason": "unauthorized_sender",
+                        "telegram_sender_id": provider_sender.get("id")
+                        if isinstance(provider_sender, Mapping)
+                        else None,
+                        "telegram_chat_id": chat.get("id"),
+                    },
+                )
+            return "unauthorized_sender"
         chat_id = chat.get("id")
         provider_message_id = message.get("message_id")
         provider_time_s = message.get("date")

{bazaar_compute_node-0.2.0rc1 → 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.0rc1 → bazaar_compute_node-0.2.0rc3}/src/bazaar_compute_node/contrib/telegram/outbound.py

@@ -64,8 +64,9 @@ class TelegramOutboundChannel(TelegramApprovalChannel):
         context: ChannelContext,
         *,
         token: str,
+        allowed_sender_ids: frozenset[int],
     ) -> None:
-        super().__init__(context, token=token)
+        super().__init__(context, token=token, allowed_sender_ids=allowed_sender_ids)
         self._outbound_requests = 0
         self._outbound_confirmed_requests = 0
         self._outbound_partial_requests = 0