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

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

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

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

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

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

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

{bazaar_compute_node-0.1.13 → bazaar_compute_node-0.1.15}/src/bazaar_compute_node/app/system_service.py

@@ -250,11 +250,24 @@ $environmentScript = {environment_script}
 $logPath = {log_path}
 
 if ($environmentScript -and (Test-Path -LiteralPath $environmentScript)) {{
-    . $environmentScript
+    try {{
+        . $environmentScript
+    }} catch {{
+        $_ | Out-String | Add-Content -LiteralPath $logPath -Encoding utf8
+        exit 1
+    }}
 }}
 
-& $executable run --config $configPath *>> $logPath
-exit $LASTEXITCODE
+# Native stderr is routed to the service log and must not terminate the wrapper.
+$ErrorActionPreference = 'Continue'
+try {{
+    & $executable run --config $configPath *>> $logPath
+    $exitCode = $LASTEXITCODE
+}} catch {{
+    $_ | Out-String | Add-Content -LiteralPath $logPath -Encoding utf8
+    exit 1
+}}
+exit $exitCode
 """
 
 

{bazaar_compute_node-0.1.13 → bazaar_compute_node-0.1.15}/src/bazaar_compute_node/contrib/codex/__init__.py

@@ -13,6 +13,7 @@ from .client import (
     build_turn_interrupt_params,
     build_turn_start_params,
     build_turn_steer_params,
+    parse_background_terminals_response,
     parse_error_notification,
     parse_fs_changed_notification,
     parse_fs_watch_response,
@@ -67,6 +68,7 @@ __all__ = [
     "build_turn_interrupt_params",
     "build_turn_start_params",
     "build_turn_steer_params",
+    "parse_background_terminals_response",
     "parse_error_notification",
     "parse_fs_changed_notification",
     "parse_fs_watch_response",

{bazaar_compute_node-0.1.13 → bazaar_compute_node-0.1.15}/src/bazaar_compute_node/contrib/codex/client.py

@@ -331,6 +331,19 @@ class Client:
             timeout=timeout,
         )
 
+    async def list_background_terminals(
+        self,
+        thread_id: str,
+        *,
+        timeout: float,
+    ) -> JsonlMessage:
+        _validate_non_empty_string("thread_id", thread_id)
+        return await self.supervisor.request(
+            "thread/backgroundTerminals/list",
+            {"threadId": thread_id},
+            timeout=timeout,
+        )
+
     async def receive(self, *, timeout: float | None = None) -> JsonlMessage:
         return await self.supervisor.receive(timeout=timeout)
 
@@ -420,6 +433,18 @@ def parse_turn_steer_response(response: Mapping[str, object]) -> str:
     return _require_text(result, "turnId", "result.turnId")
 
 
+def parse_background_terminals_response(
+    response: Mapping[str, object],
+) -> bool:
+    result = _require_mapping(response, "result")
+    data = result.get("data")
+    if not isinstance(data, list):
+        raise AppServerProtocolError("result.data must be an array")
+    if any(not isinstance(item, Mapping) for item in data):
+        raise AppServerProtocolError("result.data items must be objects")
+    return bool(data)
+
+
 def parse_turn_notification(message: Mapping[str, object]) -> tuple[str, TurnInfo]:
     params = _require_mapping(message, "params")
     thread_id = _require_text(params, "threadId", "params.threadId")
@@ -532,6 +557,7 @@ __all__ = [
     "build_thread_start_params",
     "build_turn_interrupt_params",
     "build_turn_start_params",
+    "parse_background_terminals_response",
     "parse_error_notification",
     "parse_fs_changed_notification",
     "parse_fs_watch_response",

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

@@ -32,6 +32,7 @@ from ...core.runtime import (
 )
 from .client import (
     Client,
+    parse_background_terminals_response,
     parse_fs_changed_notification,
     parse_fs_watch_response,
     parse_initialize_response,
@@ -103,6 +104,7 @@ 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
@@ -516,6 +518,25 @@ class Runtime(IRuntime, IAsyncLifecycle):
             return False
         return True
 
+    async def has_background_job(
+        self,
+        session: RuntimeSession,
+        *,
+        timeout: float,
+    ) -> bool:
+        connection = self._connections.get(session.id)
+        provider_thread_id = session.provider_thread_id
+        if connection is None or not provider_thread_id:
+            return False
+        try:
+            response = await connection.client.list_background_terminals(
+                provider_thread_id,
+                timeout=timeout,
+            )
+        except AppServerProtocolError, JsonlTransportError:
+            return False
+        return parse_background_terminals_response(response)
+
     async def stop_session(
         self,
         session: RuntimeSession,
@@ -528,15 +549,11 @@ class Runtime(IRuntime, IAsyncLifecycle):
                 status=ProviderCallStatus.CONFIRMED,
                 value=session,
             )
-        try:
-            await connection.supervisor.stop(timeout=timeout)
-        except asyncio.CancelledError:
-            raise
-        except Exception as error:  # noqa: BLE001
-            return _provider_result(error)
+        self._schedule_connection_teardown(connection, timeout=timeout)
         return ProviderCallResult(
-            status=ProviderCallStatus.CONFIRMED,
+            status=ProviderCallStatus.QUEUED,
             value=session,
+            receipt={"teardown": "scheduled"},
         )
 
     async def _open_connection(
@@ -643,6 +660,28 @@ 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.13 → bazaar_compute_node-0.1.15}/src/bazaar_compute_node/core/orchestration/session.py

@@ -68,7 +68,6 @@ def _current_time_ms() -> int:
 class _IngressItem:
     message: InboundMessage
     completion: asyncio.Future[RuntimeTurn | None]
-    activity_at_ms: int
 
 
 @dataclass(slots=True)
@@ -82,7 +81,6 @@ class _RuntimeNotification:
     message: InboundMessage
     context: _DurableSessionContext
     completion: asyncio.Future[RuntimeTurn | None]
-    activity_at_ms: int
 
 
 @dataclass(frozen=True, slots=True)
@@ -92,14 +90,6 @@ class _ReminderNotification:
     anchor_message: InboundMessage
     context: _DurableSessionContext
     wake_id: str
-    activity_at_ms: int
-
-
-@dataclass(slots=True)
-class _RuntimeActivity:
-    context: _DurableSessionContext
-    completion: asyncio.Future[RuntimeTurn | None]
-    activity_at_ms: int
 
 
 @dataclass(frozen=True, slots=True)
@@ -112,11 +102,7 @@ class _RuntimeExpiry:
 
 type _WakeNotification = _RuntimeNotification | _ReminderNotification
 type _RuntimeQueueItem = (
-    _RuntimeNotification
-    | _ReminderNotification
-    | _RuntimeActivity
-    | _RuntimeExpiry
-    | RuntimeExpire
+    _RuntimeNotification | _ReminderNotification | _RuntimeExpiry | RuntimeExpire
 )
 
 
@@ -291,7 +277,6 @@ class SessionOrchestrator(IAsyncLifecycle):
                 anchor_message=anchor_message,
                 context=context,
                 wake_id=str(uuid7()),
-                activity_at_ms=self._timer_wheel.now_ms,
             )
         )
 
@@ -348,42 +333,14 @@ class SessionOrchestrator(IAsyncLifecycle):
             binding.watcher.cancel()
         await asyncio.gather(binding.watcher, return_exceptions=True)
 
-    async def _refresh_runtime_timer(
-        self,
-        runtime_session: RuntimeSession,
-        activity_at_ms: int,
-        *,
-        full_timeout: bool = False,
-    ) -> None:
+    async def _start_runtime_timer(self, runtime_session: RuntimeSession) -> None:
         if self._runtime_idle_timeout_ms <= 0:
             return
-        binding = self._runtime_timers.get(runtime_session.bcn_session_id)
-        delay_ms = self._runtime_idle_timeout_ms
-        if not full_timeout:
-            delay_ms = max(
-                0,
-                delay_ms - (self._timer_wheel.now_ms - activity_at_ms),
-            )
-        if (
-            binding is not None
-            and binding.runtime_session_id == runtime_session.id
-            and binding.timer.active
-        ):
-            try:
-                binding.timer.reset(delay_ms)
-            except RuntimeError:
-                if binding.timer.active:
-                    raise
-            else:
-                binding.expired = False
-                return
-        if binding is not None:
-            binding.timer.cancel()
-            if not binding.watcher.done():
-                binding.watcher.cancel()
-            await asyncio.gather(binding.watcher, return_exceptions=True)
-        timer = self._timer_wheel.create(delay_ms)
-        queue = self._runtime_queues[runtime_session.bcn_session_id]
+        queue = self._runtime_queues.get(runtime_session.bcn_session_id)
+        if queue is None:
+            return
+        await self._cancel_runtime_timer(runtime_session)
+        timer = self._timer_wheel.create(self._runtime_idle_timeout_ms)
         watcher = asyncio.create_task(
             self._forward_runtime_session_expiry(runtime_session, timer, queue),
             name=f"bcn-runtime-expiry-{runtime_session.bcn_session_id}",
@@ -394,6 +351,26 @@ class SessionOrchestrator(IAsyncLifecycle):
             watcher,
         )
 
+    async def _start_runtime_timer_if_idle(self, session_id: str) -> None:
+        runtime_session = self.runtime_session(session_id)
+        if (
+            runtime_session is None
+            or runtime_session.id in self._expired_runtime_ids
+            or self._state_machine.get(session_id) is not SessionRuntimeState.IDLE
+        ):
+            return
+        try:
+            if await self._runtime.has_background_job(
+                runtime_session,
+                timeout=self._timeout_budget.provider_call_seconds,
+            ):
+                return
+        except asyncio.CancelledError:
+            raise
+        except Exception:
+            self._logger.exception("runtime background job check failed")
+        await self._start_runtime_timer(runtime_session)
+
     async def _forward_runtime_session_expiry(
         self,
         runtime_session: RuntimeSession,
@@ -567,9 +544,7 @@ class SessionOrchestrator(IAsyncLifecycle):
                 self._ingress_loop(ingress_queue),
                 name=f"bcn-ingress-{message.channel_session_id}",
             )
-        ingress_queue.put_nowait(
-            _IngressItem(message, completion, self._timer_wheel.now_ms)
-        )
+        ingress_queue.put_nowait(_IngressItem(message, completion))
         return await completion
 
     async def _ingress_loop(self, queue: asyncio.Queue[_IngressItem]) -> None:
@@ -590,24 +565,15 @@ class SessionOrchestrator(IAsyncLifecycle):
                     or self.runtime_session(session_id) is not None
                 ):
                     runtime_queue = self._runtime_queue_for_session(session_id)
-                if runtime_queue is None:
+                if runtime_queue is None or not message.notifies_runtime:
                     if not item.completion.done():
                         item.completion.set_result(None)
-                elif message.notifies_runtime:
+                else:
                     runtime_queue.put_nowait(
                         _RuntimeNotification(
                             message,
                             context,
                             item.completion,
-                            item.activity_at_ms,
-                        )
-                    )
-                else:
-                    runtime_queue.put_nowait(
-                        _RuntimeActivity(
-                            context,
-                            item.completion,
-                            item.activity_at_ms,
                         )
                     )
             except asyncio.CancelledError:
@@ -628,22 +594,6 @@ class SessionOrchestrator(IAsyncLifecycle):
         pending: list[_RuntimeQueueItem] = []
         while True:
             item = pending.pop(0) if pending else await queue.get()
-            if isinstance(item, _RuntimeActivity):
-                try:
-                    runtime_session = self.runtime_session(item.context.bcn_session.id)
-                    if runtime_session is not None:
-                        await self._refresh_runtime_timer(
-                            runtime_session,
-                            item.activity_at_ms,
-                        )
-                    if not item.completion.done():
-                        item.completion.set_result(None)
-                except Exception as error:  # noqa: BLE001
-                    if not item.completion.done():
-                        item.completion.set_exception(error)
-                finally:
-                    queue.task_done()
-                continue
             if isinstance(item, _RuntimeExpiry):
                 try:
                     await self._handle_runtime_expiry(
@@ -679,15 +629,9 @@ class SessionOrchestrator(IAsyncLifecycle):
                         pending.insert(0, candidate)
                         break
                     batch.append(candidate)
-            for notification in batch:
-                runtime_session = self.runtime_session(
-                    notification.context.bcn_session.id
-                )
-                if runtime_session is not None:
-                    await self._refresh_runtime_timer(
-                        runtime_session,
-                        notification.activity_at_ms,
-                    )
+            runtime_session = self.runtime_session(batch[0].context.bcn_session.id)
+            if runtime_session is not None:
+                await self._cancel_runtime_timer(runtime_session)
             turn_task = asyncio.create_task(
                 self._run_notification(batch[0]),
                 name=f"bcn-turn-{batch[0].context.bcn_session.id}",
@@ -711,24 +655,9 @@ class SessionOrchestrator(IAsyncLifecycle):
                                 queued_item.context.bcn_session.id
                             )
                             if runtime_session is not None:
-                                await self._refresh_runtime_timer(
-                                    runtime_session,
-                                    queued_item.activity_at_ms,
-                                )
+                                await self._cancel_runtime_timer(runtime_session)
                             pending.append(queued_item)
                             await self._steer_active_turn(queued_item)
-                        elif isinstance(queued_item, _RuntimeActivity):
-                            runtime_session = self.runtime_session(
-                                queued_item.context.bcn_session.id
-                            )
-                            if runtime_session is not None:
-                                await self._refresh_runtime_timer(
-                                    runtime_session,
-                                    queued_item.activity_at_ms,
-                                )
-                            if not queued_item.completion.done():
-                                queued_item.completion.set_result(None)
-                            queue.task_done()
                         elif isinstance(queued_item, _RuntimeExpiry):
                             await self._handle_runtime_expiry(
                                 queued_item,
@@ -749,6 +678,9 @@ class SessionOrchestrator(IAsyncLifecycle):
                     queue_item_consumed = False
 
                 result = turn_task.result()
+                await self._start_runtime_timer_if_idle(
+                    batch[0].context.bcn_session.id,
+                )
                 route_message = (
                     batch[0].message
                     if isinstance(batch[0], _RuntimeNotification)
@@ -784,7 +716,7 @@ class SessionOrchestrator(IAsyncLifecycle):
                     queue_item_consumed = True
                 for queued_item in (*batch, *pending):
                     if (
-                        isinstance(queued_item, _RuntimeNotification | _RuntimeActivity)
+                        isinstance(queued_item, _RuntimeNotification)
                         and not queued_item.completion.done()
                     ):
                         queued_item.completion.cancel()
@@ -795,6 +727,9 @@ class SessionOrchestrator(IAsyncLifecycle):
             except Exception as error:
                 turn_task.cancel()
                 await asyncio.gather(turn_task, return_exceptions=True)
+                await self._start_runtime_timer_if_idle(
+                    batch[0].context.bcn_session.id,
+                )
                 for notification in batch:
                     if (
                         isinstance(notification, _RuntimeNotification)
@@ -1205,16 +1140,6 @@ class SessionOrchestrator(IAsyncLifecycle):
                 self._state_machine.get(context.bcn_session.id)
                 is SessionRuntimeState.IDLE
             ):
-                binding = self._runtime_timers.get(context.bcn_session.id)
-                if (
-                    binding is None
-                    or binding.runtime_session_id != context.runtime_session.id
-                ):
-                    await self._refresh_runtime_timer(
-                        context.runtime_session,
-                        notification.activity_at_ms,
-                        full_timeout=establishment_attempt > 0,
-                    )
                 break
             if establishment_attempt == 0:
                 await self._discard_runtime_session(context.runtime_session)

{bazaar_compute_node-0.1.13 → bazaar_compute_node-0.1.15}/src/bazaar_compute_node/core/runtime.py

@@ -140,6 +140,10 @@ class IRuntime(IAsyncLifecycle, Protocol):
         timeout: float,
     ) -> ProviderCallResult[RuntimeTurn]: ...
 
+    async def has_background_job(
+        self, session: RuntimeSession, *, timeout: float
+    ) -> bool: ...
+
     async def stop_session(
         self, session: RuntimeSession, *, timeout: float
     ) -> ProviderCallResult[RuntimeSession]: ...