loopd: ask_memory as a core tool, and a wait of its own on brokerd

Co-Authored-By: ornith-1.5-35b-a3b <agent@wntrmute.dev>

crates/loopd/tests/broker_port_ask_wait.rs

@@ -0,0 +1,132 @@
+//! How long `BrokerPort` waits for `brokerd`, per tool: `[broker] timeout_ms` for every tool but
+//! `ask_memory`, which waits 180 s or the timeout, whichever is longer (M5c spec, sections 9 and
+//! 11). `with_ask_wait` shortens the wait here, so no test waits long. Do not edit.
+
+#[path = "support/broker.rs"]
+mod fake;
+
+use std::thread;
+use std::time::Duration;
+
+use bxcore::{ToolRequest, ToolResponse};
+use fake::{broker, in_ms, request, result, send};
+use loopd::broker_port::{ASK_MEMORY_WAIT, BrokerPort, UNAVAILABLE};
+use loopd::tools::ToolPort;
+
+/// How long the slow fake `brokerd` takes to answer.
+const SLOW: Duration = Duration::from_millis(1_500);
+/// A wait shorter than `SLOW`, and one far longer.
+const SHORT: Duration = Duration::from_millis(300);
+const LONG: Duration = Duration::from_secs(20);
+
+fn ask_memory() -> ToolRequest {
+    ToolRequest {
+        tool: "ask_memory".to_string(),
+        arguments: r#"{"question":"What does the owner prefer?"}"#.to_string(),
+        ..request()
+    }
+}
+
+fn recall() -> ToolRequest {
+    ToolRequest {
+        tool: "recall".to_string(),
+        arguments: r#"{"query":"owner"}"#.to_string(),
+        ..request()
+    }
+}
+
+/// One call of `req`, through a port with `timeout` and an `ask_memory` wait of `ask_wait`, to a
+/// fake `brokerd` that answers after `SLOW`, optionally after a pending frame that expires at once.
+fn slow_call(
+    timeout: Duration,
+    ask_wait: Duration,
+    req: &ToolRequest,
+    pending_first: bool,
+) -> ToolResponse {
+    let (socket, broker) = broker(move |stream, request| {
+        if pending_first {
+            let pending = ToolResponse::PendingApproval {
+                approval: 3,
+                expires: in_ms(50),
+            };
+            send(stream, request.id, false, pending);
+        }
+        thread::sleep(SLOW);
+        send(stream, request.id, true, result("the answer"));
+    });
+    let port = BrokerPort::with_log(socket, timeout, Box::new(|_| {})).with_ask_wait(ask_wait);
+    let response = port.call(req, &mut |_| {});
+    broker.join().unwrap();
+    response
+}
+
+fn quiet(timeout: Duration) -> BrokerPort {
+    BrokerPort::with_log("unused.sock".into(), timeout, Box::new(|_| {}))
+}
+
+fn unavailable() -> ToolResponse {
+    ToolResponse::Failed {
+        message: UNAVAILABLE.to_string(),
+    }
+}
+
+#[test]
+fn the_wait_for_each_tool() {
+    assert_eq!(ASK_MEMORY_WAIT, Duration::from_secs(180));
+    let port = BrokerPort::new("unused.sock".into(), Duration::from_secs(120));
+    assert_eq!(port.timeout_for("ask_memory"), ASK_MEMORY_WAIT);
+    for tool in ["recall", "memory", "read_file", "shell", "clock", "ask"] {
+        assert_eq!(port.timeout_for(tool), Duration::from_secs(120), "{tool}");
+    }
+    // A configured timeout longer than 180 s is kept for ask_memory too.
+    let port = BrokerPort::new("unused.sock".into(), Duration::from_secs(300));
+    assert_eq!(port.timeout_for("ask_memory"), Duration::from_secs(300));
+    let port = quiet(Duration::from_secs(120));
+    assert_eq!(
+        port.timeout_for("ask_memory"),
+        ASK_MEMORY_WAIT,
+        "with_log as new"
+    );
+    assert_eq!(port.timeout_for("recall"), Duration::from_secs(120));
+    let port = quiet(SHORT).with_ask_wait(LONG);
+    assert_eq!(port.timeout_for("ask_memory"), LONG);
+    assert_eq!(port.timeout_for("recall"), SHORT);
+    let port = quiet(LONG).with_ask_wait(SHORT);
+    assert_eq!(
+        port.timeout_for("ask_memory"),
+        LONG,
+        "the longer of the two"
+    );
+}
+
+/// A slow answer reaches `ask_memory`, whose wait is long, and not `recall` or `read_file`,
+/// which have the short timeout.
+#[test]
+fn a_slow_answer_reaches_ask_memory_only() {
+    assert_eq!(
+        slow_call(SHORT, LONG, &ask_memory(), false),
+        result("the answer")
+    );
+    assert_eq!(slow_call(SHORT, LONG, &recall(), false), unavailable());
+    assert_eq!(slow_call(SHORT, LONG, &request(), false), unavailable());
+}
+
+/// With a longer timeout than `ask_memory`'s own wait, `ask_memory` waits the timeout.
+#[test]
+fn a_longer_timeout_is_kept_for_ask_memory() {
+    assert_eq!(
+        slow_call(LONG, SHORT, &ask_memory(), false),
+        result("the answer")
+    );
+}
+
+/// After a pending frame, the port waits for the expiry plus the call's own wait: for
+/// `ask_memory`, its long wait, not the short timeout.
+#[test]
+fn after_a_pending_frame_ask_memory_keeps_its_wait() {
+    assert_eq!(
+        slow_call(SHORT, LONG, &ask_memory(), true),
+        result("the answer")
+    );
+    assert_eq!(slow_call(SHORT, LONG, &recall(), true), unavailable());
+}