bazaar-compute-node 0.1.22__tar.gz → 0.1.23__tar.gz

{bazaar_compute_node-0.1.22 → bazaar_compute_node-0.1.23}/PKG-INFO

@@ -1,12 +1,13 @@
 Metadata-Version: 2.4
 Name: bazaar-compute-node
-Version: 0.1.22
+Version: 0.1.23
 Summary: Runtime-agnostic computer node daemon for agents and channels.
 License-Expression: AGPL-3.0-only
 License-File: LICENSE
 Requires-Dist: aiohttp>=3.12.0
 Requires-Dist: aiosqlite>=0.20.0
 Requires-Dist: cryptography>=45.0.0
+Requires-Dist: pydantic>=2.0.0
 Requires-Dist: protobug==1.0.0
 Requires-Dist: tzdata>=2024.1 ; sys_platform == 'win32'
 Requires-Python: >=3.14

{bazaar_compute_node-0.1.22 → bazaar_compute_node-0.1.23}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "bazaar-compute-node"
-version = "0.1.22"
+version = "0.1.23"
 description = "Runtime-agnostic computer node daemon for agents and channels."
 readme = "README.md"
 license = "AGPL-3.0-only"
@@ -10,6 +10,7 @@ dependencies = [
     "aiohttp>=3.12.0",
     "aiosqlite>=0.20.0",
     "cryptography>=45.0.0",
+    "pydantic>=2.0.0",
     "protobug==1.0.0",
     "tzdata>=2024.1; sys_platform == 'win32'",
 ]

{bazaar_compute_node-0.1.22 → bazaar_compute_node-0.1.23}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "bazaar-compute-node"
-version = "0.1.22"
+version = "0.1.23"
 description = "Runtime-agnostic computer node daemon for agents and channels."
 readme = "README.md"
 license = "AGPL-3.0-only"
@@ -10,6 +10,7 @@ dependencies = [
     "aiohttp>=3.12.0",
     "aiosqlite>=0.20.0",
     "cryptography>=45.0.0",
+    "pydantic>=2.0.0",
     "protobug==1.0.0",
     "tzdata>=2024.1; sys_platform == 'win32'",
 ]

{bazaar_compute_node-0.1.22 → bazaar_compute_node-0.1.23}/src/bazaar_compute_node/app/agent.py

@@ -10,6 +10,8 @@ import secrets
 from collections.abc import Callable, Mapping, Sequence
 from dataclasses import dataclass
 from pathlib import Path
+from time import time_ns
+from typing import cast
 
 from ..core.channel import AgentScopedChannel, ChannelContext, IChannel
 from ..core.concurrency import ISessionConcurrency, SessionLockRegistry
@@ -17,17 +19,19 @@ from ..core.lifecycle import TimeoutBudget
 from ..core.models import RuntimeSession
 from ..core.observability import IAudit
 from ..core.orchestration import SessionOrchestrator
+from ..core.orchestration.handoff_command import HandoffCommandService
 from ..core.orchestration.reminder_command import ReminderCommandService
+from ..core.orchestration.services import SessionAuditRecorder
 from ..core.paths import resolve_workspace_dir
 from ..core.runtime import IRuntime, RuntimeCommandContext
-from ..core.storage import IStorageScope
+from ..core.storage import IHandoffStorageScope, IStorageScope
 from ..core.timerwheel import TimerWheel
 from ..i18n import Translator
 from .attachments import AttachmentMaterializer
 from .command import CommandDispatchError
 from .config import AgentConfiguration
 from .registry import AgentAdapterFactories
-from .reminder_dispatch import CommandDispatcher
+from .resource_dispatch import CommandDispatcher
 from .wrapper import install_bcc_wrapper, remove_bcc_wrapper
 
 CommandRecord = tuple[str, tuple[str, ...]]
@@ -78,6 +82,7 @@ class AgentApplication:
         self.agent_id = configuration.id
         self.name = configuration.name
         self.storage = storage
+        self._handoff_storage = cast(IHandoffStorageScope, storage)
         self.audit = audit
         self.timer_wheel = timer_wheel
         self.timeout_budget = timeout_budget
@@ -147,6 +152,7 @@ class AgentApplication:
             channel=self.channel,
             runtime=self.runtime,
             storage=self.storage,
+            handoff_storage=self._handoff_storage,
             audit=self.audit,
             timeout_budget=self.timeout_budget,
             timer_wheel=self.timer_wheel,
@@ -161,6 +167,16 @@ class AgentApplication:
             concurrency=reminder_concurrency,
             poke=reminder_poke,
         )
+        self.handoff_service = HandoffCommandService(
+            storage=self._handoff_storage,
+            audit=SessionAuditRecorder(
+                sink=self.audit,
+                timeout_budget=self.timeout_budget,
+                clock=lambda: time_ns() // 1_000_000,
+            ),
+            publish_wake=self.publish_handoff_wake,
+            node_id=lambda: self.agent_id,
+        )
         self._provider_control_handler = (
             factories.control(self._adapter_context())
             if factories.control is not None
@@ -169,6 +185,7 @@ class AgentApplication:
         self.command_dispatcher = CommandDispatcher(
             self.orchestrator.command_service,
             reminder_service=self.reminder_service,
+            handoff_service=self.handoff_service,
             timeout_budget=self.timeout_budget,
             control_handler=(
                 self._handle_control
@@ -270,6 +287,11 @@ class AgentApplication:
             raise RuntimeError("Agent application is not started")
         await self.orchestrator.publish_reminder_wake(session_id)
 
+    async def publish_handoff_wake(self, session_id: str) -> None:
+        if not self._started:
+            raise RuntimeError("Agent application is not started")
+        await self.orchestrator.publish_handoff_wake(session_id)
+
     def health_record(self) -> dict[str, object]:
         return {
             "agent_id": self.agent_id,

{bazaar_compute_node-0.1.22 → bazaar_compute_node-0.1.23}/src/bazaar_compute_node/app/command.py

@@ -4,13 +4,18 @@ import asyncio
 from collections.abc import Awaitable, Callable, Mapping
 from datetime import UTC, datetime
 from time import time_ns
+from typing import Annotated, Literal, cast
+
+from pydantic import BaseModel, ConfigDict, Field, StrictInt, StrictStr, ValidationError
 
 from ..core.command import (
     ICommandService,
+    InboxListResult,
+    MessageSendHandoffRequired,
     SessionNotFoundError,
 )
 from ..core.lifecycle import TimeoutBudget
-from ..core.models import InboundMessage, OutboundMessage
+from ..core.models import InboundMessage, InboxTargetSummary, OutboundMessage
 
 
 def serialize_inbound(message: InboundMessage) -> dict[str, object]:
@@ -84,6 +89,38 @@ def serialize_outbound(message: OutboundMessage) -> dict[str, object]:
     }
 
 
+def serialize_inbox_target(summary: InboxTargetSummary) -> dict[str, object]:
+    sender = summary.latest_sender
+    latest_time_ms = (
+        summary.latest_provider_time_ms
+        if summary.latest_provider_time_ms is not None
+        else summary.latest_received_at_ms
+    )
+    return {
+        "target": summary.target,
+        "session_id": summary.session_id,
+        "target_kind": summary.target_kind.value,
+        "current": summary.current,
+        "pending_count": summary.pending_count,
+        "last_activity_at_ms": summary.last_activity_at_ms,
+        "latest_message_id": summary.latest_message_id,
+        "latest_sender": (
+            None if sender is None else {"id": sender.id, "name": sender.name}
+        ),
+        "latest_time_ms": latest_time_ms,
+    }
+
+
+def serialize_inbox_list(result: InboxListResult) -> dict[str, object]:
+    return {
+        "targets": [serialize_inbox_target(target) for target in result.targets],
+        "total": result.total,
+        "shown": result.shown,
+        "offset": result.offset,
+        "has_more": result.has_more,
+    }
+
+
 class CommandDispatchError(ValueError):
     def __init__(
         self,
@@ -100,6 +137,125 @@ class CommandDispatchError(ValueError):
         self.next_action = next_action
 
 
+NonEmptyText = Annotated[StrictStr, Field(min_length=1)]
+PositiveInt = Annotated[StrictInt, Field(gt=0)]
+NonNegativeInt = Annotated[StrictInt, Field(ge=0)]
+
+
+class _CommandRequest(BaseModel):
+    model_config = ConfigDict(extra="ignore", strict=True)
+
+    kind: Literal["command"]
+    resource: StrictStr
+    command: StrictStr
+    session_id: NonEmptyText
+
+
+class _MessageCheckRequest(_CommandRequest):
+    resource: Literal["message"]
+    command: Literal["check"]
+
+
+class _MessageReadRequest(_CommandRequest):
+    resource: Literal["message"]
+    command: Literal["read"]
+    target: NonEmptyText
+    around_message_id: StrictStr | None = None
+    limit: PositiveInt = 100
+
+
+class _MessageSendRequest(_CommandRequest):
+    resource: Literal["message"]
+    command: Literal["send"]
+    target: NonEmptyText
+    body: StrictStr
+    command_id: NonEmptyText
+    attachment_paths: list[NonEmptyText] = Field(default_factory=list)
+    reply_to_message_id: NonEmptyText | None = None
+    created_at_ms: NonNegativeInt = Field(
+        default_factory=lambda: time_ns() // 1_000_000
+    )
+
+
+class _InboxListRequest(_CommandRequest):
+    resource: Literal["inbox"]
+    command: Literal["list"]
+    limit: PositiveInt = 100
+    offset: NonNegativeInt = 0
+
+
+class _ThreadUnfollowRequest(_CommandRequest):
+    resource: Literal["thread"]
+    command: Literal["unfollow"]
+    target: NonEmptyText
+
+
+_RequestModel = type[_CommandRequest]
+
+_REQUEST_MODELS: dict[tuple[str, str], _RequestModel] = {
+    ("message", "check"): _MessageCheckRequest,
+    ("message", "read"): _MessageReadRequest,
+    ("message", "send"): _MessageSendRequest,
+    ("inbox", "list"): _InboxListRequest,
+    ("thread", "unfollow"): _ThreadUnfollowRequest,
+}
+
+_REQUEST_ERRORS: dict[str, tuple[str, str]] = {
+    "session_id": ("SESSION_REQUIRED", "session_id must be a non-empty string"),
+    "limit": ("INVALID_LIMIT", "limit must be a positive integer"),
+    "offset": ("INVALID_OFFSET", "offset must be a non-negative integer"),
+    "target": ("TARGET_REQUIRED", "target must be a non-empty string"),
+    "around_message_id": (
+        "INVALID_AROUND_MESSAGE",
+        "around_message_id must be a string",
+    ),
+    "body": ("BODY_REQUIRED", "body must be text"),
+    "command_id": (
+        "COMMAND_ID_REQUIRED",
+        "command_id must be a non-empty string",
+    ),
+    "attachment_paths": (
+        "INVALID_ATTACHMENTS",
+        "attachment_paths must be a list of non-empty strings",
+    ),
+    "reply_to_message_id": (
+        "INVALID_REPLY_TO",
+        "reply_to_message_id must be a non-empty string",
+    ),
+    "created_at_ms": (
+        "INVALID_CREATED_AT",
+        "created_at_ms must be non-negative",
+    ),
+}
+
+
+def _parse_command_request[RequestT: _CommandRequest](
+    request: Mapping[str, object],
+    model: type[RequestT],
+    *,
+    errors: Mapping[str, tuple[str, str]] | None = None,
+) -> RequestT:
+    try:
+        return model.model_validate(request)
+    except ValidationError as error:
+        field_name = next(
+            (
+                part
+                for part in error.errors()[0].get("loc", ())
+                if isinstance(part, str)
+            ),
+            "request",
+        )
+        error_map = dict(_REQUEST_ERRORS)
+        if errors is not None:
+            error_map.update(errors)
+        code, message = error_map.get(
+            field_name,
+            ("INVALID_COMMAND", "command request is invalid"),
+        )
+        raise CommandDispatchError(code, message) from error
+
+
 ControlHandler = Callable[[Mapping[str, object]], Awaitable[Mapping[str, object]]]
 SessionBindingValidator = Callable[[str, Mapping[str, object]], Awaitable[None]]
 
@@ -225,14 +381,14 @@ class CommandDispatcher:
                     self._drained.set()
 
     async def _dispatch_command(
-        self, request: Mapping[str, object]
+        self, raw_request: Mapping[str, object]
     ) -> Mapping[str, object]:
-        resource = request.get("resource")
+        resource = raw_request.get("resource")
         if not isinstance(resource, str) or not resource:
             raise CommandDispatchError(
                 "RESOURCE_REQUIRED", "resource must be a non-empty string"
             )
-        command = request.get("command")
+        command = raw_request.get("command")
         if not isinstance(command, str) or not command:
             raise CommandDispatchError(
                 "COMMAND_REQUIRED", "command must be a non-empty string"
@@ -242,6 +398,11 @@ class CommandDispatcher:
                 raise CommandDispatchError(
                     "UNKNOWN_COMMAND", f"unsupported message command: {command}"
                 )
+        elif resource == "inbox":
+            if command != "list":
+                raise CommandDispatchError(
+                    "UNKNOWN_COMMAND", f"unsupported inbox command: {command}"
+                )
         elif resource == "thread":
             if command != "unfollow":
                 raise CommandDispatchError(
@@ -252,13 +413,12 @@ class CommandDispatcher:
                 "UNKNOWN_RESOURCE", f"unsupported command resource: {resource}"
             )
 
-        session_id = request.get("session_id")
-        if not isinstance(session_id, str) or not session_id:
-            raise CommandDispatchError(
-                "SESSION_REQUIRED", "session_id must be a non-empty string"
-            )
+        request = _parse_command_request(
+            raw_request, _REQUEST_MODELS[(resource, command)]
+        )
+        session_id = request.session_id
         if self._session_binding_validator is not None:
-            await self._session_binding_validator(session_id, request)
+            await self._session_binding_validator(session_id, raw_request)
 
         if resource == "message" and command == "check":
             result = await self._service.check(session_id)
@@ -277,27 +437,22 @@ class CommandDispatcher:
                 },
             }
 
+        if resource == "inbox" and command == "list":
+            request = cast(_InboxListRequest, request)
+            result = await self._service.list_inbox(
+                session_id,
+                limit=request.limit,
+                offset=request.offset,
+            )
+            return {"ok": True, "result": serialize_inbox_list(result)}
+
         if resource == "message" and command == "read":
-            target = request.get("target")
-            if not isinstance(target, str) or not target:
-                raise CommandDispatchError(
-                    "TARGET_REQUIRED", "target must be a non-empty string"
-                )
-            around_message_id = request.get("around_message_id")
-            if around_message_id is not None and not isinstance(around_message_id, str):
-                raise CommandDispatchError(
-                    "INVALID_AROUND_MESSAGE", "around_message_id must be a string"
-                )
-            limit = request.get("limit", 100)
-            if isinstance(limit, bool) or not isinstance(limit, int) or limit <= 0:
-                raise CommandDispatchError(
-                    "INVALID_LIMIT", "limit must be a positive integer"
-                )
+            request = cast(_MessageReadRequest, request)
             result = await self._service.read(
                 session_id,
-                target=target,
-                around_message_id=around_message_id,
-                limit=limit,
+                target=request.target,
+                around_message_id=request.around_message_id,
+                limit=request.limit,
             )
             return {
                 "ok": True,
@@ -316,65 +471,31 @@ class CommandDispatcher:
             }
 
         if resource == "message" and command == "send":
-            target = request.get("target")
-            body = request.get("body")
-            command_id = request.get("command_id")
-            attachment_paths = request.get("attachment_paths", [])
-            reply_to_message_id = request.get("reply_to_message_id")
-            created_at_ms = request.get("created_at_ms", time_ns() // 1_000_000)
-            if not isinstance(target, str) or not target:
-                raise CommandDispatchError(
-                    "TARGET_REQUIRED", "target must be a non-empty string"
-                )
-            if not isinstance(body, str):
-                raise CommandDispatchError("BODY_REQUIRED", "body must be text")
-            if not isinstance(command_id, str) or not command_id:
-                raise CommandDispatchError(
-                    "COMMAND_ID_REQUIRED", "command_id must be a non-empty string"
-                )
-            if not isinstance(attachment_paths, list) or not all(
-                isinstance(path, str) and path for path in attachment_paths
-            ):
-                raise CommandDispatchError(
-                    "INVALID_ATTACHMENTS",
-                    "attachment_paths must be a list of non-empty strings",
-                )
-            if reply_to_message_id is not None and (
-                not isinstance(reply_to_message_id, str) or not reply_to_message_id
-            ):
-                raise CommandDispatchError(
-                    "INVALID_REPLY_TO",
-                    "reply_to_message_id must be a non-empty string",
-                )
-            if (
-                isinstance(created_at_ms, bool)
-                or not isinstance(created_at_ms, int)
-                or created_at_ms < 0
-            ):
-                raise CommandDispatchError(
-                    "INVALID_CREATED_AT", "created_at_ms must be non-negative"
-                )
+            request = cast(_MessageSendRequest, request)
             result = await self._service.send(
                 session_id=session_id,
-                command_id=command_id,
-                target=target,
-                body=body,
-                created_at_ms=created_at_ms,
-                attachment_paths=tuple(attachment_paths),
-                reply_to_message_id=reply_to_message_id,
+                command_id=request.command_id,
+                target=request.target,
+                body=request.body,
+                created_at_ms=request.created_at_ms,
+                attachment_paths=tuple(request.attachment_paths),
+                reply_to_message_id=request.reply_to_message_id,
             )
+            if isinstance(result, MessageSendHandoffRequired):
+                return {
+                    "ok": True,
+                    "result": {
+                        "handoff_required": {"target": result.target},
+                    },
+                }
             return {
                 "ok": True,
                 "result": {"outbound": serialize_outbound(result)},
             }
 
         if resource == "thread" and command == "unfollow":
-            target = request.get("target")
-            if not isinstance(target, str) or not target:
-                raise CommandDispatchError(
-                    "TARGET_REQUIRED", "target must be a non-empty string"
-                )
-            changed = await self._service.unfollow(session_id, target=target)
+            request = cast(_ThreadUnfollowRequest, request)
+            changed = await self._service.unfollow(session_id, target=request.target)
             return {"ok": True, "result": {"changed": changed}}
 
         raise AssertionError("validated command route has no handler")