Add the channel server on loop.sock
Implemented-By: OpenCode session (model recorded in docs/implementer-log.md)
This commit is contained in:
@@ -0,0 +1,240 @@
|
||||
//! The channel server: one turn per connection over the M1 frame protocol. A session runs one
|
||||
//! turn at a time; the busy set keeps a second turn on the same session from starting until the
|
||||
//! first finishes, and is released before the final frame so a client can send the next turn the
|
||||
//! moment it reads the last one.
|
||||
|
||||
use std::collections::HashSet;
|
||||
use std::os::unix::net::{UnixListener, UnixStream};
|
||||
use std::sync::{Arc, Mutex};
|
||||
|
||||
use crate::baseline::Baseline;
|
||||
use crate::config::Config;
|
||||
use crate::llama::Client;
|
||||
use crate::session::{Session, SessionError};
|
||||
use crate::tools::{Registry, ToolPort};
|
||||
use crate::turn::{Runtime, TurnError, run_turn};
|
||||
use proto::{
|
||||
Envelope, ErrorCode, FrameError, Message, PROTOCOL_VERSION, SessionId, TurnDone, WireError,
|
||||
read_frame, write_frame,
|
||||
};
|
||||
|
||||
/// Everything a turn needs, shared by every connection.
|
||||
pub struct Context {
|
||||
pub cfg: Config,
|
||||
pub client: Client,
|
||||
pub port: Box<dyn ToolPort>,
|
||||
pub registry: Registry,
|
||||
busy: Mutex<HashSet<SessionId>>,
|
||||
}
|
||||
|
||||
impl Context {
|
||||
pub fn new(
|
||||
cfg: Config,
|
||||
client: Client,
|
||||
port: Box<dyn ToolPort>,
|
||||
registry: Registry,
|
||||
) -> Context {
|
||||
Context {
|
||||
cfg,
|
||||
client,
|
||||
port,
|
||||
registry,
|
||||
busy: Mutex::new(HashSet::new()),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// While a turn runs, the session is in the busy set. The guard holds only an immutable borrow of
|
||||
/// the context and a clone of the id, never the lock, so another connection can still check
|
||||
/// membership while this turn is slow. The id is removed when the guard drops.
|
||||
struct Held<'a> {
|
||||
ctx: &'a Context,
|
||||
id: SessionId,
|
||||
}
|
||||
|
||||
impl Drop for Held<'_> {
|
||||
fn drop(&mut self) {
|
||||
if let Ok(mut busy) = self.ctx.busy.lock() {
|
||||
busy.remove(&self.id);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Accepts connections forever, one thread each. Returns only if `accept` fails.
|
||||
pub fn serve(listener: UnixListener, ctx: Arc<Context>) -> std::io::Result<()> {
|
||||
for stream in listener.incoming() {
|
||||
let stream = stream?;
|
||||
let ctx = Arc::clone(&ctx);
|
||||
std::thread::spawn(move || handle(stream, ctx));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// One connection: read a turn, run it, stream its events, send the final frame.
|
||||
pub fn handle(stream: UnixStream, ctx: Arc<Context>) {
|
||||
let mut stream = stream;
|
||||
|
||||
// 1. Read the turn. A closed stream before anything is not an error; any other read failure
|
||||
// is reported and closes the connection.
|
||||
let request = match read_frame(&mut stream) {
|
||||
Ok(env) => env,
|
||||
Err(FrameError::Closed) => return,
|
||||
Err(e) => {
|
||||
let code = match &e {
|
||||
FrameError::BadVersion(_) => ErrorCode::BadVersion,
|
||||
FrameError::Json(_) => ErrorCode::BadMessage,
|
||||
_ => ErrorCode::BadFrame,
|
||||
};
|
||||
let _ = write_frame(&mut stream, &error_frame(code, 0, e.to_string()));
|
||||
return;
|
||||
}
|
||||
};
|
||||
|
||||
// 2. Only a turn is served; every reply after this carries the request's id and version.
|
||||
let Message::Turn(turn) = request.msg else {
|
||||
let _ = write_frame(
|
||||
&mut stream,
|
||||
&error_frame(ErrorCode::BadMessage, request.id, String::new()),
|
||||
);
|
||||
return;
|
||||
};
|
||||
|
||||
// 3. Mark the session busy. If it already is, refuse at once. The guard releases the lock here
|
||||
// and holds only the id plus an immutable borrow, so the turn below does not hold it.
|
||||
let held = {
|
||||
let mut busy = match ctx.busy.lock() {
|
||||
Ok(busy) => busy,
|
||||
Err(poisoned) => poisoned.into_inner(),
|
||||
};
|
||||
if busy.contains(&turn.session) {
|
||||
let _ = write_frame(
|
||||
&mut stream,
|
||||
&error_frame(ErrorCode::SessionBusy, request.id, String::new()),
|
||||
);
|
||||
return;
|
||||
}
|
||||
busy.insert(turn.session.clone());
|
||||
Held {
|
||||
ctx: &ctx,
|
||||
id: turn.session.clone(),
|
||||
}
|
||||
};
|
||||
|
||||
// 4. Open or create the session, then run the turn, streaming each event as it happens.
|
||||
let runtime = Runtime {
|
||||
cfg: &ctx.cfg,
|
||||
client: &ctx.client,
|
||||
port: &*ctx.port,
|
||||
registry: &ctx.registry,
|
||||
};
|
||||
|
||||
let mut session = if turn.resume {
|
||||
match Session::open(&ctx.cfg.paths.home, turn.session.clone()) {
|
||||
Ok(session) => session,
|
||||
Err(e) => {
|
||||
let _ = write_frame(
|
||||
&mut stream,
|
||||
&error_frame(session_code(&e), request.id, e.to_string()),
|
||||
);
|
||||
return;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
let baseline = match Baseline::assemble(&ctx.cfg, &ctx.registry) {
|
||||
Ok(baseline) => baseline,
|
||||
Err(e) => {
|
||||
let _ = write_frame(
|
||||
&mut stream,
|
||||
&error_frame(ErrorCode::Internal, request.id, e.to_string()),
|
||||
);
|
||||
return;
|
||||
}
|
||||
};
|
||||
match Session::create(
|
||||
&ctx.cfg.paths.home,
|
||||
turn.session.clone(),
|
||||
baseline,
|
||||
ctx.cfg.slots.main,
|
||||
) {
|
||||
Ok(session) => session,
|
||||
Err(e) => {
|
||||
let _ = write_frame(
|
||||
&mut stream,
|
||||
&error_frame(session_code(&e), request.id, e.to_string()),
|
||||
);
|
||||
return;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
let outcome = run_turn(&mut session, &runtime, &turn.content, &mut |event| {
|
||||
let _ = write_frame(
|
||||
&mut stream,
|
||||
&Envelope {
|
||||
v: PROTOCOL_VERSION,
|
||||
id: request.id,
|
||||
r#final: false,
|
||||
msg: Message::TurnEvent(event.clone()),
|
||||
},
|
||||
);
|
||||
});
|
||||
|
||||
// 5. Release the session before the final frame, so the next turn does not find it busy.
|
||||
drop(held);
|
||||
|
||||
// 6. and 7. A turn done is success; a turn error maps to a code. A write failure means the
|
||||
// channel is gone, so we stop and finish quietly.
|
||||
match outcome {
|
||||
Ok(outcome) => {
|
||||
let _ = write_frame(
|
||||
&mut stream,
|
||||
&Envelope {
|
||||
v: PROTOCOL_VERSION,
|
||||
id: request.id,
|
||||
r#final: true,
|
||||
msg: Message::TurnDone(TurnDone {
|
||||
content: outcome.content,
|
||||
usage: outcome.usage,
|
||||
}),
|
||||
},
|
||||
);
|
||||
}
|
||||
Err(e) => {
|
||||
let _ = write_frame(
|
||||
&mut stream,
|
||||
&error_frame(turn_code(&e), request.id, e.to_string()),
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// One error envelope: final, the given id and version.
|
||||
fn error_frame(code: ErrorCode, id: u64, detail: String) -> Envelope {
|
||||
Envelope {
|
||||
v: PROTOCOL_VERSION,
|
||||
id,
|
||||
r#final: true,
|
||||
msg: Message::Error(WireError { code, detail }),
|
||||
}
|
||||
}
|
||||
|
||||
/// The channel code for a session that could not be opened or created.
|
||||
fn session_code(e: &SessionError) -> ErrorCode {
|
||||
match e {
|
||||
SessionError::Exists(_) => ErrorCode::SessionExists,
|
||||
SessionError::NotFound(_) => ErrorCode::NoSuchSession,
|
||||
_ => ErrorCode::Internal,
|
||||
}
|
||||
}
|
||||
|
||||
/// The channel code for a turn that ran but failed.
|
||||
fn turn_code(e: &TurnError) -> ErrorCode {
|
||||
match e {
|
||||
TurnError::SessionFull => ErrorCode::SessionFull,
|
||||
TurnError::TurnLimit => ErrorCode::TurnLimit,
|
||||
TurnError::Infer(_) => ErrorCode::Inference,
|
||||
TurnError::Session(SessionError::Exists(_)) => ErrorCode::SessionExists,
|
||||
TurnError::Session(SessionError::NotFound(_)) => ErrorCode::NoSuchSession,
|
||||
TurnError::Session(_) => ErrorCode::Internal,
|
||||
}
|
||||
}
|
||||
@@ -1,6 +1,7 @@
|
||||
//! The agent loop: sessions, prompt assembly and memory. It holds no authority.
|
||||
|
||||
pub mod baseline;
|
||||
pub mod channel;
|
||||
pub mod config;
|
||||
pub mod http;
|
||||
pub mod llama;
|
||||
|
||||
@@ -0,0 +1,380 @@
|
||||
//! Tests for the channel protocol on `loop.sock`. Do not edit.
|
||||
//!
|
||||
//! A real `channel::serve` runs on a socket in a temporary home, with the fake inference server
|
||||
//! behind it. The tests speak the frame protocol to it directly.
|
||||
|
||||
mod support;
|
||||
|
||||
use loopd::channel::{Context, serve};
|
||||
use loopd::llama::Client;
|
||||
use loopd::tools::Registry;
|
||||
use proto::{
|
||||
Envelope, ErrorCode, Message, PROTOCOL_VERSION, SessionId, Turn, TurnEvent, read_frame,
|
||||
write_frame,
|
||||
};
|
||||
use std::os::unix::net::{UnixListener, UnixStream};
|
||||
use std::path::PathBuf;
|
||||
use std::sync::Arc;
|
||||
use std::thread;
|
||||
use std::time::Duration;
|
||||
use support::{FakeServer, Home, Reply, ScriptedPort};
|
||||
|
||||
const CHAT: &str = "/v1/chat/completions";
|
||||
|
||||
struct Loopd {
|
||||
home: Home,
|
||||
server: FakeServer,
|
||||
socket: PathBuf,
|
||||
}
|
||||
|
||||
fn start(replies: Vec<proto::ToolResponse>) -> Loopd {
|
||||
let home = Home::new();
|
||||
let server = FakeServer::start();
|
||||
let cfg = home.config(&server.socket);
|
||||
let socket = cfg.channel_socket();
|
||||
let listener = UnixListener::bind(&socket).unwrap();
|
||||
let ctx = Arc::new(Context::new(
|
||||
cfg.clone(),
|
||||
Client::new(cfg),
|
||||
Box::new(ScriptedPort::new(replies)),
|
||||
Registry::m2b(),
|
||||
));
|
||||
thread::spawn(move || serve(listener, ctx));
|
||||
Loopd {
|
||||
home,
|
||||
server,
|
||||
socket,
|
||||
}
|
||||
}
|
||||
|
||||
fn id(s: &str) -> SessionId {
|
||||
SessionId::new(s).unwrap()
|
||||
}
|
||||
|
||||
/// Sends one turn and collects every frame that comes back.
|
||||
fn turn(socket: &PathBuf, session: &str, content: &str, resume: bool) -> Vec<Envelope> {
|
||||
let mut stream = UnixStream::connect(socket).unwrap();
|
||||
stream
|
||||
.set_read_timeout(Some(Duration::from_secs(10)))
|
||||
.unwrap();
|
||||
let msg = Message::Turn(Turn {
|
||||
session: id(session),
|
||||
content: content.to_string(),
|
||||
resume,
|
||||
});
|
||||
write_frame(
|
||||
&mut stream,
|
||||
&Envelope {
|
||||
v: PROTOCOL_VERSION,
|
||||
id: 42,
|
||||
r#final: true,
|
||||
msg,
|
||||
},
|
||||
)
|
||||
.unwrap();
|
||||
let mut frames = Vec::new();
|
||||
loop {
|
||||
let frame = read_frame(&mut stream).unwrap();
|
||||
let last = frame.r#final;
|
||||
frames.push(frame);
|
||||
if last {
|
||||
break;
|
||||
}
|
||||
}
|
||||
frames
|
||||
}
|
||||
|
||||
fn error_code(frames: &[Envelope]) -> Option<ErrorCode> {
|
||||
match &frames.last()?.msg {
|
||||
Message::Error(e) => Some(e.code),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_turn_streams_events_and_ends_with_turn_done() {
|
||||
let l = start(vec![]);
|
||||
l.server.route(CHAT, vec![Reply::fixture("thinking")]);
|
||||
let frames = turn(&l.socket, "a", "what is 17 * 23?", false);
|
||||
assert!(frames.len() > 3, "{frames:?}");
|
||||
assert!(
|
||||
frames.iter().all(|f| f.id == 42),
|
||||
"every frame carries the request id"
|
||||
);
|
||||
assert!(frames.iter().all(|f| f.v == PROTOCOL_VERSION));
|
||||
let (last, events) = frames.split_last().unwrap();
|
||||
assert!(
|
||||
events
|
||||
.iter()
|
||||
.all(|f| !f.r#final && matches!(f.msg, Message::TurnEvent(_)))
|
||||
);
|
||||
assert!(
|
||||
events
|
||||
.iter()
|
||||
.any(|f| matches!(f.msg, Message::TurnEvent(TurnEvent::Reasoning { .. })))
|
||||
);
|
||||
assert!(
|
||||
events
|
||||
.iter()
|
||||
.any(|f| matches!(f.msg, Message::TurnEvent(TurnEvent::Content { .. })))
|
||||
);
|
||||
match &last.msg {
|
||||
Message::TurnDone(done) => {
|
||||
assert_eq!(
|
||||
done.content,
|
||||
support::expected("thinking")["content"].as_str().unwrap()
|
||||
);
|
||||
assert_eq!(done.usage.reasoning_tokens, 49);
|
||||
assert_eq!(done.usage.prompt_n, 40);
|
||||
}
|
||||
other => panic!("{other:?}"),
|
||||
}
|
||||
// The content events, concatenated, are the answer.
|
||||
let streamed: String = events
|
||||
.iter()
|
||||
.filter_map(|f| match &f.msg {
|
||||
Message::TurnEvent(TurnEvent::Content { text }) => Some(text.as_str()),
|
||||
_ => None,
|
||||
})
|
||||
.collect();
|
||||
let Message::TurnDone(done) = &last.msg else {
|
||||
unreachable!()
|
||||
};
|
||||
assert_eq!(streamed, done.content);
|
||||
// And the session is on disk.
|
||||
assert_eq!(l.home.records("a").len(), 4);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn tool_calls_are_reported_by_name_only() {
|
||||
let l = start(vec![support::ok_result("straylight\n")]);
|
||||
l.server.route(
|
||||
CHAT,
|
||||
vec![Reply::fixture("tool_call"), Reply::fixture("plain")],
|
||||
);
|
||||
let frames = turn(&l.socket, "a", "hostname?", false);
|
||||
let tool_events: Vec<&TurnEvent> = frames
|
||||
.iter()
|
||||
.filter_map(|f| match &f.msg {
|
||||
Message::TurnEvent(
|
||||
e @ (TurnEvent::ToolCallStarted { .. } | TurnEvent::ToolResult { .. }),
|
||||
) => Some(e),
|
||||
_ => None,
|
||||
})
|
||||
.collect();
|
||||
assert_eq!(tool_events.len(), 2);
|
||||
assert_eq!(
|
||||
tool_events[0],
|
||||
&TurnEvent::ToolCallStarted {
|
||||
name: "read_file".to_string()
|
||||
}
|
||||
);
|
||||
assert_eq!(
|
||||
tool_events[1],
|
||||
&TurnEvent::ToolResult {
|
||||
name: "read_file".to_string(),
|
||||
class: proto::DataClass::Private,
|
||||
truncated: false
|
||||
}
|
||||
);
|
||||
let text = serde_json::to_string(&frames).unwrap();
|
||||
assert!(
|
||||
!text.contains("straylight"),
|
||||
"the result body is not on the channel: {text}"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn resume_and_create_are_checked() {
|
||||
let l = start(vec![]);
|
||||
l.server
|
||||
.route(CHAT, vec![Reply::fixture("turn1"), Reply::fixture("turn2")]);
|
||||
assert_eq!(
|
||||
error_code(&turn(&l.socket, "a", "x", true)),
|
||||
Some(ErrorCode::NoSuchSession),
|
||||
"resume needs an existing session"
|
||||
);
|
||||
assert!(matches!(
|
||||
turn(&l.socket, "a", "one", false).last().unwrap().msg,
|
||||
Message::TurnDone(_)
|
||||
));
|
||||
assert_eq!(
|
||||
error_code(&turn(&l.socket, "a", "x", false)),
|
||||
Some(ErrorCode::SessionExists),
|
||||
"create needs a new one"
|
||||
);
|
||||
let frames = turn(&l.socket, "a", "two", true);
|
||||
assert!(
|
||||
matches!(frames.last().unwrap().msg, Message::TurnDone(_)),
|
||||
"{frames:?}"
|
||||
);
|
||||
let sent = l.server.requests_to(CHAT);
|
||||
assert_eq!(sent.len(), 2);
|
||||
assert_eq!(
|
||||
sent[1].json()["messages"].as_array().unwrap().len(),
|
||||
4,
|
||||
"the second turn carried the first"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_busy_session_is_refused_at_once_and_another_session_is_not() {
|
||||
let l = start(vec![]);
|
||||
let size = support::fixture_bytes("http", "plain.http").len();
|
||||
l.server
|
||||
.route(CHAT, vec![Reply::fixture("plain").trickle(size / 4, 120)]);
|
||||
let socket = l.socket.clone();
|
||||
let first = thread::spawn(move || turn(&socket, "a", "slow", false));
|
||||
thread::sleep(Duration::from_millis(100));
|
||||
let started = std::time::Instant::now();
|
||||
assert_eq!(
|
||||
error_code(&turn(&l.socket, "a", "again", true)),
|
||||
Some(ErrorCode::SessionBusy)
|
||||
);
|
||||
assert!(
|
||||
started.elapsed() < Duration::from_millis(100),
|
||||
"refused at once"
|
||||
);
|
||||
assert!(
|
||||
matches!(
|
||||
turn(&l.socket, "b", "other", false).last().unwrap().msg,
|
||||
Message::TurnDone(_)
|
||||
),
|
||||
"another session runs"
|
||||
);
|
||||
assert!(matches!(
|
||||
first.join().unwrap().last().unwrap().msg,
|
||||
Message::TurnDone(_)
|
||||
));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn limits_and_server_errors_come_back_as_error_codes() {
|
||||
let l = start(vec![]);
|
||||
l.server.route(CHAT, vec![Reply::fixture("context_full")]);
|
||||
assert_eq!(
|
||||
error_code(&turn(&l.socket, "a", "x", false)),
|
||||
Some(ErrorCode::SessionFull)
|
||||
);
|
||||
|
||||
l.server.route(CHAT, vec![Reply::fixture("tool_call")]);
|
||||
let frames = turn(&l.socket, "b", "x", false);
|
||||
assert_eq!(
|
||||
error_code(&frames),
|
||||
Some(ErrorCode::TurnLimit),
|
||||
"a repeated call twice"
|
||||
);
|
||||
assert!(
|
||||
frames
|
||||
.iter()
|
||||
.any(|f| matches!(f.msg, Message::TurnEvent(TurnEvent::ToolCallStarted { .. }))),
|
||||
"events before the error were delivered"
|
||||
);
|
||||
|
||||
l.server.route(CHAT, vec![Reply::fixture("bad_request")]);
|
||||
let frames = turn(&l.socket, "c", "x", false);
|
||||
assert_eq!(error_code(&frames), Some(ErrorCode::Inference));
|
||||
let Message::Error(e) = &frames.last().unwrap().msg else {
|
||||
unreachable!()
|
||||
};
|
||||
assert!(e.detail.contains("400"), "{}", e.detail);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bad_frames_get_an_error_and_a_close() {
|
||||
let l = start(vec![]);
|
||||
// A frame that is not a turn.
|
||||
let mut stream = UnixStream::connect(&l.socket).unwrap();
|
||||
stream
|
||||
.set_read_timeout(Some(Duration::from_secs(5)))
|
||||
.unwrap();
|
||||
let msg = Message::Error(proto::WireError {
|
||||
code: ErrorCode::Internal,
|
||||
detail: String::new(),
|
||||
});
|
||||
write_frame(
|
||||
&mut stream,
|
||||
&Envelope {
|
||||
v: PROTOCOL_VERSION,
|
||||
id: 1,
|
||||
r#final: true,
|
||||
msg,
|
||||
},
|
||||
)
|
||||
.unwrap();
|
||||
let reply = read_frame(&mut stream).unwrap();
|
||||
assert!(reply.r#final);
|
||||
assert!(
|
||||
matches!(
|
||||
reply.msg,
|
||||
Message::Error(proto::WireError {
|
||||
code: ErrorCode::BadMessage,
|
||||
..
|
||||
})
|
||||
),
|
||||
"{reply:?}"
|
||||
);
|
||||
assert!(
|
||||
matches!(read_frame(&mut stream), Err(proto::FrameError::Closed)),
|
||||
"then the connection is closed"
|
||||
);
|
||||
|
||||
// Bytes that are not a frame at all.
|
||||
let mut stream = UnixStream::connect(&l.socket).unwrap();
|
||||
stream
|
||||
.set_read_timeout(Some(Duration::from_secs(5)))
|
||||
.unwrap();
|
||||
std::io::Write::write_all(&mut stream, &[0, 0, 0, 3, b'{', b'{', b'{']).unwrap();
|
||||
let reply = read_frame(&mut stream).unwrap();
|
||||
assert!(
|
||||
matches!(
|
||||
reply.msg,
|
||||
Message::Error(proto::WireError {
|
||||
code: ErrorCode::BadMessage,
|
||||
..
|
||||
})
|
||||
),
|
||||
"{reply:?}"
|
||||
);
|
||||
|
||||
// A wrong protocol version.
|
||||
let mut stream = UnixStream::connect(&l.socket).unwrap();
|
||||
stream
|
||||
.set_read_timeout(Some(Duration::from_secs(5)))
|
||||
.unwrap();
|
||||
let msg = Message::Turn(Turn {
|
||||
session: id("a"),
|
||||
content: "x".to_string(),
|
||||
resume: false,
|
||||
});
|
||||
write_frame(
|
||||
&mut stream,
|
||||
&Envelope {
|
||||
v: 2,
|
||||
id: 1,
|
||||
r#final: true,
|
||||
msg,
|
||||
},
|
||||
)
|
||||
.unwrap();
|
||||
let reply = read_frame(&mut stream).unwrap();
|
||||
assert!(
|
||||
matches!(
|
||||
reply.msg,
|
||||
Message::Error(proto::WireError {
|
||||
code: ErrorCode::BadVersion,
|
||||
..
|
||||
})
|
||||
),
|
||||
"{reply:?}"
|
||||
);
|
||||
|
||||
// A client that connects and leaves.
|
||||
drop(UnixStream::connect(&l.socket).unwrap());
|
||||
thread::sleep(Duration::from_millis(50));
|
||||
l.server.route(CHAT, vec![Reply::fixture("plain")]);
|
||||
assert!(matches!(
|
||||
turn(&l.socket, "z", "still up", false).last().unwrap().msg,
|
||||
Message::TurnDone(_)
|
||||
));
|
||||
}
|
||||
Reference in New Issue
Block a user