@fitchmultz/pi-subagents 0.49.1 → 0.51.0

package/dist/pi-intercom/bridge.js

@@ -4,24 +4,14 @@ import { TLSSocket } from "node:tls";
 import { randomUUID } from "node:crypto";
 import { getBrokerSocketPath } from "./broker/paths.js";
 import { loadConfig, sameListener } from "./bridge-config.js";
-import { ASK_TIMEOUT, Fault, fingerprint, log } from "./bridge-protocol.js";
+import { Fault, fingerprint, log } from "./bridge-protocol.js";
 import { Session } from "./bridge-session.js";
 import { operationFor, routeFor } from "./bridge-routes.js";
 import { reply, replyFault } from "./bridge-http.js";
-import { sameIdentity } from "./bridge-launch.js";
-import { BridgeOperations } from "./bridge-operations.js";
-import { authenticatedCertificateChain } from "./native-control-auth.js";
 import { PersistentPresence } from "./bridge-presence.js";
 import { WakeDeliveries } from "./bridge-wake.js";
 import { spawnBrokerIfNeeded } from "./broker/spawn.js";
 const MAX_CONNECTIONS = 128;
-const LONG_ROUTES = new Set([
-    "POST /v1/start",
-    "POST /v1/spawn",
-    "POST /v1/resume",
-    "GET /v1/transcript",
-    "POST /v1/transcript",
-]);
 function validCertificateDates(starts, expires) {
     return (Number.isFinite(starts) &&
         Number.isFinite(expires) &&
@@ -33,7 +23,6 @@ class Bridge {
     configPath;
     sessions = new Map();
     losses = new Map();
-    operations;
     sockets = new Set();
     connections = new Map();
     server;
@@ -44,7 +33,6 @@ class Bridge {
     constructor(config, configPath) {
         this.config = config;
         this.configPath = configPath;
-        this.operations = new BridgeOperations(config.stateDir);
         this.deliveries = new WakeDeliveries(config.stateDir, (identity) => this.allowed(identity));
         if (config.stateDir !== undefined) {
             this.presence = new PersistentPresence({
@@ -118,8 +106,9 @@ class Bridge {
     allowed(identity) {
         const current = this.config.clients.get(identity.fingerprint256);
         return (!this.stopping &&
-            sameIdentity(identity, current) &&
-            JSON.stringify(identity.wake) === JSON.stringify(current?.wake));
+            current?.name === identity.name &&
+            current.cwd === identity.cwd &&
+            JSON.stringify(identity.wake) === JSON.stringify(current.wake));
     }
     lost(fp, count = 1) {
         if (count > 0 && this.config.clients.has(fp)) {
@@ -233,15 +222,11 @@ class Bridge {
             }
             this.config = next;
             this.revokeRemoved();
-            this.operations.revoke(next.clients).catch(() => log("launch_cleanup", { result: "failed" }));
             log("allowlist_reloaded", { result: "accepted", clients: next.clients.size });
         }
         catch {
             this.config = { ...this.config, clients: new Map() };
             this.deliveries.reload();
-            this.operations
-                .revoke(this.config.clients)
-                .catch(() => log("launch_cleanup", { result: "failed" }));
             for (const session of this.sessions.values()) {
                 session.close(new Fault(503, "configuration_invalid", "Configuration reload failed; all identities denied."));
             }
@@ -295,7 +280,6 @@ class Bridge {
         await Promise.all([
             ...this.handlers,
             ...sessions.map((session) => session.settled()),
-            this.operations.shutdown(),
             this.presence?.stop(),
             this.deliveries.stop(),
         ]);
@@ -320,7 +304,6 @@ class Bridge {
         return {
             identity,
             expires: connection.expires,
-            certificate: authenticatedCertificateChain(socket),
         };
     }
     async handle(req, res) {
@@ -343,7 +326,7 @@ class Bridge {
             deadline = setTimeout(() => cancel(new Fault(504, "request_timeout", "HTTP operation deadline exceeded; delivery may be unknown.")), Math.max(1, ms - (Date.now() - started)));
         };
         try {
-            const { identity, expires, certificate } = this.admission(req);
+            const { identity, expires } = this.admission(req);
             const route = routeFor(req);
             readOnlyInbox = route === "GET /v1/inbox";
             session = this.session(identity, expires);
@@ -351,20 +334,11 @@ class Bridge {
             const signal = controller.signal;
             req.once("aborted", abort);
             res.once("close", onClose);
-            const duration = route === "POST /v1/ask" ? ASK_TIMEOUT + 15000 : 15000;
-            setDeadline(LONG_ROUTES.has(route) ? 75000 : duration);
+            setDeadline(15000);
             const operation = await operationFor(req, route, signal);
-            if (operation.route === "POST /v1/ask") {
-                setDeadline(operation.timeoutMs + 15000);
-            }
-            else if (operation.route === "GET /v1/transcript") {
-                setDeadline(75000);
-            }
-            const data = await this.operations.execute(operation, session, {
+            const data = await session.execute(operation, {
                 signal,
                 requestId,
-                expires,
-                certificate,
                 onPeer: (id) => {
                     peer = id;
                 },
@@ -405,8 +379,11 @@ function main() {
         const path = resolve(args[1]);
         new Bridge(loadConfig(path), path).start();
     }
-    catch {
-        process.stderr.write("Bridge startup failed: check config schema, file ownership/mode 0600, absolute TLS/cwd paths, TLS credentials, stateDir (owned 0700 directory), and launch policy (0700 sessionDir, Pi packageRoot, extension paths).\n");
+    catch (error) {
+        if (error instanceof Fault) {
+            process.stderr.write(`${error.message}\n`);
+        }
+        process.stderr.write("Bridge startup failed: check config schema, file ownership/mode 0600, absolute TLS/cwd paths, TLS credentials, and stateDir (owned 0700 directory).\n");
         process.exitCode = 1;
     }
 }

package/dist/pi-intercom/broker/broker.js

@@ -1,25 +1,28 @@
 import net from "net";
-import { chmodSync, writeFileSync, unlinkSync, mkdirSync } from "fs";
+import { chmodSync, writeFileSync, unlinkSync } from "fs";
 import { join } from "path";
 import { randomUUID } from "crypto";
-import { getPiAgentDir } from "../agent-dir.js";
-import { writeMessage, createMessageReader, validateIntercomMessageSize } from "./framing.js";
-import { prepareBrokerSocketPath } from "./paths.js";
+import { writeMessage, validateIntercomMessageSize } from "./framing.js";
+import { getBrokerRuntimeDir, prepareBrokerSocketPath } from "./paths.js";
 import { brokerPidRecord } from "./pid.js";
-import { compactTopicMessage, isSessionRegistration, normalizeMessage, normalizeSessionInfo, } from "../types.js";
+import { assertBrokerCanStart } from "./spawn.js";
+import { LastMessageRelay } from "./last.js";
+import { canSeeSession, findSessions } from "./targets.js";
+import { acceptBrokerConnection, registeredSessionInfo } from "./server-connection.js";
+import { guardedDeliveryError } from "./guard.js";
+import { compactTopicMessage, normalizeMessage, normalizeSessionInfo, } from "../types.js";
 import { errorMessage, isRecord } from "../../shared/unknown.js";
 import { messageSender, snapshotFrames, TopicSnapshot, publicationMessage, deliveryAcknowledgement, shouldReplaceDelivery, } from "./snapshots.js";
-const INTERCOM_DIR = join(getPiAgentDir(), "intercom");
-const PID_PATH = join(INTERCOM_DIR, "broker.pid");
+const PID_PATH = join(getBrokerRuntimeDir(), "broker.pid");
 const REPLACE_DELIVERY_DELAY_MS = 1500;
 class IntercomBroker {
     sessions = new Map();
+    lastMessages = new LastMessageRelay(this.sessions);
     pendingReplaceDeliveries = new Map();
     server;
     shutdownTimer = null;
     socketPath;
     constructor() {
-        mkdirSync(INTERCOM_DIR, { recursive: true });
         this.socketPath = prepareBrokerSocketPath();
         try {
             unlinkSync(this.socketPath);
@@ -45,23 +48,7 @@ class IntercomBroker {
         process.on("SIGINT", () => this.shutdown());
     }
     handleConnection(socket) {
-        let sessionId = null;
-        const reader = createMessageReader((msg) => {
-            this.handleMessage(socket, msg, sessionId, (id) => {
-                sessionId = id;
-            });
-        }, (error) => {
-            socket.destroy(error);
-        });
-        socket.on("data", reader);
-        socket.on("close", () => {
-            if (sessionId !== null) {
-                this.removeSession(sessionId);
-            }
-        });
-        socket.on("error", (error) => {
-            console.error("Socket error:", error);
-        });
+        acceptBrokerConnection(socket, this.handleMessage.bind(this), this.removeSession.bind(this));
     }
     scheduleShutdownCheck() {
         if (this.shutdownTimer) {
@@ -106,6 +93,12 @@ class IntercomBroker {
             case "send":
                 this.send(socket, msg, currentId);
                 break;
+            case "last_request":
+                this.lastMessages.request(currentId, msg);
+                break;
+            case "last_response":
+                this.lastMessages.respond(currentId, msg);
+                break;
             case "presence":
                 this.presence(msg, currentId);
                 break;
@@ -114,14 +107,8 @@ class IntercomBroker {
         }
     }
     register(socket, msg, setId) {
-        if (!isSessionRegistration(msg.session)) {
-            throw new Error("Invalid register message");
-        }
-        const requestedId = typeof msg.requestedId === "string" && /^[a-zA-Z0-9_-]{8,80}$/.test(msg.requestedId)
-            ? msg.requestedId
-            : undefined;
-        const id = requestedId !== undefined && !this.sessions.has(requestedId) ? requestedId : randomUUID();
-        const info = { ...msg.session, id, lastSeen: msg.session.lastSeen ?? Date.now() };
+        const info = registeredSessionInfo(msg, this.sessions);
+        const id = info.id;
         snapshotFrames(randomUUID(), [info], true);
         const topicFrames = msg.topicFrames === true;
         this.sessions.set(id, {
@@ -129,6 +116,8 @@ class IntercomBroker {
             info: messageSender(info),
             topics: new TopicSnapshot(info),
             topicFrames,
+            lastMessages: msg.lastMessages === true,
+            receiptReads: msg.receiptReads === 1,
         });
         setId(id);
         if (this.shutdownTimer) {
@@ -138,13 +127,21 @@ class IntercomBroker {
         writeMessage(socket, {
             type: "registered",
             sessionId: id,
+            lastMessages: true,
+            receiptReads: 1,
+            ...(msg.guardedDelivery === 1 ? { guardedDelivery: 1 } : {}),
             ...(topicFrames ? { topicsSupported: true, topicFrames: true } : {}),
         });
     }
     removeSession(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            return;
+        }
         this.sessions.delete(sessionId);
+        this.lastMessages.disconnected(sessionId);
         this.clearPendingReplaceDeliveries(sessionId);
-        this.broadcast({ type: "session_left", sessionId }, sessionId);
+        this.broadcast({ type: "session_left", sessionId }, session.info);
         this.scheduleShutdownCheck();
     }
     planPublications(fromId, from, publication) {
@@ -154,7 +151,7 @@ class IntercomBroker {
         }
         for (const target of this.sessions.values()) {
             const subscription = target.topics.subscription(publication.topic);
-            if (target.info.id === fromId || !subscription) {
+            if (target.info.id === fromId || !subscription || !canSeeSession(from, target.info)) {
                 continue;
             }
             const message = publicationMessage(publication, subscription.awaitRelease === true);
@@ -188,7 +185,9 @@ class IntercomBroker {
             }
             const infos = prepared.restore
                 ? []
-                : [...this.sessions.values()].map((entry) => {
+                : [...this.sessions.values()]
+                    .filter((entry) => canSeeSession(from, entry.info))
+                    .map((entry) => {
                     if (entry === session) {
                         return nextInfo;
                     }
@@ -235,9 +234,18 @@ class IntercomBroker {
             });
             return;
         }
-        const targets = this.findSessions(msg.to);
+        const targets = findSessions(this.sessions, msg.to, currentId);
         const target = targets[0];
         if (targets.length === 1) {
+            const guardError = guardedDeliveryError(this.sessions, msg.to, message);
+            if (guardError !== null) {
+                writeMessage(socket, {
+                    type: "delivery_failed",
+                    messageId: message.id,
+                    reason: guardError,
+                });
+                return;
+            }
             const fromSession = this.sessions.get(currentId);
             if (!fromSession) {
                 writeMessage(socket, {
@@ -278,11 +286,15 @@ class IntercomBroker {
             "lastIntercomActivity",
             "subscriptions",
             "topics",
+            "applicationGuard",
         ]) {
             if (msg[key] !== undefined) {
                 update[key] = msg[key];
             }
         }
+        if (msg.applicationGuard === null) {
+            delete update.applicationGuard;
+        }
         const nextInfo = normalizeSessionInfo(update);
         if (!nextInfo) {
             throw new Error("Invalid presence update");
@@ -295,15 +307,7 @@ class IntercomBroker {
     }
     sendToSession(fromId, toId, from, message) {
         const target = this.sessions.get(toId);
-        if (!target) {
-            return {
-                id: message.id,
-                accepted: false,
-                delivered: false,
-                reason: "Recipient disconnected before delivery",
-            };
-        }
-        if (shouldReplaceDelivery(message, target.info)) {
+        if (target && shouldReplaceDelivery(message, target.info)) {
             return this.queueReplaceDelivery(fromId, toId, from, message);
         }
         const reason = this.deliverMessage(toId, from, message);
@@ -371,6 +375,10 @@ class IntercomBroker {
         })?.message ?? null);
     }
     deliverMessage(toId, from, message) {
+        const guardError = guardedDeliveryError(this.sessions, toId, message);
+        if (guardError !== null) {
+            return guardError;
+        }
         const target = this.sessions.get(toId);
         if (!target ||
             target.socket.destroyed ||
@@ -395,17 +403,9 @@ class IntercomBroker {
             return error instanceof Error ? error.message : errorMessage(error);
         }
     }
-    findSessions(nameOrId) {
-        const byId = this.sessions.get(nameOrId);
-        if (byId) {
-            return [byId];
-        }
-        const lowerName = nameOrId.toLowerCase();
-        return Array.from(this.sessions.values()).filter((session) => session.info.name?.toLowerCase() === lowerName);
-    }
-    broadcast(msg, exclude) {
+    broadcast(msg, from) {
         for (const [id, session] of this.sessions) {
-            if (id !== exclude) {
+            if (id !== from.id && canSeeSession(session.info, from)) {
                 writeMessage(session.socket, msg);
             }
         }
@@ -432,4 +432,5 @@ class IntercomBroker {
         process.exit(0);
     }
 }
+await assertBrokerCanStart();
 new IntercomBroker().start();

package/dist/pi-intercom/broker/client-last.d.ts

@@ -0,0 +1,13 @@
+import type net from "node:net";
+import { type UnknownRecord } from "../../shared/unknown.ts";
+import type { LastMessageQuery, LastMessageResult, ReceiptQuery, ReceiptResult } from "../types.ts";
+export declare class LastMessageRequests {
+    private readonly timeoutMs;
+    constructor(timeoutMs: number);
+    private readonly pending;
+    fail(error: Readonly<Error>): void;
+    receive(message: UnknownRecord): void;
+    last(socket: net.Socket, to: string, query: LastMessageQuery): Promise<LastMessageResult>;
+    receipt(socket: net.Socket, to: string, query: ReceiptQuery): Promise<ReceiptResult>;
+    private request;
+}

package/dist/pi-intercom/broker/client-last.js

@@ -0,0 +1,60 @@
+import { randomUUID } from "node:crypto";
+import { errorMessage } from "../../shared/unknown.js";
+import { isNativeReadQuery, isNativeReadResult, isLastMessageResult, isReceiptResult, } from "./last.js";
+import { writeMessage } from "./framing.js";
+export class LastMessageRequests {
+    timeoutMs;
+    constructor(timeoutMs) {
+        this.timeoutMs = timeoutMs;
+    }
+    pending = new Map();
+    fail(error) {
+        for (const pending of this.pending.values()) {
+            clearTimeout(pending.timer);
+            pending.reject(error);
+        }
+        this.pending.clear();
+    }
+    receive(message) {
+        if (typeof message.requestId !== "string" || !isNativeReadResult(message.result)) {
+            throw new Error("Invalid last-message response");
+        }
+        const pending = this.pending.get(message.requestId);
+        if (!pending) {
+            return;
+        }
+        clearTimeout(pending.timer);
+        this.pending.delete(message.requestId);
+        pending.resolve(message.result);
+    }
+    async last(socket, to, query) {
+        const result = await this.request(socket, to, query);
+        return isLastMessageResult(result) ? result : { error: "Invalid last-message response" };
+    }
+    async receipt(socket, to, query) {
+        const result = await this.request(socket, to, query);
+        return isReceiptResult(result) ? result : { error: "Invalid receipt response" };
+    }
+    request(socket, to, query) {
+        if (!isNativeReadQuery(query)) {
+            return Promise.reject(new Error("Invalid last-message query"));
+        }
+        return new Promise((resolve, reject) => {
+            const requestId = randomUUID();
+            const timer = setTimeout(() => {
+                this.pending.delete(requestId);
+                reject(new Error("Last-message read timeout"));
+            }, this.timeoutMs);
+            timer.unref();
+            this.pending.set(requestId, { resolve, reject, timer });
+            try {
+                writeMessage(socket, { type: "last_request", requestId, to, query });
+            }
+            catch (error) {
+                clearTimeout(timer);
+                this.pending.delete(requestId);
+                reject(new Error(errorMessage(error)));
+            }
+        });
+    }
+}

package/dist/pi-intercom/broker/client.d.ts

@@ -0,0 +1,60 @@
+import { EventEmitter } from "events";
+import { type SessionInfo, type TopicUpdate, type TopicChange, type SessionSnapshot, type SendResult, type LastMessageQuery, type LastMessageResult, type SendOptions, type ReceiptQuery, type ReceiptResult } from "../types.ts";
+export type { SendResult } from "../types.ts";
+export interface IntercomClientOptions {
+    /** Timeout (ms) for the broker to acknowledge message delivery. */
+    readonly sendTimeoutMs?: number;
+    /** Timeout (ms) for a session list response. */
+    readonly listTimeoutMs?: number;
+}
+export declare class IntercomClient extends EventEmitter {
+    private connection;
+    private _sessionId;
+    private _topicsSupported;
+    private lastMessagesSupported;
+    private receiptReadsSupported;
+    private guardedDeliverySupported;
+    private readonly lastRequests;
+    private readonly pendingSends;
+    private readonly pendingLists;
+    private connecting;
+    private disconnecting;
+    private readonly sendTimeoutMs;
+    private readonly listTimeoutMs;
+    constructor(options?: IntercomClientOptions);
+    private failPending;
+    get sessionId(): string | null;
+    get supportsTopics(): boolean;
+    get supportsGuardedDelivery(): boolean;
+    isConnected(): boolean;
+    private requireActiveSocket;
+    connect(session: Omit<SessionInfo, "id">, requestedId?: string): Promise<void>;
+    private restoreTopics;
+    private handleBrokerMessage;
+    private receiveRegistration;
+    private receiveLastRequest;
+    private receiveMessage;
+    private receiveDelivery;
+    private receiveSessions;
+    disconnect(): Promise<void>;
+    listSessions(): Promise<SessionInfo[]>;
+    last(to: string, query?: LastMessageQuery): Promise<LastMessageResult>;
+    receipt(to: string, query: ReceiptQuery): Promise<ReceiptResult>;
+    private readSocket;
+    respondLast(requestId: string, result: unknown): void;
+    updateTopics(change: TopicChange, onAccepted?: (snapshot: SessionSnapshot) => void): Promise<SessionSnapshot>;
+    private requestSessions;
+    private requireSendSocket;
+    send(to: string, options: SendOptions): Promise<SendResult>;
+    updatePresence(updates: {
+        readonly applicationGuard?: string | null;
+        readonly name?: string;
+        readonly status?: string;
+        readonly model?: string;
+        readonly pendingAsks?: number;
+        readonly acceptsAsks?: boolean;
+        readonly lastIntercomActivity?: number;
+        readonly subscriptions?: SessionInfo["subscriptions"];
+        readonly topics?: readonly TopicUpdate[];
+    }): void;
+}

package/dist/pi-intercom/broker/client.js

@@ -3,6 +3,8 @@ import { randomUUID } from "crypto";
 import { writeMessage } from "./framing.js";
 import { BrokerConnection, connectBrokerSocket } from "./connection.js";
 import { SnapshotReader } from "./snapshot-reader.js";
+import { LastMessageRequests } from "./client-last.js";
+import { isNativeReadQuery, isNativeReadResult } from "./last.js";
 import { errorMessage, isRecord, isUnknownArray, } from "../../shared/unknown.js";
 import { compactTopicMessage, normalizeMessage, normalizeSessionInfo, } from "../types.js";
 /** Default delivery-ack timeout for `send` (broker acknowledges quickly). */
@@ -28,6 +30,10 @@ export class IntercomClient extends EventEmitter {
     connection = null;
     _sessionId = null;
     _topicsSupported = false;
+    lastMessagesSupported = false;
+    receiptReadsSupported = false;
+    guardedDeliverySupported = false;
+    lastRequests;
     pendingSends = new Map();
     pendingLists = new Map();
     connecting = false;
@@ -38,8 +44,10 @@ export class IntercomClient extends EventEmitter {
         super();
         this.sendTimeoutMs = options.sendTimeoutMs ?? DEFAULT_SEND_TIMEOUT_MS;
         this.listTimeoutMs = options.listTimeoutMs ?? DEFAULT_LIST_TIMEOUT_MS;
+        this.lastRequests = new LastMessageRequests(this.listTimeoutMs);
     }
     failPending(error) {
+        this.lastRequests.fail(error);
         for (const pending of this.pendingSends.values()) {
             pending.reject(error);
         }
@@ -55,6 +63,9 @@ export class IntercomClient extends EventEmitter {
     get supportsTopics() {
         return this.isConnected() && this._topicsSupported;
     }
+    get supportsGuardedDelivery() {
+        return this.isConnected() && this.guardedDeliverySupported;
+    }
     isConnected() {
         return ((this._sessionId ?? "").length > 0 &&
             !this.disconnecting &&
@@ -93,6 +104,9 @@ export class IntercomClient extends EventEmitter {
                     this.connection = null;
                     this._sessionId = null;
                     this._topicsSupported = false;
+                    this.lastMessagesSupported = false;
+                    this.receiptReadsSupported = false;
+                    this.guardedDeliverySupported = false;
                     this.disconnecting = false;
                     this.failPending(error);
                     if (established && !expected) {
@@ -108,6 +122,9 @@ export class IntercomClient extends EventEmitter {
                     session: identity,
                     requestedId,
                     topicFrames: true,
+                    lastMessages: true,
+                    receiptReads: 1,
+                    guardedDelivery: 1,
                 });
             }
             catch (error) {
@@ -152,6 +169,12 @@ export class IntercomClient extends EventEmitter {
             case "sessions":
                 this.receiveSessions(brokerMessage);
                 break;
+            case "last_request":
+                this.receiveLastRequest(brokerMessage);
+                break;
+            case "last_response":
+                this.lastRequests.receive(brokerMessage);
+                break;
             case "message":
                 this.receiveMessage(brokerMessage);
                 break;
@@ -179,9 +202,21 @@ export class IntercomClient extends EventEmitter {
         }
         this._sessionId = msg.sessionId;
         this._topicsSupported = msg.topicsSupported === true && msg.topicFrames === true;
+        this.lastMessagesSupported = msg.lastMessages === true;
+        this.receiptReadsSupported = msg.receiptReads === 1;
+        this.guardedDeliverySupported = msg.guardedDelivery === 1;
         this.connection?.confirmRegistration();
         this.emit("_registered", { type: "registered", sessionId: msg.sessionId });
     }
+    receiveLastRequest(msg) {
+        const from = normalizeSessionInfo(msg.from);
+        if (typeof msg.requestId !== "string" || !from || !isNativeReadQuery(msg.query)) {
+            throw new Error("Invalid last-message request");
+        }
+        if (!this.emit("last_request", { requestId: msg.requestId, from, query: msg.query })) {
+            this.respondLast(msg.requestId, { error: "Recipient has no last-message reader." });
+        }
+    }
     receiveMessage(msg) {
         const message = normalizeMessage(msg.message);
         const from = normalizeSessionInfo(msg.from);
@@ -246,6 +281,28 @@ export class IntercomClient extends EventEmitter {
     listSessions() {
         return this.requestSessions().then((snapshot) => [...snapshot.sessions]);
     }
+    async last(to, query = {}) {
+        return await this.lastRequests.last(this.readSocket(query), to, query);
+    }
+    async receipt(to, query) {
+        return await this.lastRequests.receipt(this.readSocket(query), to, query);
+    }
+    readSocket(query) {
+        const socket = this.requireActiveSocket();
+        if (!this.lastMessagesSupported) {
+            throw new Error("This broker does not support last-message reads; reload after it exits.");
+        }
+        if ("messageId" in query && !this.receiptReadsSupported) {
+            throw new Error("publication_unavailable");
+        }
+        return socket;
+    }
+    respondLast(requestId, result) {
+        if (!isNativeReadResult(result)) {
+            throw new Error("Invalid last-message result");
+        }
+        writeMessage(this.requireActiveSocket(), { type: "last_response", requestId, result });
+    }
     updateTopics(change, onAccepted) {
         if (!this.supportsTopics) {
             return Promise.reject(new Error("This broker does not support topic snapshots."));
@@ -280,7 +337,7 @@ export class IntercomClient extends EventEmitter {
             const timeout = setTimeout(() => {
                 if (this.pendingLists.has(requestId)) {
                     this.pendingLists.delete(requestId);
-                    wrappedReject(new Error("List sessions timeout"));
+                    wrappedReject(Object.assign(new Error("List sessions timeout"), { code: "list_timeout" }));
                 }
             }, this.listTimeoutMs);
             timeout.unref();
@@ -304,23 +361,34 @@ export class IntercomClient extends EventEmitter {
             }
         });
     }
+    requireSendSocket(options) {
+        const socket = this.requireActiveSocket();
+        if (options.guard && !this.guardedDeliverySupported) {
+            throw new Error("This broker does not support guarded delivery; no message sent.");
+        }
+        return socket;
+    }
     send(to, options) {
         let socket;
         try {
-            socket = this.requireActiveSocket();
+            socket = this.requireSendSocket(options);
         }
         catch (error) {
             return Promise.reject(toError(error));
         }
-        const messageId = options.messageId ?? randomUUID();
+        const messageId = options.messageId ?? (options.guard ? "" : randomUUID());
+        if (this.pendingSends.has(messageId)) {
+            return Promise.reject(new Error("Message ID already has a pending send"));
+        }
         const message = {
             id: messageId,
             timestamp: Date.now(),
             replyTo: options.replyTo,
             expectsReply: options.expectsReply,
+            guard: options.guard,
+            replyHint: options.replyHint,
             ...(options.human ? { human: options.human } : {}),
             ...(options.topic ? { topic: options.topic } : {}),
-            ...(options.control ? { control: options.control } : {}),
             delivery: messageDelivery(options),
             queueMode: options.queueMode,
             threadId: options.threadId,
@@ -330,6 +398,9 @@ export class IntercomClient extends EventEmitter {
                 attachments: options.attachments,
             },
         };
+        if ((options.guard || options.replyHint) && normalizeMessage(message) === null) {
+            return Promise.reject(new Error("Invalid message format"));
+        }
         return new Promise((resolve, reject) => {
             const wrappedResolve = (result) => {
                 clearTimeout(timeout);