@abot-ai/runtime 1.4.0 → 1.6.0

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

@@ -6,7 +6,280 @@ 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">;
+    automations: {
+        list: () => Promise<{
+            latestRunId?: string | undefined;
+            latestRunStatus?: import("../scheduler/contracts.js").SchedulerRunStatus | "stopping" | "completed_with_skips" | undefined;
+            publishedRevision?: number;
+            status: "active" | "paused" | "draft" | "archived";
+            id: string;
+            title: string;
+            draftRevision: number;
+            updatedAt: string;
+        }[]>;
+        create: (title: string, templateId?: string) => Promise<Readonly<{
+            id: string;
+            automationId: string;
+            revision: number;
+            definition: import("../automations/definition-contracts.js").AutomationRevision;
+            updatedAt: string;
+            archivedAt?: string;
+            storageRevision?: number;
+        }>>;
+        getDraft: (automationId: string) => Promise<import("../automations/storage-records.js").AutomationDraftRecord | null>;
+        deleteDraft: (automationId: string, expectedRevision: number) => Promise<void>;
+        archive: (automationId: string, expectedRevision: number) => Promise<Readonly<{
+            id: string;
+            automationId: string;
+            revision: number;
+            definition: import("../automations/definition-contracts.js").AutomationRevision;
+            updatedAt: string;
+            archivedAt?: string;
+            storageRevision?: number;
+        }>>;
+        restore: (automationId: string, expectedRevision: number) => Promise<Readonly<{
+            id: string;
+            automationId: string;
+            revision: number;
+            definition: import("../automations/definition-contracts.js").AutomationRevision;
+            updatedAt: string;
+            archivedAt?: string;
+            storageRevision?: number;
+        }>>;
+        getPublishedDefinition: (automationId: string) => Promise<Readonly<{
+            schemaVersion: 1;
+            automationId: string;
+            revision: number;
+            title: string;
+            objective: string;
+            workingDirectory?: string;
+            trigger: import("../automations/definition-contracts.js").AutomationTrigger;
+            source?: import("../automations/definition-contracts.js").FolderSource;
+            inputs: Readonly<Record<string, import("../automations/definition-contracts.js").AutomationJsonValue>>;
+            body: import("../automations/definition-contracts.js").SequenceNode;
+            limits: import("../automations/limits.js").AutomationLimits;
+        }> | null>;
+        updateDraft: (automationId: string, expectedRevision: number, mutation: unknown) => Promise<import("../automations/storage-records.js").AutomationDraftRecord>;
+        createDraftPlan: (title: string, value: unknown, accept?: import("../automations/draft-management.js").AutomationDraftPlanAcceptance) => Promise<{
+            draft: Readonly<{
+                id: string;
+                automationId: string;
+                revision: number;
+                definition: import("../automations/definition-contracts.js").AutomationRevision;
+                updatedAt: string;
+                archivedAt?: string;
+                storageRevision?: number;
+            }>;
+            aliases: Readonly<Record<string, string>>;
+        }>;
+        applyDraftPlan: (automationId: string, expectedRevision: number, value: unknown, accept?: import("../automations/draft-management.js").AutomationDraftPlanAcceptance) => Promise<{
+            draft: Readonly<{
+                id: string;
+                automationId: string;
+                revision: number;
+                definition: import("../automations/definition-contracts.js").AutomationRevision;
+                updatedAt: string;
+                archivedAt?: string;
+                storageRevision?: number;
+            }>;
+            aliases: Readonly<Record<string, string>>;
+        }>;
+        getSavedAgent: (agentId: string, revision?: number) => Promise<import("../automations/storage-records.js").AutomationSavedAgentRecord | null>;
+        listSavedAgents: () => Promise<import("../automations/storage-records.js").AutomationSavedAgentRecord[]>;
+        saveAgentFromDraft: (input: {
+            automationId: string;
+            nodeId: string;
+            expectedDraftRevision: number;
+            agentId?: string;
+            expectedAgentRevision?: number;
+        }) => Promise<import("../automations/storage-records.js").AutomationSavedAgentRecord>;
+        validate: (automationId: string) => Promise<readonly Readonly<{
+            code: string;
+            path: string;
+            message: string;
+        }>[]>;
+        catalog: (automationId: string) => Promise<{
+            templates: {
+                id: string;
+                title: string;
+                category: string;
+                description: string;
+                setup: string;
+                toolNames: string[];
+                stepCount: number;
+                agentCount: number;
+                parallelGroupCount: number;
+                level: string;
+                highlights: readonly string[];
+                outputFiles: string[];
+            }[];
+            operations: Readonly<{
+                toolName: string;
+                operationId: string;
+                contractVersion: number;
+                label: string;
+                pluginName?: string;
+                catalogGroups: readonly import("../../capabilities/tool-types.js").ToolCatalogGroup[];
+                toolDescription?: string;
+                permissionMode: "full_access" | "full_plus";
+                effect: "read_only" | "mutating" | "mixed";
+                approval: "request_policy" | "always";
+                input: import("../../capabilities/tool-types.js").ToolNormalInvocationInput;
+                fixedParams?: import("../../capabilities/tool-types.js").ToolNormalInvocationOperation["fixedParams"];
+                payload?: import("../../capabilities/tool-types.js").ToolNormalInvocationPayload;
+                attachmentInput?: import("../../capabilities/tool-types.js").ToolNormalInvocationAttachmentInput;
+                selectionControlIds?: readonly string[];
+            }>[];
+            grantableOperations: Readonly<{
+                toolName: string;
+                operationId: string;
+                contractVersion: number;
+                label: string;
+                pluginName?: string;
+                catalogGroups: readonly import("../../capabilities/tool-types.js").ToolCatalogGroup[];
+                toolDescription?: string;
+                permissionMode: "full_access" | "full_plus";
+                effect: "read_only" | "mutating" | "mixed";
+                approval: "request_policy" | "always";
+                input: import("../../capabilities/tool-types.js").ToolNormalInvocationInput;
+                fixedParams?: import("../../capabilities/tool-types.js").ToolNormalInvocationOperation["fixedParams"];
+                payload?: import("../../capabilities/tool-types.js").ToolNormalInvocationPayload;
+                attachmentInput?: import("../../capabilities/tool-types.js").ToolNormalInvocationAttachmentInput;
+                selectionControlIds?: readonly string[];
+            }>[];
+            models: {
+                provider?: string | undefined;
+                id: string;
+                label: string;
+            }[];
+            savedAgents: {
+                id: string;
+                revision: number;
+                title: string;
+                modelProfileId: string;
+                agent: import("../automations/definition-contracts.js").AgentNode;
+            }[];
+        }>;
+        getGrant: (automationId: string) => Promise<import("../automations/storage-records.js").AutomationGrantRecord | null>;
+        replaceGrant: (input: {
+            automationId: string;
+            expectedGrantRevision: number;
+            mode: import("../scheduler/tool-permission-mode.js").SchedulerToolPermissionMode;
+            operations: readonly import("../automations/definition-contracts.js").OperationRef[];
+            actionId: string;
+        }) => Promise<import("../automations/storage-records.js").AutomationGrantRecord>;
+        publish: (automationId: string, expectedRevision: number) => Promise<{
+            definition: Readonly<{
+                id: string;
+                automationId: string;
+                revision: number;
+                definition: import("../automations/definition-contracts.js").AutomationRevision;
+                publishedAt: string;
+                dependencyFingerprint?: string;
+            }>;
+            job: import("../scheduler/contracts.js").SchedulerAutomationJob;
+        }>;
+        activate(automationId: string): Promise<import("../scheduler/contracts.js").SchedulerAutomationJob>;
+        pause(automationId: string): Promise<import("../scheduler/contracts.js").SchedulerAutomationJob>;
+        runNow(automationId: string, idempotencyKey?: string): Promise<import("../scheduler/contracts.js").SchedulerAutomationRun>;
+        listRuns: (automationId: string, query?: import("../scheduler/contracts.js").SchedulerRunListQuery) => Promise<import("../scheduler/contracts.js").SchedulerAutomationRun[]>;
+        getRun: (runId: string) => Promise<{
+            reportState?: "expired" | undefined;
+            reportExpiredAt?: string | undefined;
+            detailsExpiredAt?: string | undefined;
+            automationId: string;
+            definition: Readonly<{
+                schemaVersion: 1;
+                automationId: string;
+                revision: number;
+                title: string;
+                objective: string;
+                workingDirectory?: string;
+                trigger: import("../automations/definition-contracts.js").AutomationTrigger;
+                source?: import("../automations/definition-contracts.js").FolderSource;
+                inputs: Readonly<Record<string, import("../automations/definition-contracts.js").AutomationJsonValue>>;
+                body: import("../automations/definition-contracts.js").SequenceNode;
+                limits: import("../automations/limits.js").AutomationLimits;
+            }>;
+            nodes: {
+                errorCode?: string | undefined;
+                nodeId: string;
+                status: "failed" | "pending" | "cancelled" | "succeeded" | "running" | "ready" | "skipped" | "interrupted";
+            }[];
+            report: Readonly<{
+                runId: string;
+                automationId: string;
+                definitionRevision: number;
+                outcome: "succeeded" | "completed_with_skips" | "failed" | "cancelled" | "interrupted" | "missed";
+                startedAt: string | null;
+                finishedAt: string;
+                inputIds: readonly string[];
+                inputVersions: readonly Readonly<{
+                    inputId: string;
+                    sourceId: string;
+                    canonicalPath: string;
+                    contentVersion: string;
+                }>[];
+                nodeResults: readonly Readonly<{
+                    nodeId: string;
+                    title?: string;
+                    status: string;
+                    errorCode?: string;
+                    resultRef?: string;
+                }>[];
+                uncertainEffects: readonly Readonly<{
+                    nodeId: string;
+                    attemptId: string;
+                }>[];
+                lateEvidence: readonly Readonly<{
+                    nodeId: string;
+                    attemptId: string;
+                    revision: number;
+                    observedAt: string;
+                    status: "succeeded" | "failed" | "rejected";
+                    errorCode?: string;
+                }>[];
+                artifacts: readonly Readonly<{
+                    id: string;
+                    nodeId?: string;
+                    kind: string;
+                }>[];
+                effectSummary?: import("../automations/step-evidence-effects.js").AutomationRunEffectSummary;
+                modelCalls: number | null;
+                toolCalls: number | null;
+                toolAttempts?: number;
+            }> | null;
+            outputSummary: Readonly<{
+                entries: readonly import("../automations/run-output-summary.js").AutomationRunOutputEntry[];
+                omitted: number;
+            }>;
+            id: string;
+            jobId: string;
+            environmentId: string;
+            target: Readonly<{
+                kind: "automation";
+                automationId: string;
+                definitionRevision: number;
+            }>;
+            title: string;
+            timeZone: string;
+            jobRevision: number;
+            scheduledAt: string;
+            admittedAt?: string;
+            startedAt?: string;
+            finishedAt?: string;
+            trigger: "schedule" | "manual";
+            idempotencyKey?: string;
+            replayOf?: string;
+            status: import("../scheduler/contracts.js").SchedulerRunStatus | "stopping" | "completed_with_skips";
+            error?: string;
+            reportRef?: string;
+        }>;
+        getStepEvidence: (runId: string, nodeId: string, full?: boolean) => Promise<import("../automations/step-evidence.js").AutomationStepEvidence>;
+        stopRun: (runId: string) => Promise<import("../scheduler/contracts.js").SchedulerAutomationRun>;
+        rerun: (runId: string, idempotencyKey: string, confirmed: true) => Promise<import("../scheduler/contracts.js").SchedulerAutomationRun>;
+    };
     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/client-services.js

@@ -1,5 +1,5 @@
 import { bindManagedSessionAttachmentDeletion } from "../session/session-attachment-deletion.js";
-import { LOCAL_SESSION_METHODS, LOCAL_PROJECT_METHODS, LOCAL_ATTACHMENT_METHODS, LOCAL_SCHEDULER_METHODS, } from "./app-service-dispatch.js";
+import { LOCAL_SESSION_METHODS, LOCAL_PROJECT_METHODS, LOCAL_ATTACHMENT_METHODS, LOCAL_SCHEDULER_METHODS, LOCAL_AUTOMATION_METHODS, } from "./app-service-dispatch.js";
 /** Projections of owner APIs; lifecycle remains with the managed application. */
 export function createLocalServiceClients(call) {
     const service = (prefix, methods) => Object.fromEntries(methods.map((method) => [
@@ -9,7 +9,8 @@ export function createLocalServiceClients(call) {
     const sessions = service("sessions", LOCAL_SESSION_METHODS);
     const attachments = service("attachments", LOCAL_ATTACHMENT_METHODS);
     const scheduler = service("scheduler", LOCAL_SCHEDULER_METHODS);
+    const automations = service("automations", LOCAL_AUTOMATION_METHODS);
     bindManagedSessionAttachmentDeletion(sessions, attachments);
     const projects = service("projects", LOCAL_PROJECT_METHODS);
-    return { sessions, attachments, scheduler, projects };
+    return { sessions, attachments, scheduler, automations, projects };
 }

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,73 @@
+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",
+    "sparkToolPermissionMode",
+    "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;