Add the turn loop with its limits

Implemented-By: OpenCode session (model recorded in docs/implementer-log.md)

crates/loopd/tests/support/turn.rs

@@ -0,0 +1,97 @@
+//! A turn-loop setup shared by the `turn` and `limits` tests: a home, a fake server, a scripted
+//! port and a registry. Included with `#[path]` because it needs `loopd::turn`, which the earlier
+//! tasks' tests must not depend on. Do not edit.
+
+#![allow(dead_code)]
+
+use crate::support::{FakeServer, Home, ScriptedPort};
+use loopd::baseline::Baseline;
+use loopd::llama::Client;
+use loopd::session::Session;
+use loopd::tools::Registry;
+use loopd::turn::{Runtime, TurnError, run_turn};
+use proto::{LogRecord, SessionId, ToolResponse, TurnEvent};
+
+pub struct Setup {
+    pub home: Home,
+    pub server: FakeServer,
+    pub cfg: loopd::config::Config,
+    pub client: Client,
+    pub port: ScriptedPort,
+    pub registry: Registry,
+}
+
+pub fn setup(replies: Vec<ToolResponse>) -> Setup {
+    let home = Home::new();
+    let server = FakeServer::start();
+    let cfg = home.config(&server.socket);
+    let client = Client::new(cfg.clone());
+    Setup {
+        home,
+        server,
+        cfg,
+        client,
+        port: ScriptedPort::new(replies),
+        registry: Registry::m2b(),
+    }
+}
+
+impl Setup {
+    pub fn session(&self, id: &str) -> Session {
+        let baseline = Baseline::assemble(&self.cfg, &self.registry).unwrap();
+        Session::create(
+            &self.home.dir,
+            SessionId::new(id).unwrap(),
+            baseline,
+            self.cfg.slots.main,
+        )
+        .unwrap()
+    }
+
+    pub fn runtime(&self) -> Runtime<'_> {
+        Runtime {
+            cfg: &self.cfg,
+            client: &self.client,
+            port: &self.port,
+            registry: &self.registry,
+        }
+    }
+
+    pub fn turn(
+        &self,
+        session: &mut Session,
+        text: &str,
+    ) -> (Result<loopd::turn::TurnOutcome, TurnError>, Vec<TurnEvent>) {
+        let mut events = Vec::new();
+        let result = run_turn(session, &self.runtime(), text, &mut |e| {
+            events.push(e.clone())
+        });
+        (result, events)
+    }
+}
+
+/// The recordings were made in separate conversations, so their timings do not line up and the
+/// loop rightly reports cache losses between them. Most tests are not about that, so `types`
+/// and `records` leave `CacheLoss` out; one test checks it on purpose.
+pub fn without_cache_loss(records: &[LogRecord]) -> Vec<LogRecord> {
+    records
+        .iter()
+        .filter(|r| !matches!(r, LogRecord::CacheLoss { .. }))
+        .cloned()
+        .collect()
+}
+
+pub fn types(records: &[LogRecord]) -> Vec<&'static str> {
+    without_cache_loss(records)
+        .iter()
+        .map(|r| match r {
+            LogRecord::SessionStart { .. } => "start",
+            LogRecord::User { .. } => "user",
+            LogRecord::Assistant { .. } => "assistant",
+            LogRecord::Usage { .. } => "usage",
+            LogRecord::ToolResult { .. } => "tool_result",
+            LogRecord::CacheLoss { .. } => "cache_loss",
+            LogRecord::EpochEnd { .. } => "epoch_end",
+        })
+        .collect()
+}