Files
skills/orchestrator/kvb_orchestrator/choosing.py
T

146 lines
6.7 KiB
Python
Raw Normal View History

from __future__ import annotations
from .council import agent
from .errors import ToolError
from .fields import decode, expect, field
from .messaging import DIRECT, EVERYONE, TO_ALL
from .records import digest
from .register import REGISTER, adder, operator_rows, read_register
from .signed import signing
CHOICE_REQUEST = "send me your open decisions as choices"
CHANNELS = {**DIRECT, **TO_ALL}
CHOICE_KEYS = ("class", "to")
RECIPIENT_LIMIT = 40
ANSWER_CLASS = "post"
QUESTION_SHOWN = 200
def answer_text(decision: dict, label: str) -> str:
question = " ".join(decision["question"].split())[:QUESTION_SHOWN]
return f"Choice for decision {decision['id']} ({question}): {label}"
def answer_signed(decision: dict, label: str) -> dict:
"""Returns:
The post to the asking agent that a click on the option label
signs: the operator's answer operator_message proves.
"""
if EVERYONE in decision["agent"]:
raise ToolError(f"a choice answer goes to the asking agent, never to a name with {EVERYONE}")
return signing.message_item(agent(decision["agent"]), ANSWER_CLASS, answer_text(decision, label), "", "", "")
def row_answer_signed(row: dict, to: str, label: str) -> dict:
"""Args:
row: an open decision row of the register.
to: the row's adding agent.
label: one of the row's option labels.
Returns:
The post to that agent that a Match pick signs, in the words the
inbox's own answer sends.
"""
if not to or EVERYONE in to:
raise ToolError(f"a decision row is answered only when an agent other than {EVERYONE} holds role A on it")
return signing.message_item(agent(to), ANSWER_CLASS, f"Decision {row['task']}\nAnswer: {label}", "", "", "")
def answered(record: dict | None, row: dict) -> bool:
return record is not None and record["sha256"] == digest(row["command"])
def recipients(payload: dict) -> list[str]:
"""Args:
payload: the page's class and to: 1 to RECIPIENT_LIMIT distinct
agent names for post and call, [EVERYONE] for a class to all.
"""
cls, names = payload["class"], payload["to"]
if not isinstance(cls, str) or cls not in CHANNELS:
raise ToolError(f"class must be one of {', '.join(CHANNELS)}")
if not isinstance(names, list) or not all(isinstance(name, str) for name in names):
raise ToolError("to must be a list of agent names")
if cls in TO_ALL:
if names != [EVERYONE]:
raise ToolError(f"a choice request to all names to [{EVERYONE}]")
return names
targets = [field({"to": name}, "to").strip() for name in names]
if not 1 <= len(targets) <= RECIPIENT_LIMIT or any(EVERYONE in target for target in targets):
raise ToolError(f"a post or a call names 1 to {RECIPIENT_LIMIT} agents, never a name with {EVERYONE}")
if len({agent(target) for target in targets}) != len(targets):
raise ToolError("to must name distinct agents")
return targets
class Choosing:
def choice_items(self, payload: dict) -> list[dict]:
return [signing.message_item(target, payload["class"], CHOICE_REQUEST, "", "", "") for target in recipients(payload)]
def sign_choices(self, body: bytes) -> dict:
payload = decode(body)
expect(payload, CHOICE_KEYS)
return self.challenge_for(self.choice_items(payload))
def request_choices(self, body: bytes) -> dict:
"""Returns:
The ids of the stored requests, one per recipient, once one
passkey assertion signed each of them; nothing is stored or sent
before every item verified.
"""
payload = decode(body)
expect(payload, (*CHOICE_KEYS, "proof"))
items = self.choice_items(payload)
for item in items:
self.operator_proven(payload["proof"], item)
records = [self.stored_message(item, payload["proof"], None) for item in items]
runs = [self.radioed(record, CHANNELS[payload["class"]]) for record in records]
return {"ids": [record["id"] for record in records], "ok": all(run["code"] == 0 for run in runs), "runs": runs}
def answer_choice(self, item: dict, proof: dict) -> str:
"""Args:
item: a checked decision item whose signed is answer_signed().
proof: the relayed signature; the hub sends the answer itself,
so it verifies the signature here, once.
Returns:
The outcome words for the stream.
"""
record = self.decisions.get(item["id"])
if record is None:
return "unknown"
if record["status"] != "pending":
return f"already {record['status']}"
self.operator_proven(proof, item["signed"])
message = self.stored_message(item["signed"], proof, None)
decided, changed = self.decisions.decide(item["id"], {"status": "decided", "choice": item["label"], "message": message["id"]})
if not changed:
self.messages.remove(message["id"])
return f"already {decided['status']}"
run = self.radioed(message, CHANNELS[ANSWER_CLASS])
where = f"{ANSWER_CLASS} to {message['address']}"
return f"decided · {where}" if run["code"] == 0 else f"decided · {where} failed ({run['code']})"
def answer_row(self, item: dict, proof: dict) -> str:
"""Args:
item: a checked operator item of a decision row whose label is
the picked option and whose signed is row_answer_signed().
proof: the relayed signature, verified here once, as the hub
sends the answer itself.
Returns:
The outcome words for the stream; the row stays open until its
agent closes it, while answers keeps it off the Match stack.
"""
tasks = read_register(self.council / REGISTER)
row = next((row for row in operator_rows(tasks) if row["task"] == item["id"]), None)
if row is None or item["label"] not in [option["label"] for option in row["options"]] or row_answer_signed(row, adder(tasks[item["id"]]), item["label"]) != item["signed"]:
return "refused: the row changed since the release"
self.operator_proven(proof, item["signed"])
with self.answers.changed:
if answered(self.answers.get(item["id"]), row):
return "already answered"
message = self.stored_message(item["signed"], proof, None)
self.answers.insert(item["id"], {"sha256": digest(row["command"]), "label": item["label"], "message": message["id"]})
run = self.radioed(message, CHANNELS[ANSWER_CLASS])
where = f"{ANSWER_CLASS} to {message['address']}"
return f"answered · {where}" if run["code"] == 0 else f"answered · {where} failed ({run['code']})"