bazaar-contrib-server-activity 0.3.0rc1__py3-none-any.whl

bazaar_contrib_server_activity/__init__.py

@@ -0,0 +1,208 @@
+"""The activity of the Bazaar Compute server: what the computers report,
+kept once and cleared after the retention, the turns, usage and departures
+it adds up to, ACTIVITY for the modules that read them, and the activity's
+pages - the sections and the whole record of an agent, the agents in each
+stall and the market's feed."""
+
+from __future__ import annotations
+
+from contextlib import asynccontextmanager
+lazy import asyncio
+lazy from collections.abc import AsyncIterator
+lazy from importlib.resources import files
+lazy from pathlib import Path
+
+from bazaar_contrib_server import SERVER, Topic
+from bazaar_contrib_server_access import ACCESS
+from bazaar_contrib_server_agent import AGENTS, AgentSection, AgentTab
+from bazaar_contrib_server_computer import (
+    COMPUTER_LEFT,
+    COMPUTER_REMOVED,
+    COMPUTERS,
+    REPORTED,
+    ComputerLeft,
+    ComputerRemoved,
+    Reported,
+)
+from bazaar_contrib_server_database import SERVER_DB, SERVER_SCHEMA
+from bazaar_contrib_server_migrations import SERVER_MIGRATIONS
+from bazaar_contrib_server_overview import OVERVIEW, OverviewItem
+from bazaar_contrib_timer import TIMER
+from bazaar_core import Context, Contrib, ServiceKey
+from pydantic import BaseModel, ConfigDict, Field
+
+from .contracts import ACTIVITY, Activity, Bucket, Calls, Receipt, Turn
+lazy from .ledger import Ledger
+lazy from .pages import VIEW, Views
+lazy from .schema import MODULE
+lazy from .service import Service
+lazy from .store import Store
+
+__all__ = [
+    "ACTIVITY",
+    "Activity",
+    "ActivityConfig",
+    "Bucket",
+    "Calls",
+    "Receipt",
+    "Turn",
+    "activity",
+]
+
+# what the computers report, kept as it comes
+_LEDGER = ServiceKey["Ledger"]("server.activity.ledger")
+# the retention is swept once a day, as 0.2 did
+DAY_MS = 86_400_000
+
+
+class ActivityConfig(BaseModel):
+    model_config = ConfigDict(extra="forbid", frozen=True)
+
+    # how many days of what the computers report are kept
+    retention_days: int = Field(default=30, ge=1, strict=True)
+
+
+@asynccontextmanager
+async def _activity(ctx: Context, config: ActivityConfig) -> AsyncIterator[None]:
+    server = ctx.accept(SERVER)
+    agents = ctx.accept(AGENTS)
+    timer = ctx.accept(TIMER)
+    database = ctx.accept(SERVER_DB)
+    resources = Path(str(files(__name__))) / "resources"
+    icon = await asyncio.to_thread(
+        (resources / "templates" / "activity" / "icons" / "activity.svg").read_text,
+        encoding="utf-8",
+    )
+    async with ctx.accept(SERVER_SCHEMA).register(MODULE):
+        ledger = Ledger(database)
+        store = Store(database)
+        pages = await server.pages("activity", __name__)
+        views = Views(
+            server,
+            pages,
+            ctx.accept(ACCESS),
+            agents,
+            ctx.accept(COMPUTERS),
+            store,
+        )
+
+        async def sweep() -> None:
+            while True:
+                await ledger.sweep(config.retention_days)
+                await timer.create(DAY_MS).wait()
+
+        async with (
+            asyncio.TaskGroup() as tasks,
+            server.module(
+                "activity",
+                ui=pages.application(views.routes),
+                static=resources / "static",
+                locales=resources / "locales",
+            ),
+            server.topic(
+                Topic(
+                    name="activity.agent",
+                    fetch=views.followed,
+                    fields=("agent",),
+                    permission=VIEW,
+                )
+            ),
+            server.topic(Topic(name="activity.feed", fetch=views.fed)),
+            server.topic(
+                Topic(
+                    name="activity.stall",
+                    fetch=views.stalled,
+                    fields=("computer",),
+                    permission=VIEW,
+                )
+            ),
+            agents.section(
+                AgentSection(
+                    key="live",
+                    src="/ui/activity/live",
+                    column="main",
+                    permission=VIEW,
+                    order=10,
+                )
+            ),
+            agents.section(
+                AgentSection(
+                    key="today",
+                    src="/ui/activity/today",
+                    column="main",
+                    permission=VIEW,
+                    order=20,
+                )
+            ),
+            agents.section(
+                AgentSection(
+                    key="usage",
+                    src="/ui/activity/usage",
+                    column="side",
+                    permission=VIEW,
+                    order=20,
+                )
+            ),
+            # the whole record, opened from the activity and lighting it
+            agents.tab(
+                AgentTab(
+                    key="log",
+                    text="activity.log.title",
+                    icon=icon,
+                    src="/ui/activity/log",
+                    permission=VIEW,
+                    parent="activity",
+                )
+            ),
+            ctx.accept(COMPUTERS).stall("/ui/activity/stall"),
+            ctx.accept(OVERVIEW).register(
+                OverviewItem(
+                    key="feed",
+                    title="activity.feed.title",
+                    src="/ui/activity/feed",
+                    order=40,
+                )
+            ),
+        ):
+            task = tasks.create_task(sweep())
+            ctx.offer(_LEDGER, ledger)
+            ctx.offer(ACTIVITY, Service(store, agents))
+            try:
+                yield
+            finally:
+                task.cancel()
+
+
+async def _reported(ctx: Context, value: Reported) -> None:
+    await ctx.accept(_LEDGER).record(value.computer_id, value.event)
+
+
+async def _removed(ctx: Context, value: ComputerRemoved) -> None:
+    await ctx.accept(_LEDGER).remove(value.computer_id)
+
+
+async def _left(ctx: Context, value: ComputerLeft) -> None:
+    await ctx.accept(_LEDGER).depart(value.computer_id, value.seen_ms)
+
+
+activity = Contrib(
+    config=ActivityConfig,
+    accepts=[
+        SERVER,
+        ACCESS,
+        OVERVIEW,
+        COMPUTERS,
+        AGENTS,
+        SERVER_DB,
+        SERVER_SCHEMA,
+        SERVER_MIGRATIONS,
+        TIMER,
+    ],
+    offers=[_LEDGER, ACTIVITY],
+    lifespan=_activity,
+    listen={
+        REPORTED: _reported,
+        COMPUTER_REMOVED: _removed,
+        COMPUTER_LEFT: _left,
+    },
+)

bazaar_contrib_server_activity/contracts.py

@@ -0,0 +1,155 @@
+"""What other modules hold server-activity to: the turns, receipts, counts
+and cursors of the agents an account may see, as the events the computers
+report add up to."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Literal, Protocol
+lazy from collections.abc import Mapping, Sequence
+
+from bazaar_core import ServiceKey
+lazy from bazaar_contrib_server import Account
+
+
+@dataclass(frozen=True, slots=True)
+class Calls:
+    """Tool calls by the kind a receipt words them in: commands run, files
+    looked at, files changed, pages opened, web searches, other tools and
+    subtasks sent off."""
+
+    commands: int = 0
+    files: int = 0
+    changes: int = 0
+    pages: int = 0
+    searches: int = 0
+    tools: int = 0
+    tasks: int = 0
+
+    @property
+    def total(self) -> int:
+        return (
+            self.commands
+            + self.files
+            + self.changes
+            + self.pages
+            + self.searches
+            + self.tools
+            + self.tasks
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class Turn:
+    """A turn as its events add up to: where it came from, the runtime and
+    model it ran on, how it ended and why, the tokens it used - fresh
+    input, cache hits and output - with their cost when the runtime gives
+    one, its tool calls, and the step it is at while it runs."""
+
+    computer_id: str
+    agent_id: str
+    turn_id: str
+    session_id: str | None
+    thread_id: str | None
+    channel: str | None
+    target_kind: str | None
+    connection: str | None
+    model: str | None
+    message_id: str | None
+    started_ms: int
+    ended_ms: int | None
+    outcome: Literal["completed", "failed", "cancelled"] | None
+    reason: str | None
+    input: int
+    cached: int
+    output: int
+    cost: float | None
+    calls: Calls
+    step: Literal["reply", "thinking", "tool"] | None
+    step_ms: int | None
+
+
+@dataclass(frozen=True, slots=True)
+class Receipt:
+    """What a turn did before one of its replies, since the reply before
+    it or its start: its tool calls and how many seconds that took."""
+
+    calls: Calls
+    seconds: int
+
+
+@dataclass(frozen=True, slots=True)
+class Bucket:
+    """The turns that started and the tokens used from a moment until the
+    next bucket's."""
+
+    start_ms: int
+    turns: int
+    input: int
+    cached: int
+    output: int
+    cost: float | None
+
+
+class Activity(Protocol):
+    """The activity of the agents an account may see; any other agent is
+    not there."""
+
+    async def cursor(
+        self,
+        account: Account,
+        *,
+        agent_id: str | None = None,
+        thread_id: str | None = None,
+        messages: bool = False,
+    ) -> int:
+        """The id of the newest event of the agent, of every agent the
+        account may see for None, in the conversation when one is given;
+        only of the messages sent, received and let in when asked: 0 for
+        none."""
+        ...
+
+    async def working(
+        self,
+        account: Account,
+        *,
+        agent_id: str | None = None,
+        thread_id: str | None = None,
+    ) -> Sequence[Turn]:
+        """The turns in progress on computers that are here, oldest first."""
+        ...
+
+    async def turns(
+        self,
+        account: Account,
+        since_ms: int,
+        until_ms: int,
+        *,
+        agent_id: str | None = None,
+        thread_id: str | None = None,
+    ) -> Sequence[Turn]:
+        """The turns started in the time, newest first."""
+        ...
+
+    async def receipts(
+        self, account: Account, agent_id: str, message_ids: Sequence[str]
+    ) -> Mapping[str, Receipt]:
+        """What the turn behind each reply of the agent did before it, by
+        the reply's message id; a reply sent outside a turn has none."""
+        ...
+
+    async def stats(
+        self,
+        account: Account,
+        starts: Sequence[int],
+        until_ms: int,
+        *,
+        agent_id: str | None = None,
+    ) -> Sequence[Bucket]:
+        """The turns and tokens of each bucket, an hour or a day as the
+        caller cut them on its clock, from each start until the next and
+        the last until the end."""
+        ...
+
+
+ACTIVITY = ServiceKey[Activity]("server.activity")