@fitchmultz/pi-subagents 0.47.0 → 0.48.0

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

@@ -1,6 +1,9 @@
 import { isUnknownArray } from "../shared/unknown.js";
 import { ASK_TIMEOUT, 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": [],
@@ -10,8 +13,18 @@ const fields = {
     "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"],
+    "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"],
 };
 function isRoute(route) {
     return Object.hasOwn(fields, route);
@@ -25,8 +38,9 @@ export function routeFor(req) {
     if (!isRoute(route)) {
         throw new Fault(404, "not_found", "Unknown method or path.");
     }
-    if (req.url?.includes("?") === true && route !== "GET /v1/inbox") {
-        throw new Fault(400, "invalid_input", "Only inbox accepts query parameters.");
+    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.");
     }
     checkGetBody(req);
     return route;
@@ -38,13 +52,15 @@ function checkGetBody(req) {
         throw new Fault(400, "invalid_input", "GET requests must not have a body.");
     }
 }
-function inboxQuery(req) {
-    const url = req.url ?? "";
-    const separator = url.indexOf("?");
-    const query = new URLSearchParams(separator === -1 ? "" : url.slice(separator + 1));
-    if ([...query.keys()].some((key) => !["after", "limit"].includes(key) || query.getAll(key).length !== 1)) {
-        throw new Fault(400, "invalid_input", "Unknown or repeated inbox query parameter.");
+function queryFor(req, allowed) {
+    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)) {
+        throw new Fault(400, "invalid_input", "Unknown or repeated query parameter.");
     }
+    return query;
+}
+function inboxQuery(req) {
+    const query = queryFor(req, ["after", "limit"]);
     const after = query.get("after") ?? "0";
     const limit = query.get("limit") ?? String(INBOX_COUNT);
     if (!/^(0|[1-9]\d{0,15})$/.test(after) ||
@@ -55,32 +71,117 @@ function inboxQuery(req) {
     }
     return { route: "GET /v1/inbox", after: Number(after), limit: Number(limit) };
 }
-function timeout(value) {
-    const ms = value === undefined ? ASK_TIMEOUT : value;
-    if (typeof ms !== "number" || !Number.isInteger(ms) || ms < 100 || ms > ASK_TIMEOUT) {
-        throw new Fault(400, "invalid_input", "timeoutMs must be an integer from 100 to 120000.");
+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;
 }
-export async function operationFor(req, route, signal) {
-    const input = req.method === "POST" ? object(await body(req, signal), fields[route]) : {};
+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) {
     switch (route) {
         case "GET /v1/list":
         case "POST /v1/register":
-        case "GET /v1/sessions":
+        case "GET /v1/groups":
             return { route };
         case "GET /v1/inbox":
             return inboxQuery(req);
-        case "POST /v1/start":
-            return { route, name: label(input.name, "session name", 64).trim() };
-        case "POST /v1/stop":
-            return { route, sessionId: label(input.sessionId, "session ID", 128) };
-        case "POST /v1/ack": {
+        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.");
             }
             return { route, ids: [...new Set(input.ids.map((id) => label(id, "message ID")))] };
-        }
         case "POST /v1/send":
             return { route, message: text(input.message), to: label(input.to, "to").trim() };
         case "POST /v1/ask":
@@ -92,5 +193,53 @@ export async function operationFor(req, route, signal) {
             };
         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);
+    }
+}
+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-rpc-process.js

@@ -2,14 +2,14 @@ import { spawn } from "node:child_process";
 import { StringDecoder } from "node:string_decoder";
 import { trySignalChildTree } from "../shared/post-exit-stdio-guard.js";
 import { isRecord } from "../shared/unknown.js";
-import { Fault, log, wait } from "./bridge-protocol.js";
+import { Fault, cancelled, log, wait } from "./bridge-protocol.js";
 const FRAME_LIMIT = 4 * 1024 * 1024;
 function launchEnvironment(packageRoot) {
     const environment = Object.fromEntries(Object.entries(process.env).filter(([key]) => !key.startsWith("PI_SUBAGENT_")));
     return { ...environment, PI_PACKAGE_DIR: packageRoot };
 }
 // Native RpcClient lacks public EOF/exit/UI control and retains/reprints unbounded stderr.
-// This owner implements only get_state and dialog cancellation, never a remote RPC proxy.
+// This owner implements state, owned-run cancellation and dialog dismissal, never a raw RPC proxy.
 export class RpcProcess {
     child;
     exited;
@@ -23,8 +23,9 @@ export class RpcProcess {
     stopping;
     stderrBytes = 0;
     exitObserved = false;
-    constructor(policy, cwd, sessionFile) {
-        this.child = spawn(process.execPath, this.arguments(policy, sessionFile), {
+    cancelling = false;
+    constructor(policy, cwd, sessionFile, resuming = false) {
+        this.child = spawn(process.execPath, this.arguments(policy, sessionFile, resuming), {
             cwd,
             detached: true,
             env: launchEnvironment(policy.packageRoot),
@@ -65,19 +66,19 @@ export class RpcProcess {
     get pid() {
         return this.child.pid;
     }
-    arguments(policy, sessionFile) {
+    arguments(policy, sessionFile, resuming) {
         const args = [
             policy.cli,
             "--mode",
             "rpc",
             "--session",
             sessionFile,
-            "--provider",
-            policy.provider,
-            "--model",
-            policy.model,
             policy.trustProject ? "--approve" : "--no-approve",
         ];
+        // Resume leaves native model/thinking restoration authoritative; never force the launch default.
+        if (!resuming && policy.provider !== undefined && policy.model !== undefined) {
+            args.push("--provider", policy.provider, "--model", policy.model);
+        }
         if (!policy.discoverResources) {
             args.push("--no-extensions", "--no-skills", "--no-prompt-templates", "--no-themes", "--no-context-files");
         }
@@ -175,8 +176,10 @@ export class RpcProcess {
     response(data) {
         const pending = this.pending;
         this.pending = undefined;
-        if (data.success === true && data.command === "get_state" && isRecord(data.data)) {
-            pending?.resolve(data.data);
+        if (data.success === true &&
+            data.command === pending?.command &&
+            (pending?.command !== "get_state" || isRecord(data.data))) {
+            pending?.resolve(isRecord(data.data) ? data.data : {});
         }
         else {
             pending?.reject(new Fault(503, "rpc_failed", "Pi RPC state request failed."));
@@ -200,14 +203,18 @@ export class RpcProcess {
             this.cleanup();
         }
     }
-    async state(signal) {
+    async command(command, signal) {
+        cancelled(signal);
         if (this.failure) {
             throw this.failure;
         }
-        const id = `state-${++this.sequence}`;
+        if (this.pending) {
+            throw new Fault(409, "control_in_progress", "A native control operation is already in flight.");
+        }
+        const id = `control-${++this.sequence}`;
         const result = new Promise((resolve, reject) => {
-            this.pending = { id, resolve, reject };
-            this.write({ type: "get_state", id });
+            this.pending = { id, command, resolve, reject };
+            this.write({ type: command, id });
         });
         try {
             return await wait(result, signal);
@@ -216,6 +223,27 @@ export class RpcProcess {
             this.pending = undefined;
         }
     }
+    async state(signal) {
+        return this.command("get_state", signal);
+    }
+    async cancel(signal) {
+        if (this.cancelling) {
+            throw new Fault(409, "control_in_progress", "Native cancellation is already in flight.");
+        }
+        this.cancelling = true;
+        try {
+            await this.command("abort", signal);
+            const state = await this.state(signal);
+            if (state.isStreaming !== false) {
+                throw new Fault(409, "cancel_unconfirmed", "Native Pi has not reached idle after abort.");
+            }
+            this.status = "idle";
+            return { isStreaming: false, pendingMessageCount: state.pendingMessageCount };
+        }
+        finally {
+            this.cancelling = false;
+        }
+    }
     ready() {
         if (this.failure || this.exitObserved) {
             throw this.failure ?? new Fault(503, "session_exited", "Pi exited during startup.");

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

@@ -1,8 +1,10 @@
 import { randomUUID } from "node:crypto";
 import { IntercomClient } from "./broker/client.js";
-import { formatSessionTarget, resolveSessionProjectId, resolveSessionTarget, } from "./session-targets.js";
+import { resolveSessionProjectId } from "./session-targets.js";
 import { Fault, cancelled, log, wait } from "./bridge-protocol.js";
 import { Mailbox } from "./bridge-mailbox.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;
@@ -21,6 +23,7 @@ export class Session {
     inbox;
     replying = new Set();
     pending;
+    controls = new ControlReplies();
     closed = false;
     connecting;
     disconnecting;
@@ -51,6 +54,9 @@ export class Session {
         if (this.closed) {
             throw this.closeReason;
         }
+        this.authorize();
+    }
+    authorize() {
         if (!this.owner.allowed(this.identity)) {
             throw new Fault(403, "revoked", "Identity is no longer authorized.");
         }
@@ -143,27 +149,26 @@ export class Session {
         this.owner.retired(this.identity.fingerprint256, this.generation);
         log("session_closed", { ...this.fields(), result: this.closeReason.code });
     }
-    close(error) {
+    close(fault) {
         if (this.closed) {
             return;
         }
         this.closed = true;
-        this.closeReason = error;
+        this.closeReason = fault;
         clearTimeout(this.lease);
-        this.pending?.reject(error);
+        this.pending?.reject(fault);
+        this.controls.close(fault);
         for (const controller of this.requests) {
-            controller.abort(error);
+            controller.abort(fault);
         }
         // Retain the generation until acquisition/registration AND final disconnect settle.
-        this.startRetirement();
-    }
-    startRetirement() {
         this.retirement = this.retire().catch((caught) => this.cleanupFailed(caught));
     }
     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 }));
         }
@@ -182,6 +187,9 @@ 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;
         }
@@ -254,20 +262,16 @@ 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) {
-        const resolution = resolveSessionTarget(await this.peers(signal), to);
-        if (resolution.status === "none") {
-            throw new Fault(404, "peer_offline", "Peer is not connected.");
-        }
-        if (resolution.status !== "found" || !resolution.target) {
-            throw new Fault(409, "ambiguous_target", "Use an unambiguous peer name or session ID (prefixes need at least 8 characters).");
-        }
-        if (resolution.target.id === this.client.sessionId) {
-            throw new Fault(400, "self_target", "Choose another peer.");
-        }
-        return resolution.target;
+        return resolveBridgeTarget(await this.peers(signal), to, this.client.sessionId);
     }
     async send(peer, message, context, options = {}) {
+        await this.connect(context.signal);
         const { signal, requestId } = context;
         context.onPeer(peer);
         this.guard(signal);
@@ -400,9 +404,7 @@ export class Session {
                 const sessions = await this.peers(context.signal);
                 return {
                     sessionId: this.client.sessionId,
-                    sessions: sessions.map(({ topics: _topics, subscriptions: _subscriptions, ...entry }) => {
-                        return Object.assign(entry, { target: formatSessionTarget(entry, sessions) });
-                    }),
+                    sessions: bridgeSessionList(sessions),
                 };
             }
             case "POST /v1/send":

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

@@ -0,0 +1,22 @@
+import { resolveSessionTarget, formatSessionTarget, nativePeerId } from "./session-targets.js";
+import { Fault } from "./bridge-protocol.js";
+export function bridgeSessionList(peers) {
+    return peers.map(({ topics: _topics, subscriptions: _subscriptions, ...entry }) => ({
+        ...entry,
+        target: formatSessionTarget(entry, peers),
+    }));
+}
+export function resolveBridgeTarget(peers, to, self) {
+    const exactNative = peers.find((peer) => peer.id === nativePeerId(to));
+    const resolution = resolveSessionTarget(peers, exactNative?.id ?? to);
+    if (resolution.status === "none") {
+        throw new Fault(404, "peer_offline", "Peer is not connected.");
+    }
+    if (resolution.status !== "found" || !resolution.target) {
+        throw new Fault(409, "ambiguous_target", "Use an unambiguous peer name or session ID (prefixes need at least 8 characters).");
+    }
+    if (resolution.target.id === self) {
+        throw new Fault(400, "self_target", "Choose another peer.");
+    }
+    return resolution.target;
+}

package/dist/pi-intercom/bridge.js

@@ -7,12 +7,21 @@ import { loadConfig, sameListener } from "./bridge-config.js";
 import { ASK_TIMEOUT, Fault, fingerprint, log } from "./bridge-protocol.js";
 import { Session } from "./bridge-session.js";
 import { operationFor, routeFor } from "./bridge-routes.js";
-import { reply } from "./bridge-http.js";
-import { Launcher, sameIdentity } from "./bridge-launch.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) &&
@@ -24,7 +33,7 @@ class Bridge {
     configPath;
     sessions = new Map();
     losses = new Map();
-    launcher = new Launcher();
+    operations;
     sockets = new Set();
     connections = new Map();
     server;
@@ -35,6 +44,7 @@ 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({
@@ -221,13 +231,13 @@ class Bridge {
             }
             this.config = next;
             this.revokeRemoved();
-            this.launcher.revoke(next.clients).catch(() => log("launch_cleanup", { result: "failed" }));
+            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.launcher
+            this.operations
                 .revoke(this.config.clients)
                 .catch(() => log("launch_cleanup", { result: "failed" }));
             for (const session of this.sessions.values()) {
@@ -280,7 +290,7 @@ class Bridge {
         await Promise.all([
             ...this.handlers,
             ...sessions.map((session) => session.settled()),
-            this.launcher.shutdown(),
+            this.operations.shutdown(),
             this.presence?.stop(),
             this.deliveries.stop(),
         ]);
@@ -302,7 +312,11 @@ class Bridge {
             this.drop(connection.fingerprint, fault);
             throw fault;
         }
-        return { identity, expires: connection.expires };
+        return {
+            identity,
+            expires: connection.expires,
+            certificate: authenticatedCertificateChain(socket),
+        };
     }
     async handle(req, res) {
         const requestId = randomUUID();
@@ -322,7 +336,7 @@ class Bridge {
             deadline = setTimeout(() => session?.close(new Fault(504, "request_timeout", "HTTP operation deadline exceeded; delivery may be unknown.")), Math.max(1, ms - (Date.now() - started)));
         };
         try {
-            const { identity, expires } = this.admission(req);
+            const { identity, expires, certificate } = this.admission(req);
             const route = routeFor(req);
             session = this.session(identity, expires);
             controller = session.begin();
@@ -330,15 +344,19 @@ class Bridge {
             req.once("aborted", abort);
             res.once("close", onClose);
             const duration = route === "POST /v1/ask" ? ASK_TIMEOUT + 15000 : 15000;
-            setDeadline(route === "POST /v1/start" ? 75000 : duration);
+            setDeadline(LONG_ROUTES.has(route) ? 75000 : duration);
             const operation = await operationFor(req, route, signal);
             if (operation.route === "POST /v1/ask") {
                 setDeadline(operation.timeoutMs + 15000);
             }
-            const data = await this.execute(operation, session, {
+            else if (operation.route === "GET /v1/transcript") {
+                setDeadline(75000);
+            }
+            const data = await this.operations.execute(operation, session, {
                 signal,
                 requestId,
                 expires,
+                certificate,
                 onPeer: (id) => {
                     peer = id;
                 },
@@ -352,10 +370,7 @@ class Bridge {
                 ? error
                 : new Fault(503, "broker_unavailable", "Local broker operation failed.");
             log("request", { ...session?.fields(), requestId, peer, result: fault.code });
-            reply(res, requestId, fault.status, {
-                ok: false,
-                error: { code: fault.code, message: fault.message, ...fault.details },
-            });
+            replyFault(res, requestId, fault);
         }
         finally {
             clearTimeout(deadline);
@@ -366,29 +381,6 @@ class Bridge {
             }
         }
     }
-    async execute(operation, session, context) {
-        switch (operation.route) {
-            case "POST /v1/start":
-                return this.launcher.start(operation.name, {
-                    identity: session.identity,
-                    expires: context.expires,
-                    signal: context.signal,
-                    peers: (signal) => session.connectedPeers(signal),
-                });
-            case "GET /v1/sessions":
-                return this.launcher.list(session.identity);
-            case "POST /v1/stop":
-                return this.launcher.stop(session.identity, operation.sessionId);
-            case "GET /v1/list":
-            case "GET /v1/inbox":
-            case "POST /v1/register":
-            case "POST /v1/ask":
-            case "POST /v1/send":
-            case "POST /v1/reply":
-            case "POST /v1/ack":
-                return session.execute(operation, context);
-        }
-    }
 }
 function main() {
     const args = process.argv.slice(2);

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

@@ -320,6 +320,7 @@ export class IntercomClient extends EventEmitter {
             expectsReply: options.expectsReply,
             ...(options.human ? { human: options.human } : {}),
             ...(options.topic ? { topic: options.topic } : {}),
+            ...(options.control ? { control: options.control } : {}),
             delivery: messageDelivery(options),
             queueMode: options.queueMode,
             threadId: options.threadId,