agent-shim 8.3.0 → 8.4.1

package/dist/index.mjs

@@ -3342,6 +3342,11 @@ function realConnectEffects() {
         request4.on("data", (chunk) => {
           observer.onRequestChunk(chunk);
         });
+        if (observer.onRequestEnd !== void 0) {
+          request4.on("end", () => {
+            observer.onRequestEnd?.();
+          });
+        }
         response.on("close", () => {
           observer.onEnd();
         });
@@ -3377,6 +3382,9 @@ var RC_SESSION_ID_PREFIX = "cse_";
 var RC_IDLE_EXPIRY_MS = 45e3;
 var RC_CREATE_RESPONSE_CAP_BYTES = 8192;
 var CONFLICT_REASON_HEADER = "x-ccr-conflict-reason";
+var RC_PENDING_DEADLINE_MS = 14e3;
+var RC_REQUEST_PARSE_CAP_BYTES = 262144;
+var RC_PENDING_SUMMARY_EXCERPT_CHARS = 300;
 var SUCCESS_STATUS_MAX_EXCLUSIVE = 300;
 function isSuccessful(status) {
   return status >= HTTP_STATUS.ok && status < SUCCESS_STATUS_MAX_EXCLUSIVE;
@@ -3402,20 +3410,124 @@ function sessionCreateId(body) {
   const id = session.id;
   return typeof id === "string" && id.startsWith(RC_SESSION_ID_PREFIX) ? id : void 0;
 }
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseJsonObject(body) {
+  let parsed;
+  try {
+    parsed = JSON.parse(body);
+  } catch {
+    return void 0;
+  }
+  return isRecord2(parsed) ? parsed : void 0;
+}
+function nonEmptyString(record, field) {
+  const value = record === void 0 ? void 0 : record[field];
+  return typeof value === "string" && value !== "" ? value : void 0;
+}
+function finiteNumber(record, field) {
+  const value = record === void 0 ? void 0 : record[field];
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function excerpt(text) {
+  return text.length <= RC_PENDING_SUMMARY_EXCERPT_CHARS ? text : `${text.slice(0, RC_PENDING_SUMMARY_EXCERPT_CHARS)}...`;
+}
+function payloadEventsOf(body) {
+  const parsed = parseJsonObject(body);
+  const events = parsed === void 0 ? void 0 : parsed.events;
+  if (!Array.isArray(events)) {
+    return [];
+  }
+  const payloads = [];
+  for (const event of events) {
+    if (!isRecord2(event)) {
+      continue;
+    }
+    const payload = event.payload;
+    if (!isRecord2(payload)) {
+      continue;
+    }
+    payloads.push(payload);
+  }
+  return payloads;
+}
+function pendingOfControlRequestPayload(payload) {
+  if (payload.type !== "control_request") {
+    return void 0;
+  }
+  const requestId = nonEmptyString(payload, "request_id") ?? nonEmptyString(payload, "uuid");
+  if (requestId === void 0) {
+    return void 0;
+  }
+  const request4 = isRecord2(payload.request) ? payload.request : void 0;
+  const subtype = nonEmptyString(request4, "subtype");
+  const type = subtype ?? "control_request";
+  let summary = "";
+  if (subtype === "can_use_tool") {
+    const toolName = nonEmptyString(request4, "tool_name") ?? "unknown tool";
+    const input = request4 === void 0 ? void 0 : request4.input;
+    summary = input === void 0 ? toolName : `${toolName} ${excerpt(JSON.stringify(input))}`;
+  } else if (request4 !== void 0) {
+    summary = excerpt(JSON.stringify(request4));
+  }
+  return { requestId, type, summary };
+}
+function answeredRequestIdsOfControlResponsePayload(payload) {
+  if (payload.type !== "control_response") {
+    return [];
+  }
+  const response = isRecord2(payload.response) ? payload.response : void 0;
+  const id = nonEmptyString(response, "request_id") ?? nonEmptyString(payload, "request_id") ?? nonEmptyString(payload, "uuid");
+  return id === void 0 ? [] : [id];
+}
+function parseRcRequestBody(kind, body) {
+  if (kind === "heartbeat") {
+    return { controlRequests: [], answeredRequestIds: [], idleSeconds: finiteNumber(parseJsonObject(body), "idle_seconds"), workerStatus: void 0 };
+  }
+  if (kind === "worker-registration") {
+    return { controlRequests: [], answeredRequestIds: [], idleSeconds: void 0, workerStatus: nonEmptyString(parseJsonObject(body), "status") };
+  }
+  const controlRequests = [];
+  const answeredRequestIds = [];
+  for (const payload of payloadEventsOf(body)) {
+    const pending = pendingOfControlRequestPayload(payload);
+    if (pending !== void 0) {
+      controlRequests.push({ requestId: pending.requestId, type: pending.type, summary: pending.summary });
+      continue;
+    }
+    answeredRequestIds.push(...answeredRequestIdsOfControlResponsePayload(payload));
+  }
+  return { controlRequests, answeredRequestIds, idleSeconds: void 0, workerStatus: void 0 };
+}
 function createRcSessionTracker(deps) {
   const entries = /* @__PURE__ */ new Map();
   const expire = (id) => {
     entries.delete(id);
   };
+  const expirePendings = (entry, now) => {
+    for (const [requestId, pending] of entry.pending) {
+      if (now - pending.observedAt >= RC_PENDING_DEADLINE_MS) {
+        entry.pending.delete(requestId);
+      }
+    }
+  };
   const sweep = () => {
     for (const [id, entry] of entries) {
       if (deps.now() - entry.lastSeenAt >= deps.idleMs) {
         expire(id);
+        continue;
       }
+      expirePendings(entry, deps.now());
     }
   };
   const timer = setInterval(sweep, deps.idleMs);
   timer.unref();
+  const birth = (id, facts) => {
+    const record = { id, createdAt: deps.now(), lastSeenAt: deps.now(), ...facts, pending: /* @__PURE__ */ new Map(), workerState: void 0, workerIdleSeconds: void 0 };
+    entries.set(id, record);
+    return record;
+  };
   const observeExchange = (request4) => {
     const method = (request4.method ?? "").toUpperCase();
     const path29 = new URL(request4.url ?? "/", "http://127.0.0.1").pathname;
@@ -3432,30 +3544,30 @@ function createRcSessionTracker(deps) {
       if (method !== "POST") {
         return void 0;
       }
-      let accepted = false;
-      let buffered = 0;
+      let accepted2 = false;
+      let buffered2 = 0;
       let body = "";
       return {
         onResponse: (status) => {
-          accepted = isSuccessful(status);
+          accepted2 = isSuccessful(status);
         },
         onBodyChunk: (chunk) => {
-          if (!accepted || buffered >= RC_CREATE_RESPONSE_CAP_BYTES) {
+          if (!accepted2 || buffered2 >= RC_CREATE_RESPONSE_CAP_BYTES) {
             return;
           }
           const text = Buffer.from(chunk).toString("utf8");
-          body = body + text.slice(0, RC_CREATE_RESPONSE_CAP_BYTES - buffered);
-          buffered = body.length;
+          body = body + text.slice(0, RC_CREATE_RESPONSE_CAP_BYTES - buffered2);
+          buffered2 = body.length;
         },
         onEnd: () => {
-          if (!accepted) {
+          if (!accepted2) {
             return;
           }
           const id2 = sessionCreateId(body);
           if (id2 === void 0) {
             return;
           }
-          entries.set(id2, { id: id2, createdAt: deps.now(), lastSeenAt: deps.now(), ...facts });
+          birth(id2, facts);
         }
       };
     }
@@ -3464,21 +3576,69 @@ function createRcSessionTracker(deps) {
     if (id?.startsWith(RC_SESSION_ID_PREFIX) !== true) {
       return void 0;
     }
-    const entry = entries.get(id);
-    if (entry === void 0) {
-      entries.set(id, { id, createdAt: deps.now(), lastSeenAt: deps.now(), ...facts });
-    } else {
-      entry.lastSeenAt = deps.now();
-      entry.authorization = facts.authorization ?? entry.authorization;
-      entry.anthropicVersion = facts.anthropicVersion ?? entry.anthropicVersion;
-      entry.anthropicClientPlatform = facts.anthropicClientPlatform ?? entry.anthropicClientPlatform;
-    }
+    const entry = entries.get(id) ?? birth(id, facts);
+    entry.lastSeenAt = deps.now();
+    entry.authorization = facts.authorization ?? entry.authorization;
+    entry.anthropicVersion = facts.anthropicVersion ?? entry.anthropicVersion;
+    entry.anthropicClientPlatform = facts.anthropicClientPlatform ?? entry.anthropicClientPlatform;
+    const bodyKind = method === "POST" && rest === `${id}/worker/events` ? "worker-events" : method === "POST" && rest === `${id}/events` ? "client-events" : method === "POST" && rest === `${id}/worker/heartbeat` ? "heartbeat" : method === "PUT" && rest === `${id}/worker` ? "worker-registration" : void 0;
+    let chunks = [];
+    let buffered = 0;
+    let oversized = false;
+    let requestEnded = false;
+    let accepted;
+    let filed = false;
+    const file = () => {
+      if (filed || accepted !== true || !requestEnded || bodyKind === void 0) {
+        return;
+      }
+      filed = true;
+      const factsOfBody = oversized ? void 0 : parseRcRequestBody(bodyKind, Buffer.concat(chunks).toString("utf8"));
+      chunks = [];
+      const entryNow = entries.get(id);
+      if (entryNow === void 0 || factsOfBody === void 0) {
+        return;
+      }
+      const now = deps.now();
+      for (const controlRequest of factsOfBody.controlRequests) {
+        entryNow.pending.set(controlRequest.requestId, { sessionId: id, ...controlRequest, observedAt: now });
+      }
+      for (const requestId of factsOfBody.answeredRequestIds) {
+        entryNow.pending.delete(requestId);
+      }
+      if (factsOfBody.idleSeconds !== void 0) {
+        entryNow.workerIdleSeconds = { value: factsOfBody.idleSeconds, observedAt: now };
+      }
+      if (factsOfBody.workerStatus !== void 0) {
+        entryNow.workerState = { value: factsOfBody.workerStatus, observedAt: now };
+      }
+    };
     const archiving = method === "POST" && rest === `${id}/archive`;
     return {
+      ...bodyKind === void 0 ? {} : {
+        onRequestChunk: (chunk) => {
+          if (oversized) {
+            return;
+          }
+          chunks.push(Buffer.from(chunk));
+          buffered += chunk.length;
+          if (buffered > RC_REQUEST_PARSE_CAP_BYTES) {
+            oversized = true;
+            chunks = [];
+          }
+        },
+        onRequestEnd: () => {
+          requestEnded = true;
+          file();
+        }
+      },
       onResponse: (status, headers) => {
         if (singleHeader(headers, CONFLICT_REASON_HEADER) !== void 0 || archiving && isSuccessful(status)) {
           expire(id);
+          return;
         }
+        accepted = isSuccessful(status);
+        file();
       },
       onBodyChunk: () => {
       },
@@ -3486,16 +3646,31 @@ function createRcSessionTracker(deps) {
       }
     };
   };
+  const summaryOf = ({ id, createdAt, lastSeenAt }) => ({ id, createdAt, lastSeenAt });
+  const pendingSummaryOf = ({ sessionId, requestId, type, summary, observedAt }) => ({ sessionId, requestId, type, summary, observedAt });
+  const sortedEntries = () => [...entries.values()].sort((left, right) => left.createdAt - right.createdAt || (left.id < right.id ? -1 : 1));
+  const pendingSorted = (entry) => [...entry.pending.values()].sort((left, right) => left.observedAt - right.observedAt || (left.requestId < right.requestId ? -1 : 1)).map(pendingSummaryOf);
   return {
     observeExchange,
     list: () => {
       sweep();
-      return [...entries.values()].sort((left, right) => left.createdAt - right.createdAt || (left.id < right.id ? -1 : 1)).map(({ id, createdAt, lastSeenAt }) => ({ id, createdAt, lastSeenAt }));
+      return sortedEntries().map(summaryOf);
+    },
+    statusOf: (sessionId) => {
+      sweep();
+      return sortedEntries().filter((entry) => sessionId === void 0 || entry.id === sessionId).map((entry) => ({ ...summaryOf(entry), workerState: entry.workerState, workerIdleSeconds: entry.workerIdleSeconds, pending: pendingSorted(entry) }));
+    },
+    pendingOf: (sessionId) => {
+      sweep();
+      return sortedEntries().filter((entry) => sessionId === void 0 || entry.id === sessionId).flatMap((entry) => pendingSorted(entry));
     },
     credentialOf: (sessionId) => {
       const entry = entries.get(sessionId);
       return entry === void 0 ? void 0 : { authorization: entry.authorization, anthropicVersion: entry.anthropicVersion, anthropicClientPlatform: entry.anthropicClientPlatform };
     },
+    completePending: (sessionId, requestId) => {
+      entries.get(sessionId)?.pending.delete(requestId);
+    },
     close: () => {
       clearInterval(timer);
     }
@@ -3506,6 +3681,14 @@ function observingRoutedRoute(route, tracker) {
     ...route,
     serve: async (request4, response) => {
       const observed = tracker.observeExchange({ method: request4.method, url: request4.url, headers: request4.headers });
+      if (observed?.onRequestChunk !== void 0) {
+        request4.body.on("data", (chunk) => {
+          observed.onRequestChunk?.(chunk);
+        });
+        request4.body.on("end", () => {
+          observed.onRequestEnd?.();
+        });
+      }
       await route.serve(request4, observed === void 0 ? response : teeRoutedResponse(response, observed));
     }
   };
@@ -3538,9 +3721,13 @@ function teeRoutedResponse(response, observer) {
 }
 function rcObserverAsPassthrough(observer) {
   return {
-    // The request body carries nothing the tracker reads: the credential and the session id are in the request's headers and path, already handed over with the request.
-    onRequestChunk: () => {
-      return;
+    onRequestChunk: (chunk) => {
+      observer.onRequestChunk?.(chunk);
+    },
+    ...observer.onRequestEnd === void 0 ? {} : {
+      onRequestEnd: () => {
+        observer.onRequestEnd?.();
+      }
     },
     onResponse: (status, headers) => {
       observer.onResponse(status, headers);
@@ -3589,7 +3776,7 @@ function sequenceNumsOf(body) {
   }
   return sequenceNums.length === 0 ? void 0 : sequenceNums;
 }
-function rcInjectResultFromAnswer(answer) {
+function rcEventWriteResultFromAnswer(answer) {
   if (!isSuccessful(answer.status)) {
     if (answer.status === HTTP_STATUS.unauthorized) {
       return { ok: false, message: `the API refused the observed Authorization bearer for this session (HTTP 401): the bearer went stale after the door last saw the session's traffic. The session's own client refreshes it on its next call, which the door will observe, so retry once Remote Control has been active again. API answer: ${answer.body}` };
@@ -3602,11 +3789,7 @@ function rcInjectResultFromAnswer(answer) {
   }
   return { ok: true, sequenceNums };
 }
-async function injectRcUserMessage(deps, sessionId, text) {
-  const credential = deps.credentialOf(sessionId);
-  if (credential === void 0) {
-    return { ok: false, message: `the front door has not observed Remote Control session ${sessionId}: it may never have passed through this door, or it ended or expired (an entry lives only a bounded idle period past its last observed traffic)` };
-  }
+function rcWriteHeaders(credential) {
   const headers = { "content-type": "application/json" };
   if (credential.authorization !== void 0) {
     headers.authorization = credential.authorization;
@@ -3617,14 +3800,46 @@ async function injectRcUserMessage(deps, sessionId, text) {
   if (credential.anthropicClientPlatform !== void 0) {
     headers["anthropic-client-platform"] = credential.anthropicClientPlatform;
   }
+  return headers;
+}
+async function injectRcUserMessage(deps, sessionId, text) {
+  const credential = deps.credentialOf(sessionId);
+  if (credential === void 0) {
+    return { ok: false, message: `the front door has not observed Remote Control session ${sessionId}: it may never have passed through this door, or it ended or expired (an entry lives only a bounded idle period past its last observed traffic)` };
+  }
   const body = JSON.stringify(buildRcEventWriteBody(buildRcUserMessagePayload(deps.newUuid(), sessionId, text)));
   let answer;
   try {
-    answer = await deps.dial.writeEvents(sessionId, headers, body);
+    answer = await deps.dial.writeEvents(sessionId, rcWriteHeaders(credential), body);
   } catch (error) {
     return { ok: false, message: `the door could not reach the API host to inject into session ${sessionId}: ${error instanceof Error ? error.message : String(error)}` };
   }
-  return rcInjectResultFromAnswer(answer);
+  return rcEventWriteResultFromAnswer(answer);
+}
+function buildRcControlResponsePayload(requestId, decision) {
+  const result = decision.approve ? { behavior: "allow" } : { behavior: "deny", message: decision.message ?? "" };
+  return { type: "control_response", response: { subtype: "success", request_id: requestId, response: result } };
+}
+async function answerRcControlRequest(deps, sessionId, requestId, decision) {
+  const credential = deps.credentialOf(sessionId);
+  if (credential === void 0) {
+    return { ok: false, message: `the front door has not observed Remote Control session ${sessionId}: it may never have passed through this door, or it ended or expired (an entry lives only a bounded idle period past its last observed traffic)` };
+  }
+  if (!deps.pendingOf(sessionId).some((pending) => pending.requestId === requestId)) {
+    return { ok: false, message: `the front door has not observed control request ${requestId} pending on session ${sessionId}: it was answered already (by this door or by an attached client), it passed its answer deadline (the protocol's permission round-trip bound), or it never passed through this door` };
+  }
+  const body = JSON.stringify(buildRcEventWriteBody(buildRcControlResponsePayload(requestId, decision)));
+  let answer;
+  try {
+    answer = await deps.dial.writeEvents(sessionId, rcWriteHeaders(credential), body);
+  } catch (error) {
+    return { ok: false, message: `the door could not reach the API host to answer on session ${sessionId}: ${error instanceof Error ? error.message : String(error)}` };
+  }
+  const result = rcEventWriteResultFromAnswer(answer);
+  if (result.ok) {
+    deps.completePending(sessionId, requestId);
+  }
+  return result;
 }
 
 // src/frontdoor/rcControl.ts
@@ -3659,7 +3874,10 @@ async function readBody(request4) {
 }
 function createRcControlHandler(deps) {
   const sessionsPath = `${CONTROL_PATH_PREFIX}/sessions`;
+  const statusPath = `${CONTROL_PATH_PREFIX}/status`;
+  const pendingPath = `${CONTROL_PATH_PREFIX}/pending`;
   const injectPath = `${CONTROL_PATH_PREFIX}/inject`;
+  const answerPath = `${CONTROL_PATH_PREFIX}/answer`;
   return (request4, response) => {
     const presented = request4.headers.authorization;
     const bearerPrefix = "bearer ".length;
@@ -3668,9 +3886,9 @@ function createRcControlHandler(deps) {
       answerJson(response, HTTP_STATUS.unauthorized, { error: "the front door's control routes demand this generation's control token as a Bearer credential" });
       return;
     }
-    const url = request4.url ?? "/";
+    const url = new URL(request4.url ?? "/", "http://127.0.0.1");
     const handle = async () => {
-      if (url === sessionsPath) {
+      if (url.pathname === sessionsPath) {
         if (request4.method !== "GET") {
           answerJson(response, HTTP_STATUS.methodNotAllowed, { error: "the session list is a GET" });
           return;
@@ -3678,7 +3896,20 @@ function createRcControlHandler(deps) {
         answerJson(response, HTTP_STATUS.ok, { sessions: deps.list() });
         return;
       }
-      if (url === injectPath) {
+      if (url.pathname === statusPath || url.pathname === pendingPath) {
+        if (request4.method !== "GET") {
+          answerJson(response, HTTP_STATUS.methodNotAllowed, { error: "the status and pending reads are GETs" });
+          return;
+        }
+        const session = url.searchParams.get("session") ?? void 0;
+        if (session !== void 0 && !deps.statusOf(session).some((entry) => entry.id === session)) {
+          answerJson(response, HTTP_STATUS.notFound, { error: `the front door has not observed Remote Control session ${session}: it may never have passed through this door, or it ended or expired (an entry lives only a bounded idle period past its last observed traffic)` });
+          return;
+        }
+        answerJson(response, HTTP_STATUS.ok, url.pathname === statusPath ? { statuses: deps.statusOf(session) } : { pending: deps.pendingOf(session) });
+        return;
+      }
+      if (url.pathname === injectPath) {
         if (request4.method !== "POST") {
           answerJson(response, HTTP_STATUS.methodNotAllowed, { error: "the inject operation is a POST" });
           return;
@@ -3702,7 +3933,36 @@ function createRcControlHandler(deps) {
         answerJson(response, HTTP_STATUS.badGateway, { error: result.message });
         return;
       }
-      answerJson(response, HTTP_STATUS.notFound, { error: `no such control route: ${url}` });
+      if (url.pathname === answerPath) {
+        if (request4.method !== "POST") {
+          answerJson(response, HTTP_STATUS.methodNotAllowed, { error: "the answer operation is a POST" });
+          return;
+        }
+        let parsed;
+        try {
+          parsed = JSON.parse(await readBody(request4));
+        } catch {
+          answerJson(response, HTTP_STATUS.badRequest, { error: "the answer body is not readable JSON within the control body cap" });
+          return;
+        }
+        if (typeof parsed !== "object" || parsed === null || !("session" in parsed) || !("request" in parsed) || !("approve" in parsed) || typeof parsed.session !== "string" || typeof parsed.request !== "string" || typeof parsed.approve !== "boolean" || parsed.session === "" || parsed.request === "") {
+          answerJson(response, HTTP_STATUS.badRequest, { error: "the answer body must be JSON naming a non-empty session id, request id, and an approve boolean" });
+          return;
+        }
+        const text = "text" in parsed && typeof parsed.text === "string" ? parsed.text : void 0;
+        if (parsed.approve && text !== void 0 && text !== "") {
+          answerJson(response, HTTP_STATUS.badRequest, { error: "an approval carries no text (the protocol's allow result has no message field); text is the denial message" });
+          return;
+        }
+        const result = await deps.answer(parsed.session, parsed.request, { approve: parsed.approve, message: parsed.approve ? void 0 : text });
+        if (result.ok) {
+          answerJson(response, HTTP_STATUS.ok, { session: parsed.session, request: parsed.request, sequenceNums: result.sequenceNums });
+          return;
+        }
+        answerJson(response, HTTP_STATUS.badGateway, { error: result.message });
+        return;
+      }
+      answerJson(response, HTTP_STATUS.notFound, { error: `no such control route: ${url.pathname}` });
     };
     handle().catch((error) => {
       answerJson(response, HTTP_STATUS.internalServerError, { error: `the control route failed: ${error instanceof Error ? error.message : String(error)}` });
@@ -3761,6 +4021,39 @@ function isRcSessionSummary(value) {
   }
   return typeof value.id === "string" && typeof value.createdAt === "number" && typeof value.lastSeenAt === "number";
 }
+function isRcWorkerFact(value, valueIs) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  if (!("value" in value) || !("observedAt" in value)) {
+    return false;
+  }
+  return valueIs(value.value) && typeof value.observedAt === "number";
+}
+function isRcSessionStatus(value) {
+  if (!isRcSessionSummary(value)) {
+    return false;
+  }
+  if (!("pending" in value) || !Array.isArray(value.pending)) {
+    return false;
+  }
+  if ("workerState" in value && value.workerState !== void 0 && !isRcWorkerFact(value.workerState, (candidate) => typeof candidate === "string")) {
+    return false;
+  }
+  if ("workerIdleSeconds" in value && value.workerIdleSeconds !== void 0 && !isRcWorkerFact(value.workerIdleSeconds, (candidate) => typeof candidate === "number")) {
+    return false;
+  }
+  return value.pending.every((candidate) => isRcPendingRequestSummary(candidate));
+}
+function isRcPendingRequestSummary(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  if (!("sessionId" in value) || !("requestId" in value) || !("type" in value) || !("summary" in value) || !("observedAt" in value)) {
+    return false;
+  }
+  return typeof value.sessionId === "string" && typeof value.requestId === "string" && typeof value.type === "string" && typeof value.summary === "string" && typeof value.observedAt === "number";
+}
 function sequenceNumsOfBody(body) {
   let parsed;
   try {
@@ -3783,6 +4076,13 @@ function sequenceNumsOfBody(body) {
 }
 function frontDoorRcControl(transport, token) {
   const headers = { authorization: `Bearer ${token}` };
+  const listAnswerOf = async (path29, what) => {
+    try {
+      return await transport.request({ method: "GET", path: path29, headers });
+    } catch (error) {
+      throw new Error(`${what}: could not reach the front door's control listener: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+    }
+  };
   const sessionsOf = (answer, what) => {
     if (answer.status !== HTTP_STATUS.ok) {
       throw new Error(`${what} failed (HTTP ${String(answer.status)}): ${controlErrorOf(answer.body) ?? answer.body}`);
@@ -3806,29 +4106,77 @@ function frontDoorRcControl(transport, token) {
     }
     return sessions;
   };
-  return {
-    listSessions: async () => sessionsOf(await transport.request({ method: "GET", path: `${CONTROL_PATH_PREFIX}/sessions`, headers }), "listing the door's Remote Control sessions"),
-    sendPrompt: async (sessionId, text) => {
-      let answer;
-      try {
-        answer = await transport.request({
-          method: "POST",
-          path: `${CONTROL_PATH_PREFIX}/inject`,
-          headers: { ...headers, "content-type": "application/json" },
-          body: JSON.stringify({ session: sessionId, text })
-        });
-      } catch (error) {
-        return { ok: false, message: `could not reach the front door's control listener: ${error instanceof Error ? error.message : String(error)}` };
+  const statusesOf = (answer, what) => {
+    if (answer.status !== HTTP_STATUS.ok) {
+      throw new Error(`${what} failed (HTTP ${String(answer.status)}): ${controlErrorOf(answer.body) ?? answer.body}`);
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(answer.body);
+    } catch {
+      throw new Error(`${what}: the door's answer was not JSON: ${answer.body}`);
+    }
+    if (typeof parsed !== "object" || parsed === null || !("statuses" in parsed) || !Array.isArray(parsed.statuses)) {
+      throw new Error(`${what}: the door's answer named no status list: ${answer.body}`);
+    }
+    const statuses = [];
+    for (const value of parsed.statuses) {
+      if (!isRcSessionStatus(value)) {
+        throw new Error(`${what}: the door's answer named no status list: ${answer.body}`);
       }
-      if (answer.status === HTTP_STATUS.ok) {
-        const sequenceNums = sequenceNumsOfBody(answer.body);
-        if (sequenceNums === void 0) {
-          return { ok: false, message: `the door accepted the event but its answer named no sequence numbers: ${answer.body}` };
-        }
-        return { ok: true, sequenceNums };
+      statuses.push(value);
+    }
+    return statuses;
+  };
+  const pendingOfAnswer = (answer, what) => {
+    if (answer.status !== HTTP_STATUS.ok) {
+      throw new Error(`${what} failed (HTTP ${String(answer.status)}): ${controlErrorOf(answer.body) ?? answer.body}`);
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(answer.body);
+    } catch {
+      throw new Error(`${what}: the door's answer was not JSON: ${answer.body}`);
+    }
+    if (typeof parsed !== "object" || parsed === null || !("pending" in parsed) || !Array.isArray(parsed.pending)) {
+      throw new Error(`${what}: the door's answer named no pending list: ${answer.body}`);
+    }
+    const pending = [];
+    for (const value of parsed.pending) {
+      if (!isRcPendingRequestSummary(value)) {
+        throw new Error(`${what}: the door's answer named no pending list: ${answer.body}`);
       }
-      return { ok: false, message: `injecting into ${sessionId} failed (HTTP ${String(answer.status)}): ${controlErrorOf(answer.body) ?? answer.body}` };
+      pending.push(value);
     }
+    return pending;
+  };
+  const writeOf = async (path29, body, describeFailure) => {
+    let answer;
+    try {
+      answer = await transport.request({ method: "POST", path: path29, headers: { ...headers, "content-type": "application/json" }, body });
+    } catch (error) {
+      return { ok: false, message: `could not reach the front door's control listener: ${error instanceof Error ? error.message : String(error)}` };
+    }
+    if (answer.status === HTTP_STATUS.ok) {
+      const sequenceNums = sequenceNumsOfBody(answer.body);
+      if (sequenceNums === void 0) {
+        return { ok: false, message: `the door accepted the event but its answer named no sequence numbers: ${answer.body}` };
+      }
+      return { ok: true, sequenceNums };
+    }
+    return { ok: false, message: describeFailure(answer.status, controlErrorOf(answer.body) ?? answer.body) };
+  };
+  const sessionQuery = (sessionId) => sessionId === void 0 ? "" : `?session=${encodeURIComponent(sessionId)}`;
+  return {
+    listSessions: async () => sessionsOf(await listAnswerOf(`${CONTROL_PATH_PREFIX}/sessions`, "listing the door's Remote Control sessions"), "listing the door's Remote Control sessions"),
+    statusOf: async (sessionId) => statusesOf(await listAnswerOf(`${CONTROL_PATH_PREFIX}/status${sessionQuery(sessionId)}`, "reading the door's Remote Control session status"), "reading the door's Remote Control session status"),
+    pendingOf: async (sessionId) => pendingOfAnswer(await listAnswerOf(`${CONTROL_PATH_PREFIX}/pending${sessionQuery(sessionId)}`, "listing the door's pending Remote Control control requests"), "listing the door's pending Remote Control control requests"),
+    sendPrompt: async (sessionId, text) => await writeOf(`${CONTROL_PATH_PREFIX}/inject`, JSON.stringify({ session: sessionId, text }), (status, message) => `injecting into ${sessionId} failed (HTTP ${String(status)}): ${message}`),
+    answerRequest: async (sessionId, requestId, decision) => await writeOf(
+      `${CONTROL_PATH_PREFIX}/answer`,
+      JSON.stringify({ session: sessionId, request: requestId, approve: decision.approve, ...decision.approve || decision.message === void 0 ? {} : { text: decision.message } }),
+      (status, message) => `answering control request ${requestId} on ${sessionId} failed (HTTP ${String(status)}): ${message}`
+    )
   };
 }
 
@@ -5490,14 +5838,14 @@ function providerExists(paths, name) {
 var LEGACY_PROVIDER_FIELDS = ["tokenEnv", "tokenCommand", "authScheme"];
 var LEGACY_ENV_CREDENTIAL_KEYS = Object.values(CREDENTIAL_TARGET_VARS);
 var LEGACY_LITERAL_PLACEHOLDER = "<the value of env.ANTHROPIC_AUTH_TOKEN>";
-function isRecord2(value) {
+function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function legacyProviderConversion(raw) {
-  if (!isRecord2(raw) || "credential" in raw) {
+  if (!isRecord3(raw) || "credential" in raw) {
     return void 0;
   }
-  const env = isRecord2(raw.env) ? raw.env : void 0;
+  const env = isRecord3(raw.env) ? raw.env : void 0;
   const legacyEnvKeys = env === void 0 ? [] : Object.keys(env).filter((key) => LEGACY_ENV_CREDENTIAL_KEYS.includes(key));
   const fields = [...LEGACY_PROVIDER_FIELDS.filter((field) => field in raw), ...legacyEnvKeys.map((key) => `env.${key}`)];
   if (fields.length === 0) {
@@ -8743,6 +9091,8 @@ export {
   ProviderNotFoundError,
   ProviderSchema,
   RC_IDLE_EXPIRY_MS,
+  RC_PENDING_DEADLINE_MS,
+  RC_REQUEST_PARSE_CAP_BYTES,
   RC_SESSIONS_PATH_PREFIX,
   ROUTED_PATH_PREFIX,
   UsageError,
@@ -8753,8 +9103,10 @@ export {
   addIdentity,
   addPool,
   addProvider,
+  answerRcControlRequest,
   buildEntryFacts,
   buildLayoutPaths,
+  buildRcControlResponsePayload,
   buildRcEventWriteBody,
   buildRcUserMessagePayload,
   carryOver,
@@ -8794,7 +9146,7 @@ export {
   prepareLaunch,
   profileExists,
   providerExists,
-  rcInjectResultFromAnswer,
+  rcEventWriteResultFromAnswer,
   rcObserverAsPassthrough,
   readActiveIdentity,
   readDirectoryRules,