@fitchmultz/pi-subagents 0.50.0 → 0.52.0

package/dist/pi-intercom/lifecycle.js

@@ -1,5 +1,11 @@
+import { randomUUID } from "node:crypto";
 import { buildPresenceIdentity } from "./identity.js";
 import { resolveSessionProjectId } from "./session-targets.js";
+import { isContextTarget, } from "./types.js";
+import { isRecord, safeLabel } from "./validation.js";
+export function isContextRequest(value) {
+    return isRecord(value) && typeof value.respond === "function";
+}
 /** Owns native context validity and occupancy, never journal or socket state. */
 export class IntercomLifecycle {
     context = null;
@@ -7,6 +13,10 @@ export class IntercomLifecycle {
     model = "unknown";
     disposed = true;
     epoch = 0;
+    incarnation = null;
+    peerId = null;
+    guardedDelivery = false;
+    applicationGuard;
     running = false;
     activity = 0;
     tools = new Map();
@@ -27,15 +37,87 @@ export class IntercomLifecycle {
     get toolCount() {
         return this.tools.size;
     }
+    registerContextEvents(sync) {
+        this.pi.events.on("pi-intercom:context-query", (request) => this.contextRequest(request));
+        this.pi.events.on("pi-intercom:application-guard", (request) => this.contextRequest(request, sync));
+    }
+    contextRequest(request, sync) {
+        if (!isContextRequest(request)) {
+            return;
+        }
+        if (request.version !== 1) {
+            request.respond({ error: "unsupported_version" });
+            return;
+        }
+        if (sync) {
+            if (!isContextTarget(request.target) ||
+                !this.matches(request.target) ||
+                !(request.revision === null ||
+                    (typeof request.revision === "string" && safeLabel(request.revision)))) {
+                request.respond({ error: "context_changed" });
+                return;
+            }
+            this.applicationGuard = request.revision === null ? undefined : request.revision;
+            sync();
+            this.publishContext();
+        }
+        request.respond(this.snapshot());
+    }
+    snapshot() {
+        if (!this.live()) {
+            return {
+                version: 1,
+                rootSessionId: null,
+                peerId: null,
+                incarnation: null,
+                connected: false,
+                guardedDelivery: null,
+            };
+        }
+        return {
+            version: 1,
+            rootSessionId: this.lineage?.rootSessionId ?? this.sessionId,
+            parentSessionId: this.lineage?.parentSessionId,
+            peerId: this.peerId,
+            incarnation: this.incarnation,
+            connected: this.peerId !== null,
+            guardedDelivery: this.guardedDelivery ? 1 : null,
+            applicationGuard: this.applicationGuard,
+        };
+    }
+    publishContext() {
+        this.pi.events.emit("pi-intercom:context-state", this.snapshot());
+    }
+    transport(peerId, guardedDelivery = false) {
+        this.peerId = peerId;
+        this.guardedDelivery = guardedDelivery;
+        this.publishContext();
+    }
+    matches(target) {
+        const current = this.snapshot();
+        return (current.connected &&
+            current.rootSessionId === target.rootSessionId &&
+            current.peerId === target.peerId &&
+            current.incarnation === target.incarnation);
+    }
+    accepts(guard) {
+        return (this.guardedDelivery &&
+            this.lineage?.parentSessionId === undefined &&
+            this.matches(guard) &&
+            this.applicationGuard === guard.applicationGuard);
+    }
     start(ctx) {
         this.disposed = false;
         this.epoch += 1;
         this.context = ctx;
         this.sessionId = ctx.sessionManager.getSessionId();
+        this.incarnation = randomUUID();
+        this.applicationGuard = undefined;
         this.model = ctx.model?.id ?? "unknown";
         this.running = false;
         this.activity = 0;
         this.tools.clear();
+        this.transport(null);
         return this.epoch;
     }
     invalidate() {
@@ -43,6 +125,7 @@ export class IntercomLifecycle {
         this.epoch += 1;
         this.running = false;
         this.tools.clear();
+        this.publishContext();
     }
     clear() {
         this.context = null;
@@ -129,12 +212,14 @@ export class IntercomLifecycle {
         if (!live || this.sessionId === null) {
             throw new Error("Intercom runtime not initialized");
         }
-        const cwd = live.cwd;
         return {
             ...this.identity(this.sessionId),
-            cwd,
+            incarnation: this.incarnation ?? undefined,
+            guardedDelivery: 1,
+            applicationGuard: this.applicationGuard,
+            cwd: live.cwd,
             model: this.model,
-            projectId: await resolveSessionProjectId(cwd),
+            projectId: await resolveSessionProjectId(live.cwd),
             lastSeen: Date.now(),
             status: this.status(),
             ...this.health(pendingAsks),

package/dist/pi-intercom/outbound.js

@@ -3,7 +3,7 @@ import { resolveConnectedTarget, resolvePeerHealth, } from "./connection.js";
 import { RECIPIENT_TURN_FAILED_ATTACHMENT, } from "./runtime-types.js";
 import { errorMessage } from "./validation.js";
 import { formatAttachments } from "./message-format.js";
-import { AskDeliveryError, failureDetails, replyFailureReason, } from "./tool-results.js";
+import { AskDeliveryError, failureDetails, RecoveryError, } from "./tool-results.js";
 import { sendOptions, toolError, toolText } from "./tool-arguments.js";
 export class IntercomOutbound {
     owners;
@@ -101,8 +101,7 @@ export class IntercomOutbound {
             return this.sent(to, params, result);
         }
         catch (error) {
-            const text = errorMessage(error);
-            return toolError(`Failed to send: ${text}`, failureDetails(text.startsWith("Target ") ? "ambiguous_target" : "send_failed", [
+            return toolError(`Failed to send: ${errorMessage(error)}`, failureDetails(error instanceof RecoveryError ? error.code : "send_failed", [
                 { action: "list" },
                 { action: "send", guidance: "Retry with an exact active recipient target." },
             ], { error: true }));
@@ -147,15 +146,7 @@ export class IntercomOutbound {
             const result = this.deliveryFailure(to, error.result);
             return { ...result, details: { ...result.details, error: true } };
         }
-        const text = errorMessage(error);
-        let reason = "ask_failed";
-        if (text.startsWith("No reply from")) {
-            reason = "reply_timeout";
-        }
-        else if (text.startsWith("Target ")) {
-            reason = "ambiguous_target";
-        }
-        return toolError(`Failed: ${text}`, failureDetails(reason, [
+        return toolError(`Failed: ${errorMessage(error)}`, failureDetails(error instanceof RecoveryError ? error.code : "ask_failed", [
             { action: "status" },
             { action: "list" },
             {
@@ -293,8 +284,7 @@ export class IntercomOutbound {
         }
     }
     replyFailure(error, replyTo) {
-        const text = errorMessage(error);
-        const reason = replyFailureReason(text);
+        const reason = error instanceof RecoveryError ? error.code : "reply_failed";
         const actions = reason === "no_pending_reply"
             ? [
                 { action: "pending" },
@@ -304,7 +294,7 @@ export class IntercomOutbound {
                 },
             ]
             : [{ action: "pending" }, { action: "list" }];
-        return toolError(`Failed to reply: ${text}`, failureDetails(reason, actions, {
+        return toolError(`Failed to reply: ${errorMessage(error)}`, failureDetails(reason, actions, {
             error: true,
             ...((replyTo ?? "") !== "" ? { replyTo } : {}),
         }));

package/dist/pi-intercom/reply-tracker.js

@@ -1,4 +1,5 @@
 import { formatSessionTarget, resolveSessionTarget, shortSessionId } from "./session-targets.js";
+import { RecoveryError } from "./tool-results.js";
 function resolveBySenderTarget(contexts, to) {
     const sessions = contexts.map((context) => context.from);
     const resolution = resolveSessionTarget(sessions, to);
@@ -26,14 +27,14 @@ function pendingSenderOptions(contexts, allContexts = contexts) {
 function matchingSender(contexts, to) {
     const tooShort = tooShortSenderTargetMessage(contexts, to);
     if (tooShort !== null && tooShort !== "") {
-        throw new Error(tooShort);
+        throw new RecoveryError("ambiguous_reply_target", tooShort);
     }
     return resolveBySenderTarget(contexts, to);
 }
 function explicitReply(contexts, replyTo, to) {
     const target = contexts.find((context) => context.message.id === replyTo);
     if (!target) {
-        throw new Error(`No pending ask with replyTo "${replyTo}"`);
+        throw new RecoveryError("no_pending_reply", `No pending ask with replyTo "${replyTo}"`);
     }
     if (to !== "" &&
         !matchingSender(contexts, to).some((context) => context.message.id === target.message.id)) {
@@ -47,9 +48,9 @@ function replyBySender(contexts, to) {
         return matches[0];
     }
     if (matches.length > 1) {
-        throw new Error(`Multiple pending asks from "${to}" — use one of: ${pendingSenderOptions(matches, contexts)}.`);
+        throw new RecoveryError("ambiguous_reply_target", `Multiple pending asks from "${to}" — use one of: ${pendingSenderOptions(matches, contexts)}.`);
     }
-    throw new Error(`No pending ask from "${to}"`);
+    throw new RecoveryError("no_pending_reply", `No pending ask from "${to}"`);
 }
 export class ReplyTracker {
     pendingAsks = new Map();
@@ -151,9 +152,9 @@ export class ReplyTracker {
             return pending[0];
         }
         if (pending.length === 0) {
-            throw new Error("No active intercom context to reply to");
+            throw new RecoveryError("no_pending_reply", "No active intercom context to reply to");
         }
-        throw new Error("Multiple pending asks — specify `to`");
+        throw new RecoveryError("ambiguous_reply_target", "Multiple pending asks — specify `to`");
     }
     markReplied(replyTo) {
         this.removeContext(replyTo);

package/dist/pi-intercom/reply-wait.js

@@ -1,5 +1,5 @@
 import { asError } from "./validation.js";
-import { AskDeliveryError } from "./tool-results.js";
+import { AskDeliveryError, RecoveryError } from "./tool-results.js";
 /** One correlated blocking wait; admitted before send so a fast reply cannot race it. */
 export class ReplyWait {
     waiter = null;
@@ -42,7 +42,7 @@ export class ReplyWait {
         return new Promise((resolve, reject) => {
             const { from, replyTo, signal } = options;
             const timeout = setTimeout(() => {
-                this.reject(new Error(`No reply from "${from}" within ${Math.max(1, Math.round(this.timeoutMs / 60000))} minute(s)`));
+                this.reject(new RecoveryError("reply_timeout", `No reply from "${from}" within ${Math.max(1, Math.round(this.timeoutMs / 60000))} minute(s)`));
             }, this.timeoutMs);
             timeout.unref();
             const cleanup = () => {

package/dist/pi-intercom/session-targets.d.ts

@@ -0,0 +1,24 @@
+export interface TargetIdentity {
+    readonly id: string;
+    readonly name?: string;
+}
+export interface ProjectSessionIdentity extends TargetIdentity {
+    readonly cwd: string;
+    readonly projectId?: string;
+}
+export declare const MIN_SESSION_TARGET_PREFIX_LENGTH = 8;
+export declare function nativePeerId(sessionId: string): string;
+export interface TargetResolution<T extends TargetIdentity> {
+    readonly status: "none" | "found" | "ambiguous" | "prefix_too_short";
+    readonly target?: T;
+    readonly matches: readonly T[];
+}
+export declare function shortSessionId(sessionId: string): string;
+export declare function resolveSessionProjectId(cwd: string): Promise<string>;
+export declare function formatSessionTarget(session: TargetIdentity, allSessions?: readonly TargetIdentity[]): string;
+export declare function formatTargetOptions(sessions: readonly TargetIdentity[], allSessions?: readonly TargetIdentity[]): string;
+export declare function targetDisplayName(session: TargetIdentity, allSessions?: readonly TargetIdentity[]): string;
+export declare const PEER_AWARENESS_HINT = "Other Pi sessions may be connected to this project. Use load_intercom({}) if needed, then intercom({ action: \"list\" }) before changing shared state or coordinating known overlapping work. Routine standalone read-only tasks do not need a peer check. Coordinate only when work overlaps; use subagent controls for managed child runs.";
+export declare function filterProjectSessions<T extends ProjectSessionIdentity>(sessions: readonly T[], currentSessionId: string): T[];
+export declare function formatPeerAwarenessHint(sessions: readonly ProjectSessionIdentity[], currentSessionId: string): string | undefined;
+export declare function resolveSessionTarget<T extends TargetIdentity>(sessions: readonly T[], rawTarget: string): TargetResolution<T>;

package/dist/pi-intercom/tool-registration.js

@@ -1,11 +1,14 @@
 import { throwIfToolError } from "./tool-results.js";
 import { intercomSchema } from "./tool-schemas.js";
+import { registerCompactMessages, renderCompactResult } from "../shared/compact-cards.js";
 export function registerIntercomTools(pi, tools) {
+    registerCompactMessages(pi, ["intercom_message", "subagent-human-message"]);
     pi.registerTool({
         name: "intercom",
         label: "Intercom",
-        description: "Discover and message connected Pi sessions in your collaboration group; main sessions can also reach other mains, across projects. Use list for unambiguous targets. Send defaults to steer at the next tool boundary; queue defers; passive never wakes the model. Ask waits for a correlated reply; reply answers the active or single pending ask (specify replyTo when ambiguous). Pending lists asks; status shows connection and inbound queue state. Last reads a peer's original completed assistant response without waking it; page using entryId and nextOffset. Broker acceptance is not recipient persistence, consumption, or task completion.",
+        description: "Message connected Pi sessions in your group; mains also reach other mains across projects. List shows target IDs. Ask waits for a correlated reply; reply answers the active or sole pending ask. Pending lists asks; status shows connection and inbound queue. Last pages a peer's last completed response without waking it. Broker acceptance is not recipient persistence, consumption or completion.",
         parameters: intercomSchema,
+        renderResult: renderCompactResult,
         async execute(_id, params, signal, _update, ctx) {
             const result = throwIfToolError(await tools.execute(params, signal, ctx));
             return { content: [...result.content], details: result.details };

package/dist/pi-intercom/tool-results.js

@@ -1,14 +1,12 @@
 export function failureDetails(reasonCode, nextActions, details = {}) {
     return { ...details, reasonCode, nextActions };
 }
-export function replyFailureReason(message) {
-    if (message.startsWith("No active intercom context") || message.startsWith("No pending ask")) {
-        return "no_pending_reply";
-    }
-    if (message.startsWith("Multiple pending asks") || message.includes("too short")) {
-        return "ambiguous_reply_target";
+export class RecoveryError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
     }
-    return "reply_failed";
 }
 export function firstTextContent(result) {
     return (result.content

package/dist/pi-intercom/tool-schemas.js

@@ -1,42 +1,28 @@
 import { StringEnum } from "@earendil-works/pi-ai";
 import { Type } from "../agent/typebox.js";
 export const intercomSchema = Type.Object({
-    action: StringEnum(["list", "send", "ask", "reply", "pending", "status", "last"], {
-        description: "List, send, ask, reply, pending asks, connection status, or last completed assistant response.",
-    }),
+    action: StringEnum(["list", "send", "ask", "reply", "pending", "status", "last"]),
     scope: Type.Optional(StringEnum(["project", "all"], {
-        description: "For list/status: 'all' (default) includes every reachable session; 'project' further filters this repository and its worktrees.",
-    })),
-    to: Type.Optional(Type.String({
-        description: "Target session name or ID (for 'send', 'ask', or disambiguating 'reply')",
-    })),
-    message: Type.Optional(Type.String({
-        description: "Message for send/ask/reply",
+        description: "all (default) or project (repo and worktrees)",
     })),
+    to: Type.Optional(Type.String({ description: "Session name or ID" })),
+    message: Type.Optional(Type.String()),
     attachments: Type.Optional(Type.Array(Type.Object({
         type: StringEnum(["file", "snippet", "context"]),
         name: Type.String(),
         content: Type.String(),
         language: Type.Optional(Type.String()),
     }))),
-    replyTo: Type.Optional(Type.String({
-        description: "Message ID to reply to (for threading or responding to an 'ask')",
-    })),
+    replyTo: Type.Optional(Type.String({ description: "Message ID to answer or thread" })),
     delivery: Type.Optional(StringEnum(["queue", "steer", "passive"], {
-        description: "Delivery mode. Omitted send delivery defaults to 'steer', which injects after the current tool call. Use 'queue' only to intentionally wait behind active work; 'passive' does not wake the recipient model.",
+        description: "steer (default) at next tool boundary; queue after active work; passive never wakes the model",
     })),
     queueMode: Type.Optional(StringEnum(["stack", "replace"], {
-        description: "For delivery='queue': 'stack' keeps all messages; 'replace' keeps only the latest undelivered message for the same threadId.",
-    })),
-    threadId: Type.Optional(Type.String({ description: "Stable topic key for queueMode='replace'." })),
-    entryId: Type.Optional(Type.String({ description: "Last response entry ID for stable paging." })),
-    offset: Type.Optional(Type.Integer({ minimum: 0, description: "Last response character offset (UTF-16)." })),
-    limit: Type.Optional(Type.Integer({
-        minimum: 1,
-        maximum: 16384,
-        description: "Last response page size; default/max 16384 characters.",
-    })),
-    passive: Type.Optional(Type.Boolean({
-        description: "For action='send' only: legacy alias for delivery='passive'. Discouraged for agent-to-agent messages.",
+        description: "stack keeps all; replace keeps only the latest per threadId",
     })),
+    threadId: Type.Optional(Type.String()),
+    entryId: Type.Optional(Type.String()),
+    offset: Type.Optional(Type.Integer({ minimum: 0, description: "UTF-16 characters" })),
+    limit: Type.Optional(Type.Integer({ minimum: 1, maximum: 16384 })),
+    passive: Type.Optional(Type.Boolean({ description: "Legacy alias for delivery=passive" })),
 });

package/dist/pi-intercom/types.d.ts

@@ -0,0 +1,212 @@
+export interface SessionInfo {
+    readonly id: string;
+    readonly name?: string;
+    readonly cwd: string;
+    readonly model: string;
+    /** Opaque same-repository/worktree identity used for ambient peer awareness. */
+    readonly projectId?: string;
+    readonly rootSessionId?: string;
+    readonly parentSessionId?: string;
+    readonly incarnation?: string;
+    readonly guardedDelivery?: 1;
+    readonly applicationGuard?: string;
+    readonly status?: string;
+    readonly lastSeen?: number;
+    readonly lastIntercomActivity?: number;
+    readonly pendingAsks?: number;
+    readonly acceptsAsks?: boolean;
+    readonly subscriptions?: readonly TopicSubscription[];
+    readonly topics?: readonly TopicUpdate[];
+}
+export interface TopicSubscription {
+    readonly topic: string;
+    readonly awaitRelease?: boolean;
+}
+export interface TopicUpdate {
+    readonly topic: string;
+    readonly text: string;
+    readonly event: "update" | "blocker" | "decision" | "release";
+    readonly resource?: string;
+    readonly ownership?: "held" | "released";
+    readonly revision: number;
+    readonly updatedAt: number;
+}
+export declare function isTopicSubscription(value: unknown): value is TopicSubscription;
+export declare function isTopicUpdate(value: unknown): value is TopicUpdate;
+export type MessageDelivery = "queue" | "steer" | "passive";
+export type QueueMode = "stack" | "replace";
+export interface ContextTarget {
+    readonly rootSessionId: string;
+    readonly peerId: string;
+    readonly incarnation: string;
+}
+export interface DeliveryGuard extends ContextTarget {
+    readonly applicationGuard: string;
+}
+export interface PublicationReplyHint {
+    readonly tool: string;
+    readonly commandId: string;
+    readonly commandFingerprint?: string;
+}
+export type SendOptions = Omit<Message, "id" | "timestamp" | "content"> & Message["content"] & {
+    readonly messageId?: string;
+};
+export declare function isContextTarget(value: unknown): value is ContextTarget;
+export declare function isDeliveryGuard(value: unknown): value is DeliveryGuard;
+export declare function isPublicationReplyHint(value: unknown): value is PublicationReplyHint;
+export interface HumanMessageOrigin {
+    readonly ownerSessionId: string;
+    readonly runId: string;
+    readonly index: number;
+}
+export declare function isHumanMessageOrigin(value: unknown): value is HumanMessageOrigin;
+export interface Message {
+    readonly id: string;
+    readonly timestamp: number;
+    readonly replyTo?: string;
+    readonly expectsReply?: boolean;
+    /** Recipients verify parent ownership before elevating human origin. */
+    readonly human?: HumanMessageOrigin;
+    readonly topic?: TopicUpdate;
+    readonly delivery?: MessageDelivery;
+    readonly queueMode?: QueueMode;
+    readonly threadId?: string;
+    readonly passive?: boolean;
+    readonly guard?: DeliveryGuard;
+    readonly replyHint?: PublicationReplyHint;
+    readonly content: {
+        readonly text: string;
+        readonly attachments?: readonly Attachment[];
+    };
+}
+export interface Attachment {
+    readonly type: "file" | "snippet" | "context";
+    readonly name: string;
+    readonly content: string;
+    readonly language?: string;
+}
+export declare function isAttachment(value: unknown): value is Attachment;
+export declare function isMessage(value: unknown): value is Message;
+export declare function isSessionRegistration(value: unknown): value is Omit<SessionInfo, "id">;
+export declare function normalizeSessionInfo(value: unknown): SessionInfo | null;
+export interface SendResult {
+    readonly id: string;
+    readonly accepted: boolean;
+    readonly delivered: boolean;
+    readonly queued?: boolean;
+    readonly reason?: string;
+}
+export type TopicChange = {
+    readonly action: "publish" | "restore";
+    readonly topic: TopicUpdate;
+} | {
+    readonly action: "subscribe" | "restore";
+    readonly subscription: TopicSubscription;
+} | {
+    readonly action: "unsubscribe";
+    readonly topic: string;
+};
+export interface SessionSnapshot {
+    readonly sessions: readonly SessionInfo[];
+    readonly receipts: readonly (SendResult & {
+        readonly to: string;
+    })[];
+}
+type CompactTopicMessage = Omit<Message, "topic"> & {
+    readonly topic?: Omit<TopicUpdate, "text"> & {
+        readonly text?: string;
+    };
+};
+/** Topic text and the standard coalescing key need only one copy on the wire. */
+export declare function compactTopicMessage(message: Message): CompactTopicMessage;
+export declare function normalizeMessage(value: unknown): Message | null;
+export interface LastMessageQuery {
+    readonly entryId?: string;
+    readonly offset?: number;
+    readonly limit?: number;
+}
+export declare const LAST_MESSAGE_PAGE_LIMIT = 16384;
+export declare function isLastMessageQuery(value: unknown): value is LastMessageQuery;
+export type LastMessageResult = {
+    readonly session: SessionInfo;
+    readonly entryId: string | null;
+    readonly text: string;
+    readonly offset: number;
+    readonly totalLength: number;
+    readonly nextOffset?: number;
+} | {
+    readonly error: string;
+};
+export interface ReceiptQuery {
+    readonly rootSessionId: string;
+    readonly messageId: string;
+}
+export declare function isReceiptQuery(value: unknown): value is ReceiptQuery;
+export interface NativeReceipt extends ReceiptQuery {
+    readonly version: 1;
+    readonly sender: {
+        readonly peerId: string;
+        readonly rootSessionId?: string;
+        readonly incarnation?: string;
+    };
+    readonly textSha256: string;
+    readonly delivery: MessageDelivery;
+    readonly guard?: DeliveryGuard;
+    readonly replyHint?: PublicationReplyHint;
+    readonly checkpointEntryId: string;
+    readonly receivedAt: number;
+    /** Historical observations, not a promise that an input is still queued. */
+    readonly queued: boolean;
+    readonly nativeHandoff: boolean;
+    readonly placementEntryId: string | null;
+    readonly discarded: boolean;
+}
+export type ReceiptResult = {
+    readonly receipt: NativeReceipt;
+} | {
+    readonly error: string;
+};
+export type BrokerMessage = {
+    readonly type: "registered";
+    readonly sessionId: string;
+    readonly topicsSupported?: true;
+    readonly topicFrames?: true;
+    readonly lastMessages?: true;
+    readonly receiptReads?: 1;
+    readonly guardedDelivery?: 1;
+} | {
+    readonly type: "sessions";
+    readonly requestId: string;
+    readonly sessions: readonly (Partial<SessionInfo> & Pick<SessionInfo, "id">)[];
+    readonly more?: boolean;
+    readonly receipts?: SessionSnapshot["receipts"];
+    readonly error?: string;
+} | {
+    readonly type: "message";
+    readonly from: SessionInfo;
+    readonly message: Message | CompactTopicMessage;
+} | {
+    readonly type: "last_request";
+    readonly requestId: string;
+    readonly from: SessionInfo;
+    readonly query: LastMessageQuery | ReceiptQuery;
+} | {
+    readonly type: "last_response";
+    readonly requestId: string;
+    readonly result: LastMessageResult | ReceiptResult;
+} | {
+    readonly type: "session_left";
+    readonly sessionId: string;
+} | {
+    readonly type: "delivered";
+    readonly messageId: string;
+} | {
+    readonly type: "delivery_queued";
+    readonly messageId: string;
+    readonly reason: string;
+} | {
+    readonly type: "delivery_failed";
+    readonly messageId: string;
+    readonly reason: string;
+};
+export {};