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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bazaar-compute-node
-Version: 0.1.15
+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.15 → bazaar_compute_node-0.1.16}/pyproject.toml

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

@@ -1,6 +1,6 @@
 [project]
 name = "bazaar-compute-node"
-version = "0.1.15"
+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.15 → bazaar_compute_node-0.1.16}/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.16}/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)