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

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

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "bazaar-compute-node"
-version = "0.1.3"
+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.3 → 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.3 → 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.3 → bazaar_compute_node-0.1.5}/src/bazaar_compute_node/contrib/codex_app_server/events.py

@@ -4,7 +4,6 @@ import asyncio
 from collections.abc import Callable, Mapping
 from time import time_ns
 from typing import Self, cast
-from uuid import uuid7
 
 from ...core.approval import IApprovalHandler
 from ...core.models import (
@@ -21,12 +20,6 @@ from .approval import (
     parse_approval_request,
 )
 
-_DURABLE_ITEM_METHODS = {
-    "item/started",
-    "item/completed",
-    "item/autoApprovalReview/started",
-    "item/autoApprovalReview/completed",
-}
 _STREAM_EVENT_KINDS = {
     "item/agentMessage/delta": StreamEventKind.AGENT_MESSAGE_DELTA,
     "item/plan/delta": StreamEventKind.PLAN_DELTA,
@@ -56,8 +49,6 @@ class CodexTurnEventStream(IRuntimeTurnStream):
         self,
         supervisor: JsonlProcessSupervisor,
         *,
-        node_id: str,
-        runtime: str,
         session_id: str,
         runtime_session_id: str,
         turn_id: str,
@@ -71,8 +62,6 @@ class CodexTurnEventStream(IRuntimeTurnStream):
         on_closed: Callable[[], None] | None = None,
     ) -> None:
         self._supervisor = supervisor
-        self._node_id = node_id
-        self._runtime = runtime
         self._session_id = session_id
         self._runtime_session_id = runtime_session_id
         self._turn_id = turn_id
@@ -217,7 +206,6 @@ class CodexTurnEventStream(IRuntimeTurnStream):
             return self._event(
                 event_name="codex.turn.error",
                 state=RuntimeEventState.STARTED,
-                error_type=error.error_type,
                 error_message=error.message,
                 metadata=metadata,
             )
@@ -231,9 +219,14 @@ class CodexTurnEventStream(IRuntimeTurnStream):
             return None
         if method == "item/reasoning/summaryPartAdded":
             return None
-        if method == "turn/progress" or (
-            method.startswith("item/") and method not in _DURABLE_ITEM_METHODS
-        ):
+        if method in {
+            "item/started",
+            "item/completed",
+            "item/autoApprovalReview/started",
+            "item/autoApprovalReview/completed",
+        }:
+            return None
+        if method == "turn/progress" or method.startswith("item/"):
             stream_id = params.get("itemId")
             if not isinstance(stream_id, str) or not stream_id:
                 stream_id = None
@@ -255,15 +248,6 @@ class CodexTurnEventStream(IRuntimeTurnStream):
                 stream_id=stream_id,
                 content=content,
             )
-        if method == "turn/started" or method in _DURABLE_ITEM_METHODS:
-            metadata = self._provider_metadata(method, params)
-            if provider_turn_id is not None:
-                metadata["provider_turn_id"] = provider_turn_id
-            return self._event(
-                event_name="codex.turn.progress",
-                state=RuntimeEventState.STARTED,
-                metadata=metadata,
-            )
         return None
 
     def _event(
@@ -272,25 +256,16 @@ class CodexTurnEventStream(IRuntimeTurnStream):
         event_name: str,
         state: RuntimeEventState,
         error_kind: str | None = None,
-        error_type: str | None = None,
         error_message: str | None = None,
         metadata: Mapping[str, object] | None = None,
     ) -> RuntimeEvent:
         return RuntimeEvent(
-            event_seq=0,
-            event_id=str(uuid7()),
             created_at_ms=time_ns() // 1_000_000,
-            level="error" if error_kind else "info",
             event_name=event_name,
             state=state,
-            node_id=self._node_id,
-            bcn_session_id=self._session_id,
-            runtime_session_id=self._runtime_session_id,
             turn_id=self._turn_id,
             error_kind=error_kind,
-            error_type=error_type,
             error_message=error_message,
-            runtime=self._runtime,
             metadata=dict(metadata or {}),
         )
 

{bazaar_compute_node-0.1.3 → 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
@@ -327,8 +328,6 @@ class CodexAppServerRuntime(IRuntime, IAsyncLifecycle):
         connection.active_turn_id = turn.turn_id
         return CodexTurnEventStream(
             connection.supervisor,
-            node_id=self._context.node_id,
-            runtime=session.runtime,
             session_id=session.bcn_session_id,
             runtime_session_id=session.id,
             turn_id=turn.turn_id,
@@ -382,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.3 → bazaar_compute_node-0.1.5}/src/bazaar_compute_node/contrib/sqlite/codec.py

@@ -17,8 +17,6 @@ from ...core.models import (
     OutboundDeliveryState,
     OutboundMessage,
     RuntimeAttempt,
-    RuntimeEvent,
-    RuntimeEventState,
     RuntimeSession,
 )
 
@@ -214,40 +212,6 @@ def _outbound_message_from_row(row: aiosqlite.Row) -> OutboundMessage:
     )
 
 
-def _runtime_event_from_row(row: aiosqlite.Row) -> RuntimeEvent:
-    return RuntimeEvent(
-        event_seq=_required_non_negative_int(row["event_seq"], "event_seq"),
-        event_id=_required_text(row["event_id"], "event_id"),
-        created_at_ms=_required_non_negative_int(row["created_at_ms"], "created_at_ms"),
-        level=_required_text(row["level"], "level"),
-        event_name=_required_text(row["event_name"], "event_name"),
-        state=RuntimeEventState(_required_text(row["state"], "runtime_event.state")),
-        duration_ms=_optional_non_negative_int(row["duration_ms"], "duration_ms"),
-        node_id=_optional_text(row["node_id"], "node_id"),
-        channel=_optional_text(row["channel"], "channel"),
-        runtime=_optional_text(row["runtime"], "runtime"),
-        channel_session_id=_optional_text(
-            row["channel_session_id"], "channel_session_id"
-        ),
-        bcn_session_id=_optional_text(row["bcn_session_id"], "bcn_session_id"),
-        runtime_session_id=_optional_text(
-            row["runtime_session_id"], "runtime_session_id"
-        ),
-        turn_id=_optional_text(row["turn_id"], "turn_id"),
-        request_id=_optional_text(row["request_id"], "request_id"),
-        command_id=_optional_text(row["command_id"], "command_id"),
-        inbound_seq=_optional_non_negative_int(row["inbound_seq"], "inbound_seq"),
-        outbound_message_id=_optional_text(
-            row["outbound_message_id"], "outbound_message_id"
-        ),
-        error_kind=_optional_text(row["error_kind"], "error_kind"),
-        error_type=_optional_text(row["error_type"], "error_type"),
-        error_message=_optional_text(row["error_message"], "error_message"),
-        traceback_ref=_optional_text(row["traceback_ref"], "traceback_ref"),
-        metadata=_decode_metadata(row["metadata_json"], "metadata_json"),
-    )
-
-
 def _consumer_cursor_from_row(row: aiosqlite.Row) -> ConsumerCursor:
     return ConsumerCursor(
         session_id=_required_text(row["session_id"], "session_id"),
@@ -508,37 +472,6 @@ def _merge_timestamp(
     return incoming if incoming is not None else existing
 
 
-def _validate_runtime_event_input(event: RuntimeEvent) -> None:
-    if not isinstance(event, RuntimeEvent):
-        raise TypeError("event must be a RuntimeEvent")
-    if not isinstance(event.state, RuntimeEventState):
-        raise TypeError("runtime event state is invalid")
-    for value, field_name in (
-        (event.node_id, "node_id"),
-        (event.channel, "channel"),
-        (event.runtime, "runtime"),
-        (event.channel_session_id, "channel_session_id"),
-        (event.bcn_session_id, "bcn_session_id"),
-        (event.runtime_session_id, "runtime_session_id"),
-        (event.turn_id, "turn_id"),
-        (event.request_id, "request_id"),
-        (event.command_id, "command_id"),
-        (event.outbound_message_id, "outbound_message_id"),
-        (event.error_kind, "error_kind"),
-        (event.error_type, "error_type"),
-        (event.error_message, "error_message"),
-        (event.traceback_ref, "traceback_ref"),
-    ):
-        _validate_optional_input_text(value, field_name)
-
-
-def _same_runtime_event_payload(
-    existing: RuntimeEvent,
-    incoming: RuntimeEvent,
-) -> bool:
-    return replace(existing, event_seq=incoming.event_seq) == incoming
-
-
 def _validate_optional_input_text(value: object, field_name: str) -> None:
     if value is not None and (not isinstance(value, str) or not value):
         raise ValueError(f"{field_name} must be a non-empty string when present")

{bazaar_compute_node-0.1.3 → bazaar_compute_node-0.1.5}/src/bazaar_compute_node/contrib/sqlite/database.py

@@ -13,6 +13,7 @@ import aiosqlite
 from ...core.paths import resolve_data_dir
 from ...core.storage import NodeIdentity
 from .migrations import (
+    RUNTIME_EVENTS_REMOVAL_MIGRATION,
     MigrationChecksumError,
     MigrationError,
     apply_migrations,
@@ -117,6 +118,39 @@ class SqliteDatabase:
                             transaction,
                             clock=_current_time_ms,
                         )
+                    compaction_row: aiosqlite.Row | None = None
+                    async with SqliteTransaction(self) as transaction:
+                        compaction_row = await transaction.fetchone(
+                            "SELECT compaction_completed_at_ms "
+                            "FROM schema_migrations WHERE version = ?",
+                            (RUNTIME_EVENTS_REMOVAL_MIGRATION.version,),
+                        )
+                    if compaction_row is None:
+                        raise MigrationError(
+                            "runtime event removal migration is missing from ledger"
+                        )
+                    if compaction_row["compaction_completed_at_ms"] is None:
+                        async with self._transaction_lock:
+                            await connection.execute("VACUUM")
+                        async with SqliteTransaction(self) as transaction:
+                            await transaction.execute(
+                                "UPDATE schema_migrations "
+                                "SET compaction_completed_at_ms = ? WHERE version = ?",
+                                (
+                                    _current_time_ms(),
+                                    RUNTIME_EVENTS_REMOVAL_MIGRATION.version,
+                                ),
+                            )
+                    async with self._transaction_lock:
+                        checkpoint_cursor = await connection.execute(
+                            "PRAGMA wal_checkpoint(TRUNCATE)"
+                        )
+                        try:
+                            checkpoint_row = await checkpoint_cursor.fetchone()
+                        finally:
+                            await checkpoint_cursor.close()
+                    if checkpoint_row is None or checkpoint_row[0] != 0:
+                        raise MigrationError("SQLite WAL checkpoint could not complete")
             except BaseException:
                 self._connection = None
                 self._node_state = None

{bazaar_compute_node-0.1.3 → bazaar_compute_node-0.1.5}/src/bazaar_compute_node/contrib/sqlite/migrations.py

@@ -551,6 +551,20 @@ TRANSIENT_STREAM_EVENT_MIGRATION = Migration(
     ),
 )
 
+RUNTIME_EVENTS_REMOVAL_MIGRATION = Migration(
+    version=9,
+    name="remove_runtime_events",
+    statements=(
+        """
+        ALTER TABLE schema_migrations
+        ADD COLUMN compaction_completed_at_ms INTEGER
+        """,
+        """
+        DROP TABLE runtime_events
+        """,
+    ),
+)
+
 MIGRATIONS: tuple[Migration, ...] = (
     SCHEMA_MIGRATION,
     SESSION_MAPPING_INDEX_MIGRATION,
@@ -560,6 +574,7 @@ MIGRATIONS: tuple[Migration, ...] = (
     INBOUND_MESSAGE_REFERENCE_INTEGRITY_MIGRATION,
     INBOUND_PROVIDER_IDENTITY_MIGRATION,
     TRANSIENT_STREAM_EVENT_MIGRATION,
+    RUNTIME_EVENTS_REMOVAL_MIGRATION,
 )
 
 

{bazaar_compute_node-0.1.3 → bazaar_compute_node-0.1.5}/src/bazaar_compute_node/contrib/sqlite/repository.py

@@ -17,7 +17,6 @@ from ...core.models import (
     InboundMessage,
     OutboundMessage,
     RuntimeAttempt,
-    RuntimeEvent,
     RuntimeSession,
 )
 from .codec import (
@@ -31,9 +30,7 @@ from .codec import (
     _required_non_negative_int,
     _required_positive_int,
     _runtime_attempt_from_row,
-    _runtime_event_from_row,
     _runtime_session_from_row,
-    _same_runtime_event_payload,
     _validate_bcn_session_update,
     _validate_channel_session_input,
     _validate_channel_session_update,
@@ -47,7 +44,6 @@ from .codec import (
     _validate_outbound_message_input,
     _validate_outbound_update,
     _validate_positive_int,
-    _validate_runtime_event_input,
     _validate_runtime_session_update,
 )
 
@@ -664,212 +660,6 @@ class SqliteTransaction(AbstractAsyncContextManager["SqliteTransaction"]):
         )
         return canonical
 
-    async def append_runtime_event(self, event: RuntimeEvent) -> RuntimeEvent:
-        _validate_runtime_event_input(event)
-        existing_row = await self._fetch_one_or_conflict(
-            "SELECT event_seq, event_id, created_at_ms, level, event_name, state, "
-            "duration_ms, node_id, channel, runtime, "
-            "channel_session_id, bcn_session_id, runtime_session_id, "
-            "turn_id, request_id, command_id, inbound_seq, outbound_message_id, "
-            "error_kind, error_type, error_message, traceback_ref, metadata_json "
-            "FROM runtime_events WHERE event_id = ? ORDER BY event_seq",
-            (event.event_id,),
-            "runtime event identity",
-        )
-        if existing_row is not None:
-            existing = _runtime_event_from_row(existing_row)
-            if _same_runtime_event_payload(existing, event):
-                return existing
-            raise ValueError(
-                "runtime event id is already bound to different event content"
-            )
-
-        await self._validate_runtime_event_references(event)
-        sequence_row = await self.fetchone(
-            "SELECT COALESCE(MAX(event_seq), 0) + 1 AS next_event_seq "
-            "FROM runtime_events"
-        )
-        if sequence_row is None:
-            raise RuntimeError("SQLite runtime event sequence query returned no row")
-        next_event_seq = _required_positive_int(
-            sequence_row["next_event_seq"], "next_event_seq"
-        )
-        canonical = replace(event, event_seq=next_event_seq)
-        await self.execute(
-            "INSERT INTO runtime_events ("
-            "event_seq, event_id, created_at_ms, level, event_name, state, "
-            "duration_ms, node_id, channel, runtime, "
-            "channel_session_id, bcn_session_id, runtime_session_id, "
-            "turn_id, request_id, command_id, inbound_seq, outbound_message_id, "
-            "error_kind, error_type, error_message, traceback_ref, metadata_json"
-            ") VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
-            (
-                canonical.event_seq,
-                canonical.event_id,
-                canonical.created_at_ms,
-                canonical.level,
-                canonical.event_name,
-                canonical.state.value,
-                canonical.duration_ms,
-                canonical.node_id,
-                canonical.channel,
-                canonical.runtime,
-                canonical.channel_session_id,
-                canonical.bcn_session_id,
-                canonical.runtime_session_id,
-                canonical.turn_id,
-                canonical.request_id,
-                canonical.command_id,
-                canonical.inbound_seq,
-                canonical.outbound_message_id,
-                canonical.error_kind,
-                canonical.error_type,
-                canonical.error_message,
-                canonical.traceback_ref,
-                _encode_metadata(canonical.metadata),
-            ),
-        )
-        return canonical
-
-    async def _validate_runtime_event_references(self, event: RuntimeEvent) -> None:
-        channel_session = None
-        if event.channel_session_id is not None:
-            channel_session = await self.get_channel_session(event.channel_session_id)
-            if channel_session is None:
-                raise ValueError(f"unknown channel session: {event.channel_session_id}")
-            if event.channel is not None and event.channel != channel_session.channel:
-                raise ValueError("runtime event channel binding does not match")
-
-        bcn_session = None
-        if event.bcn_session_id is not None:
-            bcn_session = await self.get_bcn_session(event.bcn_session_id)
-            if bcn_session is None:
-                raise ValueError(f"unknown bcn session: {event.bcn_session_id}")
-            if (
-                event.channel_session_id is not None
-                and bcn_session.channel_session_id != event.channel_session_id
-            ):
-                raise ValueError("runtime event bcn/channel binding does not match")
-            if channel_session is None:
-                channel_session = await self.get_channel_session(
-                    bcn_session.channel_session_id
-                )
-            if (
-                event.channel is not None
-                and channel_session is not None
-                and event.channel != channel_session.channel
-            ):
-                raise ValueError("runtime event channel binding does not match")
-
-        runtime_session = None
-        if event.runtime_session_id is not None:
-            runtime_session = await self.get_runtime_session(event.runtime_session_id)
-            if runtime_session is None:
-                raise ValueError(f"unknown runtime session: {event.runtime_session_id}")
-            if (
-                event.bcn_session_id is not None
-                and runtime_session.bcn_session_id != event.bcn_session_id
-            ):
-                raise ValueError("runtime event runtime/bcn binding does not match")
-            if (
-                event.channel_session_id is not None
-                and runtime_session.channel_session_id != event.channel_session_id
-            ):
-                raise ValueError("runtime event runtime/channel binding does not match")
-            if event.runtime is not None and runtime_session.runtime != event.runtime:
-                raise ValueError("runtime event runtime name does not match")
-            if event.channel is not None:
-                runtime_channel = await self.get_channel_session(
-                    runtime_session.channel_session_id
-                )
-                if (
-                    runtime_channel is not None
-                    and runtime_channel.channel != event.channel
-                ):
-                    raise ValueError("runtime event channel binding does not match")
-
-        if event.turn_id is not None:
-            attempt = await self.get_runtime_attempt(event.turn_id)
-            if attempt is None:
-                raise ValueError(f"unknown runtime attempt: {event.turn_id}")
-            if (
-                event.runtime_session_id is not None
-                and attempt.session_id != event.runtime_session_id
-            ):
-                raise ValueError("runtime event attempt/runtime binding does not match")
-            if runtime_session is None:
-                runtime_session = await self.get_runtime_session(attempt.session_id)
-            if (
-                event.bcn_session_id is not None
-                and runtime_session is not None
-                and runtime_session.bcn_session_id != event.bcn_session_id
-            ):
-                raise ValueError("runtime event turn/bcn binding does not match")
-            if runtime_session is not None:
-                if (
-                    event.channel_session_id is not None
-                    and runtime_session.channel_session_id != event.channel_session_id
-                ):
-                    raise ValueError(
-                        "runtime event turn/channel binding does not match"
-                    )
-                if (
-                    event.runtime is not None
-                    and runtime_session.runtime != event.runtime
-                ):
-                    raise ValueError("runtime event turn/runtime name does not match")
-                if event.channel is not None:
-                    turn_channel = await self.get_channel_session(
-                        runtime_session.channel_session_id
-                    )
-                    if (
-                        turn_channel is not None
-                        and turn_channel.channel != event.channel
-                    ):
-                        raise ValueError(
-                            "runtime event turn/channel binding does not match"
-                        )
-
-        if event.outbound_message_id is not None:
-            outbound = await self.get_outbound_message(event.outbound_message_id)
-            if outbound is None:
-                raise ValueError(
-                    f"unknown outbound message: {event.outbound_message_id}"
-                )
-            if (
-                event.bcn_session_id is not None
-                and outbound.session_id != event.bcn_session_id
-            ):
-                raise ValueError("runtime event outbound/bcn binding does not match")
-            if (
-                event.channel_session_id is not None
-                and outbound.channel_session_id != event.channel_session_id
-            ):
-                raise ValueError(
-                    "runtime event outbound/channel binding does not match"
-                )
-            if event.channel is not None:
-                outbound_channel = await self.get_channel_session(
-                    outbound.channel_session_id
-                )
-                if (
-                    outbound_channel is not None
-                    and outbound_channel.channel != event.channel
-                ):
-                    raise ValueError(
-                        "runtime event outbound/channel binding does not match"
-                    )
-
-        if event.inbound_seq is not None and event.bcn_session_id is not None:
-            row = await self.fetchone(
-                "SELECT 1 FROM inbound_messages WHERE session_id = ? AND seq = ?",
-                (event.bcn_session_id, event.inbound_seq),
-            )
-            if row is None:
-                raise ValueError(
-                    f"unknown inbound sequence for bcn session: {event.inbound_seq}"
-                )
-
     async def save_channel_session(self, session: ChannelSession) -> None:
         _validate_channel_session_input(session)
         existing = await self.get_channel_session(session.id)

{bazaar_compute_node-0.1.3 → bazaar_compute_node-0.1.5}/src/bazaar_compute_node/core/models/entities.py

@@ -476,39 +476,23 @@ class StreamEvent:
 
 @dataclass(frozen=True, slots=True)
 class RuntimeEvent:
-    event_seq: int
-    event_id: str
     created_at_ms: int
-    level: str
     event_name: str
     state: RuntimeEventState
-    duration_ms: int | None = None
-    node_id: str | None = None
-    channel: str | None = None
-    channel_session_id: str | None = None
-    bcn_session_id: str | None = None
-    runtime_session_id: str | None = None
     turn_id: str | None = None
-    request_id: str | None = None
-    command_id: str | None = None
-    inbound_seq: int | None = None
-    outbound_message_id: str | None = None
     error_kind: str | None = None
-    error_type: str | None = None
     error_message: str | None = None
-    traceback_ref: str | None = None
-    runtime: str | None = None
     metadata: Metadata = field(default_factory=dict)
 
     def __post_init__(self) -> None:
-        _validate_non_negative(self.event_seq, "event_seq")
-        _validate_text(self.event_id, "event_id")
         _validate_non_negative(self.created_at_ms, "created_at_ms")
-        _validate_text(self.level, "level")
         _validate_text(self.event_name, "event_name")
+        if not isinstance(self.state, RuntimeEventState):
+            raise TypeError("state must be a RuntimeEventState")
         for value, field_name in (
-            (self.duration_ms, "duration_ms"),
-            (self.inbound_seq, "inbound_seq"),
+            (self.turn_id, "turn_id"),
+            (self.error_kind, "error_kind"),
+            (self.error_message, "error_message"),
         ):
             if value is not None:
-                _validate_non_negative(value, field_name)
+                _validate_text(value, field_name)

{bazaar_compute_node-0.1.3 → 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.3 → 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,
@@ -354,58 +406,56 @@ class SessionTurnCoordinator:
         if event.turn_id is not None and event.turn_id != turn.turn_id:
             raise ValueError("runtime event turn correlation mismatch")
         async with self._concurrency.for_session(message.session_id):
-            async with self._storage.transaction() as transaction:
-                event = await transaction.append_runtime_event(event)
-                agent_signal = _runtime_event_agent_signal(event)
-                if not _is_turn_event(event.event_name):
-                    target_state = turn.state
-                elif event.state is RuntimeEventState.STARTED:
-                    target_state = RuntimeTurnState.RUNNING
-                elif event.state is RuntimeEventState.COMPLETED:
-                    target_state = RuntimeTurnState.COMPLETED
-                elif event.state is RuntimeEventState.FAILED:
-                    target_state = RuntimeTurnState.FAILED
-                elif event.state is RuntimeEventState.CANCELLED:
-                    target_state = RuntimeTurnState.CANCELLED
-                else:
-                    target_state = RuntimeTurnState.UNKNOWN
-                provider_turn_id = event.metadata.get("provider_turn_id")
-                if provider_turn_id is not None and (
-                    not isinstance(provider_turn_id, str) or not provider_turn_id
-                ):
-                    raise ValueError("runtime event provider_turn_id is invalid")
-                if (
-                    provider_turn_id is not None
-                    and turn.provider_turn_id is not None
-                    and turn.provider_turn_id != provider_turn_id
-                ):
-                    raise ValueError("runtime event provider turn correlation mismatch")
-                error_kind = event.error_kind
-                if event.state is RuntimeEventState.FAILED and error_kind is None:
-                    error_kind = ErrorKind.PROVIDER_FAILED.value
-                if event.state is RuntimeEventState.UNKNOWN and error_kind is None:
-                    error_kind = ErrorKind.PROVIDER_UNKNOWN.value
-                if event.state is RuntimeEventState.CANCELLED and error_kind is None:
-                    error_kind = ErrorKind.CANCELLED.value
-                updated_turn = turn.transition_to(
-                    target_state,
-                    at_ms=event.created_at_ms,
-                    error_kind=error_kind,
-                    error_message=event.error_message,
-                    latest_event_name=event.event_name,
-                )
-                if provider_turn_id is not None:
-                    updated_turn = replace(
-                        updated_turn,
-                        provider_turn_id=provider_turn_id,
-                    )
-                agent_tick = AgentTick(
-                    source=AgentTickSource.RUNTIME,
-                    signal=agent_signal,
-                    observed_at_ms=self._clock(),
-                    error_kind=error_kind,
-                    error_message=event.error_message,
+            agent_signal = _runtime_event_agent_signal(event)
+            if not _is_turn_event(event.event_name):
+                target_state = turn.state
+            elif event.state is RuntimeEventState.STARTED:
+                target_state = RuntimeTurnState.RUNNING
+            elif event.state is RuntimeEventState.COMPLETED:
+                target_state = RuntimeTurnState.COMPLETED
+            elif event.state is RuntimeEventState.FAILED:
+                target_state = RuntimeTurnState.FAILED
+            elif event.state is RuntimeEventState.CANCELLED:
+                target_state = RuntimeTurnState.CANCELLED
+            else:
+                target_state = RuntimeTurnState.UNKNOWN
+            provider_turn_id = event.metadata.get("provider_turn_id")
+            if provider_turn_id is not None and (
+                not isinstance(provider_turn_id, str) or not provider_turn_id
+            ):
+                raise ValueError("runtime event provider_turn_id is invalid")
+            if (
+                provider_turn_id is not None
+                and turn.provider_turn_id is not None
+                and turn.provider_turn_id != provider_turn_id
+            ):
+                raise ValueError("runtime event provider turn correlation mismatch")
+            error_kind = event.error_kind
+            if event.state is RuntimeEventState.FAILED and error_kind is None:
+                error_kind = ErrorKind.PROVIDER_FAILED.value
+            if event.state is RuntimeEventState.UNKNOWN and error_kind is None:
+                error_kind = ErrorKind.PROVIDER_UNKNOWN.value
+            if event.state is RuntimeEventState.CANCELLED and error_kind is None:
+                error_kind = ErrorKind.CANCELLED.value
+            updated_turn = turn.transition_to(
+                target_state,
+                at_ms=event.created_at_ms,
+                error_kind=error_kind,
+                error_message=event.error_message,
+                latest_event_name=event.event_name,
+            )
+            if provider_turn_id is not None:
+                updated_turn = replace(
+                    updated_turn,
+                    provider_turn_id=provider_turn_id,
                 )
+            agent_tick = AgentTick(
+                source=AgentTickSource.RUNTIME,
+                signal=agent_signal,
+                observed_at_ms=self._clock(),
+                error_kind=error_kind,
+                error_message=event.error_message,
+            )
             if _is_terminal_turn_event(event):
                 self._turns.pop(turn.turn_id, None)
             else:

{bazaar_compute_node-0.1.3 → 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,

{bazaar_compute_node-0.1.3 → bazaar_compute_node-0.1.5}/src/bazaar_compute_node/core/storage.py

@@ -12,7 +12,6 @@ from .models import (
     InboundMessage,
     OutboundMessage,
     RuntimeAttempt,
-    RuntimeEvent,
     RuntimeSession,
 )
 
@@ -140,10 +139,6 @@ class IStorageTransaction(Protocol):
         """Persist a draft or delivery transition and return its canonical row."""
         ...
 
-    async def append_runtime_event(self, event: RuntimeEvent) -> RuntimeEvent:
-        """Append an operational event and return its canonical local sequence."""
-        ...
-
 
 class IStorage(IAsyncLifecycle, Protocol):
     """Provider-neutral storage lifecycle and explicit transaction factory."""