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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bazaar-compute-node
-Version: 0.2.0rc3
+Version: 0.2.0rc5
 Summary: Runtime-agnostic computer node daemon for agents and channels.
 License-Expression: AGPL-3.0-only
 License-File: LICENSE
@@ -19,9 +19,9 @@ Description-Content-Type: text/markdown
 
 # Bazaar Compute Node
 
-Collaborate with your Agents in the bazaar across compute nodes, through any interface, with any harness runtime.
+Bring Your Own Agents to the bazaar, and build with your teams in the open.
 
-在集市里与你的 Agent 们合作，透过任意界面与任意 Harness。
+不必独自建造——带上你的智能体，来集市。
 
 <p align="left">
   <a href="https://github.com/yuchanns/bazaar-compute-node/actions"><img
@@ -50,7 +50,7 @@ bcn --version
 # Upgrade / 升级
 uv tool upgrade bazaar-compute-node
 
-# Add an Agent / 添加 Agent
+# Add an Agent / 添加智能体
 # allowed_sender_ids holds the Telegram user ids allowed to open a private chat
 # allowed_sender_ids 是允许与其私聊的 Telegram 用户 id
 bcn agent add \
@@ -97,8 +97,8 @@ Windows: Get-Content "$env:USERPROFILE\.bcn\system-service.log" -Wait
 | --- | --- |
 | ✅ | Reminders / 定时器 |
 | ✅ | Attachments / 附件 |
-| ✅ | Multi-Agents / 多 Agent |
-| 🚧 | Teams / 团队协作 |
+| ✅ | Multi-Agents / 多智能体 |
+| ✅ | Teams / 团队协作 |
 
 ### Channels / 渠道
 

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

@@ -1,8 +1,8 @@
 # Bazaar Compute Node
 
-Collaborate with your Agents in the bazaar across compute nodes, through any interface, with any harness runtime.
+Bring Your Own Agents to the bazaar, and build with your teams in the open.
 
-在集市里与你的 Agent 们合作，透过任意界面与任意 Harness。
+不必独自建造——带上你的智能体，来集市。
 
 <p align="left">
   <a href="https://github.com/yuchanns/bazaar-compute-node/actions"><img
@@ -31,7 +31,7 @@ bcn --version
 # Upgrade / 升级
 uv tool upgrade bazaar-compute-node
 
-# Add an Agent / 添加 Agent
+# Add an Agent / 添加智能体
 # allowed_sender_ids holds the Telegram user ids allowed to open a private chat
 # allowed_sender_ids 是允许与其私聊的 Telegram 用户 id
 bcn agent add \
@@ -78,8 +78,8 @@ Windows: Get-Content "$env:USERPROFILE\.bcn\system-service.log" -Wait
 | --- | --- |
 | ✅ | Reminders / 定时器 |
 | ✅ | Attachments / 附件 |
-| ✅ | Multi-Agents / 多 Agent |
-| 🚧 | Teams / 团队协作 |
+| ✅ | Multi-Agents / 多智能体 |
+| ✅ | Teams / 团队协作 |
 
 ### Channels / 渠道
 

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

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

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

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

{bazaar_compute_node-0.2.0rc3 → bazaar_compute_node-0.2.0rc5}/src/bazaar_compute_node/app/agent.py

@@ -281,11 +281,6 @@ class AgentApplication:
     ) -> Mapping[str, object]:
         return await self.command_dispatcher(request)
 
-    async def has_session(self, thread_id: str) -> bool:
-        if not isinstance(thread_id, str) or not thread_id:
-            return False
-        return await self.storage.get_thread(thread_id) is not None
-
     async def publish_inbox_wake(self, message: Message[InboundAttachment]) -> None:
         if not self._started:
             raise RuntimeError("Agent application is not started")

{bazaar_compute_node-0.2.0rc3 → bazaar_compute_node-0.2.0rc5}/src/bazaar_compute_node/app/application.py

@@ -243,23 +243,17 @@ class NodeApplication:
             await self.version_watcher.stop(
                 timeout=self.timeout_budget.shutdown_seconds,
             )
-        except asyncio.CancelledError:
-            raise
         except Exception as error:  # noqa: BLE001
             errors.append(f"version_watcher.stop:{type(error).__name__}")
         try:
             await self.reminder_scheduler.stop(
                 timeout=self.timeout_budget.shutdown_seconds,
             )
-        except asyncio.CancelledError:
-            raise
         except Exception as error:  # noqa: BLE001
             errors.append(f"reminder_scheduler.stop:{type(error).__name__}")
         for agent_id, agent in tuple(self.agents.items()):
             try:
                 await agent.stop()
-            except asyncio.CancelledError:
-                raise
             except Exception as error:  # noqa: BLE001
                 errors.append(f"agent[{agent_id}].stop:{type(error).__name__}")
                 self._log(
@@ -374,8 +368,6 @@ class NodeApplication:
             return False
         try:
             await agent.publish_inbox_wake(message)
-        except asyncio.CancelledError:
-            raise
         except Exception as error:  # noqa: BLE001
             self._log(
                 "reminder.wake.failed",

{bazaar_compute_node-0.2.0rc3 → bazaar_compute_node-0.2.0rc5}/src/bazaar_compute_node/app/command.py

@@ -404,8 +404,6 @@ class CommandDispatcher:
             raise CommandDispatchError(
                 "INVALID_COMMAND", "request kind is not supported"
             )
-        except asyncio.CancelledError:
-            raise
         except CommandDispatchError as error:
             response: dict[str, object] = {
                 "ok": False,

{bazaar_compute_node-0.2.0rc3 → bazaar_compute_node-0.2.0rc5}/src/bazaar_compute_node/app/transport.py

@@ -10,7 +10,7 @@ import tempfile
 from collections.abc import Awaitable, Callable, Mapping
 from pathlib import Path
 from typing import Any
-from urllib.parse import parse_qs, urlsplit
+from urllib.parse import urlsplit
 
 from ..core.utils import UnlimitedLineReader
 from ..core.utils.text import format_exception
@@ -56,14 +56,8 @@ class LocalCommandServer:
         self._unix_path: Path | None = None
         self._unix_identity: tuple[int, int] | None = None
         self._windows_server: Any | None = None
-        self._capability: str | None = None
         self._endpoint: str | None = None
 
-    def set_handler(self, handler: RequestHandler) -> None:
-        if self._server is not None or self._windows_server is not None:
-            raise RuntimeError("local command server handler is already active")
-        self._handler = handler
-
     @property
     def endpoint(self) -> str:
         if self._endpoint is None:
@@ -114,13 +108,11 @@ class LocalCommandServer:
         if windows_server is not None:
             await windows_server.stop()
             self._endpoint = None
-            self._capability = None
             return
 
         server = self._server
         self._server = None
         self._endpoint = None
-        self._capability = None
         if server is not None:
             server.close()
             await server.wait_closed()
@@ -157,8 +149,6 @@ class LocalCommandServer:
             if not isinstance(payload, dict):
                 raise TypeError("request must be a JSON object")
             response = await self._dispatch(payload)
-        except asyncio.CancelledError:
-            raise
         except json.JSONDecodeError as error:
             response = {
                 "ok": False,
@@ -194,14 +184,6 @@ class LocalCommandServer:
         if self._handler is None:
             raise RuntimeError("local command server is not ready")
         request = dict(payload)
-        if self._capability is not None:
-            capability = request.pop("capability", None)
-            if capability != self._capability:
-                return {
-                    "ok": False,
-                    "code": "LOCAL_AUTH_FAILED",
-                    "error": "local command capability is invalid",
-                }
         return await self._handler(request)
 
 
@@ -243,24 +225,6 @@ class LocalCommandClient:
             return await asyncio.to_thread(request_named_pipe, endpoint, payload)
         if parsed.scheme == "unix":
             reader, writer = await _open_unix_connection(parsed.path)
-        elif parsed.scheme == "tcp":
-            query = parse_qs(parsed.query)
-            token_values = query.get("token")
-            if (
-                set(query) != {"token"}
-                or token_values is None
-                or len(token_values) != 1
-            ):
-                raise ValueError("TCP command endpoint has no capability token")
-            if parsed.hostname != "127.0.0.1":
-                raise ValueError("TCP command endpoint must use loopback")
-            request["capability"] = token_values[0]
-            if parsed.hostname is None or parsed.port is None:
-                raise ValueError("TCP command endpoint is invalid")
-            reader, writer = await asyncio.open_connection(
-                parsed.hostname,
-                parsed.port,
-            )
         else:
             raise ValueError(f"unsupported local command endpoint: {endpoint}")
 

{bazaar_compute_node-0.2.0rc3 → bazaar_compute_node-0.2.0rc5}/src/bazaar_compute_node/app/version_check.py

@@ -78,8 +78,6 @@ class VersionWatcher:
             self._available = (
                 latest if Version(latest) > Version(self._current_version) else None
             )
-        except asyncio.CancelledError:
-            raise
         except aiohttp.ClientError, TimeoutError, ValueError, KeyError, TypeError:
             self._logger.warning("version check failed", exc_info=True)
 

{bazaar_compute_node-0.2.0rc3 → bazaar_compute_node-0.2.0rc5}/src/bazaar_compute_node/contrib/claude/client.py

@@ -343,8 +343,6 @@ class Client:
                 await self._route_business_message(envelope, sequence)
                 if self._message_observer is not None:
                     self._message_observer(envelope)
-        except asyncio.CancelledError:
-            raise
         except Exception as error:  # noqa: BLE001
             self._fail_pending(error)
             self._publish_failure(error)
@@ -359,8 +357,6 @@ class Client:
                     "Claude control request has no active turn handler"
                 )
             response = await handler(envelope)
-        except asyncio.CancelledError:
-            raise
         except Exception as error:  # noqa: BLE001
             _LOGGER.warning(
                 "Claude control request handler failed",
@@ -404,8 +400,6 @@ class Client:
                         },
                     },
                 )
-        except asyncio.CancelledError:
-            raise
         except Exception as error:  # noqa: BLE001
             self._publish_failure(
                 error

{bazaar_compute_node-0.2.0rc3 → bazaar_compute_node-0.2.0rc5}/src/bazaar_compute_node/contrib/claude/events.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import asyncio
 import json
 import logging
 from collections import deque
@@ -84,9 +83,6 @@ class TurnEventStream(IRuntimeTurnStream):
         self._pending: deque[RuntimeOutputEvent] = deque()
         self._tool_names: dict[str, str] = {}
         self._block_stream_ids: dict[int, str] = {}
-        self._terminal_future: asyncio.Future[RuntimeOutputEvent] = (
-            asyncio.get_running_loop().create_future()
-        )
 
     def __aiter__(self) -> Self:
         return self
@@ -117,8 +113,6 @@ class TurnEventStream(IRuntimeTurnStream):
             try:
                 message = await self._inbox.receive()
                 items = await self._map_message(message)
-            except asyncio.CancelledError:
-                raise
             except (ClaudeProtocolError, TypeError, ValueError) as error:
                 await self._on_unusable(error)
                 return await self._terminal_event(
@@ -148,10 +142,6 @@ class TurnEventStream(IRuntimeTurnStream):
             )
         await self._call_closed()
 
-    async def wait_terminal(self, *, timeout: float) -> RuntimeOutputEvent:
-        async with asyncio.timeout(timeout):
-            return await asyncio.shield(self._terminal_future)
-
     async def _map_message(self, message: JsonObject) -> tuple[RuntimeOutputEvent, ...]:
         kind = message["type"]
         session_id = message.get("session_id")
@@ -568,8 +558,6 @@ class TurnEventStream(IRuntimeTurnStream):
             error_message=error_message,
             metadata=metadata,
         )
-        if not self._terminal_future.done():
-            self._terminal_future.set_result(event)
         await self._call_closed()
         return event
 

{bazaar_compute_node-0.2.0rc3 → bazaar_compute_node-0.2.0rc5}/src/bazaar_compute_node/contrib/claude/process.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import asyncio
 import json
+import logging
 from collections import deque
 from collections.abc import Mapping
 from dataclasses import dataclass
@@ -22,6 +23,8 @@ from .protocol import (
 MAX_JSONL_BYTES = 1024 * 1024
 _EXIT_PIPE_DRAIN_SECONDS = 1
 _CLOSED = object()
+_REAP_REPORT_SECONDS = 30.0
+_LOGGER = logging.getLogger("bazaar_compute_node.runtime.claude.process")
 
 
 class ProcessState(StrEnum):
@@ -120,6 +123,8 @@ class ProcessSupervisor:
         self._write_lock = asyncio.Lock()
         self._lifecycle_lock = asyncio.Lock()
         self._exit_event = asyncio.Event()
+        self._abandoned: set[asyncio.Task[None]] = set()
+        self._started = False
 
     @property
     def state(self) -> ProcessState:
@@ -147,8 +152,9 @@ class ProcessSupervisor:
 
     async def start(self, *, timeout: float) -> None:
         async with self._lifecycle_lock:
-            if self.is_running:
-                return
+            if self._started:
+                raise RuntimeError("a stopped supervisor cannot start again")
+            self._started = True
             self._state = ProcessState.RUNNING
             try:
                 async with asyncio.timeout(timeout):
@@ -227,6 +233,7 @@ class ProcessSupervisor:
             now = asyncio.get_running_loop().time()
             graceful_deadline = now + timeout * 0.6
             terminate_deadline = now + timeout * 0.9
+            kill_deadline = now + timeout
             if process.stdin is not None:
                 process.stdin.close()
             try:
@@ -237,12 +244,74 @@ class ProcessSupervisor:
                     await self._wait_until(process, terminate_deadline)
                 except TimeoutError:
                     process.kill()
-                    await process.wait()
+                    try:
+                        await self._wait_until(process, kill_deadline)
+                    except TimeoutError:
+                        # a process that survived a kill will not be waited out,
+                        # so let go of it here instead of holding the lifecycle
+                        # lock
+                        self._abandon(process)
+                        self._state = ProcessState.STOPPED
+                        self._exit_event.set()
+                        return
             self._returncode = process.returncode
             await self._join_tasks(cancel=True)
             self._state = ProcessState.STOPPED
             self._exit_event.set()
 
+    def _abandon(self, process: asyncio.subprocess.Process) -> None:
+        """Give up on a process without losing track of it.
+
+        Closing this side of the pipes is what unblocks everything: the readers
+        stop waiting for an EOF that a grandchild holding the write end will
+        never deliver, and the exit waiters can complete once the pipes count as
+        disconnected. Whoever still holds that write end is free to keep it.
+        """
+
+        transport = getattr(process, "_transport", None)
+        if transport is not None:
+            for fd in (1, 2):
+                pipe = transport.get_pipe_transport(fd)
+                if pipe is not None:
+                    pipe.close()
+        # the watcher normally closes the queue, and it is about to be
+        # cancelled, so release whoever is already waiting in receive()
+        self._incoming.put_nowait(_CLOSED)
+        tasks = tuple(
+            task
+            for task in (self._stdout_task, self._stderr_task, self._watch_task)
+            if task is not None and task is not asyncio.current_task()
+        )
+        for task in tasks:
+            task.cancel()
+        self._stdout_task = None
+        self._stderr_task = None
+        self._watch_task = None
+        self._process = None
+        reaper = asyncio.create_task(
+            self._reap(process, tasks),
+            name=f"bcn-claude-reap-{process.pid}",
+        )
+        self._abandoned.add(reaper)
+        reaper.add_done_callback(self._abandoned.discard)
+
+    async def _reap(
+        self,
+        process: asyncio.subprocess.Process,
+        tasks: tuple[asyncio.Task[None], ...],
+    ) -> None:
+        """Outlive the caller waiting for a process nobody else is waiting for."""
+
+        if tasks:
+            await asyncio.gather(*tasks, return_exceptions=True)
+        try:
+            async with asyncio.timeout(_REAP_REPORT_SECONDS):
+                returncode = await process.wait()
+        except TimeoutError:
+            _LOGGER.warning("process %s outlived its kill; still waiting", process.pid)
+            returncode = await process.wait()
+        self._returncode = returncode
+
     async def _read_stdout(self, process: asyncio.subprocess.Process) -> None:
         stdout = process.stdout
         if stdout is None:
@@ -262,8 +331,6 @@ class ProcessSupervisor:
                             if isinstance(error, str) and error.strip():
                                 self._result_error_tail.append(error.strip())
                 await self._incoming.put(payload)
-        except asyncio.CancelledError:
-            raise
         except (UnicodeDecodeError, json.JSONDecodeError, ClaudeProtocolError) as error:
             await self._fail(ClaudeProtocolError(str(error)))
         except (ConnectionError, OSError) as error:
@@ -279,8 +346,6 @@ class ProcessSupervisor:
                 self._stderr_tail.append(
                     line.decode("utf-8", errors="replace").rstrip("\r\n")
                 )
-        except asyncio.CancelledError:
-            raise
         except ConnectionError, OSError:
             return
 

{bazaar_compute_node-0.2.0rc3 → bazaar_compute_node-0.2.0rc5}/src/bazaar_compute_node/contrib/claude/runtime.py

@@ -25,7 +25,6 @@ from ...core.paths import resolve_workspace_dir
 from ...core.runtime import (
     IRuntime,
     IRuntimeTurnStream,
-    RuntimeBackgroundIdle,
     RuntimeCommandContext,
     RuntimeLifecycleEvent,
     RuntimeSandboxMode,
@@ -60,7 +59,6 @@ class _Connection:
     queued_human_cycle_started: asyncio.Event = field(default_factory=asyncio.Event)
     active_stream: TurnEventStream | None = None
     active_background_task_ids: set[str] = field(default_factory=set)
-    background_active: bool = False
 
 
 class Runtime(IRuntime, IAsyncLifecycle):
@@ -120,8 +118,6 @@ class Runtime(IRuntime, IAsyncLifecycle):
         for connection in connections:
             try:
                 await self._stop_connection(connection, timeout=timeout)
-            except asyncio.CancelledError:
-                raise
             except OSError, TimeoutError, ClaudeTransportError:
                 continue
         self._started = False
@@ -387,8 +383,6 @@ class Runtime(IRuntime, IAsyncLifecycle):
                 connection.queued_human_cycle_started.clear()
             try:
                 await connection.client.send_user_message(input_text, timeout=timeout)
-            except asyncio.CancelledError:
-                raise
             except ClaudeTransportError:
                 return False
             connection.pending_human_results += 1
@@ -511,8 +505,7 @@ class Runtime(IRuntime, IAsyncLifecycle):
                 self._retirement_tasks.add(task)
                 task.add_done_callback(self._retirement_tasks.discard)
                 return
-            if _observe_background(connection, message):
-                self._lifecycle_events.put_nowait(RuntimeBackgroundIdle(session.id))
+            _observe_background(connection, message)
 
         client.set_message_observer(observe)
         return connection
@@ -535,8 +528,6 @@ class Runtime(IRuntime, IAsyncLifecycle):
             await self._stop_connection(
                 connection, timeout=_UNUSABLE_CONNECTION_STOP_SECONDS
             )
-        except asyncio.CancelledError:
-            raise
         except OSError, TimeoutError, ClaudeTransportError:
             return
 
@@ -601,32 +592,24 @@ def _sandbox_settings(
     return settings
 
 
-def _observe_background(connection: _Connection, message: dict[str, object]) -> bool:
-    was_active = connection.background_active
-    if message.get("type") == "system":
-        subtype = message.get("subtype")
-        task_id = message.get("task_id")
-        if isinstance(task_id, str) and task_id:
-            if subtype == "task_started" and message.get("task_type") in {
-                "local_agent",
-                "local_workflow",
-            }:
-                connection.active_background_task_ids.add(task_id)
-            elif subtype == "task_notification":
-                connection.active_background_task_ids.discard(task_id)
-            elif subtype == "task_updated":
-                patch = message.get("patch")
-                if isinstance(patch, dict) and patch.get("status") in {
-                    "completed",
-                    "failed",
-                    "stopped",
-                    "killed",
-                }:
-                    connection.active_background_task_ids.discard(task_id)
-    connection.background_active = bool(
-        connection.active_background_task_ids or connection.client.provider_wake_active
-    )
-    return was_active and not connection.background_active
+def _observe_background(connection: _Connection, message: dict[str, object]) -> None:
+    # Claude Code republishes the whole set on every change, so the latest
+    # snapshot is the answer and nothing has to be accumulated from edges
+    if (
+        message.get("type") != "system"
+        or message.get("subtype") != "background_tasks_changed"
+    ):
+        return
+    tasks = message.get("tasks")
+    if not isinstance(tasks, list):
+        return
+    connection.active_background_task_ids = {
+        task_id
+        for task in tasks
+        if isinstance(task, dict)
+        and isinstance(task_id := task.get("task_id"), str)
+        and task_id
+    }
 
 
 def _provider_result(error: BaseException) -> ProviderCallResult[Any]:

{bazaar_compute_node-0.2.0rc3 → bazaar_compute_node-0.2.0rc5}/src/bazaar_compute_node/contrib/codex/events.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import asyncio
 from collections.abc import Callable, Mapping
 from time import time_ns
 from typing import Annotated, Literal, Self, cast
@@ -646,8 +645,6 @@ class TurnEventStream(IRuntimeTurnStream):
                 result=response,
                 timeout=self._approval_timeout,
             )
-        except asyncio.CancelledError:
-            raise
         except Exception as error:
             if not response_attempted:
                 await self._respond_with_error(request_id, error)