zettcode-server 0.4.0__tar.gz → 0.4.2__tar.gz

{zettcode_server-0.4.0 → zettcode_server-0.4.2}/.gitignore

@@ -35,3 +35,8 @@ docs/internal/palettes.html
 
 # The release order is generated from the pyproject.toml files (`make order`); it is not kept in git.
 packages/order.txt
+
+# The desktop and phone apps build the gateway's page into their own folders, and electron-builder writes its
+# installers under release/.
+clients/desktop/renderer/
+clients/desktop/release/

{zettcode_server-0.4.0 → zettcode_server-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: zettcode-server
-Version: 0.4.0
+Version: 0.4.2
 Summary: The HTTP face of ZettCode: a FastAPI server that drives the SDK
 Project-URL: Repository, https://github.com/Chang-LeHung/zettcode
 Author: Chang-LeHung
@@ -17,7 +17,7 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.10
 Requires-Dist: fastapi<1,>=0.115
 Requires-Dist: pydantic<3,>=2
-Requires-Dist: starlette<2,>=0.48
+Requires-Dist: starlette<2,>=0.51
 Requires-Dist: uvicorn<1,>=0.35
 Requires-Dist: zettcode-engine
 Requires-Dist: zettcode-sdk

{zettcode_server-0.4.0 → zettcode_server-0.4.2}/pyproject.toml

@@ -20,7 +20,7 @@ dependencies = [
   "zettcode-engine",
   "zettcode-sdk",
   "fastapi>=0.115,<1",
-  "starlette>=0.48,<2",
+  "starlette>=0.51,<2",
   "uvicorn>=0.35,<1",
   "pydantic>=2,<3",
 ]

{zettcode_server-0.4.0 → zettcode_server-0.4.2}/src/zettcode/server/app.py

@@ -84,6 +84,7 @@ from .schemas import (
     SideQuestionRequest,
     SteeredOut,
     SteerIn,
+    TriggerOut,
     UsageOut,
     WorkspaceUsageOut,
 )
@@ -619,7 +620,7 @@ def create_app(settings: Settings, *, client_factory: ClientFactory | None = Non
 
     @protected.get("/plugins", response_model=PluginsOut, tags=["models"])
     async def plugins(runner: RunnerDep) -> PluginsOut:
-        """List the plugins this server loaded, the ones that failed, and every one a switch can reach."""
+        """List the plugins this server loaded, what failed, every one a switch can reach, and their triggers."""
         report = runner.client.plugins
         return PluginsOut(
             loaded=list(report.loaded),
@@ -634,9 +635,14 @@ def create_app(settings: Settings, *, client_factory: ClientFactory | None = Non
                     setting=entry.setting,
                     switchable=entry.switchable,
                     why=entry.why,
+                    note=entry.note,
                 )
                 for entry in report.entries
             ],
+            triggers=[
+                TriggerOut(name=trigger.name, scope=trigger.scope, state=trigger.state, detail=trigger.detail)
+                for trigger in report.triggers
+            ],
         )
 
     @protected.put("/plugins/{name}", response_model=PluginOut, tags=["models"])

{zettcode_server-0.4.0 → zettcode_server-0.4.2}/src/zettcode/server/runner.py

@@ -27,7 +27,7 @@ from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Literal, cast
 
 from zettcode.modes import MODE_STEER
-from zettcode.relay import Relayed
+from zettcode.sdk.commands import PlainCommandHost
 from zettcode.sdk.errors import SessionBusyError
 from zettcode.sdk.events import AnyEvent, ApprovalRequested, QuestionAsked, Steered
 from zettcode.sdk.handlers import ApprovalHandler, approve_all, approve_commands, deny_all
@@ -194,6 +194,34 @@ class NoModelError(RuntimeError):
     """
 
 
+class _SessionHost(PlainCommandHost):
+    """What the session commands do here: the same things the terminal's own versions do, without a screen.
+
+    Nothing is caught: a busy or locked session, a blank title and a file that cannot be written keep the status the
+    rest of the API gives them, and a command that could do nothing answers with the line the session gave it.
+    """
+
+    def __init__(self, client: Client) -> None:
+        self._client = client
+
+    @property
+    def _session(self) -> Session:
+        return self._client.session
+
+    async def compact(self) -> str:
+        done = await self._session.compact()
+        return "Compacted." if done is not None else "Nothing to compact: the conversation is already short."
+
+    async def title(self, name: str | None) -> str:
+        if name:
+            return f"Session named {await self._session.rename(name)!r}."
+        current = self._session.title
+        return f"This session is called {current!r}." if current else "This session has no name yet: /title <name>."
+
+    async def export(self, path: str | None) -> str:
+        return f"Wrote this session to {await self._session.export(path)}."
+
+
 class Runner:
     """The agent, one run at a time, and the events and answers of the run that is going.
 
@@ -364,7 +392,8 @@ class Runner:
         command = next((item for item in commands if item.name == wanted), None)
         if command is None:
             raise KeyError(wanted)
-        result = command.handler(PlainCommandContext(argument=argument, level=self.client.permission))
+        context = PlainCommandContext(argument=argument, level=self.client.permission, host=_SessionHost(self.client))
+        result = command.handler(context)
         if inspect.isawaitable(result):
             result = await result
         if isinstance(result, TurnCommandResult):
@@ -710,17 +739,7 @@ class Runner:
     @staticmethod
     def _steer(slot: Slot, message: IncomingMessage) -> str | None:
         """Hand a message to the run in progress, framed for the model; the text it will report it by, or ``None``."""
-        relayed = Relayed(
-            sender_id=message.sender_id,
-            sender=message.sender,
-            text=message.text,
-            via=message.via,
-            hops=message.hops,
-            direct=message.direct,
-            mode=message.mode,
-            group=message.group,
-        )
-        return slot.client.session._steer_message(relayed.message())
+        return slot.client.session._steer_incoming(message)
 
     def _hold_message(self, slot: Slot, message: IncomingMessage) -> None:
         """Put a message in the chat's inbox, with the id its client answers it by."""

{zettcode_server-0.4.0 → zettcode_server-0.4.2}/src/zettcode/server/schemas.py

@@ -532,6 +532,8 @@ class PluginOut(BaseModel):
             installed one, which `[plugins] disable` holds.
         switchable: Whether there is a switch to draw; a panel shows the rest without one and says ``why``.
         why: Why it cannot be switched, when it cannot; empty otherwise.
+        note: What else a panel should say — a plugin that lost its name to one loaded before it has no switch and is
+            not a failure, and this says why.
     """
 
     name: str
@@ -542,14 +544,33 @@ class PluginOut(BaseModel):
     setting: str = ""
     switchable: bool = True
     why: str = ""
+    note: str = ""
+
+
+class TriggerOut(BaseModel):
+    """Where one trigger a plugin registered is.
+
+    Attributes:
+        name: The trigger's name.
+        scope: ``"process"`` (one per process) or ``"machine"`` (one on the whole machine).
+        state: ``pending``, ``standby`` (another process holds the machine's lock), ``running``, ``skipped``
+            (another runtime in this process runs it), ``finished``, ``failed`` or ``stopped``.
+        detail: Why, for ``standby``, ``skipped`` and ``failed``; empty otherwise.
+    """
+
+    name: str
+    scope: str
+    state: str
+    detail: str = ""
 
 
 class PluginsOut(BaseModel):
-    """The plugins this server loaded, the ones that refused to load, and every one a switch can reach."""
+    """The plugins this server loaded, what refused to load, every one a switch can reach, and its triggers."""
 
     loaded: list[str]
     failures: list[str]
     entries: list[PluginOut] = Field(default_factory=list)
+    triggers: list[TriggerOut] = Field(default_factory=list)
 
 
 class PluginSwitchIn(BaseModel):