@abot-ai/runtime 1.4.0 → 1.5.0

package/dist/src/runtime/local-host/client-requests.js

@@ -1,33 +1,58 @@
+import { PendingClientRequest, hasLiveApprovalAttachment, hasApprovalEndedBeforeAttachment, isApprovalTransportLoss, shouldRetainDetachedRequest, } from "./pending-client-request.js";
 /** Client projections only. The owner validates and commits every steering update. */
 export class LocalRuntimeClientRequests {
     call;
     scheduledOptions;
+    approvalCall;
     active = new Map();
-    approvals = new Map();
+    approvalCallbacks = new Map();
     listeners = new Set();
-    constructor(call, scheduledOptions) {
+    constructor(call, scheduledOptions, approvalCall = call) {
         this.call = call;
         this.scheduledOptions = scheduledOptions;
+        this.approvalCall = approvalCall;
     }
     requests = {
+        cancel: async (requestId, sessionId, wait) => {
+            const state = this.active.get(requestId);
+            await state?.accepted;
+            if (state && shouldRetainDetachedRequest(state))
+                await this.restoreCancellationDelivery(requestId, sessionId, state);
+            return (await this.call("request.cancel", [
+                requestId,
+                sessionId,
+                ...(wait ? [wait] : []),
+            ]));
+        },
         handle: async (ws, message, options = {}) => {
             const requestId = String(message.requestId ?? "");
             if (this.active.has(requestId))
                 throw new Error("local_runtime_request_already_active");
-            const state = this.open(requestId, options, (event) => ws.send(JSON.stringify(event)));
+            const state = this.open(requestId, String(message.sessionId ?? ""), options, (event) => ws.send(JSON.stringify(event)));
+            const cancel = () => {
+                void this.requests.cancel(requestId, String(message.sessionId ?? "")).catch(() => { });
+            };
+            options.abortSignal?.addEventListener("abort", cancel, { once: true });
+            if (options.abortSignal?.aborted)
+                cancel();
+            let outcome = undefined;
             try {
-                await this.call("request.run", [
+                outcome = (await this.trackOwnerRequest(state, () => this.call("request.run", [
                     message,
                     {
                         approvalAvailable: Boolean(options.toolApprovalController),
+                        durableApprovals: options.durableApprovals === true,
                         steeringUpdates: options.requestSteering?.snapshot().updates ?? [],
                     },
-                ]);
+                ])));
             }
             finally {
-                state.accept();
-                this.active.delete(requestId);
+                options.abortSignal?.removeEventListener("abort", cancel);
+                state.releaseAcceptance();
+                if (this.active.get(requestId) === state)
+                    this.active.delete(requestId);
             }
+            return outcome;
         },
         steer: async (requestId, input) => {
             await this.active.get(requestId)?.accepted;
@@ -37,6 +62,50 @@ export class LocalRuntimeClientRequests {
             ]));
         },
     };
+    approvals = {
+        list: async (sessionId) => {
+            const captures = [...this.active.values()].flatMap((state) => {
+                const revision = state.captureApprovalSnapshotRevision(sessionId);
+                if (revision === undefined)
+                    return [];
+                return [{ state, revision }];
+            });
+            const pending = (await this.approvalCall("request.approvals", [
+                sessionId,
+            ]));
+            for (const { state, revision } of captures) {
+                if (this.active.get(state.requestId) !== state)
+                    continue;
+                const ownerActive = state.needsOwnerActivityCheck(pending, revision)
+                    ? (await this.call("request.active", [
+                        state.requestId,
+                        state.sessionId,
+                    ]))
+                    : undefined;
+                if (this.active.get(state.requestId) !== state)
+                    continue;
+                if (!state.reconcileApprovalSnapshot(pending, revision, ownerActive))
+                    continue;
+                this.publishDisconnectedScheduledRequest(state);
+                this.active.delete(state.requestId);
+            }
+            return pending;
+        },
+        decide: async (input) => {
+            const state = this.active.get(input.requestId);
+            if (state && shouldRetainDetachedRequest(state))
+                await this.restoreApprovalDelivery(input.requestId, input.sessionId, state);
+            // Once delivery is bound, a new loss must fail this decision attempt.
+            const decide = state ? this.call : this.approvalCall;
+            return (await decide("request.approval.decide", [
+                input,
+            ]));
+        },
+        attach: async (requestId, sessionId, ws, options = {}, onAccepted) => {
+            const send = (event) => ws.send(JSON.stringify(event));
+            return this.attachRequest(requestId, sessionId, options, send, onAccepted);
+        },
+    };
     subscribe(listener) {
         this.listeners.add(listener);
         return () => {
@@ -49,18 +118,27 @@ export class LocalRuntimeClientRequests {
         const envelope = event;
         if (envelope.type === "scheduled.started") {
             const run = envelope.run;
-            if (this.active.has(run.requestId))
+            const existing = this.active.get(run.requestId);
+            if (existing) {
+                existing.detached = false;
                 return;
-            const state = this.open(run.requestId, this.scheduledOptions?.(run) ?? {});
+            }
+            const state = this.open(run.requestId, run.sessionId, this.scheduledOptions?.(run) ?? {});
             state.run = run;
             state.accept();
             return;
         }
+        if (envelope.type === "request.event") {
+            this.publish(envelope.event);
+            return;
+        }
         if (envelope.type !== "scheduled.event")
             return;
         const payload = envelope.event;
+        this.active.get(String(payload.requestId))?.observeApproval(payload);
         this.publish(payload);
         if (payload.type === "completed" || payload.type === "failed") {
+            this.active.get(String(payload.requestId))?.settle();
             this.active.delete(String(payload.requestId));
         }
     }
@@ -74,64 +152,143 @@ export class LocalRuntimeClientRequests {
             return null;
         }
         if (method === "request.event") {
-            this.active
-                .get(String(args[0]))
-                ?.send?.(args[1]);
+            const state = this.active.get(String(args[0]));
+            const event = args[1];
+            state?.observeApproval(event);
+            state?.send?.(event);
             return null;
         }
         if (method === "request.approval.cancel") {
-            this.approvals.get(String(args[0]))?.abort();
+            this.approvalCallbacks.get(String(args[0]))?.controller.abort();
             return null;
         }
         if (method !== "request.approval")
             throw new Error("local_runtime_callback_unknown");
         const request = args[0];
-        const approval = this.active.get(request.requestId)?.options
-            .toolApprovalController;
-        if (!approval)
-            return { approved: false, reason: "Tool approval is unavailable." };
+        const state = this.active.get(request.requestId);
+        const approval = state?.options.toolApprovalController;
+        if (!approval) {
+            if (state)
+                state.callbackUnavailable = true;
+            throw new Error("local_runtime_tool_approval_view_unavailable");
+        }
+        state.callbackUnavailable = false;
         const controller = new AbortController();
-        this.approvals.set(request.approvalId, controller);
+        const callback = {
+            controller,
+            requestId: request.requestId,
+            detached: false,
+        };
+        this.approvalCallbacks.set(request.approvalId, callback);
+        state?.observeApprovalCallback(request.approvalId);
         try {
             return await approval.requestToolApproval(request, {
                 abortSignal: controller.signal,
             });
         }
+        catch (error) {
+            state.callbackUnavailable = true;
+            throw error;
+        }
         finally {
-            this.approvals.delete(request.approvalId);
+            if (this.approvalCallbacks.get(request.approvalId) === callback)
+                this.approvalCallbacks.delete(request.approvalId);
         }
     }
     close(disconnected = false) {
         if (disconnected) {
-            for (const [requestId, state] of this.active) {
-                if (!state.run)
+            for (const state of this.active.values()) {
+                state.markDisconnected();
+                if (shouldRetainDetachedRequest(state))
                     continue;
-                this.publish({
-                    type: "failed",
-                    requestId,
-                    sessionId: state.run.sessionId,
-                    environment: state.run.environmentId,
-                    error: "local_runtime_disconnected_outcome_unknown",
-                });
+                this.publishDisconnectedScheduledRequest(state);
             }
         }
-        for (const controller of this.approvals.values())
-            controller.abort();
-        for (const state of this.active.values())
-            state.accept();
-        this.active.clear();
-        this.approvals.clear();
-        this.listeners.clear();
+        for (const callback of this.approvalCallbacks.values()) {
+            callback.detached = disconnected;
+            callback.controller.abort();
+        }
+        this.approvalCallbacks.clear();
+        for (const [requestId, state] of this.active) {
+            state.releaseAcceptance();
+            if (disconnected && shouldRetainDetachedRequest(state))
+                continue;
+            state.settle(new Error(disconnected
+                ? "local_runtime_connection_lost"
+                : "local_runtime_stopped"));
+            this.active.delete(requestId);
+        }
+        if (!disconnected)
+            this.listeners.clear();
     }
-    open(requestId, options, send) {
-        let accept;
-        const accepted = new Promise((resolve) => {
-            accept = resolve;
-        });
-        const state = { options, send, accept, accepted };
+    open(requestId, sessionId, options, send) {
+        const state = new PendingClientRequest(requestId, sessionId, options, send);
         this.active.set(requestId, state);
         return state;
     }
+    async restoreCancellationDelivery(requestId, sessionId, state) {
+        try {
+            await this.restoreApprovalDelivery(requestId, sessionId, state);
+        }
+        catch (error) {
+            if (!hasApprovalEndedBeforeAttachment(error))
+                throw error;
+        }
+    }
+    restoreApprovalDelivery(requestId, sessionId, state) {
+        // Scheduled delivery uses owner broadcasts and controls registration.
+        if (state.run)
+            return this.approvalCall("request.approvals", [sessionId]).then(() => { });
+        return new Promise((resolve, reject) => {
+            void this.attachRequest(requestId, sessionId, state.options, state.send, resolve).catch(reject);
+        });
+    }
+    async attachRequest(requestId, sessionId, options, send, onAccepted) {
+        const existing = this.active.get(requestId);
+        if (existing && hasLiveApprovalAttachment(existing)) {
+            await existing.accepted;
+            onAccepted?.();
+            return existing.waitForCompletion();
+        }
+        const state = existing ?? this.open(requestId, sessionId, options, send);
+        state.options = options;
+        state.send = send;
+        state.prepareAttachment(onAccepted);
+        try {
+            await this.trackOwnerRequest(state, () => this.approvalCall("request.attach", [requestId, sessionId]), false);
+        }
+        finally {
+            state.releaseAcceptance();
+            if (!shouldRetainDetachedRequest(state))
+                this.active.delete(requestId);
+        }
+    }
+    async trackOwnerRequest(state, invoke, retainOriginalWait = true) {
+        let outcome;
+        try {
+            outcome = await invoke();
+            state.settle();
+        }
+        catch (error) {
+            if (!isApprovalTransportLoss(state, error))
+                state.settle(error);
+            if (!retainOriginalWait)
+                throw error;
+        }
+        await state.waitForCompletion();
+        return outcome;
+    }
+    publishDisconnectedScheduledRequest(state) {
+        if (!state.run)
+            return;
+        this.publish({
+            type: "failed",
+            requestId: state.requestId,
+            sessionId: state.run.sessionId,
+            environment: state.run.environmentId,
+            error: "local_runtime_disconnected_outcome_unknown",
+        });
+    }
     publish(event) {
         for (const listener of this.listeners) {
             try {

package/dist/src/runtime/local-host/client-services.d.ts

@@ -6,7 +6,7 @@ import type { LocalRuntimeCallHandler } from "./contracts.js";
 export declare function createLocalServiceClients(call: LocalRuntimeCallHandler): {
     sessions: SessionStore;
     attachments: RuntimeAttachmentStore;
-    scheduler: Omit<SchedulerService, "stop" | "start">;
+    scheduler: Omit<SchedulerService, "start" | "stop">;
     projects: Readonly<{
         list: () => Promise<readonly import("../projects/contracts.js").RuntimeProject[]>;
         get: (id: string) => Promise<import("../projects/contracts.js").RuntimeProject | null>;

package/dist/src/runtime/local-host/contracts.d.ts

@@ -20,6 +20,8 @@ export type LocalRuntimeConnection = Readonly<{
     setClientHandler: (handler: LocalRuntimeCallHandler) => void;
     onClose: (listener: () => void) => () => void;
     close: () => Promise<void>;
+    /** Explicit attachment to the same live owner; never elects or replays work. */
+    reconnect: () => Promise<boolean>;
     /** Only the owning connection can synchronously observe its idle fence. */
     isOwnerIdle: () => boolean;
     /** Closes intake in the same turn as the idle check; clients never close owners. */

package/dist/src/runtime/local-host/learning-events.d.ts

@@ -0,0 +1,4 @@
+import type { LearningChangedEvent } from "../passive-learning/contracts.js";
+/** Only committed proposal identity crosses invalidation transports. */
+export declare function projectLearningChangedEvent(value: unknown): LearningChangedEvent | undefined;
+export declare function isLearningEventId(value: unknown): value is string;

package/dist/src/runtime/local-host/learning-events.js

@@ -0,0 +1,24 @@
+/** Only committed proposal identity crosses invalidation transports. */
+export function projectLearningChangedEvent(value) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const event = value;
+    if (event.type !== "proposal_delivered")
+        return undefined;
+    if (!isLearningEventId(event.proposalId))
+        return undefined;
+    if (!isLearningEventId(event.sessionId))
+        return undefined;
+    return {
+        type: "proposal_delivered",
+        proposalId: event.proposalId,
+        sessionId: event.sessionId,
+    };
+}
+export function isLearningEventId(value) {
+    if (typeof value !== "string")
+        return false;
+    if (!value.trim() || value.length > 256)
+        return false;
+    return !/[\u0000-\u001f\u007f]/u.test(value);
+}

package/dist/src/runtime/local-host/learning-preferences-input.d.ts

@@ -0,0 +1,3 @@
+import type { PassiveLearningPreferences } from "../passive-learning/contracts.js";
+/** Transport shape only; the persisted preferences owner validates all policy values. */
+export declare function readLearningPreferencesInput(value: unknown): Partial<PassiveLearningPreferences>;

package/dist/src/runtime/local-host/learning-preferences-input.js

@@ -0,0 +1,72 @@
+import { DEFAULT_LEARNING_PREFERENCES, normalizeLearningPreferences, } from "../passive-learning/store.js";
+const PREFERENCE_KEYS = [
+    "activityPermissions",
+    "enabled",
+    "processingPaused",
+    "modelProfileId",
+    "excludedApplications",
+    "processingExcludedApplications",
+    "analysisIntervalMinutes",
+    "analysisTrigger",
+    "analysisObservationCount",
+    "analysisWindow",
+    "maxConcurrentBatches",
+    "collectionWindow",
+    "proactiveEnabled",
+    "proactiveModelProfileId",
+    "proactiveIntervalMinutes",
+    "proactiveWindow",
+    "proactiveMessagesPerDay",
+    "maturation",
+    "resourceLimits",
+];
+const NESTED_KEYS = {
+    activityPermissions: ["collection", "learning", "proactive"],
+    analysisWindow: ["start", "end", "timeZone"],
+    collectionWindow: ["start", "end", "timeZone"],
+    proactiveWindow: ["start", "end", "timeZone"],
+    maturation: ["promotionScore", "retentionDays", "maxCandidates", "maxBytes"],
+    resourceLimits: [
+        "modelCallsPerDay",
+        "embeddingCallsPerDay",
+        "embeddingCharactersPerDay",
+        "maxConcurrentCalls",
+        "timeZone",
+    ],
+};
+/** Transport shape only; the persisted preferences owner validates all policy values. */
+export function readLearningPreferencesInput(value) {
+    if (!isPreferenceObject(value))
+        throw new Error("passive_learning_preferences_invalid");
+    for (const [key, input] of Object.entries(value)) {
+        if (!PREFERENCE_KEYS.includes(key))
+            throw new Error("passive_learning_preferences_invalid");
+        if (input === undefined)
+            continue;
+        if (input === null && !isClearedLearningPreference(key, input))
+            throw new Error("passive_learning_preferences_invalid");
+        if (!NESTED_KEYS[key] || input === null)
+            continue;
+        if (!isPreferenceObject(input))
+            throw new Error("passive_learning_preferences_invalid");
+        if (Object.keys(input).some((field) => !NESTED_KEYS[key].includes(field)))
+            throw new Error("passive_learning_preferences_invalid");
+        if (NESTED_KEYS[key].some((field) => input[field] === undefined))
+            throw new Error("passive_learning_preferences_invalid");
+    }
+    const normalized = normalizeLearningPreferences(value, DEFAULT_LEARNING_PREFERENCES);
+    return Object.fromEntries(Object.keys(value)
+        .filter((key) => value[key] !== undefined)
+        .map((key) => [key, isClearedLearningPreference(key, value[key])
+            ? null : normalized[key]]));
+}
+function isClearedLearningPreference(key, value) {
+    if (value !== null)
+        return false;
+    return ["analysisWindow", "collectionWindow", "proactiveWindow", "proactiveModelProfileId"].includes(key);
+}
+function isPreferenceObject(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    return !Array.isArray(value);
+}

package/dist/src/runtime/local-host/pending-client-request.d.ts

@@ -0,0 +1,40 @@
+import type { RuntimeRequestOptions } from "../composition.js";
+import type { SchedulerRun } from "../scheduler/contracts.js";
+import type { LocalPendingToolApproval } from "./request-approval-contracts.js";
+/** One client view of an owner request; detachment never settles owner work. */
+export declare class PendingClientRequest {
+    readonly requestId: string;
+    readonly sessionId: string;
+    options: RuntimeRequestOptions;
+    send?: ((event: Record<string, unknown>) => void) | undefined;
+    run?: SchedulerRun;
+    detached: boolean;
+    callbackUnavailable: boolean;
+    awaitingApprovalAttachment: boolean;
+    private approvalStateUnconfirmed;
+    private approvalObservationRevision;
+    readonly approvalIds: Set<string>;
+    accepted: Promise<void>;
+    accept: () => void;
+    releaseAcceptance: () => void;
+    private finish;
+    private readonly completion;
+    constructor(requestId: string, sessionId: string, options: RuntimeRequestOptions, send?: ((event: Record<string, unknown>) => void) | undefined);
+    resetAcceptance(onAccepted?: () => void): void;
+    settle(error?: unknown): void;
+    markDisconnected(): void;
+    prepareAttachment(onAccepted?: () => void): void;
+    observeApprovalCallback(approvalId: string): void;
+    captureApprovalSnapshotRevision(sessionId?: string): number | undefined;
+    reconcileApprovalSnapshot(pending: readonly LocalPendingToolApproval[], capturedRevision: number, ownerActive?: boolean): boolean;
+    needsOwnerActivityCheck(pending: readonly LocalPendingToolApproval[], capturedRevision: number): boolean;
+    private canApplyOwnerSnapshot;
+    private matchesApprovalIdentity;
+    hasUnconfirmedApproval(): boolean;
+    observeApproval(event: Record<string, unknown>): void;
+    waitForCompletion(): Promise<void>;
+}
+export declare function shouldRetainDetachedRequest(state: PendingClientRequest): boolean;
+export declare function isApprovalTransportLoss(state: PendingClientRequest, error: unknown): boolean;
+export declare function hasLiveApprovalAttachment(state: PendingClientRequest): boolean;
+export declare function hasApprovalEndedBeforeAttachment(error: unknown): boolean;

package/dist/src/runtime/local-host/pending-client-request.js

@@ -0,0 +1,152 @@
+/** One client view of an owner request; detachment never settles owner work. */
+export class PendingClientRequest {
+    requestId;
+    sessionId;
+    options;
+    send;
+    run;
+    detached = false;
+    callbackUnavailable = false;
+    awaitingApprovalAttachment = false;
+    approvalStateUnconfirmed = false;
+    approvalObservationRevision = 0;
+    approvalIds = new Set();
+    accepted;
+    accept;
+    releaseAcceptance;
+    finish;
+    completion = new Promise((resolve) => {
+        this.finish = resolve;
+    });
+    constructor(requestId, sessionId, options, send) {
+        this.requestId = requestId;
+        this.sessionId = sessionId;
+        this.options = options;
+        this.send = send;
+        this.resetAcceptance();
+    }
+    resetAcceptance(onAccepted) {
+        this.accepted = new Promise((resolve) => {
+            this.releaseAcceptance = resolve;
+            this.accept = () => {
+                resolve();
+                onAccepted?.();
+                onAccepted = undefined;
+            };
+        });
+    }
+    settle(error) {
+        this.finish({ error });
+    }
+    markDisconnected() {
+        this.detached = true;
+        this.approvalStateUnconfirmed = Boolean(this.options.toolApprovalController);
+        this.approvalObservationRevision += 1;
+    }
+    prepareAttachment(onAccepted) {
+        this.detached = false;
+        this.callbackUnavailable = false;
+        this.awaitingApprovalAttachment = true;
+        this.approvalStateUnconfirmed = false;
+        this.approvalObservationRevision += 1;
+        this.resetAcceptance(onAccepted);
+    }
+    observeApprovalCallback(approvalId) {
+        this.approvalIds.add(approvalId);
+        this.awaitingApprovalAttachment = false;
+        this.approvalStateUnconfirmed = false;
+        this.approvalObservationRevision += 1;
+    }
+    captureApprovalSnapshotRevision(sessionId) {
+        if (!shouldRetainDetachedRequest(this))
+            return undefined;
+        if (sessionId !== undefined && sessionId !== this.sessionId)
+            return undefined;
+        return this.approvalObservationRevision;
+    }
+    reconcileApprovalSnapshot(pending, capturedRevision, ownerActive) {
+        if (!this.canApplyOwnerSnapshot(capturedRevision))
+            return false;
+        const matching = pending.filter((entry) => this.matchesApprovalIdentity(entry));
+        this.approvalIds.clear();
+        this.approvalStateUnconfirmed = matching.length === 0;
+        this.awaitingApprovalAttachment = false;
+        this.approvalObservationRevision += 1;
+        for (const entry of matching)
+            this.approvalIds.add(entry.request.approvalId);
+        if (matching.length > 0)
+            return false;
+        if (ownerActive !== false)
+            return false;
+        this.settle(new Error("local_runtime_connection_lost"));
+        return true;
+    }
+    needsOwnerActivityCheck(pending, capturedRevision) {
+        if (!this.canApplyOwnerSnapshot(capturedRevision))
+            return false;
+        return !pending.some((entry) => this.matchesApprovalIdentity(entry));
+    }
+    canApplyOwnerSnapshot(capturedRevision) {
+        if (!shouldRetainDetachedRequest(this))
+            return false;
+        return capturedRevision === this.approvalObservationRevision;
+    }
+    matchesApprovalIdentity(entry) {
+        if (entry.sessionId !== this.sessionId)
+            return false;
+        return entry.request.requestId === this.requestId;
+    }
+    hasUnconfirmedApproval() {
+        return this.approvalStateUnconfirmed;
+    }
+    observeApproval(event) {
+        const approvalId = String(event.approvalId ?? "");
+        if (!approvalId)
+            return;
+        if (event.name === "tool.approval.required") {
+            this.observeApprovalCallback(approvalId);
+            return;
+        }
+        if (event.name === "tool.approval.granted") {
+            this.approvalObservationRevision += 1;
+            this.approvalIds.delete(approvalId);
+            this.awaitingApprovalAttachment = false;
+        }
+        if (event.name === "tool.approval.rejected") {
+            this.approvalObservationRevision += 1;
+            this.approvalIds.delete(approvalId);
+            this.awaitingApprovalAttachment = false;
+        }
+    }
+    async waitForCompletion() {
+        const result = await this.completion;
+        if (result.error !== undefined)
+            throw result.error;
+    }
+}
+export function shouldRetainDetachedRequest(state) {
+    if (!state.detached)
+        return false;
+    if (state.hasUnconfirmedApproval())
+        return true;
+    if (state.awaitingApprovalAttachment)
+        return true;
+    return state.approvalIds.size > 0;
+}
+export function isApprovalTransportLoss(state, error) {
+    if (!shouldRetainDetachedRequest(state))
+        return false;
+    if (!(error instanceof Error))
+        return false;
+    return error.message === "local_runtime_connection_lost";
+}
+export function hasLiveApprovalAttachment(state) {
+    if (state.detached)
+        return false;
+    return !state.callbackUnavailable;
+}
+export function hasApprovalEndedBeforeAttachment(error) {
+    if (!(error instanceof Error))
+        return false;
+    return error.message === "local_runtime_request_not_awaiting_approval";
+}

package/dist/src/runtime/local-host/reconnectable-connection.d.ts

@@ -0,0 +1,4 @@
+import type { LocalRuntimeConnection, LocalRuntimeEndpoint } from "./contracts.js";
+import type { LocalRuntimeRpcPeer } from "./rpc-peer.js";
+/** A fresh explicit attachment retains the original owner's credentials and lease. */
+export declare function createReconnectableRuntimeConnection(initialPeer: LocalRuntimeRpcPeer, endpoint: LocalRuntimeEndpoint, ownership: "owner" | "client", closeOwner?: () => Promise<void>, isOwnerIdle?: () => boolean): LocalRuntimeConnection;