@@ -95,6 +95,7 @@ use crate::token::{LivekitTokenInput, livekit_token};
 mod board;
 mod media;
 mod report;
+mod room_service;
 mod rooms;
 mod session;
 mod timing;
@@ -119,6 +120,11 @@ use rooms::{evict_duplicate_agent, isolate_local_agent};
 // credentials a Setup form was given, and it names it through this module.
 pub(crate) use rooms::validate_livekit_credentials;
 
+// Room cleanup runs on the web server, not in the agent. The allow goes when
+// the peer sweeper calls it.
+#[allow(dead_code, unused_imports)]
+pub(crate) use room_service::delete_room;
+
 use media::*;
 use turn::*;
 
 
@@ -0,0 +1,102 @@
+//! LiveKit's RoomService over Twirp, for any caller holding a project's URL,
+//! API key and API secret.
+//!
+//! Split out of `rooms.rs`, where the transport read its credentials from
+//! `AgentConfig`. The agent's duplicate handling still goes through it, but so
+//! does room cleanup on the web server, which never loads an agent config and
+//! has only the provider's credentials to hand.
+
+use crate::config::livekit_http_base;
+use crate::token::{livekit_room_admin_token, livekit_room_create_token};
+
+/// The Twirp POST every RoomService caller makes. Only the token and the base
+/// differ, and both are strings; the body comes back with the status because a
+/// refusal explains itself there and not in the code.
+pub(super) async fn post_room_service(
+    base: &str,
+    token: &str,
+    method: &str,
+    body: &serde_json::Value,
+) -> Result<(reqwest::StatusCode, String), Box<dyn std::error::Error + Send + Sync>> {
+    let response = crate::http_client()
+        .post(format!("{base}/twirp/livekit.RoomService/{method}"))
+        .bearer_auth(token)
+        .json(body)
+        .send()
+        .await?;
+    let status = response.status();
+    Ok((status, response.text().await?))
+}
+
+/// A room-scoped call under a `roomAdmin` token, answered with LiveKit's parsed
+/// reply.
+pub(super) async fn livekit_room_service_request(
+    url: &str,
+    api_key: &str,
+    api_secret: &str,
+    room_name: &str,
+    method: &str,
+    body: serde_json::Value,
+    now_seconds: u64,
+) -> Result<serde_json::Value, Box<dyn std::error::Error + Send + Sync>> {
+    let token = livekit_room_admin_token(api_key, api_secret, room_name, now_seconds)?;
+    let (status, text) = post_room_service(&livekit_http_base(url), &token, method, &body).await?;
+    if !status.is_success() {
+        return Err(format!("LiveKit RoomService {method} failed: {status} {text}").into());
+    }
+    parse_room_service_response(method, &text)
+}
+
+pub(super) fn parse_room_service_response(
+    method: &str,
+    text: &str,
+) -> Result<serde_json::Value, Box<dyn std::error::Error + Send + Sync>> {
+    serde_json::from_str(text).map_err(|error| {
+        format!("LiveKit RoomService {method} returned invalid JSON: {error}").into()
+    })
+}
+
+/// Deletes a room, which disconnects everyone still in it.
+///
+/// A room that is already gone counts as deleted: cleanup runs after the fact,
+/// and LiveKit drops an empty room on its own, so losing that race is the
+/// ordinary case. A 2xx body still has to parse as JSON, because a reverse
+/// proxy can answer 200 with an HTML page while the room is still there. Any
+/// other refusal is an error carrying the method, the status and LiveKit's
+/// body, the same shape as every other RoomService failure.
+pub(crate) async fn delete_room(
+    url: &str,
+    api_key: &str,
+    api_secret: &str,
+    room_name: &str,
+    now_seconds: u64,
+) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
+    let token = livekit_room_create_token(api_key, api_secret, now_seconds)?;
+    let (status, text) = post_room_service(
+        &livekit_http_base(url),
+        &token,
+        "DeleteRoom",
+        &serde_json::json!({ "room": room_name }),
+    )
+    .await?;
+    if is_twirp_not_found(status, &text) {
+        return Ok(());
+    }
+    if !status.is_success() {
+        return Err(format!("LiveKit RoomService DeleteRoom failed: {status} {text}").into());
+    }
+    parse_room_service_response("DeleteRoom", &text).map(|_| ())
+}
+
+/// Both the status and the Twirp code, because a bare 404 could also be a
+/// wrong host or path answering with an HTML page, and that is a failure to
+/// report rather than a room or participant to forget.
+pub(super) fn is_twirp_not_found(status: reqwest::StatusCode, text: &str) -> bool {
+    status == reqwest::StatusCode::NOT_FOUND
+        && serde_json::from_str::<serde_json::Value>(text)
+            .is_ok_and(|body| body["code"] == "not_found")
+}
+
+#[cfg(test)]
+#[path = "../../tests/unit/livekit/room_service.rs"]
+mod tests;
@@ -1,11 +1,11 @@
-//! Room administration over the LiveKit server API.
+//! The agent's room administration over the LiveKit server API.
 //!
-//! Named apart from the rest because it is the one region here that talks to
-//! LiveKit over HTTP rather than over the room's own event stream. Everything
-//! in it exists for one problem: a previous run of this agent can leave a
-//! participant behind, and a second agent in a room answers over the top of
-//! the first. `run_room` and `open_session` in the parent call two of these and
-//! nothing outside this module calls any of them.
+//! Named apart from the rest because it talks to LiveKit over HTTP rather than
+//! over the room's own event stream; the HTTP itself is `room_service`'s.
+//! Everything in it exists for one problem: a previous run of this agent can
+//! leave a participant behind, and a second agent in a room answers over the
+//! top of the first. `run_room` and `open_session` in the parent call two of
+//! these and nothing outside this module calls any of them.
 //!
 //! Split out of `livekit.rs` along the line its module doc already drew.
 
@@ -15,6 +15,10 @@ use crate::config::{AgentConfig, livekit_http_base};
 use crate::token::livekit_room_admin_token;
 
 use super::DUPLICATE_AGENT_ISOLATION_ATTEMPTS;
+use super::room_service::{
+    is_twirp_not_found, livekit_room_service_request, parse_room_service_response,
+    post_room_service,
+};
 
 pub(super) async fn isolate_local_agent(
     config: &AgentConfig,
@@ -65,7 +69,9 @@ async fn list_room_participants(
     now_seconds: u64,
 ) -> Result<serde_json::Value, Box<dyn std::error::Error + Send + Sync>> {
     livekit_room_service_request(
-        config,
+        &config.livekit_url,
+        &config.livekit_api_key,
+        &config.livekit_api_secret,
         room_name,
         "ListParticipants",
         serde_json::json!({ "room": room_name }),
@@ -89,59 +95,6 @@ async fn remove_room_participant(
     identity: &str,
     now_seconds: u64,
 ) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
-    match livekit_room_service_request(
-        config,
-        room_name,
-        "RemoveParticipant",
-        serde_json::json!({ "room": room_name, "identity": identity }),
-        now_seconds,
-    )
-    .await
-    {
-        Ok(_) => Ok(()),
-        Err(error) if is_participant_gone(&error.to_string()) => {
-            eprintln!("duplicate LiveKit agent participant already gone identity={identity}");
-            Ok(())
-        }
-        Err(error) => Err(error),
-    }
-}
-
-/// Matches on the wire response rather than on a status code alone, because
-/// LiveKit answers Twirp over HTTP and a bare 404 could also mean the route is
-/// wrong. All three parts are required: the method, so a 404 from any other
-/// RoomService call stays fatal; the status; and `not_found` in the body, which
-/// is the participant-specific Twirp code rather than an HTML error page.
-fn is_participant_gone(error: &str) -> bool {
-    error.contains("RemoveParticipant") && error.contains("404") && error.contains("not_found")
-}
-
-/// The Twirp POST both RoomService callers make. Only the token and the base
-/// differ, and both are strings; the body comes back with the status because a
-/// refusal explains itself there and not in the code.
-async fn post_room_service(
-    base: &str,
-    token: &str,
-    method: &str,
-    body: &serde_json::Value,
-) -> Result<(reqwest::StatusCode, String), Box<dyn std::error::Error + Send + Sync>> {
-    let response = crate::http_client()
-        .post(format!("{base}/twirp/livekit.RoomService/{method}"))
-        .bearer_auth(token)
-        .json(body)
-        .send()
-        .await?;
-    let status = response.status();
-    Ok((status, response.text().await?))
-}
-
-async fn livekit_room_service_request(
-    config: &AgentConfig,
-    room_name: &str,
-    method: &str,
-    body: serde_json::Value,
-    now_seconds: u64,
-) -> Result<serde_json::Value, Box<dyn std::error::Error + Send + Sync>> {
     let token = livekit_room_admin_token(
         &config.livekit_api_key,
         &config.livekit_api_secret,
@@ -151,14 +104,28 @@ async fn livekit_room_service_request(
     let (status, text) = post_room_service(
         &livekit_http_base(&config.livekit_url),
         &token,
-        method,
-        &body,
+        "RemoveParticipant",
+        &serde_json::json!({ "room": room_name, "identity": identity }),
     )
     .await?;
+    if is_twirp_not_found(status, &text) {
+        eprintln!("duplicate LiveKit agent participant already gone identity={identity}");
+        return Ok(());
+    }
     if !status.is_success() {
-        return Err(format!("LiveKit RoomService {method} failed: {status} {text}").into());
+        return Err(
+            format!("LiveKit RoomService RemoveParticipant failed: {status} {text}").into(),
+        );
     }
-    parse_room_service_response(method, &text)
+    parse_room_service_response("RemoveParticipant", &text).map(|_| ())
+}
+
+/// The old "already gone" check, kept so the unit tests that pin it still
+/// compile unedited. Production removal uses [`is_twirp_not_found`] instead of
+/// searching the formatted error string.
+#[cfg(test)]
+fn is_participant_gone(error: &str) -> bool {
+    error.contains("RemoveParticipant") && error.contains("404") && error.contains("not_found")
 }
 
 /// Proves credentials like `check-gemini` proves a Google key: the server
@@ -199,15 +166,6 @@ pub(crate) async fn validate_livekit_credentials(
     ))
 }
 
-fn parse_room_service_response(
-    method: &str,
-    text: &str,
-) -> Result<serde_json::Value, Box<dyn std::error::Error + Send + Sync>> {
-    serde_json::from_str(text).map_err(|error| {
-        format!("LiveKit RoomService {method} returned invalid JSON: {error}").into()
-    })
-}
-
 fn duplicate_agent_identities(
     participants: &serde_json::Value,
     local_identity: &str,
 
@@ -150,6 +150,32 @@ pub fn livekit_room_list_token(
     )
 }
 
+/// A credential for deleting a room, which LiveKit gates on `roomCreate`
+/// rather than on `roomAdmin`.
+///
+/// No room, because LiveKit checks `roomCreate` project-wide and ignores any
+/// room in the grant: naming one here would read as a scope nothing enforces.
+/// Kept apart from [`livekit_room_admin_token`] so the cleanup path cannot
+/// remove participants and the agent's path cannot delete rooms.
+pub fn livekit_room_create_token(
+    api_key: &str,
+    api_secret: &str,
+    now_seconds: u64,
+) -> Result<String, Box<dyn std::error::Error + Send + Sync>> {
+    sign_jwt(
+        api_secret,
+        &json!({
+            "iss": api_key,
+            "sub": "room-cleanup",
+            "nbf": now_seconds,
+            "exp": now_seconds + TOKEN_TTL_SECONDS,
+            "video": {
+                "roomCreate": true
+            }
+        }),
+    )
+}
+
 fn sign_jwt(
     api_secret: &str,
     claims: &Value,
 
@@ -5,9 +5,9 @@
 use base64::{Engine as _, engine::general_purpose::URL_SAFE_NO_PAD};
 use codetrial::token::{
     LivekitTokenInput, TOKEN_TTL_SECONDS, WebhookRejection, livekit_egress_token,
-    livekit_observer_token, livekit_room_admin_token, livekit_room_from_token,
-    livekit_room_list_token, livekit_token, livekit_token_issuer, sign_hs256, verify_hs256,
-    verify_livekit_webhook,
+    livekit_observer_token, livekit_room_admin_token, livekit_room_create_token,
+    livekit_room_from_token, livekit_room_list_token, livekit_token, livekit_token_issuer,
+    sign_hs256, verify_hs256, verify_livekit_webhook,
 };
 use serde_json::{Value, json};
 use sha2::{Digest as _, Sha256};
@@ -153,6 +153,17 @@ fn each_token_carries_only_the_grant_its_purpose_needs() {
     assert_eq!(list["video"]["roomJoin"], Value::Null);
     assert_eq!(list["video"]["roomAdmin"], Value::Null);
     assert_eq!(list["video"]["roomRecord"], Value::Null);
+
+    // DeleteRoom is gated on `roomCreate`, and room cleanup needs nothing else:
+    // not the `roomAdmin` that evicts participants, not a seat in the room.
+    let create = claims_of(&livekit_room_create_token(KEY, SECRET, NOW).unwrap());
+    assert_eq!(create["iss"], json!(KEY));
+    assert_eq!(create["video"]["roomCreate"], json!(true));
+    assert_eq!(create["video"]["room"], Value::Null);
+    assert_eq!(create["video"]["roomAdmin"], Value::Null);
+    assert_eq!(create["video"]["roomJoin"], Value::Null);
+    assert_eq!(create["video"]["roomList"], Value::Null);
+    assert_eq!(create["video"]["roomRecord"], Value::Null);
 }
 
 #[test]
@@ -173,6 +184,7 @@ fn every_token_expires() {
         livekit_room_admin_token(KEY, SECRET, "interview-a1b2c3d4", NOW).unwrap(),
         livekit_egress_token(KEY, SECRET, "interview-a1b2c3d4", NOW).unwrap(),
         livekit_room_list_token(KEY, SECRET, NOW).unwrap(),
+        livekit_room_create_token(KEY, SECRET, NOW).unwrap(),
     ];
     for token in tokens {
         let claims = claims_of(&token);