@abot-ai/runtime 1.4.0 → 1.6.0

package/dist/src/runtime/local-host/app-owner.js

@@ -3,6 +3,10 @@ import { LocalMemoryDispatcher } from "./app-memory-dispatch.js";
 import { LocalRequestControls, } from "./app-request-control.js";
 import { dispatchLocalServiceCall } from "./app-service-dispatch.js";
 import { LocalRuntimeOwnerActivity } from "./owner-activity.js";
+import { dispatchLocalLearningCall } from "./app-learning-dispatch.js";
+import { projectLearningChangedEvent } from "./learning-events.js";
+import { SavedRequestApprovals } from "./saved-approvals.js";
+import { isLocalNativePermissionMethod, LocalNativePermissions } from "./app-native-permissions.js";
 export async function createLocalRuntimeOwner(config, overrides = {}) {
     const listeners = new Set();
     const publish = (event) => {
@@ -17,23 +21,31 @@ export async function createLocalRuntimeOwner(config, overrides = {}) {
     };
     const controls = new LocalRequestControls(publish);
     const activity = new LocalRuntimeOwnerActivity();
+    const nativePermissions = new LocalNativePermissions();
     const application = createRuntimeApplication(config, {
         ...overrides,
         scheduledRequestOptions: (run) => controls.scheduled(run),
     });
     const memory = new LocalMemoryDispatcher(application.services.longTermMemory);
+    const savedApprovals = new SavedRequestApprovals(application, controls, activity, publish);
     const unsubscribe = application.subscribeScheduledEvents((event) => {
         publish({ type: "scheduled.event", event });
         if (event.type === "completed" || event.type === "failed")
             controls.finish(String(event.requestId));
     });
+    const unsubscribeLearning = application.services.passiveLearning?.subscribe((change) => {
+        const event = projectLearningChangedEvent(change);
+        publish({ type: "learning.changed", ...(event ? { event } : {}) });
+    });
     try {
+        await savedApprovals.recover();
         await application.start();
     }
     catch (error) {
         activity.stop();
         application.services.requestAdmission?.close();
         unsubscribe();
+        unsubscribeLearning?.();
         await application.stop();
         throw error;
     }
@@ -41,14 +53,51 @@ export async function createLocalRuntimeOwner(config, overrides = {}) {
     return {
         call(method, args, peer) {
             return activity.run(async () => {
+                if (isLocalNativePermissionMethod(method))
+                    return nativePermissions.call(method, args, peer);
                 if (method === "controls.register")
                     return controls.register(peer);
-                if (method === "request.steer")
+                if (method === "request.active")
+                    return controls.hasActiveRequest(args[0], args[1]);
+                if (method === "request.approvals")
+                    return [
+                        ...(await savedApprovals.list(args[0])),
+                        ...controls.listApprovals(args[0]),
+                    ];
+                if (method === "request.approval.decide")
+                    return ((await savedApprovals.decide(args[0], peer)) ??
+                        controls.decideApproval(args[0], peer));
+                if (method === "request.attach") {
+                    if (await savedApprovals.attach(args[0], args[1], peer))
+                        return;
+                    return controls.attach(args[0], args[1], peer);
+                }
+                if (method === "request.steer") {
+                    const sessionId = controls.activeSessionId(args[0]);
+                    if (sessionId)
+                        await application.services.sessions.assertInteractiveSession?.(sessionId);
                     return controls.steer(args[0], args[1]);
+                }
+                if (method === "request.cancel") {
+                    if (await savedApprovals.cancel(args[0], args[1], args[2]))
+                        return { accepted: true };
+                    return controls.cancel(args[0], args[1], args[2]);
+                }
                 if (method === "request.run")
-                    return runPeerRequest(application, controls, activity, args, peer);
-                if (method.startsWith("memory."))
-                    return memory.call(method, args, peer);
+                    return savedApprovals.track(String(args[0]?.requestId), () => runPeerRequest(application, controls, activity, savedApprovals, args, peer));
+                if (method.startsWith("memory.")) {
+                    const result = await memory.call(method, args, peer);
+                    if ([
+                        "memory.create",
+                        "memory.update",
+                        "memory.delete",
+                        "memory.clear",
+                    ].includes(method))
+                        publish({ type: "learning.changed" });
+                    return result;
+                }
+                if (method.startsWith("learning."))
+                    return dispatchLocalLearningCall(application.services.passiveLearning, method, args);
                 return dispatchLocalServiceCall(application.services, method, args);
             });
         },
@@ -60,10 +109,12 @@ export async function createLocalRuntimeOwner(config, overrides = {}) {
             if (shutdown)
                 return shutdown;
             activity.stop();
+            nativePermissions.stop();
             application.services.requestAdmission?.close();
             memory.stop();
             controls.stop();
             unsubscribe();
+            unsubscribeLearning?.();
             listeners.clear();
             shutdown = application.stop();
             return shutdown;
@@ -81,39 +132,29 @@ export async function createLocalRuntimeOwner(config, overrides = {}) {
         },
     };
 }
-async function runPeerRequest(application, controls, activity, args, peer) {
+async function runPeerRequest(application, controls, activity, savedApprovals, args, peer) {
     const message = args[0];
     if (!message || typeof message.requestId !== "string")
         throw new Error("local_runtime_request_invalid");
-    const options = controls.ordinary(message.requestId, peer, (args[1] ?? {}));
-    let connected = true;
-    const removeClose = peer.onClose(() => {
-        connected = false;
-    });
-    let delivery = Promise.resolve();
+    if (typeof message.sessionId === "string")
+        await application.services.sessions.assertInteractiveSession?.(message.sessionId);
+    const options = controls.ordinary(message.requestId, peer, (args[1] ?? {}), typeof message.sessionId === "string" ? message.sessionId : "");
+    const durable = args[1]?.durableApprovals === true;
+    if (durable)
+        options.approvalExecution = { activation: savedApprovals.activation() };
     const socket = {
         send(data) {
-            if (!connected)
-                return;
-            const event = JSON.parse(data);
-            delivery = delivery
-                .then(async () => {
-                if (connected)
-                    await peer.callClient("request.event", [message.requestId, event]);
-            })
-                .catch(() => {
-                connected = false;
-            });
+            controls.send(message.requestId, JSON.parse(data));
         },
     };
     try {
         await peer.callClient("request.accepted", [message.requestId]);
         activity.assertAcceptingRequests();
-        await application.requests.handle(socket, message, options);
-        await delivery;
+        const result = await application.requests.handle(socket, message, options);
+        await controls.drain(message.requestId);
+        return result;
     }
     finally {
-        removeClose();
         controls.finish(message.requestId);
     }
 }

package/dist/src/runtime/local-host/app-request-approvals.d.ts

@@ -0,0 +1,18 @@
+import type { ToolApprovalDecision, ToolApprovalRequest } from "../ports.js";
+import type { LocalRuntimePeer } from "./contracts.js";
+import type { LocalPendingToolApproval, LocalToolApprovalDecisionInput, LocalToolApprovalDecisionResult } from "./request-approval-contracts.js";
+export declare function hasApprovalDecisionIdentity(input: unknown): input is LocalToolApprovalDecisionInput;
+/** Approval promises belong to the live request, never to a transport attempt. */
+export declare class LocalRequestApprovals {
+    private readonly pending;
+    list(sessionId?: unknown): LocalPendingToolApproval[];
+    hasPending(requestId: string): boolean;
+    decide(input: unknown): LocalToolApprovalDecisionResult;
+    wait(sessionId: string, peer: LocalRuntimePeer | undefined, request: ToolApprovalRequest, signal: AbortSignal): Promise<ToolApprovalDecision>;
+    detach(requestId: string): void;
+    attach(requestId: string, peer: LocalRuntimePeer): void;
+    cancel(requestId: string): void;
+    private offer;
+    private isCurrentOffer;
+    private detachOffer;
+}

package/dist/src/runtime/local-host/app-request-approvals.js

@@ -0,0 +1,150 @@
+export function hasApprovalDecisionIdentity(input) {
+    if (!input || typeof input !== "object")
+        return false;
+    const value = input;
+    if (typeof value.sessionId !== "string")
+        return false;
+    if (typeof value.requestId !== "string")
+        return false;
+    if (typeof value.approvalId !== "string")
+        return false;
+    if (typeof value.approved !== "boolean")
+        return false;
+    return value.reason === undefined || typeof value.reason === "string";
+}
+function readCallbackDecision(value) {
+    if (typeof value !== "object" || value === null)
+        return { approved: false, reason: "Tool approval response was invalid." };
+    const decision = value;
+    return {
+        approved: decision.approved === true,
+        ...(typeof decision.reason === "string" ? { reason: decision.reason } : {}),
+    };
+}
+/** Approval promises belong to the live request, never to a transport attempt. */
+export class LocalRequestApprovals {
+    pending = new Map();
+    list(sessionId) {
+        const entries = [...this.pending.values()].flatMap((group) => [
+            ...group.values(),
+        ]);
+        return entries
+            .filter((entry) => sessionId === undefined || entry.sessionId === sessionId)
+            .map((entry) => ({
+            sessionId: entry.sessionId,
+            request: structuredClone(entry.request),
+        }));
+    }
+    hasPending(requestId) {
+        return Boolean(this.pending.get(requestId)?.size);
+    }
+    decide(input) {
+        if (!hasApprovalDecisionIdentity(input))
+            return { accepted: false, reason: "invalid_approval_decision" };
+        const entry = this.pending.get(input.requestId)?.get(input.approvalId);
+        if (!entry)
+            return { accepted: false, reason: "approval_not_pending" };
+        if (entry.sessionId !== input.sessionId)
+            return { accepted: false, reason: "approval_identity_mismatch" };
+        entry.complete({
+            approved: input.approved,
+            ...(input.reason !== undefined ? { reason: input.reason } : {}),
+        });
+        return { accepted: true };
+    }
+    wait(sessionId, peer, request, signal) {
+        if (signal.aborted)
+            return Promise.reject(signal.reason);
+        const snapshot = structuredClone(request);
+        const { requestId, approvalId } = snapshot;
+        const group = this.pending.get(requestId) ?? new Map();
+        if (group.has(approvalId))
+            throw new Error("local_runtime_approval_already_pending");
+        return new Promise((resolve, reject) => {
+            const release = (entry, notify = true) => {
+                if (group.get(approvalId) !== entry)
+                    return false;
+                group.delete(approvalId);
+                if (!group.size)
+                    this.pending.delete(requestId);
+                signal.removeEventListener("abort", cancel);
+                this.detachOffer(entry, notify);
+                return true;
+            };
+            const entry = {
+                sessionId,
+                request: snapshot,
+                complete: (decision, notify = true) => {
+                    if (release(entry, notify))
+                        resolve(decision);
+                },
+                abort: (reason) => {
+                    if (release(entry))
+                        reject(reason);
+                },
+            };
+            const cancel = () => entry.abort(signal.reason);
+            group.set(approvalId, entry);
+            this.pending.set(requestId, group);
+            signal.addEventListener("abort", cancel, { once: true });
+            if (peer)
+                this.offer(entry, peer);
+        });
+    }
+    detach(requestId) {
+        for (const entry of this.pending.get(requestId)?.values() ?? [])
+            this.detachOffer(entry);
+    }
+    attach(requestId, peer) {
+        for (const entry of this.pending.get(requestId)?.values() ?? [])
+            this.offer(entry, peer);
+    }
+    cancel(requestId) {
+        for (const entry of this.pending.get(requestId)?.values() ?? [])
+            entry.abort(new Error("request_activation_retired"));
+    }
+    offer(entry, peer) {
+        this.detachOffer(entry);
+        const offer = {
+            peer,
+            connected: true,
+            removeClose: () => { },
+        };
+        entry.offer = offer;
+        offer.removeClose = peer.onClose(() => {
+            offer.connected = false;
+        });
+        if (!offer.connected)
+            return;
+        void peer
+            .callClient("request.approval", [structuredClone(entry.request)])
+            .then((decision) => {
+            if (!this.isCurrentOffer(entry, offer))
+                return;
+            entry.complete(readCallbackDecision(decision), false);
+        }, () => {
+            // Delivery failure leaves the same canonical approval unresolved.
+            offer.connected = false;
+        });
+    }
+    isCurrentOffer(entry, offer) {
+        if (entry.offer !== offer)
+            return false;
+        return offer.connected;
+    }
+    detachOffer(entry, notify = true) {
+        const offer = entry.offer;
+        entry.offer = undefined;
+        if (!offer)
+            return;
+        offer.removeClose();
+        if (!offer.connected)
+            return;
+        offer.connected = false;
+        if (!notify)
+            return;
+        void offer.peer
+            .callClient("request.approval.cancel", [entry.request.approvalId])
+            .catch(() => undefined);
+    }
+}

package/dist/src/runtime/local-host/app-request-control.d.ts

@@ -1,9 +1,13 @@
 import type { RuntimeRequestOptions } from "../composition.js";
+import type { SessionWaitExpectation } from "../../sessions/request-lifecycle/contracts.js";
+import { type RequestCancellationResult } from "../request/cancellation.js";
 import { type RequestSteeringUpdate } from "../request/request-steering.js";
 import type { SchedulerRun } from "../scheduler/contracts.js";
 import type { LocalRuntimePeer } from "./contracts.js";
+import type { LocalPendingToolApproval, LocalToolApprovalDecisionResult } from "./request-approval-contracts.js";
 export type LocalRequestRunOptions = {
     approvalAvailable?: boolean;
+    durableApprovals?: boolean;
     steeringUpdates?: readonly RequestSteeringUpdate[];
 };
 export declare class LocalRequestControls {
@@ -11,14 +15,27 @@ export declare class LocalRequestControls {
     private readonly active;
     private readonly controlPeers;
     private readonly pendingApprovals;
+    private stopped;
     constructor(publish: (event: unknown) => void);
     register(peer: LocalRuntimePeer): Promise<void>;
-    ordinary(requestId: string, peer: LocalRuntimePeer, options: LocalRequestRunOptions): RuntimeRequestOptions;
+    ordinary(requestId: string, peer: LocalRuntimePeer, options: LocalRequestRunOptions, sessionId?: string, resumedWait?: SessionWaitExpectation): RuntimeRequestOptions;
     scheduled(run: SchedulerRun): RuntimeRequestOptions;
     steer(requestId: unknown, update: unknown): unknown;
+    activeSessionId(requestId: unknown): string | undefined;
     finish(requestId: string): void;
+    cancel(requestId: unknown, sessionId: unknown, wait?: unknown): RequestCancellationResult;
+    private matchesResumedWaitCancellation;
+    private claimFinalization;
     stop(): void;
     private open;
+    hasActiveRequest(requestId: unknown, sessionId: unknown): boolean;
+    listApprovals(sessionId?: unknown): LocalPendingToolApproval[];
+    decideApproval(input: unknown, peer: LocalRuntimePeer): LocalToolApprovalDecisionResult;
+    private requiresApprovalRequestAttachment;
+    attach(requestId: unknown, sessionId: unknown, peer: LocalRuntimePeer): Promise<void>;
+    send(requestId: string, event: unknown): void;
+    drain(requestId: string): Promise<void>;
+    private isAttachedApprovalPeer;
+    private getAttachableRequest;
     private approvals;
-    private requestApproval;
 }

package/dist/src/runtime/local-host/app-request-control.js

@@ -1,18 +1,14 @@
+import { createRequestInterruptionError } from "../request/interruption.js";
+import { createRequestCancellationError, } from "../request/cancellation.js";
 import { createRequestSteeringInbox, } from "../request/request-steering.js";
-function readApprovalDecision(value) {
-    if (typeof value !== "object" || value === null)
-        return { approved: false, reason: "Tool approval response was invalid." };
-    const decision = value;
-    return {
-        approved: decision.approved === true,
-        ...(typeof decision.reason === "string" ? { reason: decision.reason } : {}),
-    };
-}
+import { hasApprovalDecisionIdentity, LocalRequestApprovals, } from "./app-request-approvals.js";
+import { LocalRequestDelivery } from "./app-request-delivery.js";
 export class LocalRequestControls {
     publish;
     active = new Map();
     controlPeers = new Map();
-    pendingApprovals = new Set();
+    pendingApprovals = new LocalRequestApprovals();
+    stopped = false;
     constructor(publish) {
         this.publish = publish;
     }
@@ -25,8 +21,8 @@ export class LocalRequestControls {
         // Queue snapshots on the same ordered channel as subsequent run events.
         await Promise.all(runs.map((run) => peer.callClient("scheduled.started", [run])));
     }
-    ordinary(requestId, peer, options) {
-        const steering = this.open(requestId);
+    ordinary(requestId, peer, options, sessionId = "", resumedWait) {
+        const steering = this.open(requestId, sessionId);
         try {
             for (const update of options.steeringUpdates ?? []) {
                 const accepted = steering.append(update);
@@ -38,27 +34,38 @@ export class LocalRequestControls {
             this.finish(requestId);
             throw error;
         }
+        const control = this.active.get(requestId);
+        control.resumedWait = resumedWait;
+        control.peer = peer;
+        control.delivery.attach(peer);
         return {
+            abortSignal: control.abort.signal,
+            claimFinalization: () => this.claimFinalization(control),
             requestSteering: steering,
             ...(options.approvalAvailable
-                ? { toolApprovalController: this.approvals(peer) }
+                ? { toolApprovalController: this.approvals(requestId, control) }
                 : {}),
         };
     }
     scheduled(run) {
-        const steering = this.open(run.requestId, run);
+        const steering = this.open(run.requestId, run.sessionId, run);
+        const control = this.active.get(run.requestId);
         this.publish({ type: "scheduled.started", run });
         const peer = this.controlPeers.values().next().value;
         return {
+            abortSignal: control.abort.signal,
+            claimFinalization: () => this.claimFinalization(control),
             requestSteering: steering,
-            ...(peer ? { toolApprovalController: this.approvals(peer) } : {}),
+            ...(peer
+                ? { toolApprovalController: this.approvals(run.requestId, control) }
+                : {}),
         };
     }
     steer(requestId, update) {
         if (typeof requestId !== "string")
             return { ok: false, reason: "request_not_active" };
         const control = this.active.get(requestId);
-        if (!control)
+        if (!control || control.abort.signal.aborted)
             return { ok: false, reason: "request_not_active" };
         if (!update || typeof update !== "object")
             return { ok: false, reason: "invalid_steer_request" };
@@ -70,66 +77,155 @@ export class LocalRequestControls {
             text: input.text,
         });
     }
+    activeSessionId(requestId) {
+        return typeof requestId === "string"
+            ? this.active.get(requestId)?.sessionId
+            : undefined;
+    }
     finish(requestId) {
         const entry = this.active.get(requestId);
         this.active.delete(requestId);
+        this.pendingApprovals.cancel(requestId);
+        entry?.delivery.finish();
         void entry?.steering.close();
     }
+    cancel(requestId, sessionId, wait) {
+        const control = typeof requestId === "string" ? this.active.get(requestId) : undefined;
+        if (!control)
+            return { accepted: false, reason: "request_not_active" };
+        if (typeof sessionId !== "string" ||
+            !sessionId ||
+            sessionId !== control.sessionId)
+            return { accepted: false, reason: "session_mismatch" };
+        if (control.finalizing)
+            return { accepted: false, reason: "request_not_active" };
+        if (!this.matchesResumedWaitCancellation(control, wait))
+            return { accepted: false, reason: "request_not_active" };
+        control.abort.abort(createRequestCancellationError());
+        return { accepted: true };
+    }
+    matchesResumedWaitCancellation(control, input) {
+        if (input === undefined)
+            return true;
+        if (!input || typeof input !== "object")
+            return false;
+        const wait = control.resumedWait;
+        if (!wait)
+            return false;
+        const command = input;
+        if (typeof command.commandId !== "string" || !command.commandId)
+            return false;
+        if (command.generation !== wait.generation)
+            return false;
+        if (command.waitId !== wait.waitId)
+            return false;
+        return command.revision === wait.revision;
+    }
+    claimFinalization(control) {
+        // In-flight requests retain this exact control until canonical finalization.
+        control.abort.signal.throwIfAborted();
+        control.finalizing = true;
+    }
     stop() {
+        this.stopped = true;
         this.controlPeers.clear();
-        for (const cancel of this.pendingApprovals)
-            cancel();
-        // Active canonical requests own their inbox lifetime until finalization.
-        this.active.clear();
+        for (const [requestId, control] of this.active) {
+            control.abort.abort(createRequestInterruptionError());
+        }
+        // Accepted requests retain their controls and inboxes until finalization.
     }
-    open(requestId, run) {
+    open(requestId, sessionId, run) {
+        if (this.stopped)
+            throw new Error("local_runtime_owner_stopped");
         if (!requestId || this.active.has(requestId))
             throw new Error("local_runtime_request_already_active");
         const steering = createRequestSteeringInbox({ requestId });
-        this.active.set(requestId, { steering, ...(run ? { run } : {}) });
+        this.active.set(requestId, {
+            steering,
+            sessionId,
+            abort: new AbortController(),
+            finalizing: false,
+            delivery: new LocalRequestDelivery(requestId),
+            ...(run ? { run } : {}),
+        });
         return steering;
     }
-    approvals(peer) {
-        return {
-            requestToolApproval: (request, options) => this.requestApproval(peer, request, options?.abortSignal),
-        };
+    hasActiveRequest(requestId, sessionId) {
+        if (typeof requestId !== "string")
+            return false;
+        const control = this.active.get(requestId);
+        if (!control)
+            return false;
+        return control.sessionId === sessionId;
     }
-    requestApproval(peer, request, signal) {
-        if (signal?.aborted)
-            return Promise.resolve({
-                approved: false,
-                reason: "Tool approval was cancelled.",
-            });
-        return new Promise((resolve) => {
-            let settled = false;
-            let removeClose = () => { };
-            const complete = (decision) => {
-                if (settled)
-                    return;
-                settled = true;
-                signal?.removeEventListener("abort", cancel);
-                this.pendingApprovals.delete(cancel);
-                removeClose();
-                resolve(decision);
-            };
-            const cancel = () => {
-                void peer
-                    .callClient("request.approval.cancel", [request.approvalId])
-                    .catch(() => undefined);
-                complete({ approved: false, reason: "Tool approval was cancelled." });
-            };
-            this.pendingApprovals.add(cancel);
-            removeClose = peer.onClose(() => complete({
-                approved: false,
-                reason: "Tool approval connection was closed.",
-            }));
-            if (settled)
-                return;
-            signal?.addEventListener("abort", cancel, { once: true });
-            void peer.callClient("request.approval", [request]).then((decision) => complete(readApprovalDecision(decision)), () => complete({
-                approved: false,
-                reason: "Tool approval connection was closed.",
-            }));
+    listApprovals(sessionId) {
+        return this.pendingApprovals.list(sessionId).map((entry) => {
+            const run = this.active.get(entry.request.requestId)?.run;
+            return { ...entry, ...(run ? { run: structuredClone(run) } : {}) };
         });
     }
+    decideApproval(input, peer) {
+        if (!hasApprovalDecisionIdentity(input))
+            return this.pendingApprovals.decide(input);
+        const control = this.active.get(input.requestId);
+        if (this.requiresApprovalRequestAttachment(control, peer))
+            return { accepted: false, reason: "approval_request_not_attached" };
+        return this.pendingApprovals.decide(input);
+    }
+    requiresApprovalRequestAttachment(control, peer) {
+        if (!control)
+            return false;
+        if (control.run)
+            return false;
+        return control.peer !== peer;
+    }
+    async attach(requestId, sessionId, peer) {
+        const control = this.getAttachableRequest(requestId, sessionId);
+        this.pendingApprovals.detach(String(requestId));
+        control.peer = peer;
+        control.delivery.attach(peer);
+        // The readiness acknowledgement permits a decision immediately; bind first.
+        await peer.callClient("request.accepted", [requestId]);
+        if (this.isAttachedApprovalPeer(control, peer))
+            this.pendingApprovals.attach(String(requestId), peer);
+        await control.delivery.finished;
+    }
+    send(requestId, event) {
+        this.active.get(requestId)?.delivery.send(event);
+    }
+    async drain(requestId) {
+        await this.active.get(requestId)?.delivery.drain();
+    }
+    isAttachedApprovalPeer(control, peer) {
+        return control.peer === peer;
+    }
+    getAttachableRequest(requestId, sessionId) {
+        if (typeof requestId !== "string")
+            throw new Error("local_runtime_request_not_awaiting_approval");
+        const control = this.active.get(requestId);
+        if (!control)
+            throw new Error("local_runtime_request_not_awaiting_approval");
+        if (control.sessionId !== sessionId)
+            throw new Error("local_runtime_session_mismatch");
+        if (control.run)
+            throw new Error("local_runtime_request_is_scheduled");
+        if (!this.pendingApprovals.hasPending(requestId))
+            throw new Error("local_runtime_request_not_awaiting_approval");
+        return control;
+    }
+    approvals(requestId, control) {
+        return {
+            requestToolApproval: (request, options) => {
+                if (request.requestId !== requestId)
+                    throw new Error("local_runtime_approval_identity_mismatch");
+                if (this.stopped)
+                    control.abort.abort(createRequestInterruptionError());
+                const signal = options?.abortSignal
+                    ? AbortSignal.any([control.abort.signal, options.abortSignal])
+                    : control.abort.signal;
+                const peer = control.peer ?? this.controlPeers.values().next().value;
+                return this.pendingApprovals.wait(control.sessionId, peer, request, signal);
+            },
+        };
+    }
 }

package/dist/src/runtime/local-host/app-request-delivery.d.ts

@@ -0,0 +1,16 @@
+import type { LocalRuntimePeer } from "./contracts.js";
+/** Replaces a live request subscriber without replaying execution or past events. */
+export declare class LocalRequestDelivery {
+    private readonly requestId;
+    private target?;
+    private delivery;
+    private settle;
+    readonly finished: Promise<void>;
+    constructor(requestId: string);
+    attach(peer: LocalRuntimePeer): void;
+    send(event: unknown): void;
+    drain(): Promise<void>;
+    finish(): void;
+    private isCurrentTarget;
+    private detach;
+}