yog 0.0.76

yog: the standalone server for litany loops — the world, the balls and the conversations, behind one wire
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

//! The capability family's half of the [`codec`](super) (VISION §4.11, §8.6):
//! the hold answer. Split from the top-level codec beside the §4.9 monitor's
//! own half, per §12's line budget.
//!
//! Strict, like the rest of the codec: the verdict is a required field, and it
//! must be one of the control's three words. There is no default — an answer
//! that guessed its own verdict would be the boundary inventing an operator's
//! decision, which is the one thing a gesture must never do.
//!
//! The **scope** is a field, and a required one (bl-94a5, PROTOCOL 17): an
//! answer that stands over a class of calls rather than over one is a
//! different instruction, and a default read out of an absent field would let
//! two ends disagree about which instruction was sent.
//!
//! The `tool_use` id is **not** a field, in either direction. It is derived
//! from `refs/litany/held/<agent>` at fire time (§8.6): a headless caller that
//! had to quote an id would be quoting a fact it read a tick ago, and the
//! whole point of scoping the answer to a provider-unique id is that it names
//! what is parked *now*.

use serde_json::{Map, Value, json};

use crate::control::judge::{Answer, Ruling, Scope};

use super::{Action, Gesture, str_of};

/// One hold answer as its envelope.
pub(super) fn encode(workspace: &str, agent: &str, answer: Answer) -> Value {
    json!({ "op": "answer", "workspace": workspace, "agent": agent,
            "verdict": answer.ruling.word(), "scope": answer.scope.word() })
}

/// The inverse. `op` is already known to be `answer`; both words are checked
/// here, where the refusal can name what was said and what is allowed.
pub(super) fn decode(o: &Map<String, Value>) -> Result<Gesture, String> {
    let workspace = str_of(o, "workspace")?;
    let agent = str_of(o, "agent")?;
    let word = str_of(o, "verdict")?;
    let ruling = Ruling::of(&word)
        .ok_or_else(|| format!("answer: unknown verdict {word:?}; say pass, hold or refuse"))?;
    let said = str_of(o, "scope")?;
    let scope = Scope::of(&said).ok_or_else(|| {
        format!("answer: unknown scope {said:?}; say call, conversation or workspace")
    })?;
    Ok(Gesture::Act(Action::AnswerHold {
        workspace,
        agent,
        answer: Answer { ruling, scope },
    }))
}

/// One floor gesture as its envelope (VISION §4.9's fifth rung). **Two ops for
/// one variant**, exactly as the monitor's arm and disarm are: raising and
/// lowering are two instructions, and a boolean field would make the second one
/// the absence of the first.
pub(super) fn encode_floor(workspace: &str, agent: &str, raised: bool) -> Value {
    let op = if raised { "revoke" } else { "restore" };
    json!({ "op": op, "workspace": workspace, "agent": agent })
}

/// The inverse. `op` is already known to be one of the two; the direction it
/// names is the whole difference between them.
pub(super) fn decode_floor(op: &str, o: &Map<String, Value>) -> Result<Gesture, String> {
    Ok(Gesture::Act(Action::Floor {
        workspace: str_of(o, "workspace")?,
        agent: str_of(o, "agent")?,
        raised: op == "revoke",
    }))
}