@fitchmultz/pi-subagents 0.49.1 → 0.51.0

package/dist/intercom-client.js

@@ -0,0 +1,45 @@
+import { IntercomClient as BrokerClient, } from "./pi-intercom/broker/client.js";
+import { isDeliveryGuard, } from "./pi-intercom/types.js";
+import { isRecord } from "./shared/unknown.js";
+function requireNoSpawn(value) {
+    if (value !== false) {
+        throw new Error("The supported Intercom client requires spawn:false.");
+    }
+}
+function guardedSend(to, input) {
+    return (isRecord(input) &&
+        isDeliveryGuard(input.guard) &&
+        to === input.guard.peerId &&
+        typeof input.messageId === "string" &&
+        input.expectsReply === false &&
+        input.delivery !== undefined);
+}
+/** Connect to an existing native broker. No Pi runtime, broker spawn or automatic retry. */
+export async function connectIntercom(options) {
+    requireNoSpawn(options.spawn);
+    const client = new BrokerClient(options);
+    client.on("error", (error) => options.onError?.(error));
+    try {
+        await client.connect(options.session, options.requestedId);
+    }
+    catch (error) {
+        await client.disconnect();
+        throw error;
+    }
+    return Object.freeze({
+        get sessionId() {
+            return client.sessionId;
+        },
+        isConnected: () => client.isConnected(),
+        listSessions: () => client.listSessions(),
+        async send(to, input) {
+            if (!guardedSend(to, input)) {
+                throw new Error("An exact guarded nonblocking send with an original message ID is required.");
+            }
+            return await client.send(to, input);
+        },
+        last: (to, query) => client.last(to, query),
+        receipt: (to, query) => client.receipt(to, query),
+        disconnect: () => client.disconnect(),
+    });
+}

package/dist/pi-intercom/agent-dir.d.ts

@@ -0,0 +1 @@
+export declare function getPiAgentDir(): string;

package/dist/pi-intercom/bridge-config.js

@@ -1,10 +1,8 @@
-import { realpathSync, statSync } from "node:fs";
 import { isAbsolute } from "node:path";
 import { createSecureContext } from "node:tls";
 import { parseEnv } from "node:util";
 import { isUnknownArray } from "../shared/unknown.js";
-import { BODY_LIMIT, object, label, fingerprint } from "./bridge-protocol.js";
-import { launchPolicy } from "./bridge-launch-policy.js";
+import { BODY_LIMIT, object, label, fingerprint, log } from "./bridge-protocol.js";
 import { stateDirectory } from "./bridge-storage.js";
 import { readBridgeFile } from "./bridge-files.js";
 const MAX_CLIENTS = 64;
@@ -34,45 +32,40 @@ function identities(value) {
     }
     const clients = new Map();
     const names = new Set();
+    let retiredLaunch = false;
     for (const raw of value) {
-        const entry = object(raw, ["fingerprint256", "name", "cwd", "launch", "wake"]);
+        const entry = object(raw, ["fingerprint256", "name", "cwd", "wake", "launch"]);
+        retiredLaunch ||= Object.hasOwn(entry, "launch");
         const fingerprint256 = fingerprint(entry.fingerprint256);
         const name = label(entry.name, "name", 128).trim();
         const cwd = label(entry.cwd, "cwd", 4096);
         if (!isAbsolute(cwd)) {
             throw new Error("Client cwd must be absolute.");
         }
-        const launch = launchPolicy(entry.launch);
-        if (launch && !statSync(cwd).isDirectory()) {
-            throw new Error("Launch cwd must be an existing directory.");
-        }
         if (clients.has(fingerprint256) || names.has(name.toLowerCase())) {
             throw new Error("Client fingerprints and names must be unique.");
         }
         clients.set(fingerprint256, {
             fingerprint256,
             name,
-            cwd: launch ? realpathSync(cwd) : cwd,
-            launch,
+            cwd,
             wake: wakePolicy(entry.wake),
         });
         names.add(name.toLowerCase());
     }
+    if (retiredLaunch) {
+        log("deprecated_config_field", {
+            field: "clients[].launch",
+            action: "ignored",
+            note: "Remote launch is retired. Remove this field when convenient; no launch permission is granted.",
+        });
+    }
     return clients;
 }
 function configInput(path) {
     const raw = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(readBridgeFile(path, true, BODY_LIMIT)));
     return object(raw, ["port", "ca", "cert", "key", "clients", "stateDir"]);
 }
-/** Recipient admission reads private policy and the public CA, never the server key. */
-export function loadControlPolicy(path) {
-    const input = configInput(path);
-    const ca = label(input.ca, "ca path", 4096);
-    if (!isAbsolute(ca)) {
-        throw new Error("CA path must be absolute.");
-    }
-    return { clients: identities(input.clients), ca: readBridgeFile(ca, false, 1024 * 1024) };
-}
 export function loadConfig(path) {
     const input = configInput(path);
     const port = input.port === undefined ? 9443 : input.port;

package/dist/pi-intercom/bridge-http.js

@@ -1,4 +1,4 @@
-import { BODY_LIMIT, Fault, BroadcastFault } from "./bridge-protocol.js";
+import { BODY_LIMIT, Fault } from "./bridge-protocol.js";
 import { errorMessage } from "../shared/unknown.js";
 function validateHeaders(req) {
     const type = req.headers["content-type"];
@@ -87,7 +87,6 @@ export function reply(res, requestId, status, data) {
 export function replyFault(res, requestId, fault) {
     reply(res, requestId, fault.status, {
         ok: false,
-        ...(fault instanceof BroadcastFault ? fault.outcome : {}),
         error: { code: fault.code, message: fault.message, ...fault.details },
     });
 }

package/dist/pi-intercom/bridge-mailbox.js

@@ -146,20 +146,15 @@ export class Mailbox {
     }
     ack(ids) {
         const acked = [];
-        const retained = [];
         for (const id of ids) {
             const entry = this.get(id);
-            if (entry?.message.expectsReply === true) {
-                // Durable consumer intake owns the primary wake; keep only the reply obligation here.
+            if (entry) {
                 this.notificationAccepted(id);
-                retained.push(id);
-            }
-            else if (entry) {
                 this.remove(id);
                 acked.push(id);
             }
         }
-        return { acked, retained };
+        return { acked };
     }
     page(after, limit) {
         return this.readPage(after, limit, false);

package/dist/pi-intercom/bridge-protocol.js

@@ -1,6 +1,5 @@
 import { errorMessage, isRecord } from "../shared/unknown.js";
 export const BODY_LIMIT = 64 * 1024;
-export const ASK_TIMEOUT = 120000;
 export const INBOX_COUNT = 256;
 export const INBOX_BYTES = 4 * 1024 * 1024;
 export class Fault extends Error {
@@ -14,19 +13,13 @@ export class Fault extends Error {
         this.details = details;
     }
 }
-export class BroadcastFault extends Fault {
-    outcome;
-    constructor(fault, outcome) {
-        super(fault.status, fault.code, fault.message, fault.details);
-        this.outcome = { ...outcome, status: "partial" };
-    }
-}
 export function object(value, fields) {
     if (!isRecord(value)) {
         throw new Fault(400, "invalid_input", "Expected a JSON object.");
     }
-    if (Object.keys(value).some((key) => !fields.includes(key))) {
-        throw new Fault(400, "invalid_input", "Unknown field.");
+    const unknown = Object.keys(value).find((key) => !fields.includes(key));
+    if (unknown !== undefined) {
+        throw new Fault(400, "invalid_input", `Unknown field ${JSON.stringify(label(unknown, "field name", 128))}.`);
     }
     return value;
 }

package/dist/pi-intercom/bridge-routes.js

@@ -1,30 +1,12 @@
 import { isUnknownArray } from "../shared/unknown.js";
-import { ASK_TIMEOUT, Fault, INBOX_COUNT, label, object, text } from "./bridge-protocol.js";
+import { Fault, INBOX_COUNT, label, object, text } from "./bridge-protocol.js";
 import { body } from "./bridge-http.js";
-import { groupDefinition } from "./bridge-groups.js";
-import { isControlVerb } from "./native-control-protocol.js";
-import { transcriptOptions } from "./transcript.js";
 const fields = {
     "GET /v1/list": [],
     "GET /v1/inbox": [],
     "POST /v1/register": [],
     "POST /v1/ack": ["ids"],
-    "POST /v1/send": ["to", "message", "passive", "messageId"],
-    "POST /v1/ask": ["to", "message", "timeoutMs"],
-    "POST /v1/reply": ["replyTo", "message"],
-    "POST /v1/start": ["name"],
-    "POST /v1/spawn": ["name", "cwd", "task", "provider", "model"],
-    "POST /v1/resume": ["sessionId", "name", "target", "task"],
-    "GET /v1/sessions": [],
-    "POST /v1/stop": ["sessionId", "target", "to", "mode", "timeoutMs"],
-    "POST /v1/cancel": ["sessionId", "target", "to", "timeoutMs"],
-    "GET /v1/groups": [],
-    "POST /v1/groups": ["name", "members", "namePattern", "cwdPattern", "match"],
-    "POST /v1/broadcast": ["message", "group"],
-    "POST /v1/control": ["to", "verb", "options", "timeoutMs"],
-    "POST /v1/capabilities": ["to", "timeoutMs"],
-    "POST /v1/transcript": ["to", "limit", "maxBytes", "cursor", "timeoutMs"],
-    "GET /v1/transcript": ["target", "limit", "maxBytes", "cursor", "timeoutMs"],
+    "POST /v1/send": ["to", "message", "passive", "messageId", "replyTo", "expectsReply"],
 };
 function isRoute(route) {
     return Object.hasOwn(fields, route);
@@ -38,9 +20,8 @@ export function routeFor(req) {
     if (!isRoute(route)) {
         throw new Fault(404, "not_found", "Unknown method or path.");
     }
-    if (req.url?.includes("?") === true &&
-        !["GET /v1/inbox", "GET /v1/sessions", "GET /v1/transcript"].includes(route)) {
-        throw new Fault(400, "invalid_input", "Query parameters are only supported for inbox, sessions and transcript.");
+    if (req.url?.includes("?") === true && route !== "GET /v1/inbox") {
+        throw new Fault(400, "invalid_input", "Query parameters are only supported for inbox.");
     }
     checkGetBody(req);
     return route;
@@ -52,15 +33,15 @@ function checkGetBody(req) {
         throw new Fault(400, "invalid_input", "GET requests must not have a body.");
     }
 }
-function queryFor(req, allowed) {
+function queryFor(req) {
     const query = new URL(req.url ?? "", "https://127.0.0.1").searchParams;
-    if ([...query.keys()].some((key) => !allowed.includes(key) || query.getAll(key).length !== 1)) {
+    if ([...query.keys()].some((key) => !["after", "limit", "waitMs"].includes(key) || query.getAll(key).length !== 1)) {
         throw new Fault(400, "invalid_input", "Unknown or repeated query parameter.");
     }
     return query;
 }
 function inboxQuery(req) {
-    const query = queryFor(req, ["after", "limit", "waitMs"]);
+    const query = queryFor(req);
     const after = query.get("after") ?? "0";
     const limit = query.get("limit") ?? String(INBOX_COUNT);
     const waitMs = query.get("waitMs") ?? "0";
@@ -78,112 +59,14 @@ function inboxQuery(req) {
         waitMs: Number(waitMs),
     };
 }
-function pageNumber(value, fallback, min, max) {
-    const number = value === null ? fallback : Number(value);
-    if (value === "" || !Number.isSafeInteger(number) || number < min || number > max) {
-        throw new Fault(400, "invalid_input", "Invalid catalog pagination.");
-    }
-    return number;
-}
-function queryBoolean(value) {
-    if (value !== null && value !== "true" && value !== "false") {
-        throw new Fault(400, "invalid_input", "Catalog switches must be true or false.");
-    }
-    return value === "true";
-}
-function catalogQuery(req) {
-    if (req.url?.includes("?") !== true) {
-        return undefined;
-    }
-    const params = queryFor(req, ["live", "saved", "q", "offset", "limit"]);
-    return {
-        live: queryBoolean(params.get("live")),
-        saved: queryBoolean(params.get("saved")),
-        q: params.has("q") ? label(params.get("q"), "catalog filter", 128) : undefined,
-        offset: pageNumber(params.get("offset"), 0, 0, Number.MAX_SAFE_INTEGER),
-        limit: pageNumber(params.get("limit"), 50, 1, 100),
-    };
-}
-function timeout(value, control = false) {
-    const defaultMs = control ? 3000 : ASK_TIMEOUT;
-    const ms = value === undefined ? defaultMs : value;
-    const max = control ? 10000 : ASK_TIMEOUT;
-    if (typeof ms !== "number" || !Number.isInteger(ms) || ms < 100 || ms > max) {
-        throw new Fault(400, "invalid_input", `timeoutMs must be an integer from 100 to ${max}.`);
-    }
-    return ms;
-}
-function resume(input) {
-    if (["sessionId", "name", "target"].filter((key) => input[key] !== undefined).length !== 1) {
-        throw new Fault(400, "invalid_input", "Resume requires exactly one of sessionId, name or target.");
-    }
-    const sessionId = input.sessionId === undefined ? undefined : label(input.sessionId, "native session ID", 128);
-    if (sessionId !== undefined && !/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(sessionId)) {
-        throw new Fault(400, "invalid_input", "Resume takes a native ID, never a journal path.");
-    }
-    return {
-        route: "POST /v1/resume",
-        sessionId,
-        target: input.target === undefined ? undefined : label(input.target, "resume target", 256).trim(),
-        name: input.name === undefined ? undefined : label(input.name, "saved session name", 256).trim(),
-        task: input.task === undefined ? undefined : text(input.task),
-    };
-}
-function stop(route, input) {
-    if (["sessionId", "target", "to"].filter((key) => input[key] !== undefined).length !== 1) {
-        throw new Fault(400, "invalid_input", "Control requires exactly one sessionId, target or to.");
-    }
-    const mode = input.mode ?? "kill";
-    if (mode !== "kill" && mode !== "cancel") {
-        throw new Fault(400, "invalid_input", "Stop mode must be cancel or kill.");
-    }
-    return {
-        route: mode === "cancel" ? "POST /v1/cancel" : route,
-        sessionId: label(input.sessionId ?? input.target ?? input.to, "session target", 256).trim(),
-        timeoutMs: timeout(input.timeoutMs, true),
-    };
-}
-function nativeControl(route, input) {
-    const verb = route === "POST /v1/control" ? input.verb : route.split("/").at(-1);
-    if (!isControlVerb(verb)) {
-        throw new Fault(400, "invalid_input", "Unknown native control verb.");
-    }
-    const timeoutMs = timeout(input.timeoutMs, true);
-    const to = label(input.to ?? input.target, "session target").trim();
-    if (verb === "transcript") {
-        const options = transcriptOptions(route === "POST /v1/control"
-            ? input.options
-            : { limit: input.limit, maxBytes: input.maxBytes, cursor: input.cursor });
-        return { route: "GET /v1/transcript", target: to, options, timeoutMs };
-    }
-    if (input.options !== undefined) {
-        throw new Fault(400, "invalid_input", "Only transcript accepts options.");
-    }
-    return { route: "POST /v1/control", verb, to, timeoutMs };
-}
-async function operationInput(req, route, signal) {
-    if (req.method === "POST") {
-        return object(await body(req, signal), fields[route]);
-    }
-    if (route !== "GET /v1/transcript") {
-        return {};
-    }
-    const input = {};
-    for (const [key, value] of queryFor(req, fields[route])) {
-        input[key] = ["limit", "maxBytes", "timeoutMs"].includes(key) ? Number(value) : value;
-    }
-    return input;
-}
-function messagingOperation(route, input, req) {
+export async function operationFor(req, route, signal) {
+    const input = req.method === "POST" ? object(await body(req, signal), fields[route]) : {};
     switch (route) {
         case "GET /v1/list":
         case "POST /v1/register":
-        case "GET /v1/groups":
             return { route };
         case "GET /v1/inbox":
             return inboxQuery(req);
-        case "GET /v1/sessions":
-            return { route, query: catalogQuery(req) };
         case "POST /v1/ack":
             if (!isUnknownArray(input.ids) || input.ids.length > INBOX_COUNT) {
                 throw new Fault(400, "invalid_input", "ids must be an array of at most 256 message IDs.");
@@ -191,74 +74,20 @@ function messagingOperation(route, input, req) {
             return { route, ids: [...new Set(input.ids.map((id) => label(id, "message ID")))] };
         case "POST /v1/send":
             return send(input);
-        case "POST /v1/ask":
-            return {
-                route,
-                message: text(input.message),
-                to: label(input.to, "to").trim(),
-                timeoutMs: timeout(input.timeoutMs),
-            };
-        case "POST /v1/reply":
-            return { route, message: text(input.message), replyTo: label(input.replyTo, "replyTo") };
-        case "GET /v1/transcript":
-        case "POST /v1/control":
-        case "POST /v1/transcript":
-        case "POST /v1/capabilities":
-            return nativeControl(route, input);
     }
 }
 function send(input) {
-    if (input.passive !== undefined && typeof input.passive !== "boolean") {
-        throw new Fault(400, "invalid_input", "passive must be a boolean.");
+    if ((input.passive !== undefined && typeof input.passive !== "boolean") ||
+        (input.expectsReply !== undefined && typeof input.expectsReply !== "boolean")) {
+        throw new Fault(400, "invalid_input", "passive and expectsReply must be booleans.");
     }
     return {
         route: "POST /v1/send",
-        message: text(input.message),
         to: label(input.to, "to").trim(),
+        message: text(input.message),
         passive: input.passive,
         messageId: input.messageId === undefined ? undefined : label(input.messageId, "message ID"),
+        replyTo: input.replyTo === undefined ? undefined : label(input.replyTo, "replyTo"),
+        expectsReply: input.expectsReply,
     };
 }
-export async function operationFor(req, route, signal) {
-    const input = await operationInput(req, route, signal);
-    switch (route) {
-        case "POST /v1/start":
-            return { route, name: label(input.name, "session name", 64).trim() };
-        case "POST /v1/spawn":
-            return {
-                route,
-                name: label(input.name, "session name", 64).trim(),
-                cwd: input.cwd === undefined ? undefined : label(input.cwd, "cwd", 4096),
-                provider: input.provider === undefined ? undefined : label(input.provider, "provider", 128),
-                model: input.model === undefined ? undefined : label(input.model, "model reference", 512),
-                task: input.task === undefined ? undefined : text(input.task),
-            };
-        case "POST /v1/resume":
-            return resume(input);
-        case "POST /v1/stop":
-        case "POST /v1/cancel":
-            return stop(route, input);
-        case "POST /v1/groups":
-            return { route, group: groupDefinition(input) };
-        case "POST /v1/broadcast":
-            return {
-                route,
-                message: text(input.message),
-                group: input.group === undefined ? undefined : label(input.group, "group", 64).trim(),
-            };
-        case "GET /v1/groups":
-        case "GET /v1/inbox":
-        case "GET /v1/list":
-        case "GET /v1/sessions":
-        case "GET /v1/transcript":
-        case "POST /v1/ack":
-        case "POST /v1/ask":
-        case "POST /v1/capabilities":
-        case "POST /v1/control":
-        case "POST /v1/register":
-        case "POST /v1/reply":
-        case "POST /v1/send":
-        case "POST /v1/transcript":
-            return messagingOperation(route, input, req);
-    }
-}

package/dist/pi-intercom/bridge-session.js

@@ -4,9 +4,8 @@ import { IntercomClient } from "./broker/client.js";
 import { resolveSessionProjectId } from "./session-targets.js";
 import { Fault, cancelled, log, wait } from "./bridge-protocol.js";
 import { Mailbox } from "./bridge-mailbox.js";
+import { hasErrorCode } from "../shared/unknown.js";
 import { resolveBridgeTarget, bridgeSessionList } from "./bridge-target.js";
-import { ControlReplies } from "./bridge-control.js";
-import { WaitingAsk } from "./bridge-ask.js";
 const MAX_REQUESTS = 8;
 const IDLE_TIMEOUT = 5 * 60 * 1000;
 const SEND_TIMEOUT = 8000;
@@ -23,9 +22,6 @@ export class Session {
     requests = new Set();
     inbox;
     inboxChanged = new AbortController();
-    replying = new Set();
-    pending;
-    controls = new ControlReplies();
     closed = false;
     connecting;
     disconnecting;
@@ -46,7 +42,6 @@ export class Session {
             }
         });
         this.client.on("message", (from, message) => this.receive(from, message));
-        this.client.on("session_left", (id) => this.peerLeft(id));
         this.touch();
     }
     guard(signal) {
@@ -156,8 +151,6 @@ export class Session {
         this.closed = true;
         this.closeReason = fault;
         clearTimeout(this.lease);
-        this.pending?.reject(fault);
-        this.controls.close(fault);
         for (const controller of this.requests) {
             controller.abort(fault);
         }
@@ -167,13 +160,6 @@ export class Session {
     async settled() {
         await this.retirement;
     }
-    peerLeft(id) {
-        this.controls.peerLeft(id);
-        if (this.pending?.peer === id && !this.pending.settled) {
-            this.pending.reject(new Fault(409, "peer_offline", "Ask recipient disconnected.", { id: this.pending.id }));
-        }
-        this.presence();
-    }
     receive(from, message) {
         if (this.closed) {
             return;
@@ -187,12 +173,6 @@ export class Session {
                 : new Fault(403, "revoked", "Identity is no longer authorized."));
             return;
         }
-        if (this.controls.receive(from.id, message)) {
-            return;
-        }
-        if (!this.inbox.persistent && this.resolveReply(from, message)) {
-            return;
-        }
         this.storeReceive(from, message);
     }
     storeReceive(from, message) {
@@ -225,19 +205,10 @@ export class Session {
             result: result === "lost" && this.inbox.persistent ? "storage_failed" : result,
         });
         if (result !== "lost") {
-            this.resolveReply(from, message);
             this.owner.mailboxChanged?.();
         }
         this.presence();
     }
-    resolveReply(from, message) {
-        const pending = this.pending;
-        if (pending?.matches(from.id, message.replyTo) !== true) {
-            return false;
-        }
-        pending.resolve({ from, message });
-        return true;
-    }
     presence() {
         if (this.closed) {
             return;
@@ -252,7 +223,7 @@ export class Session {
         }
         catch (error) {
             cancelled(signal);
-            if (error instanceof Error && error.message === "List sessions timeout") {
+            if (hasErrorCode(error, "list_timeout")) {
                 throw new Fault(504, "list_timeout", "Broker session list deadline exceeded.");
             }
             throw new Fault(503, "broker_unavailable", "Broker session list failed.");
@@ -264,11 +235,6 @@ export class Session {
         await this.connect(signal);
         return this.peers(signal);
     }
-    async nativeControl(operation, certificate, context) {
-        await this.connect(context.signal);
-        const peer = await this.target(operation.to, context.signal);
-        return this.controls.request(this.client, { ...operation, peer: peer.id, certificate }, { ...context, guard: () => this.guard(context.signal) });
-    }
     async target(to, signal) {
         return resolveBridgeTarget(await this.peers(signal), to, this.client.sessionId);
     }
@@ -306,32 +272,6 @@ export class Session {
         }
         return result;
     }
-    async ask(operation, context) {
-        if (this.pending) {
-            throw new Fault(409, "ask_in_progress", "Only one concurrent ask is allowed per identity.");
-        }
-        const waiting = new WaitingAsk();
-        this.pending = waiting;
-        const { signal } = context;
-        try {
-            await this.connect(signal);
-            const peer = await this.target(operation.to, signal);
-            this.guard(signal);
-            waiting.peer = peer.id;
-            waiting.deadline(operation.timeoutMs, (error) => this.close(error));
-            waiting.receipt = await this.send(peer.id, operation.message, context, {
-                messageId: waiting.id,
-                expectsReply: true,
-            });
-            const answer = await wait(waiting.reply, signal);
-            this.guard(signal);
-            return { ...waiting.receipt, replied: true, reply: answer };
-        }
-        finally {
-            waiting.clear();
-            this.pending = undefined;
-        }
-    }
     async readInbox(operation, context) {
         const read = () => ({
             ...this.inbox.page(operation.after, operation.limit),
@@ -361,41 +301,8 @@ export class Session {
             this.guard(context.signal);
         }
     }
-    async answer(replyTo, message, context) {
-        const entry = this.inbox.get(replyTo);
-        if (entry?.message.expectsReply !== true) {
-            throw new Fault(404, "unknown_ask", "replyTo must identify an unanswered inbound ask.");
-        }
-        if (this.replying.has(replyTo)) {
-            throw new Fault(409, "reply_in_progress", "This ask already has a reply in flight.");
-        }
-        this.replying.add(replyTo);
-        const peer = entry.from.id;
-        context.onPeer(peer);
-        try {
-            const peers = await this.peers(context.signal);
-            if (!peers.some((candidate) => candidate.id === peer)) {
-                throw new Fault(409, "peer_offline", "Original ask sender is disconnected.");
-            }
-            this.guard(context.signal);
-            if (!this.inbox.get(replyTo)) {
-                throw new Fault(409, "ask_retired", "Inbound ask is no longer replyable.");
-            }
-            const data = { ...(await this.send(peer, message, context, { replyTo })) };
-            this.inbox.remove(replyTo);
-            this.owner.mailboxChanged?.();
-            this.presence();
-            return data;
-        }
-        finally {
-            this.replying.delete(replyTo);
-        }
-    }
     async execute(operation, context) {
         this.guard(context.signal);
-        if (operation.route === "POST /v1/ask") {
-            return this.ask(operation, context);
-        }
         if (operation.route === "GET /v1/inbox" || operation.route === "POST /v1/ack") {
             // Durable reads/acks remain available while the local broker is down.
             if (!this.inbox.persistent) {
@@ -422,12 +329,12 @@ export class Session {
                 const peer = await this.target(operation.to, context.signal);
                 const receipt = await this.send(peer.id, operation.message, context, {
                     messageId: operation.messageId,
+                    replyTo: operation.replyTo,
+                    expectsReply: operation.expectsReply,
                     delivery: operation.passive === true ? "passive" : "steer",
                 });
                 return { ...receipt };
             }
-            case "POST /v1/reply":
-                return this.answer(operation.replyTo, operation.message, context);
         }
     }
 }