bazaar-compute-node 0.1.3__py3-none-any.whl

bazaar_compute_node/app/command.py

@@ -0,0 +1,342 @@
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Awaitable, Callable, Mapping
+from datetime import UTC, datetime
+from time import time_ns
+
+from ..core.command import (
+    ICommandService,
+    SessionNotFoundError,
+)
+from ..core.lifecycle import TimeoutBudget
+from ..core.models import InboundMessage, OutboundMessage
+
+
+def serialize_inbound(message: InboundMessage) -> dict[str, object]:
+    return {
+        "seq": message.seq,
+        "message_id": message.message_id,
+        "session_id": message.session_id,
+        "channel_session_id": message.channel_session_id,
+        "channel": message.channel,
+        "received_at_ms": message.received_at_ms,
+        "provider_time_ms": message.provider_time_ms,
+        "sender": message.sender,
+        "message_type": message.message_type,
+        "canonical_target": message.canonical_target,
+        "target_kind": message.target_kind.value,
+        "mentions_agent": message.mentions_agent,
+        "notifies_runtime": message.notifies_runtime,
+        "attachments": [
+            {
+                "attachment_id": attachment.attachment_id,
+                "name": attachment.name,
+                "kind": attachment.kind,
+                "state": attachment.state,
+                "media_type": attachment.media_type,
+                "relative_path": attachment.relative_path,
+                "size_bytes": attachment.size_bytes,
+                "error": attachment.error,
+            }
+            for attachment in message.attachments
+        ],
+        "body": message.body,
+        "reply_to_message_id": message.reply_to_message_id,
+    }
+
+
+def serialize_outbound(message: OutboundMessage) -> dict[str, object]:
+    return {
+        "outbound_message_id": message.outbound_message_id,
+        "command_id": message.command_id,
+        "session_id": message.session_id,
+        "channel_session_id": message.channel_session_id,
+        "target": message.target,
+        "reply_to_message_id": message.reply_to_message_id,
+        "body": message.body,
+        "state": message.state.value,
+        "fresh_check_state": message.fresh_check_state.value,
+        "created_at_ms": message.created_at_ms,
+        "snapshot_seq": message.snapshot_seq,
+        "current_inbound_seq": message.current_inbound_seq,
+        "provider_attempted_at_ms": message.provider_attempted_at_ms,
+        "completed_at_ms": message.completed_at_ms,
+        "draft_saved_at_ms": message.draft_saved_at_ms,
+        "error_kind": message.error_kind,
+        "error_message": message.error_message,
+        "next_action": message.next_action,
+    }
+
+
+class CommandDispatchError(ValueError):
+    def __init__(
+        self,
+        code: str,
+        message: str,
+        *,
+        draft_saved: bool = False,
+        next_action: str | None = None,
+    ) -> None:
+        super().__init__(message)
+        self.code = code
+        self.message = message
+        self.draft_saved = draft_saved
+        self.next_action = next_action
+
+
+ControlHandler = Callable[[Mapping[str, object]], Awaitable[Mapping[str, object]]]
+SessionBindingValidator = Callable[[str, Mapping[str, object]], Awaitable[None]]
+
+
+class CommandDispatcher:
+    """Translate local JSON requests into core command results."""
+
+    def __init__(
+        self,
+        service: ICommandService,
+        *,
+        timeout_budget: TimeoutBudget,
+        control_handler: ControlHandler | None = None,
+        session_binding_validator: SessionBindingValidator | None = None,
+    ) -> None:
+        self._service = service
+        self._timeout_budget = timeout_budget
+        self._control_handler = control_handler
+        self._session_binding_validator = session_binding_validator
+        self._accepting = False
+        self._in_flight: set[asyncio.Task[object]] = set()
+        self._drained = asyncio.Event()
+        self._drained.set()
+
+    @property
+    def accepting(self) -> bool:
+        return self._accepting
+
+    def start_accepting(self) -> None:
+        self._accepting = True
+        self._drained.clear()
+
+    def stop_accepting(self) -> None:
+        self._accepting = False
+        if not self._in_flight:
+            self._drained.set()
+
+    async def drain(self, *, timeout: float) -> None:
+        if timeout <= 0:
+            raise ValueError("timeout must be positive")
+        self.stop_accepting()
+        if not self._in_flight:
+            return
+        try:
+            await asyncio.wait_for(asyncio.shield(self._drained.wait()), timeout)
+            return
+        except TimeoutError:
+            pass
+        current_task = asyncio.current_task()
+        pending = tuple(
+            task
+            for task in self._in_flight
+            if task is not current_task and not task.done()
+        )
+        for task in pending:
+            task.cancel()
+        if pending:
+            await asyncio.gather(*pending, return_exceptions=True)
+
+    async def __call__(self, request: Mapping[str, object]) -> Mapping[str, object]:
+        if not self._accepting:
+            return {
+                "ok": False,
+                "code": "SERVICE_NOT_READY",
+                "error": "command service is not accepting requests",
+            }
+        current_task = asyncio.current_task()
+        if current_task is not None:
+            self._in_flight.add(current_task)
+            self._drained.clear()
+        try:
+            kind = request.get("kind")
+            if kind == "command":
+                async with asyncio.timeout(self._timeout_budget.command_seconds):
+                    return await self._dispatch_command(request)
+            if kind == "control" and self._control_handler is not None:
+                result = await self._control_handler(request)
+                return {"ok": True, "result": dict(result)}
+            raise CommandDispatchError(
+                "INVALID_COMMAND", "request kind is not supported"
+            )
+        except asyncio.CancelledError:
+            raise
+        except CommandDispatchError as error:
+            response: dict[str, object] = {
+                "ok": False,
+                "code": error.code,
+                "error": error.message,
+            }
+            if error.draft_saved:
+                response["draft_saved"] = True
+            if error.next_action is not None:
+                response["next_action"] = error.next_action
+            return response
+        except SessionNotFoundError as error:
+            return {
+                "ok": False,
+                "code": "SESSION_NOT_FOUND",
+                "error": str(error),
+            }
+        except TimeoutError as error:
+            return {
+                "ok": False,
+                "code": "COMMAND_TIMEOUT",
+                "error": str(error) or "command timed out",
+            }
+        except ValueError as error:
+            return {
+                "ok": False,
+                "code": "INVALID_COMMAND",
+                "error": str(error),
+            }
+        except Exception as error:  # noqa: BLE001
+            return {
+                "ok": False,
+                "code": "COMMAND_FAILED",
+                "error": str(error),
+            }
+        finally:
+            if current_task is not None:
+                self._in_flight.discard(current_task)
+                if not self._in_flight:
+                    self._drained.set()
+
+    async def _dispatch_command(
+        self, request: Mapping[str, object]
+    ) -> Mapping[str, object]:
+        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"
+            )
+        command = request.get("command")
+        if not isinstance(command, str) or not command:
+            raise CommandDispatchError(
+                "COMMAND_REQUIRED", "command must be a non-empty string"
+            )
+        if self._session_binding_validator is not None:
+            await self._session_binding_validator(session_id, request)
+
+        if command == "check":
+            result = await self._service.check(session_id)
+            return {
+                "ok": True,
+                "result": {
+                    "messages": [
+                        serialize_inbound(message) for message in result.messages
+                    ],
+                    "referenced_messages": [
+                        serialize_inbound(message)
+                        for message in result.referenced_messages
+                    ],
+                    "snapshot_seq": result.snapshot_seq,
+                    "delivered_through_seq": result.delivered_through_seq,
+                },
+            }
+
+        if 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"
+                )
+            result = await self._service.read(
+                session_id,
+                target=target,
+                around_message_id=around_message_id,
+                limit=limit,
+            )
+            return {
+                "ok": True,
+                "result": {
+                    "messages": [
+                        serialize_inbound(message) for message in result.messages
+                    ],
+                    "referenced_messages": [
+                        serialize_inbound(message)
+                        for message in result.referenced_messages
+                    ],
+                    "snapshot_seq": result.snapshot_seq,
+                    "first_seq": result.first_seq,
+                    "last_seq": result.last_seq,
+                },
+            }
+
+        if command == "send":
+            target = request.get("target")
+            body = request.get("body")
+            command_id = request.get("command_id")
+            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 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"
+                )
+            result = await self._service.send(
+                session_id=session_id,
+                command_id=command_id,
+                target=target,
+                body=body,
+                created_at_ms=created_at_ms,
+                reply_to_message_id=reply_to_message_id,
+            )
+            return {
+                "ok": True,
+                "result": {"outbound": serialize_outbound(result)},
+            }
+
+        if 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)
+            return {"ok": True, "result": {"changed": changed}}
+
+        raise CommandDispatchError("UNKNOWN_COMMAND", f"unsupported command: {command}")
+
+
+def format_message_time(timestamp_ms: int) -> str:
+    return datetime.fromtimestamp(timestamp_ms / 1000, tz=UTC).strftime(
+        "%Y-%m-%d %H:%M:%S"
+    )

bazaar_compute_node/app/config.py

@@ -0,0 +1,121 @@
+from __future__ import annotations
+
+import tomllib
+from dataclasses import dataclass
+from pathlib import Path
+
+from ..core.paths import resolve_data_dir
+from ..core.runtime import RuntimeSandboxMode
+
+CONFIG_FILENAME = "config.toml"
+
+
+@dataclass(frozen=True, slots=True)
+class NodeConfiguration:
+    """Optional startup settings loaded from the node's persistent config."""
+
+    channel: str | None = None
+    runtime: str | None = None
+    storage: str | None = None
+    audit: str | None = None
+    endpoint: str | None = None
+    model: str | None = None
+    effort: str | None = None
+    sandbox_mode: RuntimeSandboxMode = RuntimeSandboxMode.WORKSPACE_WRITE
+    network_access: bool = True
+    runtime_env_include: tuple[str, ...] = ()
+    wecom_bot_id: str | None = None
+    wecom_websocket_url: str | None = None
+
+
+class ConfigurationError(ValueError):
+    """Raised when the persistent bcn configuration is invalid."""
+
+
+def resolve_config_path() -> Path:
+    return resolve_data_dir() / CONFIG_FILENAME
+
+
+def load_node_configuration() -> NodeConfiguration:
+    path = resolve_config_path()
+    try:
+        with path.open("rb") as config_file:
+            payload = tomllib.load(config_file)
+    except FileNotFoundError:
+        return NodeConfiguration()
+    except (OSError, UnicodeDecodeError, tomllib.TOMLDecodeError) as error:
+        raise ConfigurationError(f"cannot read {path}: {error}") from error
+
+    node = payload.get("node", {})
+    if not isinstance(node, dict):
+        raise ConfigurationError("[node] must be a TOML table")
+    runtime = payload.get("runtime", {})
+    if not isinstance(runtime, dict):
+        raise ConfigurationError("[runtime] must be a TOML table")
+    runtime_env = runtime.get("env", {})
+    if not isinstance(runtime_env, dict):
+        raise ConfigurationError("[runtime.env] must be a TOML table")
+    channel = payload.get("channel", {})
+    if not isinstance(channel, dict):
+        raise ConfigurationError("[channel] must be a TOML table")
+    wecom = channel.get("wecom", {})
+    if not isinstance(wecom, dict):
+        raise ConfigurationError("[channel.wecom] must be a TOML table")
+    sandbox_mode = runtime.get("sandbox_mode", RuntimeSandboxMode.WORKSPACE_WRITE.value)
+    if not isinstance(sandbox_mode, str):
+        raise ConfigurationError("runtime.sandbox_mode must be text")
+    try:
+        parsed_sandbox_mode = RuntimeSandboxMode(sandbox_mode)
+    except ValueError as error:
+        allowed = ", ".join(mode.value for mode in RuntimeSandboxMode)
+        raise ConfigurationError(
+            f"runtime.sandbox_mode must be one of: {allowed}"
+        ) from error
+    network_access = runtime.get("network_access", True)
+    if not isinstance(network_access, bool):
+        raise ConfigurationError("runtime.network_access must be a boolean")
+    return NodeConfiguration(
+        channel=_optional_text(node.get("channel"), "node.channel"),
+        runtime=_optional_text(node.get("runtime"), "node.runtime"),
+        storage=_optional_text(node.get("storage"), "node.storage"),
+        audit=_optional_text(node.get("audit"), "node.audit"),
+        endpoint=_optional_text(node.get("endpoint"), "node.endpoint"),
+        model=_optional_text(runtime.get("model"), "runtime.model"),
+        effort=_optional_text(runtime.get("effort"), "runtime.effort"),
+        sandbox_mode=parsed_sandbox_mode,
+        network_access=network_access,
+        runtime_env_include=_text_list(
+            runtime_env.get("include", []), "runtime.env.include"
+        ),
+        wecom_bot_id=_optional_text(wecom.get("bot_id"), "channel.wecom.bot_id"),
+        wecom_websocket_url=_optional_text(
+            wecom.get("websocket_url"), "channel.wecom.websocket_url"
+        ),
+    )
+
+
+def _optional_text(value: object, field_name: str) -> str | None:
+    if value is None:
+        return None
+    if not isinstance(value, str) or not value:
+        raise ConfigurationError(f"{field_name} must be non-empty text")
+    return value
+
+
+def _text_list(value: object, field_name: str) -> tuple[str, ...]:
+    if not isinstance(value, list) or any(
+        not isinstance(item, str) or not item for item in value
+    ):
+        raise ConfigurationError(f"{field_name} must be an array of non-empty text")
+    if len(set(value)) != len(value):
+        raise ConfigurationError(f"{field_name} cannot contain duplicates")
+    return tuple(value)
+
+
+__all__ = [
+    "CONFIG_FILENAME",
+    "ConfigurationError",
+    "NodeConfiguration",
+    "load_node_configuration",
+    "resolve_config_path",
+]

bazaar_compute_node/app/registry.py

@@ -0,0 +1,120 @@
+from __future__ import annotations
+
+from collections.abc import Callable, Mapping
+from dataclasses import dataclass
+from importlib.metadata import EntryPoint, entry_points
+from typing import Any, cast
+
+from ..core.channel import ChannelContext, IChannel
+from ..core.observability import IAudit
+from ..core.runtime import IRuntime, RuntimeCommandContext
+from ..core.storage import IStorage
+from .command import ControlHandler
+
+CHANNEL_ENTRY_POINT_GROUP = "bazaar_compute_node.channels"
+RUNTIME_ENTRY_POINT_GROUP = "bazaar_compute_node.runtimes"
+STORAGE_ENTRY_POINT_GROUP = "bazaar_compute_node.storages"
+AUDIT_ENTRY_POINT_GROUP = "bazaar_compute_node.audits"
+CONTROL_ENTRY_POINT_GROUP = "bazaar_compute_node.controls"
+
+ChannelFactory = Callable[[ChannelContext], IChannel]
+RuntimeFactory = Callable[[RuntimeCommandContext], IRuntime]
+StorageFactory = Callable[[], IStorage]
+AuditFactory = Callable[[], IAudit]
+
+
+@dataclass(frozen=True, slots=True)
+class AdapterFactories:
+    channel: ChannelFactory
+    runtime: RuntimeFactory
+    storage: StorageFactory
+    audit: AuditFactory
+    control: Callable[[Mapping[str, object]], ControlHandler] | None = None
+
+
+class ProviderLoadError(RuntimeError):
+    """A selected provider is missing or has an invalid entry point."""
+
+
+class AdapterRegistry:
+    """Discover provider factories through Python package entry points."""
+
+    def load(
+        self,
+        *,
+        channel: str,
+        runtime: str,
+        storage: str = "sqlite",
+        audit: str = "logging",
+    ) -> AdapterFactories:
+        control = self._load_optional(
+            CONTROL_ENTRY_POINT_GROUP,
+            f"{channel}+{runtime}+{storage}",
+        )
+        return AdapterFactories(
+            channel=cast(
+                ChannelFactory,
+                self._load(CHANNEL_ENTRY_POINT_GROUP, channel),
+            ),
+            runtime=cast(
+                RuntimeFactory,
+                self._load(RUNTIME_ENTRY_POINT_GROUP, runtime),
+            ),
+            storage=cast(
+                StorageFactory,
+                self._load(STORAGE_ENTRY_POINT_GROUP, storage),
+            ),
+            audit=cast(
+                AuditFactory,
+                self._load(AUDIT_ENTRY_POINT_GROUP, audit),
+            ),
+            control=cast(
+                Callable[[Mapping[str, object]], ControlHandler] | None,
+                control,
+            ),
+        )
+
+    def _load(self, group: str, name: str) -> Any:
+        entry_point = self._find(group, name)
+        if entry_point is None:
+            raise ProviderLoadError(
+                f"provider '{name}' is not installed for entry point group '{group}'"
+            )
+        try:
+            factory = entry_point.load()
+        except Exception as error:
+            raise ProviderLoadError(
+                f"failed to load provider '{name}' from '{group}': {error}"
+            ) from error
+        if not callable(factory):
+            raise ProviderLoadError(f"provider '{name}' from '{group}' is not callable")
+        return factory
+
+    def _load_optional(self, group: str, name: str) -> Any | None:
+        entry_point = self._find(group, name)
+        if entry_point is None:
+            return None
+        try:
+            factory = entry_point.load()
+        except Exception as error:
+            raise ProviderLoadError(
+                f"failed to load optional provider '{name}' from '{group}': {error}"
+            ) from error
+        if not callable(factory):
+            raise ProviderLoadError(
+                f"optional provider '{name}' from '{group}' is not callable"
+            )
+        return factory
+
+    @staticmethod
+    def _find(group: str, name: str) -> EntryPoint | None:
+        if not name:
+            raise ProviderLoadError(f"provider name for '{group}' is empty")
+        return next(
+            (
+                candidate
+                for candidate in entry_points(group=group)
+                if candidate.name == name
+            ),
+            None,
+        )