bazaar-compute-node 0.1.4__tar.gz → 0.1.5__tar.gz

{bazaar_compute_node-0.1.4 → bazaar_compute_node-0.1.5}/PKG-INFO

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

{bazaar_compute_node-0.1.4 → bazaar_compute_node-0.1.5}/pyproject.toml

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

{bazaar_compute_node-0.1.4 → bazaar_compute_node-0.1.5}/pyproject.toml.orig

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

{bazaar_compute_node-0.1.4 → bazaar_compute_node-0.1.5}/src/bazaar_compute_node/contrib/codex_app_server/__init__.py

@@ -11,10 +11,12 @@ from .client import (
     build_thread_start_params,
     build_turn_interrupt_params,
     build_turn_start_params,
+    build_turn_steer_params,
     parse_error_notification,
     parse_thread_response,
     parse_turn_notification,
     parse_turn_response,
+    parse_turn_steer_response,
 )
 from .events import CodexTurnEventStream
 from .process import (
@@ -56,8 +58,10 @@ __all__ = [
     "build_thread_start_params",
     "build_turn_interrupt_params",
     "build_turn_start_params",
+    "build_turn_steer_params",
     "parse_error_notification",
     "parse_thread_response",
     "parse_turn_notification",
     "parse_turn_response",
+    "parse_turn_steer_response",
 ]

{bazaar_compute_node-0.1.4 → bazaar_compute_node-0.1.5}/src/bazaar_compute_node/contrib/codex_app_server/client.py

@@ -153,6 +153,21 @@ def build_turn_interrupt_params(thread_id: str, turn_id: str) -> dict[str, objec
     return {"threadId": thread_id, "turnId": turn_id}
 
 
+def build_turn_steer_params(
+    thread_id: str,
+    turn_id: str,
+    input_text: str,
+) -> dict[str, object]:
+    _validate_non_empty_string("thread_id", thread_id)
+    _validate_non_empty_string("turn_id", turn_id)
+    _validate_non_empty_string("input_text", input_text)
+    return {
+        "threadId": thread_id,
+        "expectedTurnId": turn_id,
+        "input": [{"type": "text", "text": input_text}],
+    }
+
+
 class CodexAppServerClient:
     """Typed facade over the adapter-local Codex JSONL supervisor."""
 
@@ -270,6 +285,20 @@ class CodexAppServerClient:
             timeout=timeout,
         )
 
+    async def steer_turn(
+        self,
+        thread_id: str,
+        turn_id: str,
+        input_text: str,
+        *,
+        timeout: float,
+    ) -> JsonlMessage:
+        return await self.supervisor.request(
+            "turn/steer",
+            build_turn_steer_params(thread_id, turn_id, input_text),
+            timeout=timeout,
+        )
+
     async def receive(self, *, timeout: float | None = None) -> JsonlMessage:
         return await self.supervisor.receive(timeout=timeout)
 
@@ -290,6 +319,11 @@ def parse_turn_response(response: Mapping[str, object]) -> CodexTurnInfo:
     return _parse_turn(_require_mapping(result, "turn"))
 
 
+def parse_turn_steer_response(response: Mapping[str, object]) -> str:
+    result = _require_mapping(response, "result")
+    return _require_text(result, "turnId", "result.turnId")
+
+
 def parse_turn_notification(message: Mapping[str, object]) -> tuple[str, CodexTurnInfo]:
     params = _require_mapping(message, "params")
     thread_id = _require_text(params, "threadId", "params.threadId")

{bazaar_compute_node-0.1.4 → bazaar_compute_node-0.1.5}/src/bazaar_compute_node/contrib/codex_app_server/runtime.py

@@ -30,6 +30,7 @@ from .client import (
     CodexAppServerClient,
     parse_thread_response,
     parse_turn_response,
+    parse_turn_steer_response,
 )
 from .events import CodexTurnEventStream
 from .process import JsonlProcessSpec, JsonlProcessSupervisor
@@ -380,6 +381,56 @@ class CodexAppServerRuntime(IRuntime, IAsyncLifecycle):
             },
         )
 
+    async def steer_turn(
+        self,
+        session: RuntimeSession,
+        turn: RuntimeTurn,
+        input_text: str,
+        *,
+        timeout: float,
+    ) -> bool:
+        self._ensure_started()
+        connection = self._connections.get(session.id)
+        provider_turn_id = turn.provider_turn_id
+        if (
+            connection is None
+            or not connection.supervisor.is_running
+            or connection.active_turn_id != turn.turn_id
+            or provider_turn_id is None
+        ):
+            return False
+        try:
+            response = await connection.client.steer_turn(
+                connection.provider_thread_id,
+                provider_turn_id,
+                input_text,
+                timeout=timeout,
+            )
+            accepted_turn_id = parse_turn_steer_response(response)
+            if accepted_turn_id != provider_turn_id:
+                raise CodexAppServerProtocolError(
+                    "turn/steer returned a different provider turn"
+                )
+        except asyncio.CancelledError:
+            raise
+        except Exception as error:  # noqa: BLE001
+            self._logger.warning(
+                "%s",
+                json.dumps(
+                    {
+                        "event_name": "runtime.turn.steer.not_accepted",
+                        "metadata": {
+                            "error_type": type(error).__name__,
+                            "session_id": session.bcn_session_id,
+                        },
+                    },
+                    separators=(",", ":"),
+                    sort_keys=True,
+                ),
+            )
+            return False
+        return True
+
     async def stop_session(
         self, session: RuntimeSession, *, timeout: float
     ) -> ProviderCallResult[RuntimeSession]:

{bazaar_compute_node-0.1.4 → bazaar_compute_node-0.1.5}/src/bazaar_compute_node/core/orchestration/session.py

@@ -332,29 +332,132 @@ class SessionOrchestrator(IAsyncLifecycle):
         self,
         queue: asyncio.Queue[_RuntimeNotification],
     ) -> None:
+        pending: list[_RuntimeNotification] = []
         while True:
-            batch = [await queue.get()]
+            if pending:
+                batch = pending
+                pending = []
+            else:
+                batch = [await queue.get()]
             while True:
                 try:
                     batch.append(queue.get_nowait())
                 except asyncio.QueueEmpty:
                     break
+            turn_task = asyncio.create_task(
+                self._run_notification(batch[0]),
+                name=f"bcn-turn-{batch[0].context.bcn_session.id}",
+            )
+            queue_task = asyncio.create_task(queue.get())
+            queue_notification_consumed = False
             try:
-                result = await self._run_notification(batch[0])
+                while True:
+                    notification: _RuntimeNotification | None = None
+                    done, _ = await asyncio.wait(
+                        (turn_task, queue_task),
+                        return_when=asyncio.FIRST_COMPLETED,
+                    )
+                    if queue_task in done:
+                        notification = queue_task.result()
+                        pending.append(notification)
+                        queue_notification_consumed = True
+                        while True:
+                            try:
+                                pending.append(queue.get_nowait())
+                            except asyncio.QueueEmpty:
+                                break
+                    if turn_task in done:
+                        break
+
+                    async with self._storage.transaction() as transaction:
+                        runtime_session = await transaction.find_runtime_session(
+                            batch[0].context.bcn_session.id
+                        )
+                        cursor = await transaction.get_consumer_cursor(
+                            batch[0].context.bcn_session.id
+                        )
+                        delivered_through_seq = (
+                            cursor.delivered_through_seq if cursor is not None else 0
+                        )
+                        unread = await transaction.list_inbound_messages(
+                            batch[0].context.bcn_session.id,
+                            after_seq=delivered_through_seq,
+                            notifying_only=True,
+                        )
+
+                    active_turn = next(
+                        (
+                            turn
+                            for turn in self._runtime_turns.values()
+                            if turn.session_id == batch[0].context.runtime_session.id
+                            and turn.state is RuntimeTurnState.RUNNING
+                            and turn.provider_turn_id is not None
+                        ),
+                        None,
+                    )
+                    if (
+                        runtime_session is not None
+                        and unread
+                        and active_turn is not None
+                        and notification is not None
+                    ):
+                        context = SessionContext(
+                            batch[0].context.channel_session,
+                            batch[0].context.bcn_session,
+                            runtime_session,
+                        )
+                        await self._turns.steer_turn(
+                            notification.message,
+                            context,
+                            active_turn,
+                            unread_count=len(unread),
+                        )
+                    queue_task = asyncio.create_task(queue.get())
+                    queue_notification_consumed = False
+
+                result = turn_task.result()
                 for notification in batch:
                     if not notification.completion.done():
                         notification.completion.set_result(result)
             except asyncio.CancelledError:
-                for notification in batch:
+                turn_task.cancel()
+                queue_task.cancel()
+                await asyncio.gather(
+                    turn_task,
+                    queue_task,
+                    return_exceptions=True,
+                )
+                if (
+                    not queue_notification_consumed
+                    and not queue_task.cancelled()
+                    and queue_task.exception() is None
+                ):
+                    pending.append(queue_task.result())
+                    queue_notification_consumed = True
+                for notification in (*batch, *pending):
                     if not notification.completion.done():
                         notification.completion.cancel()
+                for _ in range(len(pending)):
+                    queue.task_done()
+                pending.clear()
                 raise
             except Exception as error:  # noqa: BLE001
+                turn_task.cancel()
+                await asyncio.gather(turn_task, return_exceptions=True)
                 for notification in batch:
                     if not notification.completion.done():
                         notification.completion.set_exception(error)
             finally:
-                for _notification in batch:
+                if not queue_task.done():
+                    queue_task.cancel()
+                try:
+                    notification = await queue_task
+                except asyncio.CancelledError:
+                    pass
+                else:
+                    if not queue_notification_consumed:
+                        pending.append(notification)
+                for _ in range(len(batch)):
                     queue.task_done()
 
     async def _receive_loop(self) -> None:

{bazaar_compute_node-0.1.4 → bazaar_compute_node-0.1.5}/src/bazaar_compute_node/core/orchestration/turn.py

@@ -81,6 +81,14 @@ def _is_terminal_turn_event(event: RuntimeEvent) -> bool:
     }
 
 
+def inbox_notice(session_id: str, unread_count: int) -> str:
+    return (
+        f"[inbox notice session={session_id}]\n"
+        f"Inbox update: {unread_count} unread message(s). "
+        "Use the message command to read them."
+    )
+
+
 @dataclass(frozen=True, slots=True)
 class SessionContext:
     channel_session: ChannelSession
@@ -211,9 +219,7 @@ class SessionTurnCoordinator:
                 stream = await self._runtime.start_turn(
                     context.runtime_session,
                     turn,
-                    f"[inbox notice session={context.bcn_session.id}]\n"
-                    f"Inbox update: {unread_count} unread message(s). "
-                    "Use the message command to read them.",
+                    inbox_notice(context.bcn_session.id, unread_count),
                     approval_handler,
                     timeout=self._timeout_budget.provider_call_seconds,
                 )
@@ -284,6 +290,52 @@ class SessionTurnCoordinator:
         finally:
             await self._close_stream(stream)
 
+    async def steer_turn(
+        self,
+        message: InboundMessage,
+        context: SessionContext,
+        turn: RuntimeTurn,
+        *,
+        unread_count: int,
+    ) -> None:
+        try:
+            accepted = await self._runtime.steer_turn(
+                context.runtime_session,
+                turn,
+                inbox_notice(context.bcn_session.id, unread_count),
+                timeout=self._timeout_budget.provider_call_seconds,
+            )
+        except asyncio.CancelledError:
+            raise
+        except Exception as error:  # noqa: BLE001
+            self._logger.warning(
+                "runtime turn steer failed",
+                extra={
+                    "error_type": type(error).__name__,
+                    "session_id": context.bcn_session.id,
+                    "turn_id": turn.turn_id,
+                },
+            )
+            accepted = False
+        try:
+            await self._audit.append(
+                event_name=(
+                    "runtime.request.turn.steer.accepted"
+                    if accepted
+                    else "runtime.request.turn.steer.not_accepted"
+                ),
+                state=RuntimeEventState.COMPLETED,
+                correlation=self.turn_correlation(message, context, turn),
+                metadata={
+                    "provider_method": "turn/steer",
+                    "unread_count": unread_count,
+                },
+            )
+        except asyncio.CancelledError:
+            raise
+        except Exception:
+            self._logger.exception("runtime turn steer audit failed")
+
     async def finish_turn(
         self,
         turn: RuntimeTurn,

{bazaar_compute_node-0.1.4 → bazaar_compute_node-0.1.5}/src/bazaar_compute_node/core/runtime.py

@@ -101,6 +101,22 @@ class IRuntime(IAsyncLifecycle, Protocol):
         """
         ...
 
+    async def steer_turn(
+        self,
+        session: RuntimeSession,
+        turn: RuntimeTurn,
+        input_text: str,
+        *,
+        timeout: float,
+    ) -> bool:
+        """Append input to the active turn when the runtime supports steering.
+
+        Return true only when the runtime confirms that the active turn accepted
+        the input. Unsupported or unconfirmed steering returns false without
+        changing the turn lifecycle.
+        """
+        ...
+
     async def interrupt_turn(
         self,
         session: RuntimeSession,