bazaar-compute-node 0.1.15__tar.gz → 0.1.17__tar.gz

{bazaar_compute_node-0.1.15 → bazaar_compute_node-0.1.17}/PKG-INFO

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

{bazaar_compute_node-0.1.15 → bazaar_compute_node-0.1.17}/pyproject.toml

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

{bazaar_compute_node-0.1.15 → bazaar_compute_node-0.1.17}/pyproject.toml.orig

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

{bazaar_compute_node-0.1.15 → bazaar_compute_node-0.1.17}/src/bazaar_compute_node/bcc.py

@@ -483,24 +483,12 @@ def _message_header_fields(
     sender_value = message.get("sender")
     sender: str | None = None
     if sender_value is not None:
-        if isinstance(sender_value, str) and sender_value:
-            sender = sender_value
-        elif not isinstance(sender_value, Mapping):
+        if not isinstance(sender_value, Mapping):
             _invalid_response("command response contains an invalid message sender")
         else:
             sender_id = sender_value.get("id")
             sender_name = sender_value.get("name")
-            if sender_id is not None and (
-                not isinstance(sender_id, str) or not sender_id
-            ):
-                _invalid_response("command response contains an invalid sender id")
-            if sender_name is not None and (
-                not isinstance(sender_name, str) or not sender_name
-            ):
-                _invalid_response("command response contains an invalid sender name")
-            sender = sender_name or sender_id
-            if sender is None:
-                _invalid_response("command response contains an empty message sender")
+            sender = f"@{sender_id}({sender_name})" if sender_name else f"@{sender_id}"
     return (
         target,
         message_id,
@@ -553,7 +541,7 @@ def _format_check_message(message: Mapping[str, object]) -> str:
         line += f" reply_to={reply_to_message_id}"
     line += "] "
     if sender is not None:
-        line += f"@{sender}: "
+        line += f"{sender} "
     return line + body + _attachment_suffix(message)
 
 
@@ -583,7 +571,7 @@ def _format_read_message(
         fields.append(f"replyTo={reply_to_message_id}")
     line = f"[{index}/{count} {' '.join(fields)}] "
     if sender is not None:
-        line += f"@{sender}: "
+        line += f"{sender} "
     return line + body + _attachment_suffix(message)
 
 

{bazaar_compute_node-0.1.15 → bazaar_compute_node-0.1.17}/src/bazaar_compute_node/contrib/codex/runtime.py

@@ -104,7 +104,6 @@ class Runtime(IRuntime, IAsyncLifecycle):
         self._model = model
         self._effort = effort
         self._connections: dict[str, _Connection] = {}
-        self._teardown_tasks: set[asyncio.Task[None]] = set()
         self._expire_events: asyncio.Queue[RuntimeExpire] = asyncio.Queue()
         self._logger = logging.getLogger("bazaar_compute_node.runtime.codex")
         self._started = False
@@ -114,6 +113,11 @@ class Runtime(IRuntime, IAsyncLifecycle):
         del timeout
         if self._stopping:
             raise RuntimeError("Codex App Server runtime is stopping")
+        if os.name == "nt":
+            self._logger.warning(
+                "Codex idle timeout is not supported on Windows; "
+                "see openai/codex#15461."
+            )
         self._started = True
 
     async def stop(self, *, timeout: float) -> None:
@@ -524,6 +528,9 @@ class Runtime(IRuntime, IAsyncLifecycle):
         *,
         timeout: float,
     ) -> bool:
+        if os.name == "nt":
+            # Detached OS processes are not exposed by the Windows Codex provider.
+            return True
         connection = self._connections.get(session.id)
         provider_thread_id = session.provider_thread_id
         if connection is None or not provider_thread_id:
@@ -549,11 +556,10 @@ class Runtime(IRuntime, IAsyncLifecycle):
                 status=ProviderCallStatus.CONFIRMED,
                 value=session,
             )
-        self._schedule_connection_teardown(connection, timeout=timeout)
+        await self._stop_connection(connection, timeout=timeout)
         return ProviderCallResult(
-            status=ProviderCallStatus.QUEUED,
+            status=ProviderCallStatus.CONFIRMED,
             value=session,
-            receipt={"teardown": "scheduled"},
         )
 
     async def _open_connection(
@@ -660,28 +666,6 @@ class Runtime(IRuntime, IAsyncLifecycle):
         except OSError, TimeoutError, JsonlTransportError:
             return
 
-    def _schedule_connection_teardown(
-        self,
-        connection: _Connection,
-        *,
-        timeout: float,
-    ) -> None:
-        task = asyncio.create_task(
-            self._stop_connection(connection, timeout=timeout),
-            name=f"bcn-codex-teardown-{connection.provider_thread_id}",
-        )
-        self._teardown_tasks.add(task)
-        task.add_done_callback(self._forget_teardown_task)
-
-    def _forget_teardown_task(self, task: asyncio.Task[None]) -> None:
-        self._teardown_tasks.discard(task)
-        if task.cancelled():
-            return
-        try:
-            task.result()
-        except Exception:
-            self._logger.exception("Codex runtime connection teardown failed")
-
     def _clear_active_turn(self, session_id: str, turn_id: str) -> None:
         connection = self._connections.get(session_id)
         if connection is not None and connection.active_turn_id == turn_id:

{bazaar_compute_node-0.1.15 → bazaar_compute_node-0.1.17}/src/bazaar_compute_node/contrib/telegram/channel.py

@@ -67,6 +67,7 @@ class TelegramChannel(IChannel):
         self._api: TelegramBotApi | None = None
         self._bot_id: int | None = None
         self._bot_username: str | None = None
+        self._bot_first_name: str | None = None
         self._state = "stopped"
         self._poll_attempts = 0
         self._last_poll_at_ms: int | None = None
@@ -102,6 +103,7 @@ class TelegramChannel(IChannel):
             "started_at_s": self._started_at_s,
             "bot_id": self._bot_id,
             "bot_username": self._bot_username,
+            "bot_first_name": self._bot_first_name,
             "poll_timeout_seconds": 50,
             "poll_attempts": self._poll_attempts,
             "last_poll_at_ms": self._last_poll_at_ms,
@@ -127,9 +129,15 @@ class TelegramChannel(IChannel):
     def get_identity(self) -> ChannelIdentity | None:
         bot_id = self._bot_id
         bot_username = self._bot_username
-        if bot_id is None or bot_username is None:
+        bot_first_name = self._bot_first_name
+        if bot_id is None or bot_first_name is None:
             return None
-        return ChannelIdentity(id=str(bot_id), name=bot_username)
+        return ChannelIdentity(
+            id=str(bot_id),
+            name=(
+                f"{bot_username}({bot_first_name})" if bot_username else bot_first_name
+            ),
+        )
 
     async def start(self, *, timeout: float) -> None:
         if self._runner is not None:
@@ -156,16 +164,22 @@ class TelegramChannel(IChannel):
             bot_id = bot.get("id")
             is_bot = bot.get("is_bot")
             username = bot.get("username")
+            first_name = bot.get("first_name")
             if (
                 not isinstance(bot_id, int)
                 or isinstance(bot_id, bool)
                 or is_bot is not True
-                or not isinstance(username, str)
-                or not username
+                or (
+                    username is not None
+                    and (not isinstance(username, str) or not username)
+                )
+                or not isinstance(first_name, str)
+                or not first_name
             ):
                 raise ValueError("Telegram getMe returned an invalid bot identity")
             self._bot_id = bot_id
-            self._bot_username = username
+            self._bot_username = username if isinstance(username, str) else None
+            self._bot_first_name = first_name
             self._typing_runner = asyncio.create_task(
                 self._run_typing_dispatcher(),
                 name="bcn-telegram-typing",
@@ -195,6 +209,7 @@ class TelegramChannel(IChannel):
             self._session = None
             self._bot_id = None
             self._bot_username = None
+            self._bot_first_name = None
             self._typing_leases.clear()
             await session.close()
             self._state = "stopped"
@@ -227,6 +242,7 @@ class TelegramChannel(IChannel):
         self._session = None
         self._bot_id = None
         self._bot_username = None
+        self._bot_first_name = None
         if session is not None and not session.closed:
             await session.close()
         self._ready.clear()
@@ -462,8 +478,8 @@ class TelegramChannel(IChannel):
         update_id: int,
     ) -> None:
         bot_id = self._bot_id
-        bot_username = self._bot_username
-        if bot_id is None or bot_username is None:
+        bot_username = self._bot_username or ""
+        if bot_id is None:
             raise RuntimeError("Telegram bot identity is not initialized")
 
         provider_sender = message.get("from")
@@ -631,8 +647,8 @@ class TelegramChannel(IChannel):
         if topic_id is None or topic_id != identity.topic_id:
             return None
         bot_id = self._bot_id
-        bot_username = self._bot_username
-        if bot_id is None or bot_username is None:
+        bot_username = self._bot_username or ""
+        if bot_id is None:
             raise RuntimeError("Telegram bot identity is not initialized")
         content = await self._content(
             reply,
@@ -826,11 +842,11 @@ class TelegramChannel(IChannel):
             if entity_text is None:
                 continue
             if entity_type == "mention":
-                if entity_text.casefold() == f"@{username}":
+                if username and entity_text.casefold() == f"@{username}":
                     return True
                 continue
             _, separator, target = entity_text.rpartition("@")
-            if separator and target.casefold() == username:
+            if separator and username and target.casefold() == username:
                 return True
         return False
 

{bazaar_compute_node-0.1.15 → bazaar_compute_node-0.1.17}/src/bazaar_compute_node/contrib/wecom/channel.py

@@ -136,7 +136,7 @@ class WeComChannel(IChannel):
         }
 
     def get_identity(self) -> ChannelIdentity | None:
-        return None
+        return ChannelIdentity(id=self._bot_id)
 
     async def start(self, *, timeout: float) -> None:
         if self._runner is not None:

{bazaar_compute_node-0.1.15 → bazaar_compute_node-0.1.17}/src/bazaar_compute_node/core/instruction.py

@@ -71,10 +71,10 @@ Do not obstruct a human-directed use of a credential: use or send it on the requ
 Messages you receive have a single RFC 5424-style structured data header followed by the sender and content:
 
 ```
-[target=<thread-target> msg=00000000 time=2026-03-15T01:00:00 type=human] @richard: hello everyone
-[target=<thread-target> msg=11111111 time=2026-03-15T01:00:01 type=agent] @Alice: hi there
-[target=dm:@richard msg=22222222 time=2026-03-15T01:00:02 type=human] @richard: hey, can you help?
-[target=<thread-target> msg=33333333 time=2026-03-15T01:00:03 type=human] @richard: thread reply
+[target=<thread-target> msg=00000000 time=2026-03-15T01:00:00 type=human] @yuchanns(Hanchin Hsieh) hello everyone
+[target=<thread-target> msg=11111111 time=2026-03-15T01:00:01 type=agent] @Alice(Aeris) hi there
+[target=dm:@yuchanss msg=22222222 time=2026-03-15T01:00:02 type=human] @yuchanns(Hanchin Hsieh) hey, can you help?
+[target=<thread-target> msg=33333333 time=2026-03-15T01:00:03 type=human] @yuchanns(Hanchin Hsieh) thread reply
 ```
 
 Prompt examples use obvious placeholder IDs such as `00000000`, `11111111`, and `22222222`. They show the shape of a real message ID but are not actual messages. Do not cite them as evidence; use only IDs from messages you actually received or read.
@@ -257,9 +257,9 @@ class DeveloperInstructionContext:
     def render(self) -> str:
         rendered = DEVELOPER_INSTRUCTIONS
         identity_statement = (
-            f'You\'re "{self.bot_name}", A.K.A "{self.agent_name}"'
+            f"You're {self.bot_name}, A.K.A {self.agent_name}"
             if self.bot_name is not None
-            else f'You\'re "{self.agent_name}"'
+            else f"You're {self.agent_name}"
         )
         for placeholder, value in (
             ("{{identity_statement}}", identity_statement),

{bazaar_compute_node-0.1.15 → bazaar_compute_node-0.1.17}/src/bazaar_compute_node/core/orchestration/session.py

@@ -204,6 +204,7 @@ class SessionOrchestrator(IAsyncLifecycle):
             clock=self._clock,
         )
         self._active_tasks: set[asyncio.Task[RuntimeTurn | None]] = set()
+        self._runtime_teardown_tasks: set[asyncio.Task[None]] = set()
         self._ingress_queues: dict[tuple[str, str], asyncio.Queue[_IngressItem]] = {}
         self._ingress_workers: dict[tuple[str, str], asyncio.Task[None]] = {}
         self._runtime_queues: dict[str, asyncio.Queue[_RuntimeQueueItem]] = {}
@@ -408,7 +409,7 @@ class SessionOrchestrator(IAsyncLifecycle):
             )
         except BaseException:
             try:
-                await self._runtime.stop_session(
+                await self._stop_runtime_session(
                     context.runtime_session,
                     timeout=self._timeout_budget.provider_call_seconds,
                 )
@@ -497,6 +498,8 @@ class SessionOrchestrator(IAsyncLifecycle):
         for runtime_session in tuple(self._runtime_sessions.values()):
             await self._stop_runtime_session(runtime_session, timeout=timeout)
 
+        await self._wait_for_runtime_teardown_tasks(timeout=timeout)
+
         try:
             await self._runtime.stop(timeout=timeout)
         except asyncio.CancelledError:
@@ -1515,38 +1518,45 @@ class SessionOrchestrator(IAsyncLifecycle):
         async with self._concurrency.for_session(runtime_session.bcn_session_id):
             await self._stop_runtime_session_locked(runtime_session, timeout=timeout)
 
-    async def _stop_runtime_session_locked(
+    async def _wait_for_runtime_teardown_tasks(self, *, timeout: float) -> None:
+        tasks = tuple(self._runtime_teardown_tasks)
+        if not tasks:
+            return
+        gathered = asyncio.gather(*tasks, return_exceptions=True)
+        try:
+            await asyncio.wait_for(asyncio.shield(gathered), timeout=timeout)
+        except TimeoutError:
+            self._shutdown_errors.append("runtime session teardown: shutdown timeout")
+
+    def _schedule_runtime_session_teardown(
         self,
         runtime_session: RuntimeSession,
         *,
+        correlation: CorrelationContext,
         timeout: float,
     ) -> None:
-        process_correlation = CorrelationContext(
-            node_id=self.agent_id,
-            channel_session_id=runtime_session.channel_session_id,
-            bcn_session_id=runtime_session.bcn_session_id,
-            runtime_session_id=runtime_session.id,
-            provider_thread_id=runtime_session.provider_thread_id,
-        )
-        await self._audit.append(
-            event_name="runtime.process.stop.requested",
-            state=RuntimeEventState.STARTED,
-            correlation=process_correlation,
-            metadata={
-                "runtime": runtime_session.runtime,
-                "workspace_id": runtime_session.workspace_id,
-            },
-        )
-        await self._state_machine.apply_locked(
-            runtime_session.bcn_session_id,
-            SessionRuntimeObservation(
-                source=SessionRuntimeObservationSource.SESSION,
-                signal=SessionRuntimeSignal.STOP_REQUESTED,
-                observed_at_ms=self._clock(),
+        task = asyncio.create_task(
+            self._complete_runtime_session_teardown(
+                runtime_session,
+                correlation=correlation,
+                timeout=timeout,
             ),
+            name=f"bcn-runtime-teardown-{runtime_session.id}",
         )
+        self._runtime_teardown_tasks.add(task)
+        task.add_done_callback(self._forget_runtime_teardown_task)
+
+    async def _complete_runtime_session_teardown(
+        self,
+        runtime_session: RuntimeSession,
+        *,
+        correlation: CorrelationContext,
+        timeout: float,
+    ) -> None:
         try:
             result = await self._runtime.stop_session(runtime_session, timeout=timeout)
+        except asyncio.CancelledError:
+            raise
         except Exception as error:  # noqa: BLE001
             result = None
             stop_error = error
@@ -1563,7 +1573,6 @@ class SessionOrchestrator(IAsyncLifecycle):
             else ErrorKind.PROVIDER_UNKNOWN.value
         )
         error_message = result.error_message if result is not None else str(stop_error)
-        await self._discard_runtime_session(runtime_session)
         await self._audit.append(
             event_name=(
                 "runtime.process.stop.completed"
@@ -1579,7 +1588,7 @@ class SessionOrchestrator(IAsyncLifecycle):
                 if unknown
                 else RuntimeEventState.FAILED
             ),
-            correlation=process_correlation,
+            correlation=correlation,
             error_kind=(
                 ErrorKind(error_kind)
                 if error_kind in ErrorKind._value2member_map_
@@ -1595,3 +1604,53 @@ class SessionOrchestrator(IAsyncLifecycle):
                 "workspace_id": runtime_session.workspace_id,
             },
         )
+
+    def _forget_runtime_teardown_task(self, task: asyncio.Task[None]) -> None:
+        self._runtime_teardown_tasks.discard(task)
+        if task.cancelled():
+            return
+        error = task.exception()
+        if error is None:
+            return
+        self._logger.error(
+            "runtime session teardown failed: %s",
+            error,
+            exc_info=(type(error), error, error.__traceback__),
+        )
+
+    async def _stop_runtime_session_locked(
+        self,
+        runtime_session: RuntimeSession,
+        *,
+        timeout: float,
+    ) -> None:
+        process_correlation = CorrelationContext(
+            node_id=self.agent_id,
+            channel_session_id=runtime_session.channel_session_id,
+            bcn_session_id=runtime_session.bcn_session_id,
+            runtime_session_id=runtime_session.id,
+            provider_thread_id=runtime_session.provider_thread_id,
+        )
+        await self._audit.append(
+            event_name="runtime.process.stop.requested",
+            state=RuntimeEventState.STARTED,
+            correlation=process_correlation,
+            metadata={
+                "runtime": runtime_session.runtime,
+                "workspace_id": runtime_session.workspace_id,
+            },
+        )
+        await self._state_machine.apply_locked(
+            runtime_session.bcn_session_id,
+            SessionRuntimeObservation(
+                source=SessionRuntimeObservationSource.SESSION,
+                signal=SessionRuntimeSignal.STOP_REQUESTED,
+                observed_at_ms=self._clock(),
+            ),
+        )
+        self._schedule_runtime_session_teardown(
+            runtime_session,
+            correlation=process_correlation,
+            timeout=timeout,
+        )
+        await self._discard_runtime_session(runtime_session)