bazaar-compute-node 0.1.14__tar.gz → 0.1.16__tar.gz

{bazaar_compute_node-0.1.14 → bazaar_compute_node-0.1.16}/PKG-INFO

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

{bazaar_compute_node-0.1.14 → bazaar_compute_node-0.1.16}/pyproject.toml

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

{bazaar_compute_node-0.1.14 → bazaar_compute_node-0.1.16}/pyproject.toml.orig

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

{bazaar_compute_node-0.1.14 → bazaar_compute_node-0.1.16}/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.14 → bazaar_compute_node-0.1.16}/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.14 → bazaar_compute_node-0.1.16}/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,
@@ -112,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:
@@ -516,6 +522,28 @@ class Runtime(IRuntime, IAsyncLifecycle):
             return False
         return True
 
+    async def has_background_job(
+        self,
+        session: RuntimeSession,
+        *,
+        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:
+            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,12 +556,7 @@ 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)
+        await self._stop_connection(connection, timeout=timeout)
         return ProviderCallResult(
             status=ProviderCallStatus.CONFIRMED,
             value=session,

{bazaar_compute_node-0.1.14 → bazaar_compute_node-0.1.16}/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
 )
 
 
@@ -218,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]] = {}
@@ -291,7 +278,6 @@ class SessionOrchestrator(IAsyncLifecycle):
                 anchor_message=anchor_message,
                 context=context,
                 wake_id=str(uuid7()),
-                activity_at_ms=self._timer_wheel.now_ms,
             )
         )
 
@@ -348,42 +334,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 +352,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,
@@ -431,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,
                 )
@@ -520,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:
@@ -567,9 +547,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 +568,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 +597,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 +632,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 +658,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 +681,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 +719,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 +730,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 +1143,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)
@@ -1590,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
@@ -1638,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"
@@ -1654,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_
@@ -1670,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)

{bazaar_compute_node-0.1.14 → bazaar_compute_node-0.1.16}/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]: ...