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

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

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

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

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

@@ -327,8 +327,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,

{bazaar_compute_node-0.1.3 → bazaar_compute_node-0.1.4}/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.4}/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.4}/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.4}/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.4}/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.4}/src/bazaar_compute_node/core/orchestration/turn.py

@@ -354,58 +354,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.4}/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."""