@fitchmultz/pi-subagents 0.51.0 → 0.52.0

package/dist/agent/runner.js

@@ -2,10 +2,12 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { commandSchema } from "./contracts.js";
 import { launchAt, missing, read, runDirectory, write } from "./storage.js";
-import { ownIdentity, ParentCheck, shellCommand, shells, signalProcess } from "./process.js";
+import { ownIdentity, ParentCheck, shells, signalProcess } from "./process.js";
 import { errorText, loadSDK } from "./host.js";
+import { Parking } from "./parking.js";
 import { childUsage } from "./usage.js";
-import { initializeCwd, localCwdOwner } from "./cwd.js";
+import { initializeCwd } from "./cwd.js";
+import { childRuntime } from "./child-runtime.js";
 import { ActorObservation } from "./observation.js";
 import { DirectoryWatch, Wake } from "./wake.js";
 function commandIdentity(file) {
@@ -29,28 +31,12 @@ function completionStatus(stopping, message, error) {
     }
     return "completed";
 }
-function guard(pi, directory, token) {
-    pi.on("tool_call", (event) => {
-        if (event.toolName === "delegate" || event.toolName === "agent_runs") {
-            return { block: true, reason: "Only a main session may delegate or control children." };
-        }
-        const owner = pi.getAllTools().find((tool) => tool.name === "bash")?.sourceInfo;
-        if (event.toolName === "bash" &&
-            typeof event.input.command === "string" &&
-            owner &&
-            (owner.source === "builtin" || localCwdOwner(owner))) {
-            // Preserve the selected local owner's cwd/env and leave remote/custom tools alone.
-            const input = event.input;
-            input.command = shellCommand(event.input.command, directory, token);
-        }
-        return;
-    });
-}
 class Actor {
     active;
     stopping = false;
     stopDeadline;
     nextParentCheck = 0;
+    parking = false;
     parent = new ParentCheck();
     // Raised when durable commands may need admission: change hints and stop.
     wake = new Wake();
@@ -128,63 +114,6 @@ class Actor {
             .map((block) => block.text)
             .join("\n") ?? "");
     }
-    createRuntime(sdk) {
-        return async ({ sessionManager }) => {
-            const launch = this.initial;
-            if (!fs.existsSync(launch.sessionFile)) {
-                throw new Error("Missing saved native session; refusing to create another.");
-            }
-            const settingsManager = sdk.SettingsManager.create(launch.cwd, launch.agentDir, {
-                projectTrusted: launch.trusted,
-            });
-            const services = await sdk.createAgentSessionServices({
-                cwd: launch.cwd,
-                agentDir: launch.agentDir,
-                settingsManager,
-                resourceLoaderOptions: {
-                    additionalExtensionPaths: [launch.entry],
-                    extensionFactories: [
-                        {
-                            name: "codemode",
-                            builtin: true,
-                            factory: sdk.createCodemodeExtension({ mode: "on" }),
-                        },
-                        { name: "tool_search", builtin: true, factory: sdk.createToolSearchExtension() },
-                        { name: "mcp", builtin: true, factory: sdk.createMcpExtension() },
-                        (pi) => {
-                            guard(pi, this.dir, this.token);
-                            pi.on("session_start", (_event, ctx) => {
-                                this.context = { pi, ctx };
-                            });
-                            // Sparse tool lifecycle keeps the live view's tools even while nobody watches.
-                            const tool = (event) => this.observation?.tool(event);
-                            pi.on("tool_execution_start", tool);
-                            pi.on("tool_execution_update", tool);
-                            pi.on("tool_execution_end", tool);
-                        },
-                    ],
-                },
-            });
-            const diagnostics = services.resourceLoader.getExtensions().errors;
-            if (diagnostics.length > 0) {
-                throw new Error(`Child extension load failed: ${JSON.stringify(diagnostics)}`);
-            }
-            const model = services.modelRuntime.getModel(launch.provider, launch.model);
-            if (!model) {
-                throw new Error(`Saved model ${launch.provider}/${launch.model} is unavailable; no fallback was used.`);
-            }
-            return {
-                ...(await sdk.createAgentSessionFromServices({
-                    services,
-                    sessionManager,
-                    model,
-                    thinkingLevel: launch.thinking,
-                })),
-                services,
-                diagnostics: services.diagnostics,
-            };
-        };
-    }
     stop = () => {
         if (this.stopping) {
             return;
@@ -362,7 +291,7 @@ class Actor {
         return this.stopping && this.active === undefined && (this.session?.isIdle ?? true);
     }
     /** Durable command readiness, not elapsed time, defines admission. */
-    async admitCommands() {
+    async admitCommands(runtime, parked) {
         // Queued commands create this directory; otherwise pending() does and the next pass arms.
         const directory = path.join(this.dir, "commands");
         const commands = new DirectoryWatch(directory, () => true, this.wake.raise);
@@ -374,6 +303,10 @@ class Actor {
                     this.retry = false;
                     this.pending().forEach((command) => this.accept(command));
                 }
+                // oxlint-disable-next-line no-await-in-loop
+                if (await this.park(runtime, parked)) {
+                    return;
+                }
                 const polling = this.retry || this.stopping || watch === "unwatched";
                 const tick = Math.max(1, this.nextParentCheck - performance.now());
                 // oxlint-disable-next-line no-await-in-loop
@@ -386,6 +319,36 @@ class Actor {
             commands.close();
         }
     }
+    /** Parks a final-idle actor; the parent/stop owner stays live while preparation awaits. */
+    async park(runtime, parked) {
+        const owner = new AbortController();
+        const watch = setInterval(() => {
+            if (this.shouldExit() || this.stopping) {
+                owner.abort();
+            }
+        }, 100);
+        try {
+            this.parking = await parked.park(runtime, {
+                signal: owner.signal,
+                pi: this.context?.pi,
+                busy: this.stopping || this.active !== undefined || this.observation?.watched === true,
+                // Raced commands and viewers keep this actor resident; the loop admits after release.
+                quiet: () => {
+                    const queued = this.pending().some((command) => this.commandLaunch(command));
+                    if (queued) {
+                        this.wake.raise();
+                    }
+                    const idle = this.active === undefined && !this.stopping;
+                    return !queued && idle && this.observation?.watched !== true;
+                },
+                errors: this.errors,
+            });
+        }
+        finally {
+            clearInterval(watch);
+        }
+        return this.parking;
+    }
     failure(error) {
         const launch = this.current ?? this.initial;
         const result = {
@@ -402,69 +365,104 @@ class Actor {
         }
         process.exitCode = 1;
     }
+    async start(sdk, parked) {
+        const sessionManager = parked.open();
+        const factory = childRuntime(sdk, this.initial, {
+            directory: this.dir,
+            token: this.token,
+            saved: parked.saved,
+            started: (pi, ctx) => {
+                this.context = { pi, ctx };
+            },
+            tool: (event) => this.observation?.tool(event),
+        });
+        const runtime = await sdk.createAgentSessionRuntime(factory, {
+            cwd: this.initial.cwd,
+            agentDir: this.initial.agentDir,
+            sessionManager,
+        });
+        try {
+            await this.ready(runtime, parked);
+        }
+        catch (error) {
+            // A runtime that never became ready is still disposed, so the failed actor exits.
+            await runtime.dispose();
+            throw error;
+        }
+        return runtime;
+    }
+    async ready(runtime, parked) {
+        this.session = runtime.session;
+        await this.session.bindExtensions({
+            mode: "print",
+            onError: (error) => {
+                this.errors.push(error.error);
+            },
+        });
+        if (!this.context) {
+            throw new Error("Child extension context is unavailable.");
+        }
+        initializeCwd(this.context.pi, this.context.ctx, this.initial.cwd, this.dir);
+        if (this.initial.name !== undefined && !parked.saved) {
+            this.session.sessionManager.appendSessionInfo(this.initial.name);
+        }
+        // Optional live view, bound before readiness; its faults never change native execution.
+        this.observation = await ActorObservation.open(this.session, {
+            token: this.token,
+            rootId: this.initial.rootId,
+            sessionId: this.session.sessionManager.getSessionId(),
+        });
+        write(path.join(this.dir, "actor.lock", "process.json"), {
+            ...ownIdentity(),
+            token: this.token,
+        });
+        write(path.join(this.dir, "ready.json"), {
+            pid: process.pid,
+            token: this.token,
+            sessionId: this.session.sessionManager.getSessionId(),
+            at: Date.now(),
+        });
+        parked.adopt();
+    }
     async serve() {
         const sdk = await loadSDK(this.initial.sdk);
+        const parked = new Parking(this.base, this.initial, this.token, sdk);
         let runtime;
         try {
-            runtime = await sdk.createAgentSessionRuntime(this.createRuntime(sdk), {
-                cwd: this.initial.cwd,
-                agentDir: this.initial.agentDir,
-                sessionManager: sdk.SessionManager.open(this.initial.sessionFile, undefined, this.initial.cwd),
-            });
-            this.session = runtime.session;
-            await this.session.bindExtensions({
-                mode: "print",
-                onError: (error) => {
-                    this.errors.push(error.error);
-                },
-            });
-            if (!this.context) {
-                throw new Error("Child extension context is unavailable.");
-            }
-            initializeCwd(this.context.pi, this.context.ctx, this.initial.cwd, this.dir);
-            if (this.initial.name !== undefined) {
-                this.session.sessionManager.appendSessionInfo(this.initial.name);
-            }
-            // Optional live view, bound before readiness; its faults never change native execution.
-            this.observation = await ActorObservation.open(this.session, {
-                token: this.token,
-                rootId: this.initial.rootId,
-                sessionId: this.session.sessionManager.getSessionId(),
-            });
-            write(path.join(this.dir, "actor.lock", "process.json"), {
-                ...ownIdentity(),
-                token: this.token,
-            });
-            write(path.join(this.dir, "ready.json"), {
-                pid: process.pid,
-                token: this.token,
-                sessionId: this.session.sessionManager.getSessionId(),
-                at: Date.now(),
-            });
+            runtime = await this.start(sdk, parked);
             process.on("SIGTERM", this.stop);
             process.on("SIGINT", this.stop);
-            await this.admitCommands();
+            await this.admitCommands(runtime, parked);
             await this.active;
         }
         catch (error) {
             this.failure(error);
         }
         finally {
-            process.off("SIGTERM", this.stop);
-            process.off("SIGINT", this.stop);
-            const observation = this.observation?.close();
+            await this.finish(runtime);
+        }
+    }
+    async finish(runtime) {
+        process.off("SIGTERM", this.stop);
+        process.off("SIGINT", this.stop);
+        const observation = this.observation?.close();
+        if (!this.parking) {
             await runtime?.dispose();
-            if (this.stopping) {
-                this.stopShells("SIGKILL");
-            }
-            clearTimeout(this.stopDeadline);
-            write(path.join(this.dir, `shutdown-${this.token}.json`), {
-                at: Date.now(),
-                errors: this.errors,
-                ...(observation === undefined ? {} : { observation }),
-            });
-            // Keep the process claim until a launcher proves this exact actor is gone.
         }
+        if (this.stopping) {
+            this.stopShells("SIGKILL");
+        }
+        clearTimeout(this.stopDeadline);
+        write(path.join(this.dir, `shutdown-${this.token}.json`), {
+            at: Date.now(),
+            errors: this.errors,
+            ...(observation === undefined ? {} : { observation }),
+        });
+        if (this.parking) {
+            // Parked authority requires actual exit; no leftover extension handle may keep it alive.
+            process.exit();
+        }
+        // Keep the process claim until a launcher proves this exact actor is gone.
     }
 }
 const base = process.argv.at(2);

package/dist/agent/storage.js

@@ -82,6 +82,24 @@ export function launchAt(base, id, owner) {
     }
     return launch;
 }
+/** Claims the single successor of a saved run; undefined when another caller already has. */
+export function successor(base, launch, prompt) {
+    const id = randomUUID();
+    const next = { ...launch, id, predecessor: launch.id, prompt, createdAt: Date.now() };
+    fs.mkdirSync(runDirectory(base, id), { mode: 0o700 });
+    write(path.join(runDirectory(base, id), "launch.json"), next, true);
+    try {
+        write(path.join(runDirectory(base, launch.id), "successor.json"), { id }, true);
+    }
+    catch (error) {
+        fs.rmSync(runDirectory(base, id), { recursive: true });
+        if (!(error instanceof Error && "code" in error && error.code === "EEXIST")) {
+            throw error;
+        }
+        return undefined;
+    }
+    return next;
+}
 export function latest(base, initial) {
     const seen = new Set();
     let launch = initial;

package/dist/build-info.js

@@ -1 +1 @@
-export const EXTENSION_BUILD = Object.freeze({"version":"0.51.0","sha256":"fc084c36d416e6ea9947600b7d1fdef98c84a82f3408dea2ea028a9c485ac31e"});
+export const EXTENSION_BUILD = Object.freeze({"version":"0.52.0","sha256":"a9faf29451051826907d9343b432c9232529ccaa68c75d681dbcb464702fc25f"});

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

@@ -8,6 +8,7 @@ import { brokerPidRecord } from "./pid.js";
 import { assertBrokerCanStart } from "./spawn.js";
 import { LastMessageRelay } from "./last.js";
 import { canSeeSession, findSessions } from "./targets.js";
+import { ParkedSessions, reachable } from "./parked.js";
 import { acceptBrokerConnection, registeredSessionInfo } from "./server-connection.js";
 import { guardedDeliveryError } from "./guard.js";
 import { compactTopicMessage, normalizeMessage, normalizeSessionInfo, } from "../types.js";
@@ -18,6 +19,7 @@ const REPLACE_DELIVERY_DELAY_MS = 1500;
 class IntercomBroker {
     sessions = new Map();
     lastMessages = new LastMessageRelay(this.sessions);
+    parking = new ParkedSessions(this.sessions, this.deliverMessage.bind(this));
     pendingReplaceDeliveries = new Map();
     server;
     shutdownTimer = null;
@@ -56,7 +58,7 @@ class IntercomBroker {
         }
         this.shutdownTimer = setTimeout(() => {
             this.shutdownTimer = null;
-            if (this.sessions.size === 0) {
+            if (this.parking.exited) {
                 console.log("No sessions connected, shutting down");
                 this.shutdown();
             }
@@ -84,7 +86,7 @@ class IntercomBroker {
         }
         switch (msg.type) {
             case "unregister":
-                this.removeSession(currentId);
+                this.removeSession(currentId, socket);
                 setId(null);
                 break;
             case "list":
@@ -94,7 +96,8 @@ class IntercomBroker {
                 this.send(socket, msg, currentId);
                 break;
             case "last_request":
-                this.lastMessages.request(currentId, msg);
+                // Reads never spawn a parked child.
+                this.lastMessages.request(currentId, msg, (id) => this.parking.reader(id));
                 break;
             case "last_response":
                 this.lastMessages.respond(currentId, msg);
@@ -102,21 +105,28 @@ class IntercomBroker {
             case "presence":
                 this.presence(msg, currentId);
                 break;
+            case "park":
+            case "unpark":
+                this.parking.park(socket, currentId, msg.type === "park");
+                break;
             default:
                 throw new Error(`Unknown client message type: ${msg.type}`);
         }
     }
     register(socket, msg, setId) {
-        const info = registeredSessionInfo(msg, this.sessions);
-        const id = info.id;
+        const registered = registeredSessionInfo(msg, this.sessions);
+        const { id, resumed } = this.parking.claim(msg.requestedId, registered);
+        const info = { ...registered, id };
         snapshotFrames(randomUUID(), [info], true);
         const topicFrames = msg.topicFrames === true;
         this.sessions.set(id, {
             socket,
             info: messageSender(info),
-            topics: new TopicSnapshot(info),
+            // A woken generation registers no topics; the parked identity's owner keeps them.
+            topics: resumed?.topics ?? new TopicSnapshot(info),
             topicFrames,
             lastMessages: msg.lastMessages === true,
+            parking: msg.parking === true,
             receiptReads: msg.receiptReads === 1,
         });
         setId(id);
@@ -128,20 +138,24 @@ class IntercomBroker {
             type: "registered",
             sessionId: id,
             lastMessages: true,
+            parking: msg.parking === true,
             receiptReads: 1,
             ...(msg.guardedDelivery === 1 ? { guardedDelivery: 1 } : {}),
             ...(topicFrames ? { topicsSupported: true, topicFrames: true } : {}),
         });
+        this.parking.registered(id, resumed);
     }
-    removeSession(sessionId) {
+    removeSession(sessionId, socket) {
         const session = this.sessions.get(sessionId);
-        if (!session) {
+        if (session?.socket !== socket) {
             return;
         }
-        this.sessions.delete(sessionId);
         this.lastMessages.disconnected(sessionId);
-        this.clearPendingReplaceDeliveries(sessionId);
-        this.broadcast({ type: "session_left", sessionId }, session.info);
+        if (!this.parking.closed(session)) {
+            this.sessions.delete(sessionId);
+            this.clearPendingReplaceDeliveries(sessionId);
+            this.broadcast({ type: "session_left", sessionId }, session.info);
+        }
         this.scheduleShutdownCheck();
     }
     planPublications(fromId, from, publication) {
@@ -155,7 +169,7 @@ class IntercomBroker {
                 continue;
             }
             const message = publicationMessage(publication, subscription.awaitRelease === true);
-            const error = this.validateDeliveryPayload(from, message, target.topicFrames);
+            const error = this.validateDeliveryPayload(from, message, target);
             if (error !== null) {
                 throw new Error(error);
             }
@@ -307,14 +321,16 @@ class IntercomBroker {
     }
     sendToSession(fromId, toId, from, message) {
         const target = this.sessions.get(toId);
-        if (target && shouldReplaceDelivery(message, target.info)) {
+        if (target && target.parked === undefined && shouldReplaceDelivery(message, target.info)) {
             return this.queueReplaceDelivery(fromId, toId, from, message);
         }
         const reason = this.deliverMessage(toId, from, message);
+        const queued = reason === null && target?.parked !== undefined;
         return {
             id: message.id,
             accepted: reason === null,
-            delivered: reason === null,
+            delivered: reason === null && !queued,
+            ...(queued ? { queued } : {}),
             ...(reason !== null ? { reason } : {}),
         };
     }
@@ -335,7 +351,7 @@ class IntercomBroker {
         return `${fromId}\0${toId}\0${threadId}`;
     }
     queueReplaceDelivery(fromId, toId, from, message) {
-        const validationError = this.validateDeliveryPayload(from, message, this.sessions.get(toId)?.topicFrames === true);
+        const validationError = this.validateDeliveryPayload(from, message, this.sessions.get(toId));
         if (validationError !== null) {
             return { id: message.id, accepted: false, delivered: false, reason: validationError };
         }
@@ -367,28 +383,25 @@ class IntercomBroker {
             }
         }
     }
-    validateDeliveryPayload(from, message, topicFrames) {
+    /** One admission rule; retained input is checked as the uncompacted envelope any later
+     * transport generation accepts. */
+    validateDeliveryPayload(from, message, target) {
+        const compact = target?.parked === undefined && target?.topicFrames === true;
         return (validateIntercomMessageSize({
             type: "message",
             from: messageSender(from),
-            message: topicFrames ? compactTopicMessage(message) : message,
+            message: compact ? compactTopicMessage(message) : message,
         })?.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 ||
-            target.socket.writableEnded ||
-            !target.socket.writable) {
-            return "Recipient disconnected before delivery";
+        const refused = guardedDeliveryError(this.sessions, toId, message) ??
+            this.validateDeliveryPayload(from, message, target);
+        if (refused !== null || this.parking.retain(target, from, message)) {
+            return refused;
         }
-        const validationError = this.validateDeliveryPayload(from, message, target.topicFrames);
-        if (validationError !== null) {
-            return validationError;
+        if (!reachable(target)) {
+            return "Recipient disconnected before delivery";
         }
         this.touchActivity(toId, true);
         try {

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

@@ -1,7 +1,18 @@
 import type net from "node:net";
 import { type UnknownRecord } from "../../shared/unknown.ts";
-import type { LastMessageQuery, LastMessageResult, ReceiptQuery, ReceiptResult } from "../types.ts";
+import { type NativeReadQuery } from "./last.ts";
+import { type LastMessageQuery, type LastMessageResult, type ReceiptQuery, type ReceiptResult, type SessionInfo } from "../types.ts";
+/** A peer's read of this session or, for a main, of its exited `parked` child. */
+export declare function lastRequest(msg: UnknownRecord): {
+    readonly requestId: string;
+    readonly from: SessionInfo;
+    readonly query: NativeReadQuery;
+    readonly parked?: SessionInfo;
+};
 export declare class LastMessageRequests {
+    /** Negotiated at registration; a failed connection supports neither. */
+    lastMessages: boolean;
+    receiptReads: boolean;
     private readonly timeoutMs;
     constructor(timeoutMs: number);
     private readonly pending;

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

@@ -1,14 +1,33 @@
 import { randomUUID } from "node:crypto";
 import { errorMessage } from "../../shared/unknown.js";
 import { isNativeReadQuery, isNativeReadResult, isLastMessageResult, isReceiptResult, } from "./last.js";
+import { normalizeSessionInfo, } from "../types.js";
 import { writeMessage } from "./framing.js";
+/** A peer's read of this session or, for a main, of its exited `parked` child. */
+export function lastRequest(msg) {
+    const from = normalizeSessionInfo(msg.from);
+    if (typeof msg.requestId !== "string" || !from || !isNativeReadQuery(msg.query)) {
+        throw new Error("Invalid last-message request");
+    }
+    return {
+        requestId: msg.requestId,
+        from,
+        query: msg.query,
+        parked: normalizeSessionInfo(msg.parked) ?? undefined,
+    };
+}
 export class LastMessageRequests {
+    /** Negotiated at registration; a failed connection supports neither. */
+    lastMessages = false;
+    receiptReads = false;
     timeoutMs;
     constructor(timeoutMs) {
         this.timeoutMs = timeoutMs;
     }
     pending = new Map();
     fail(error) {
+        this.lastMessages = false;
+        this.receiptReads = false;
         for (const pending of this.pending.values()) {
             clearTimeout(pending.timer);
             pending.reject(error);
@@ -36,9 +55,15 @@ export class LastMessageRequests {
         return isReceiptResult(result) ? result : { error: "Invalid receipt response" };
     }
     request(socket, to, query) {
+        if (!this.lastMessages) {
+            return Promise.reject(new Error("This broker does not support last-message reads; reload after it exits."));
+        }
         if (!isNativeReadQuery(query)) {
             return Promise.reject(new Error("Invalid last-message query"));
         }
+        if ("messageId" in query && !this.receiptReads) {
+            return Promise.reject(new Error("publication_unavailable"));
+        }
         return new Promise((resolve, reject) => {
             const requestId = randomUUID();
             const timer = setTimeout(() => {

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

@@ -0,0 +1,9 @@
+import type net from "node:net";
+/** Parking negotiation and its single outstanding broker acknowledgement. */
+export declare class ParkRequests {
+    supported: boolean;
+    private acknowledged?;
+    settle(parked: boolean): void;
+    /** True once the broker retains later input; false when it cannot or the socket closed. */
+    request(socket: () => net.Socket, on: boolean): Promise<boolean>;
+}

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

@@ -0,0 +1,21 @@
+import { writeMessage } from "./framing.js";
+/** Parking negotiation and its single outstanding broker acknowledgement. */
+export class ParkRequests {
+    supported = false;
+    acknowledged;
+    settle(parked) {
+        this.acknowledged?.(parked);
+    }
+    /** True once the broker retains later input; false when it cannot or the socket closed. */
+    request(socket, on) {
+        return new Promise((resolve) => {
+            this.acknowledged = on && this.supported ? resolve : undefined;
+            if (this.supported) {
+                writeMessage(socket(), { type: on ? "park" : "unpark" });
+            }
+            if (this.acknowledged === undefined) {
+                resolve(false);
+            }
+        });
+    }
+}

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

@@ -11,8 +11,7 @@ export declare class IntercomClient extends EventEmitter {
     private connection;
     private _sessionId;
     private _topicsSupported;
-    private lastMessagesSupported;
-    private receiptReadsSupported;
+    private readonly parking;
     private guardedDeliverySupported;
     private readonly lastRequests;
     private readonly pendingSends;
@@ -36,11 +35,11 @@ export declare class IntercomClient extends EventEmitter {
     private receiveMessage;
     private receiveDelivery;
     private receiveSessions;
+    park(on?: boolean): Promise<boolean>;
     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;