bazaar-compute-node 0.2.1rc11__tar.gz → 0.2.1rc12__tar.gz

{bazaar_compute_node-0.2.1rc11 → bazaar_compute_node-0.2.1rc12}/PKG-INFO

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

{bazaar_compute_node-0.2.1rc11 → bazaar_compute_node-0.2.1rc12}/pyproject.toml

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

{bazaar_compute_node-0.2.1rc11 → bazaar_compute_node-0.2.1rc12}/pyproject.toml.orig

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

{bazaar_compute_node-0.2.1rc11 → bazaar_compute_node-0.2.1rc12}/src/bazaar_compute_node/app/command.py

@@ -5,7 +5,7 @@ import json
 from collections.abc import Awaitable, Callable, Mapping, Sequence
 from datetime import UTC, datetime
 from time import time_ns
-from typing import Annotated, Literal, cast
+from typing import Annotated, Literal, Self, cast
 
 from pydantic import (
     BaseModel,
@@ -15,12 +15,17 @@ from pydantic import (
     StrictInt,
     StrictStr,
     ValidationError,
+    ValidationInfo,
+    model_validator,
 )
+from pydantic_core import PydanticCustomError
 
-from ..core.actor import Actor, Actors
+from ..core.actor import Actor, Actors, Thread
 from ..core.command import (
     ICommandService,
     MessageBroadcast,
+    MessageSearchRequest,
+    MessageSearchTimeoutError,
     MessageSendFreshnessHold,
     MessageSendSuccess,
     TargetProjection,
@@ -30,7 +35,7 @@ from ..core.models import (
     Message,
     OutboundDeliveryState,
 )
-from ..core.serialize import serialize_inbox_target, serialize_message
+from ..core.serialize import serialize_inbox_target, serialize_message, serialize_search
 from ..rendering import TextTemplate
 
 
@@ -76,6 +81,48 @@ class _MessageCheckRequest(_CommandRequest):
     command: Literal["check"]
 
 
+class _MessageSearchRequest(_CommandRequest):
+    resource: Literal["message"]
+    command: Literal["search"]
+    target: NonEmptyText | None = None
+    query: StrictStr = ""
+    sender: NonEmptyText | None = None
+    after_ms: StrictInt | None = None
+    before_ms: StrictInt | None = None
+    sort: Literal["time", "relevance"] = "time"
+    limit: Annotated[StrictInt, Field(ge=1, le=50)] = 20
+    offset: NonNegativeInt = 0
+
+    @model_validator(mode="after")
+    def search_filters(self, info: ValidationInfo) -> Self:
+        self.query = " ".join(self.query.split()[:5])
+        if self.sender is not None:
+            self.sender = self.sender.strip()
+            if not self.sender or self.sender == "@":
+                raise PydanticCustomError(
+                    "INVALID_SENDER", "sender must be a handle, id, or self"
+                )
+        if (
+            self.after_ms is not None
+            and self.before_ms is not None
+            and self.after_ms > self.before_ms
+        ):
+            raise PydanticCustomError(
+                "INVALID_TIME_RANGE", "after must be at or before before"
+            )
+        if (
+            not isinstance((info.context or {}).get("actor"), Thread)
+            and not any((self.query, self.target, self.sender))
+            and self.after_ms is None
+            and self.before_ms is None
+        ):
+            raise PydanticCustomError(
+                "SEARCH_FILTER_REQUIRED",
+                "Search requires a query, target, sender, or time filter",
+            )
+        return self
+
+
 class _MessageReadRequest(_CommandRequest):
     resource: Literal["message"]
     command: Literal["read"]
@@ -110,6 +157,7 @@ class _ThreadUnfollowRequest(_CommandRequest):
 
 _REQUEST_MODELS: dict[tuple[str, str], type[_CommandRequest]] = {
     ("message", "check"): _MessageCheckRequest,
+    ("message", "search"): _MessageSearchRequest,
     ("message", "read"): _MessageReadRequest,
     ("message", "send"): _MessageSendRequest,
     ("inbox", "check"): _InboxCheckRequest,
@@ -152,6 +200,11 @@ _REQUEST_ERRORS: dict[str, tuple[str, str]] = {
     "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"),
+    "query": ("INVALID_QUERY", "query must be text"),
+    "sender": ("INVALID_SENDER", "sender must be a handle, id, or self"),
+    "after_ms": ("INVALID_TIME", "after_ms must be an integer timestamp"),
+    "before_ms": ("INVALID_TIME", "before_ms must be an integer timestamp"),
+    "sort": ("INVALID_SORT", "sort must be time or relevance"),
     "around_message_id": (
         "INVALID_AROUND_MESSAGE",
         "around_message_id must be a string",
@@ -177,10 +230,18 @@ def _parse_command_request[RequestT: _CommandRequest](
     model: type[RequestT],
     *,
     errors: Mapping[str, tuple[str, str]] | None = None,
+    actor: Actor | None = None,
 ) -> RequestT:
     try:
-        return model.model_validate(request)
+        return model.model_validate(request, context={"actor": actor})
     except ValidationError as error:
+        detail = error.errors()[0]
+        if detail["type"] in {
+            "INVALID_TIME_RANGE",
+            "SEARCH_FILTER_REQUIRED",
+            "INVALID_SENDER",
+        }:
+            raise CommandDispatchError(detail["type"], detail["msg"]) from error
         field_name = next(
             (
                 part
@@ -298,6 +359,8 @@ class CommandDispatcher:
                 "code": "SESSION_NOT_FOUND",
                 "error": str(error),
             }
+        except MessageSearchTimeoutError as error:
+            return {"ok": False, "code": error.code, "error": str(error)}
         except TimeoutError as error:
             return {
                 "ok": False,
@@ -345,14 +408,26 @@ class CommandDispatcher:
                 "UNKNOWN_COMMAND", f"unsupported {resource} command: {command}"
             )
 
-        request = _parse_command_request(raw_request, _REQUEST_MODELS[route])
+        request = _parse_command_request(raw_request, _CommandRequest)
         actor = self._resolve_actor(request.actor_id)
         if self._session_binding_validator is not None:
             await self._session_binding_validator(actor, raw_request)
+        request = _parse_command_request(
+            raw_request,
+            _REQUEST_MODELS[route],
+            actor=actor,
+            errors={"limit": ("INVALID_LIMIT", "search limit must be between 1 and 50")}
+            if route == ("message", "search")
+            else None,
+        )
 
         match route:
             case ("message", "check"):
                 return await self._check_messages(actor)
+            case ("message", "search"):
+                return await self._search_messages(
+                    actor, cast(_MessageSearchRequest, request)
+                )
             case ("message", "read"):
                 return await self._read_messages(
                     actor, cast(_MessageReadRequest, request)
@@ -433,6 +508,27 @@ class CommandDispatcher:
             },
         }
 
+    async def _search_messages(
+        self, actor: Actor, request: _MessageSearchRequest
+    ) -> Mapping[str, object]:
+        result = await self._service.search_messages(
+            actor,
+            MessageSearchRequest(
+                query=request.query,
+                raw_target=request.target,
+                sender=request.sender,
+                after_ms=request.after_ms,
+                before_ms=request.before_ms,
+                sort=request.sort,
+                limit=request.limit,
+                offset=request.offset,
+            ),
+        )
+        return {
+            "ok": True,
+            "result": serialize_search(result, self._actors),
+        }
+
     async def _send_message(
         self, actor: Actor, request: _MessageSendRequest
     ) -> Mapping[str, object]:

{bazaar_compute_node-0.2.1rc11 → bazaar_compute_node-0.2.1rc12}/src/bazaar_compute_node/app/resource_dispatch.py

@@ -250,7 +250,7 @@ class CommandDispatcher(_MessageCommandDispatcher):
             )
 
         if resource == "message":
-            if command not in {"check", "read", "send"}:
+            if command not in {"check", "read", "send", "search"}:
                 raise CommandDispatchError(
                     "UNKNOWN_COMMAND",
                     f"unsupported message command: {command}",

{bazaar_compute_node-0.2.1rc11 → bazaar_compute_node-0.2.1rc12}/src/bazaar_compute_node/cmd/bcc/_format.py

@@ -1,8 +1,11 @@
 from __future__ import annotations
 
 import json
+import re
 import sys
 from collections.abc import Mapping
+from datetime import UTC, datetime
+from html import escape
 from typing import Annotated, cast
 
 import click
@@ -39,6 +42,7 @@ def print_error(error: BccCommandError) -> None:
 _INBOX_CHECK = TextTemplate.from_resource("bcc/inbox_check.tpl")
 _CHECK = TextTemplate.from_resource("bcc/check.tpl")
 _READ = TextTemplate.from_resource("bcc/read.tpl")
+_SEARCH = TextTemplate.from_resource("bcc/search.tpl")
 _UNFOLLOW = TextTemplate.from_resource("bcc/unfollow.tpl")
 _REMINDER_SCHEDULE = TextTemplate.from_resource("bcc/reminder_schedule.tpl")
 _REMINDER_LIST = TextTemplate.from_resource("bcc/reminder_list.tpl")
@@ -132,6 +136,56 @@ def serialize_send(result: Mapping[str, object]) -> str:
         ) from error
 
 
+def _search_text(text: str, *, references: bool = True) -> str:
+    text = re.sub(
+        r"</?(?:result|preview|match)\b[^>]*>|<omit\s*/>",
+        lambda match: escape(match[0], quote=False),
+        text,
+        flags=re.IGNORECASE,
+    )
+    if not references:
+        return text
+    text = re.sub(r"\bdm:@([A-Za-z0-9][A-Za-z0-9_-]*)", r"dm:user:\1", text)
+    text = re.sub(r"\btask #([0-9]+)\b", r"task:\1", text)
+    text = re.sub(r"(^|[\n\s([{\"'`;])@([A-Za-z0-9][A-Za-z0-9_-]*)", r"\1user:\2", text)
+    return re.sub(r"(^|[\n\s([{\"'`;])#([A-Za-z][A-Za-z0-9_-]*)", r"\1channel:\2", text)
+
+
+def serialize_search(result: Mapping[str, object]) -> str:
+    messages = cast(list[Mapping[str, object]], result["messages"])
+    hits: list[dict[str, object]] = []
+    for message in messages:
+        sender = cast(Mapping[str, object] | None, message["sender"])
+        timestamp = datetime.fromtimestamp(
+            cast(int, message["at_ms"]) / 1000, tz=UTC
+        ).astimezone()
+        offset = timestamp.strftime("%z")
+        hits.append(
+            {
+                "source": _search_text(cast(str, message["target"]), references=False),
+                "message_id": message["message_id"],
+                "timestamp": (
+                    f"{timestamp:%Y-%m-%d %H:%M:%S} {offset[:3]}:{offset[3:]}"
+                ),
+                "sender_kind": message["sender_kind"],
+                "sender": _search_text(
+                    "self"
+                    if message["direction"] == "outbound"
+                    else cast(str, sender.get("name") or sender.get("id") or "unknown")
+                    if sender is not None
+                    else "unknown"
+                ),
+                "preview": "".join(
+                    "<match>" + _search_text(text) + "</match>"
+                    if matched
+                    else _search_text(text)
+                    for text, matched in cast(list[tuple[str, bool]], message["parts"])
+                ),
+            }
+        )
+    return _SEARCH.render({**result, "messages": hits})
+
+
 def serialize_version(result: Mapping[str, object]) -> str:
     return _VERSION.render(
         {

{bazaar_compute_node-0.2.1rc11 → bazaar_compute_node-0.2.1rc12}/src/bazaar_compute_node/cmd/bcc/message.py

@@ -2,12 +2,19 @@ from __future__ import annotations
 
 import asyncio
 import sys
+from datetime import date, datetime, time
 from pathlib import Path
 
 import click
 
 from ._client import BccCommandError, request, run
-from ._format import echo, serialize_check, serialize_read, serialize_send
+from ._format import (
+    echo,
+    serialize_check,
+    serialize_read,
+    serialize_search,
+    serialize_send,
+)
 
 
 @click.group(help="Message operations")
@@ -25,6 +32,95 @@ async def check() -> None:
     echo(serialize_check(await request("message", "check")))
 
 
+@message.command(
+    help="Search readable message history in the current actor's conversations"
+)
+@click.option(
+    "--query",
+    default="",
+    metavar="<text>",
+    help="Literal body fragments; the first five whitespace-separated fragments must match.",
+)
+@click.option(
+    "--target",
+    metavar="<target>",
+    help="Restrict to a single readable conversation.",
+)
+@click.option(
+    "--sender",
+    metavar="<@handle-or-id|self>",
+    help="Full sender handle or id, or self for outgoing messages.",
+)
+@click.option(
+    "--after",
+    metavar="<time>",
+    help="Inclusive ISO 8601 lower bound; dates start at local midnight.",
+)
+@click.option(
+    "--before",
+    metavar="<time>",
+    help="Inclusive ISO 8601 upper bound; dates end at local day's end.",
+)
+@click.option(
+    "--sort",
+    type=click.Choice(("time", "relevance")),
+    default="time",
+    show_default=True,
+)
+@click.option(
+    "--limit", type=click.IntRange(1, 50), default=20, show_default=True, metavar="<n>"
+)
+@click.option(
+    "--offset", type=click.IntRange(min=0), default=0, show_default=True, metavar="<n>"
+)
+@run
+async def search(
+    query: str,
+    target: str | None,
+    sender: str | None,
+    after: str | None,
+    before: str | None,
+    sort: str,
+    limit: int,
+    offset: int,
+) -> None:
+    bounds: dict[str, object] = {}
+    for option, text in (("after", after), ("before", before)):
+        if text is None:
+            continue
+        try:
+            try:
+                day = date.fromisoformat(text)
+            except ValueError:
+                value = datetime.fromisoformat(text)
+            else:
+                value = datetime.combine(
+                    day, time.min if option == "after" else time.max
+                )
+            bounds[f"{option}_ms"] = int(value.astimezone().timestamp() * 1000)
+        except (ValueError, OverflowError, OSError) as error:
+            raise click.BadParameter(
+                "Use an ISO 8601 date or datetime.", param_hint=f"--{option}"
+            ) from error
+    echo(
+        serialize_search(
+            await request(
+                "message",
+                "search",
+                {
+                    "query": query,
+                    "target": target,
+                    "sender": sender,
+                    "sort": sort,
+                    "limit": limit,
+                    "offset": offset,
+                    **bounds,
+                },
+            )
+        )
+    )
+
+
 @message.command(help="Read message history for a channel, DM, or thread")
 @click.option(
     "--target",

{bazaar_compute_node-0.2.1rc11 → bazaar_compute_node-0.2.1rc12}/src/bazaar_compute_node/contrib/server/control.py

@@ -10,22 +10,26 @@ import os
 from collections.abc import Awaitable, Callable, Mapping
 from functools import partial
 from inspect import isawaitable
-from typing import Literal
+from typing import Annotated, Literal, Self
 
 import aiohttp
 from pydantic import (
     BaseModel,
     ConfigDict,
+    Field,
     NonNegativeInt,
     PositiveInt,
+    StrictInt,
     StrictStr,
     TypeAdapter,
     ValidationError,
+    model_validator,
 )
 from yarl import URL
 
 from ...core.actor import Agent
 from ...core.audit import AuditEvent
+from ...core.command import MessageSearchRequest, MessageSearchTimeoutError
 from ...core.control import (
     AgentCommands,
     ControlContext,
@@ -40,6 +44,7 @@ from ...core.serialize import (
     serialize_inbox_target,
     serialize_message,
     serialize_reminder,
+    serialize_search,
 )
 from ...core.utils.clock import now_ms
 from ...core.utils.text import format_exception
@@ -85,6 +90,64 @@ class _ContactsRead(BaseModel):
         }
 
 
+class _SearchRead(BaseModel):
+    """Search the selected agent's conversations as their operator."""
+
+    model_config = ConfigDict(extra="ignore", strict=True)
+
+    read: Literal["search"]
+    agent_id: StrictStr
+    query: StrictStr = ""
+    target: StrictStr | None = None
+    sender: StrictStr | None = None
+    after_ms: StrictInt | None = None
+    before_ms: StrictInt | None = None
+    sort: Literal["time", "relevance"] = "time"
+    limit: Annotated[StrictInt, Field(ge=1, le=50)] = 20
+    offset: NonNegativeInt = 0
+    review: Literal["pending", "approved", "denied"] | None = None
+
+    @model_validator(mode="after")
+    def filters(self) -> Self:
+        self.query = " ".join(self.query.split()[:5])
+        if self.sender is not None:
+            self.sender = self.sender.strip()
+            if not self.sender or self.sender == "@":
+                raise ValueError("sender must be a handle, id, or self")
+        if self.target is not None and not self.target.strip():
+            raise ValueError("target must be non-empty")
+        if (
+            self.after_ms is not None
+            and self.before_ms is not None
+            and self.after_ms > self.before_ms
+        ):
+            raise ValueError("after must be at or before before")
+        if (
+            not any((self.query, self.target, self.sender))
+            and self.after_ms is None
+            and self.before_ms is None
+        ):
+            raise ValueError("search requires a query or filter")
+        return self
+
+    async def answer(self, commands: AgentCommands) -> dict[str, object]:
+        result = await commands.service.search_messages(
+            Agent(self.agent_id),
+            MessageSearchRequest(
+                query=self.query,
+                raw_target=self.target,
+                sender=self.sender,
+                after_ms=self.after_ms,
+                before_ms=self.before_ms,
+                sort=self.sort,
+                limit=self.limit,
+                offset=self.offset,
+            ),
+            review=None if self.review is None else Review(self.review),
+        )
+        return serialize_search(result, commands.actors)
+
+
 class _HistoryRead(BaseModel):
     """One conversation's messages around one of them, read as the actor the
     conversation is answered by."""
@@ -290,7 +353,12 @@ class _WorkspaceRead(BaseModel):
 # only an operator may do, which `bcc` has no word for. each request knows
 # how it is answered; `read` or `write` tells them apart on the wire
 type _AgentRequest = (
-    _ContactsRead | _HistoryRead | _RemindersRead | _ReviewWrite | _SettingWrite
+    _ContactsRead
+    | _SearchRead
+    | _HistoryRead
+    | _RemindersRead
+    | _ReviewWrite
+    | _SettingWrite
 )
 # and what it may ask about the node rather than of one agent: the
 # operator's own requests, which `bcc` has no word for
@@ -521,6 +589,8 @@ class ServerControl(IControl):
             }
         except Refused as error:
             return {"ok": False, "code": "REFUSED", "error": str(error)}
+        except MessageSearchTimeoutError as error:
+            return {"ok": False, "code": error.code, "error": str(error)}
         except ValueError as error:
             return {"ok": False, "code": "TARGET_NOT_FOUND", "error": str(error)}
         except Exception as error:

{bazaar_compute_node-0.2.1rc11 → bazaar_compute_node-0.2.1rc12}/src/bazaar_compute_node/contrib/sqlite/executor.py

@@ -2,9 +2,10 @@ from __future__ import annotations
 
 import asyncio
 import logging
+import sqlite3
 from collections import deque
-from collections.abc import Awaitable, Callable, Iterable, Sequence
-from contextlib import AbstractAsyncContextManager
+from collections.abc import AsyncIterator, Awaitable, Callable, Iterable, Sequence
+from contextlib import AbstractAsyncContextManager, asynccontextmanager
 from dataclasses import dataclass, field
 from time import monotonic
 from types import TracebackType
@@ -23,6 +24,10 @@ class SqliteExecutorClosedError(RuntimeError):
     """The SQLite executor is not accepting new work."""
 
 
+class SqliteQueryTimeoutError(TimeoutError):
+    """SQLite interrupted a query after its connection's execution budget."""
+
+
 @dataclass(frozen=True, slots=True)
 class SqliteExecuteResult:
     rowcount: int
@@ -36,6 +41,36 @@ class SqliteSession:
     def __init__(self, connection: aiosqlite.Connection) -> None:
         self._connection = connection
 
+    @asynccontextmanager
+    async def query_budget(self, seconds: float) -> AsyncIterator[None]:
+        """Bound SQL execution and remove the handler before reusing the session."""
+
+        deadline = monotonic() + seconds
+        expired = False
+
+        def progress() -> int:
+            nonlocal expired
+            expired = monotonic() >= deadline
+            return int(expired)
+
+        try:
+            await self._connection.set_progress_handler(progress, 1_000)
+            yield
+        except sqlite3.OperationalError as error:
+            if expired and error.sqlite_errorcode == sqlite3.SQLITE_INTERRUPT:
+                raise SqliteQueryTimeoutError(
+                    "SQLite query exceeded its execution budget"
+                ) from error
+            raise
+        except asyncio.CancelledError:
+            await self._connection.interrupt()
+            raise
+        finally:
+            # sqlite3 removes the handler with None; aiosqlite's annotation omits it.
+            await asyncio.shield(
+                self._connection.set_progress_handler(None, 0)  # type: ignore[arg-type]
+            )
+
     async def execute(
         self,
         statement: str,
@@ -573,6 +608,7 @@ __all__ = [
     "SqliteExecuteResult",
     "SqliteExecutor",
     "SqliteExecutorClosedError",
+    "SqliteQueryTimeoutError",
     "SqliteReadSession",
     "SqliteSession",
 ]

{bazaar_compute_node-0.2.1rc11 → bazaar_compute_node-0.2.1rc12}/src/bazaar_compute_node/contrib/sqlite/migrations/registry.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from collections.abc import Callable
+from sqlite3 import OperationalError
 from time import monotonic_ns
 from typing import TYPE_CHECKING
 
@@ -42,6 +43,7 @@ from .v28_channel_session_identity import CHANNEL_SESSION_IDENTITY_MIGRATION
 from .v29_backfill_channel_identity import BACKFILL_CHANNEL_IDENTITY_MIGRATION
 from .v30_remove_command_id import COMMAND_ID_REMOVAL_MIGRATION
 from .v31_channel_session_review import CHANNEL_SESSION_REVIEW_MIGRATION
+from .v32_message_search import MESSAGE_SEARCH_MIGRATION
 
 if TYPE_CHECKING:
     from ..executor import SqliteSession
@@ -95,6 +97,7 @@ MIGRATIONS = _migration_ledger(
     BACKFILL_CHANNEL_IDENTITY_MIGRATION,
     COMMAND_ID_REMOVAL_MIGRATION,
     CHANNEL_SESSION_REVIEW_MIGRATION,
+    MESSAGE_SEARCH_MIGRATION,
 )
 
 
@@ -163,7 +166,17 @@ async def apply_migrations(
             continue
         started_at_ns = monotonic_ns()
         for statement in migration.statements:
-            await transaction.execute(statement)
+            try:
+                await transaction.execute(statement)
+            except OperationalError as error:
+                if migration is MESSAGE_SEARCH_MIGRATION and (
+                    "no such module: fts5" in str(error)
+                    or "no such tokenizer: trigram" in str(error)
+                ):
+                    raise MigrationError(
+                        "Message search requires SQLite FTS5 with the trigram tokenizer"
+                    ) from error
+                raise
         await transaction.execute(
             "INSERT INTO schema_migrations "
             "(version, migration_name, checksum, applied_at_ms, duration_ms) "