rea-agents 6.0.0 → 6.2.0

package/dist/application/binary/BinarySession.js

@@ -6,13 +6,14 @@ import { err, ok } from "../../domain/result.js";
 import { createEvidence } from "../../domain/evidence.js";
 import { OFFICIAL_TOOL_CONTRACTS } from "../../contracts/officialToolContracts.js";
 import { ENHANCED_TOOL_CONTRACTS } from "../../contracts/enhancedToolContracts.js";
+import { writeAnalysisSnapshot } from "./AnalysisSnapshotFiles.js";
 import { SessionProviderRouter, } from "./SessionProviderRouter.js";
 import { InvestigationRecords } from "../investigation/InvestigationRecords.js";
 import { BinarySessionRecords } from "./BinarySessionRecords.js";
 import { binarySessionStatus } from "./BinarySessionStatus.js";
 import { resolveSessionOpen, resolveSessionTarget, validateResolvedSessionTarget, } from "./BinarySessionOpen.js";
 import { bindExecutionTarget, commitExecutionProfile, prepareSessionExecution, } from "./BinarySessionExecution.js";
-import { closeAnalysisClient } from "./AnalysisClientCleanup.js";
+import { analysisErrorWithCleanupFailure, closeAnalysisClient, } from "./AnalysisClientCleanup.js";
 const OFFICIAL_OPERATIONS = new Set(OFFICIAL_TOOL_CONTRACTS.map(({ name }) => name));
 const ENHANCED_OPERATIONS = new Set(ENHANCED_TOOL_CONTRACTS.map(({ name }) => name));
 /**
@@ -24,8 +25,10 @@ const ENHANCED_OPERATIONS = new Set(ENHANCED_TOOL_CONTRACTS.map(({ name }) => na
  */
 export class BinarySession extends BinarySessionRecords {
     #active;
+    #pendingCleanup;
     #transition = Promise.resolve();
-    #calls = new Set();
+    #transitionGeneration = 0;
+    #calls = new Map();
     #providerRouter;
     #runtimeUnavailability = new Map();
     #availabilityListeners = new Set();
@@ -36,14 +39,14 @@ export class BinarySession extends BinarySessionRecords {
     /** Identify the provider producing evidence for this session. */
     providerIdentity(operation) {
         const route = this.#currentRoute();
-        let selected = route.identity;
+        let selected = route.binding?.identity ?? route.identity;
         if (operation !== undefined) {
-            const exact = route.capabilities?.get(operation)?.provider;
+            const exact = route.capabilities.get(operation)?.provider;
             if (exact !== undefined)
                 selected = exact;
             else if (ENHANCED_OPERATIONS.has(operation)) {
                 const providers = new Map();
-                for (const descriptor of route.capabilities?.values() ?? [])
+                for (const descriptor of route.capabilities.values())
                     if (descriptor.available &&
                         OFFICIAL_OPERATIONS.has(descriptor.operation))
                         providers.set(descriptor.provider.id, descriptor.provider);
@@ -79,10 +82,6 @@ export class BinarySession extends BinarySessionRecords {
             return undefined;
         return structuredClone(profile);
     }
-    /** Return opaque adapter metadata retained for legacy open_binary output. */
-    openCompatibility() {
-        return structuredClone(this.#active?.compatibility ?? {});
-    }
     /** Observe runtime provider-health changes that affect discovery metadata. */
     onAvailabilityChanged(listener) {
         this.#availabilityListeners.add(listener);
@@ -125,62 +124,66 @@ export class BinarySession extends BinarySessionRecords {
         })), options);
     }
     #open(resolve, options) {
-        return this.#serialize(async () => {
+        return this.#serialize(async (admittedThrough) => {
             if (isAborted(options.signal))
                 return err(new AnalysisCancelledError("open_binary"));
             const resolved = await resolve();
             if (!resolved.ok)
                 return resolved;
             const { target, route, sameTarget } = resolved.value;
-            const { profile, compatibility } = route;
+            const { profile } = route;
             if (isAborted(options.signal))
                 return err(new AnalysisCancelledError("open_binary"));
             const activeProfile = this.#active?.profile;
             const sameProfile = activeProfile === null || activeProfile === undefined
                 ? profile === null
                 : profile !== null && analysisProfilesEqual(activeProfile, profile);
+            await this.#drainCalls(admittedThrough);
+            if (isAborted(options.signal))
+                return err(new AnalysisCancelledError("open_binary"));
+            const pendingClosed = await this.#retryPendingCleanup();
+            if (!pendingClosed.ok)
+                return pendingClosed;
+            if (isAborted(options.signal))
+                return err(new AnalysisCancelledError("open_binary"));
             if (sameTarget && sameProfile) {
                 if (options.snapshot !== undefined) {
                     const imported = this.importAnalysisSnapshot(options.snapshot);
                     if (!imported.ok)
                         return imported;
                 }
-                this.resetSnapshotInvalidation();
                 return ok(target);
             }
-            await this.#drainCalls();
             const previous = this.#active;
             this.#active = undefined;
             if (previous !== undefined) {
-                const closed = await closeAnalysisClient(previous.client, previous.route.identity.id);
+                const closed = await this.#retireClient(previous.client, previous.route.identity.id);
                 if (!closed.ok) {
                     this.clearSessionRecords();
                     this.#clearRuntimeAvailability();
                     return closed;
                 }
             }
+            if (isAborted(options.signal))
+                return err(await this.#restoreAfterFailedOpen(previous, new AnalysisCancelledError("open_binary")));
             const runId = randomUUID();
             const client = route.createClient(target, { runId });
             const started = await client.execute("health", {}, options);
             if (!started.ok) {
-                await client.close();
-                await this.#restore(previous);
-                return started;
+                return err(await this.#failedOpen(client, route.identity.id, previous, started.error));
             }
             if (isAborted(options.signal)) {
-                await client.close();
-                await this.#restore(previous);
-                return err(new AnalysisCancelledError("open_binary"));
+                return err(await this.#failedOpen(client, route.identity.id, previous, new AnalysisCancelledError("open_binary")));
             }
             this.#active = {
                 target,
                 client,
                 profile,
-                compatibility: structuredClone(compatibility),
                 route,
                 runId,
             };
             this.#clearRuntimeAvailability();
+            this.resetSnapshotInvalidation();
             if (options.snapshot === undefined) {
                 if (profile === null)
                     this.clearSnapshot();
@@ -191,36 +194,93 @@ export class BinarySession extends BinarySessionRecords {
                 const imported = this.importAnalysisSnapshot(options.snapshot);
                 if (!imported.ok) {
                     this.#active = undefined;
-                    await client.close();
-                    await this.#restore(previous);
-                    return imported;
+                    return err(await this.#failedOpen(client, route.identity.id, previous, imported.error));
                 }
             }
-            this.resetSnapshotInvalidation();
             return ok(target);
         });
     }
     /** Close the active target, if any. */
     close(options = {}) {
-        return this.#serialize(async () => {
-            const previous = this.#active;
-            this.#active = undefined;
-            await this.#drainCalls();
-            const closed = previous === undefined
-                ? ok(null)
-                : await closeAnalysisClient(previous.client, previous.route.identity.id, {
-                    ...(options.progress === undefined
-                        ? {}
-                        : { progress: options.progress }),
-                    ...(options.retainProviderDocuments === true
-                        ? { retainDocument: true }
-                        : {}),
-                });
-            this.clearSessionRecords();
-            this.#clearRuntimeAvailability();
-            return closed;
+        return this.#serialize(async (admittedThrough) => {
+            await this.#drainCalls(admittedThrough);
+            return this.#closeActive(options);
         });
     }
+    /** Drain earlier requests, save an immutable snapshot, and close under one lifecycle lock. */
+    closeWithSnapshot(path, overwrite, options = {}) {
+        return this.#serialize(async (admittedThrough) => {
+            await this.#drainCalls(admittedThrough);
+            const snapshot = this.exportAnalysisSnapshot();
+            if (!snapshot.ok)
+                return snapshot;
+            const written = await writeAnalysisSnapshot(snapshot.value, path, overwrite);
+            if (!written.ok)
+                return written;
+            const closed = await this.#closeActive(options);
+            return closed.ok
+                ? ok({
+                    ...written.value,
+                    primitive_entries: snapshot.value.entries.length,
+                    workflow_entries: snapshot.value.workflow_entries.length,
+                    evidence_records: snapshot.value.evidence_bundle.records.length,
+                })
+                : closed;
+        });
+    }
+    async #closeActive(options) {
+        const previous = this.#active;
+        this.#active = undefined;
+        const closed = previous === undefined
+            ? await this.#retryPendingCleanup(options.progress, options.retainProviderDocuments)
+            : await this.#retireClient(previous.client, previous.route.identity.id, {
+                ...(options.progress === undefined
+                    ? {}
+                    : { progress: options.progress }),
+                ...(options.retainProviderDocuments === true
+                    ? { retainDocument: true }
+                    : {}),
+            });
+        this.clearSessionRecords();
+        this.#clearRuntimeAvailability();
+        return closed;
+    }
+    async #retireClient(client, providerId, options = {}) {
+        this.#pendingCleanup = {
+            client,
+            providerId,
+            retainDocument: options.retainDocument === true,
+        };
+        return this.#retryPendingCleanup(options.progress);
+    }
+    async #retryPendingCleanup(progress, retainDocument) {
+        let pending = this.#pendingCleanup;
+        if (pending === undefined)
+            return ok(null);
+        if (retainDocument !== undefined) {
+            pending = { ...pending, retainDocument };
+            this.#pendingCleanup = pending;
+        }
+        const closed = await closeAnalysisClient(pending.client, pending.providerId, {
+            ...(progress === undefined ? {} : { progress }),
+            ...(pending.retainDocument ? { retainDocument: true } : {}),
+        });
+        if (closed.ok)
+            this.#pendingCleanup = undefined;
+        return closed;
+    }
+    async #failedOpen(client, providerId, previous, primary) {
+        const closed = await this.#retireClient(client, providerId);
+        if (!closed.ok)
+            return analysisErrorWithCleanupFailure(primary, closed.error, "open_binary");
+        return this.#restoreAfterFailedOpen(previous, primary);
+    }
+    async #restoreAfterFailedOpen(previous, primary) {
+        const restored = await this.#restore(previous);
+        return restored.ok
+            ? primary
+            : analysisErrorWithCleanupFailure(primary, restored.error, "open_binary");
+    }
     /** Describe the active binary session. */
     status() {
         return binarySessionStatus({
@@ -231,6 +291,7 @@ export class BinarySession extends BinarySessionRecords {
             runId: this.#active?.runId,
             runtimeLineageSnapshots: this.#active?.client.runtimeLineageSnapshots?.() ?? [],
             requestActivitySnapshots: this.#active?.client.requestActivitySnapshots?.() ?? [],
+            providerOperationHealth: this.#active?.client.operationHealthSnapshot?.() ?? null,
         });
     }
     /** Return the immutable artifact identity captured before its provider started. */
@@ -247,8 +308,14 @@ export class BinarySession extends BinarySessionRecords {
      * Calls may overlap, but a pending target transition prevents new calls from
      * entering until the transition has settled.
      */
-    async execute(name, arguments_, options) {
-        const transitioned = await this.#waitForTransition(name, options?.signal);
+    execute(name, arguments_, options) {
+        const generation = this.#transitionGeneration;
+        const call = this.#execute(name, arguments_, options, this.#transition);
+        this.#calls.set(call, generation);
+        return call.finally(() => this.#calls.delete(call));
+    }
+    async #execute(name, arguments_, options, transition) {
+        const transitioned = await this.#waitForTransition(name, options?.signal, transition);
         if (!transitioned.ok)
             return transitioned;
         const prepared = prepareSessionExecution({
@@ -269,46 +336,40 @@ export class BinarySession extends BinarySessionRecords {
         if (cached !== undefined)
             return ok(cached);
         const call = active.client.execute(name, arguments_, options);
-        this.#calls.add(call);
-        try {
-            const result = await call;
-            const profiled = bindExecutionTarget(commitExecutionProfile(name, result, profile), name, active.target);
-            this.#observeRuntimeAvailability(name, profiled);
-            if (profiled.ok &&
-                cacheable &&
-                profile !== undefined &&
-                name !== "decode_interface_builder" &&
-                name !== "inspect_asset_catalog" &&
-                name !== "inspect_keyed_archive" &&
-                name !== "trace_dylib_resolution") {
-                const evidence = createEvidence(profiled.value.subject ?? active.target, profiled.value.provider, {
-                    operation: name,
-                    parameters: arguments_,
-                    result: profiled.value.result,
-                    analysisProfile: profile,
-                    rawResult: profiled.value.rawResult,
-                    limitations: profiled.value.limitations,
-                    locations: profiled.value.locations,
-                });
-                const recorded = this.recordEvidence(evidence);
-                if (!recorded.ok)
-                    return recorded;
-                this.recordSnapshot({
-                    target: active.target,
-                    profile,
-                    operation: name,
-                    parameters: arguments_,
-                    execution: profiled.value,
-                });
-            }
-            else if (profiled.ok && capability?.effects.mutatesArtifact === true) {
-                this.invalidateSnapshot();
-            }
-            return profiled;
+        const result = await call;
+        const profiled = bindExecutionTarget(commitExecutionProfile(name, result, profile), name, active.target);
+        this.#observeRuntimeAvailability(name, profiled);
+        if (profiled.ok &&
+            cacheable &&
+            profile !== undefined &&
+            name !== "decode_interface_builder" &&
+            name !== "inspect_asset_catalog" &&
+            name !== "inspect_keyed_archive" &&
+            name !== "trace_dylib_resolution") {
+            const evidence = createEvidence(profiled.value.subject ?? active.target, profiled.value.provider, {
+                operation: name,
+                parameters: arguments_,
+                result: profiled.value.result,
+                analysisProfile: profile,
+                rawResult: profiled.value.rawResult,
+                limitations: profiled.value.limitations,
+                locations: profiled.value.locations,
+            });
+            const recorded = this.recordEvidence(evidence);
+            if (!recorded.ok)
+                return recorded;
+            this.recordSnapshot({
+                target: active.target,
+                profile,
+                operation: name,
+                parameters: arguments_,
+                execution: profiled.value,
+            });
         }
-        finally {
-            this.#calls.delete(call);
+        else if (profiled.ok && capability.effects.mutatesArtifact) {
+            this.invalidateSnapshot();
         }
+        return profiled;
     }
     #observeRuntimeAvailability(operation, result) {
         if (result.ok) {
@@ -374,36 +435,43 @@ export class BinarySession extends BinarySessionRecords {
         return this.#active?.route ?? this.#providerRouter.initialRoute();
     }
     #serialize(operation) {
-        const result = this.#transition.then(operation, operation);
+        // Later calls wait for this transition and must not be included in its drain.
+        const admittedThrough = this.#transitionGeneration++;
+        const result = this.#transition.then(() => operation(admittedThrough), () => operation(admittedThrough));
         this.#transition = result.then(() => undefined, () => undefined);
         return result;
     }
-    async #drainCalls() {
-        await Promise.allSettled(this.#calls);
+    async #drainCalls(admittedThrough) {
+        await Promise.allSettled([...this.#calls]
+            .filter(([, generation]) => generation <= admittedThrough)
+            .map(([call]) => call));
     }
     async #restore(previous) {
         if (previous === undefined)
-            return;
+            return ok(null);
         const runId = randomUUID();
         const client = previous.route.createClient(previous.target, { runId });
         const started = await client.execute("health", {});
-        if (started.ok)
+        if (started.ok) {
             this.#active = {
                 target: previous.target,
                 client,
                 profile: previous.profile,
-                compatibility: previous.compatibility,
                 route: previous.route,
                 runId,
             };
-        else
-            await client.close();
+            return ok(null);
+        }
+        const closed = await this.#retireClient(client, previous.route.identity.id);
+        return closed.ok
+            ? ok(null)
+            : err(analysisErrorWithCleanupFailure(started.error, closed.error, "open_binary"));
     }
-    async #waitForTransition(operation, signal) {
+    async #waitForTransition(operation, signal, transition) {
         if (signal?.aborted === true)
             return err(new AnalysisCancelledError(operation));
         if (signal === undefined) {
-            await this.#transition;
+            await transition;
             return ok(undefined);
         }
         return new Promise((resolve) => {
@@ -411,7 +479,7 @@ export class BinarySession extends BinarySessionRecords {
                 resolve(err(new AnalysisCancelledError(operation)));
             };
             signal.addEventListener("abort", onAbort, { once: true });
-            this.#transition.then(() => {
+            transition.then(() => {
                 signal.removeEventListener("abort", onAbort);
                 resolve(signal.aborted
                     ? err(new AnalysisCancelledError(operation))

package/dist/application/binary/BinarySessionComposition.js

@@ -6,6 +6,4 @@ import { SessionProviderRouter } from "./SessionProviderRouter.js";
  * Compose one provider-neutral session from deep-provider selection and
  * disjoint auxiliary operation families.
  */
-export const composeBinarySession = (registry, auxiliaryProviders = []) => new BinarySession(registry instanceof SessionProviderRouter
-    ? registry
-    : SessionProviderRouter.selectable(registry, auxiliaryProviders), new InvestigationRecords());
+export const composeBinarySession = (registry, auxiliaryProviders = []) => new BinarySession(SessionProviderRouter.selectable(registry, auxiliaryProviders), new InvestigationRecords());

package/dist/application/binary/BinarySessionExecution.js

@@ -9,17 +9,15 @@ export const prepareSessionExecution = (input) => {
     const { active, operation, parameters, unboundOperationError, lookupSnapshot, } = input;
     if (active === undefined)
         return err(new NoBinaryOpenError());
-    const capability = active.route.capabilities?.get(operation);
-    if (active.route.capabilities !== undefined &&
-        capability?.available !== true) {
+    const capability = active.route.capabilities.get(operation);
+    if (capability?.available !== true) {
         const selectionError = unboundOperationError(operation, active.route);
         if (selectionError !== undefined)
             return err(selectionError);
         return err(new AnalysisCapabilityUnavailableError(active.route.binding?.identity.id ?? active.route.identity.id, operation, capability?.reason ?? "operation is not declared by this provider"));
     }
     const profile = active.profile !== null &&
-        (capability === undefined ||
-            capability.provider.id === active.profile.provider.id)
+        capability.provider.id === active.profile.provider.id
         ? active.profile
         : undefined;
     const cacheable = profile !== undefined &&

package/dist/application/binary/BinarySessionOpen.js

@@ -1,7 +1,7 @@
 import { snapshotMatchesBinding, snapshotMatchesTarget, snapshotTarget, } from "../../domain/analysisSnapshot.js";
 import { parseBinaryTarget } from "../BinaryTargetResolver.js";
-import {} from "../../domain/binaryTarget.js";
-import { EvidenceIntegrityError } from "../../domain/evidenceErrors.js";
+import {} from "../../domain/binaryTargetTypes.js";
+import { EvidenceIntegrityError, AnalysisSnapshotMismatchError, } from "../../domain/evidenceErrors.js";
 import {} from "../../domain/analysisErrorBase.js";
 import { err } from "../../domain/result.js";
 import { SessionProviderRouter } from "./SessionProviderRouter.js";
@@ -47,8 +47,8 @@ export const validateResolvedSessionTarget = (input) => {
 const validateSnapshot = ({ snapshot, target, profile, current, stagedSnapshotMatches, }) => {
     if (snapshot !== undefined &&
         (profile === null || !snapshotMatchesBinding(snapshot, target, profile)))
-        return new EvidenceIntegrityError("Analysis snapshot profile_mismatch: target, provider, or analysis profile does not match the requested binary");
+        return new AnalysisSnapshotMismatchError("Analysis snapshot profile_mismatch: target, provider, or analysis profile does not match the requested binary");
     if (current === undefined && !stagedSnapshotMatches(target, profile))
-        return new EvidenceIntegrityError("Analysis snapshot profile_mismatch: staged target, provider, or analysis profile does not match");
+        return new AnalysisSnapshotMismatchError("Analysis snapshot profile_mismatch: staged target, provider, or analysis profile does not match");
     return undefined;
 };

package/dist/application/binary/BinarySessionRecords.js

@@ -1,11 +1,12 @@
 import { evidenceBundleForTarget } from "../../domain/evidenceBundle.js";
-import { EvidenceIntegrityError } from "../../domain/evidenceErrors.js";
+import { EvidenceIntegrityError, AnalysisSnapshotMismatchError, } from "../../domain/evidenceErrors.js";
 import {} from "../../domain/analysisErrorBase.js";
 import {} from "../../domain/unknownRegistryError.js";
 import { err, ok } from "../../domain/result.js";
 import { AnalysisSnapshotCache } from "./AnalysisSnapshotCache.js";
 import { InvestigationRecords } from "../investigation/InvestigationRecords.js";
-/** Binary snapshot owner and compatibility facade for composed investigation records. */
+const SNAPSHOT_MUTATION_RECOVERY = "Export session observations through export_evidence_bundle if needed. Close the active target without saving a snapshot, then reopen it before importing or saving a snapshot.";
+/** Own binary snapshots and coordinate the composed investigation records. */
 export class BinarySessionRecords {
     #records;
     #snapshot = new AnalysisSnapshotCache();
@@ -31,9 +32,17 @@ export class BinarySessionRecords {
     evidenceById(evidenceId) {
         return this.#records.evidenceById(evidenceId);
     }
+    /** Borrow immutable investigation Evidence without copying a complete graph. */
+    evidenceForAnalysis(evidenceId) {
+        return this.#records.evidenceForAnalysis(evidenceId);
+    }
     exportEvidenceBundle() {
         return this.#records.exportEvidenceBundle();
     }
+    /** Borrow a sealed bundle for complete serialization without cloning retained graphs. */
+    evidenceBundleForSerialization() {
+        return this.#records.evidenceBundleForSerialization();
+    }
     importEvidenceBundle(bundle) {
         const imported = this.#records.mergeEvidenceBundle(bundle);
         if (!imported.ok)
@@ -47,7 +56,9 @@ export class BinarySessionRecords {
     exportAnalysisSnapshot() {
         const active = this.activeAnalysisBinding();
         if (this.#snapshotInvalidated)
-            return err(new EvidenceIntegrityError("Analysis snapshots are unavailable after analysis metadata mutations"));
+            return err(new EvidenceIntegrityError("Analysis snapshots are unavailable after analysis metadata mutations", {
+                userMessage: `Analysis snapshots are unavailable after analysis metadata mutations. ${SNAPSHOT_MUTATION_RECOVERY}`,
+            }));
         const target = active?.target;
         const profile = active?.profile ?? undefined;
         if (target !== undefined && profile === undefined)
@@ -58,8 +69,12 @@ export class BinarySessionRecords {
     }
     importAnalysisSnapshot(snapshot) {
         const active = this.activeAnalysisBinding();
+        if (active !== undefined && this.#snapshotInvalidated)
+            return err(new EvidenceIntegrityError("Analysis snapshots cannot be imported after analysis metadata mutations", {
+                userMessage: `Analysis snapshots cannot be imported after analysis metadata mutations. ${SNAPSHOT_MUTATION_RECOVERY}`,
+            }));
         if (active?.profile === null)
-            return err(new EvidenceIntegrityError("Analysis snapshot profile_mismatch: the active target has no concrete analysis profile"));
+            return err(new AnalysisSnapshotMismatchError("Analysis snapshot profile_mismatch: the active target has no concrete analysis profile"));
         const imported = this.#snapshot.import(snapshot, active === undefined
             ? undefined
             : { target: active.target, profile: active.profile }, (bundle) => {
@@ -78,9 +93,13 @@ export class BinarySessionRecords {
         this.#emitSnapshotChanged();
     }
     lookupSnapshot(target, profile, operation, parameters) {
+        if (this.#snapshotInvalidated)
+            return undefined;
         return this.#snapshot.lookup(target, profile, operation, parameters);
     }
     recordSnapshot(input) {
+        if (this.#snapshotInvalidated)
+            return;
         this.#snapshot.record(input);
         this.#emitSnapshotChanged();
     }
@@ -89,6 +108,8 @@ export class BinarySessionRecords {
         const active = this.activeAnalysisBinding();
         if (active === undefined || active.profile === null)
             return err(new EvidenceIntegrityError("Workflow snapshot entries require an active concrete provider profile"));
+        if (this.#snapshotInvalidated)
+            return ok(null);
         try {
             this.#snapshot.recordWorkflow({
                 target: active.target,
@@ -112,6 +133,7 @@ export class BinarySessionRecords {
     resetSnapshotInvalidation() {
         if (!this.#snapshotInvalidated)
             return;
+        this.#snapshot.clear();
         this.#snapshotInvalidated = false;
         this.#emitSnapshotChanged();
     }

package/dist/application/binary/BinarySessionStatus.js

@@ -1,9 +1,6 @@
 /** Project internal provider routing state into the caller-visible session status. */
-export const binarySessionStatus = ({ target, route, router, runtimeUnavailability, runId, runtimeLineageSnapshots, requestActivitySnapshots, }) => {
-    const configuredProvider = router.configuredIdentity();
-    const provider = providerSummary(configuredProvider);
-    const providers = router.providerIdentities(route).map(providerSummary);
-    const capabilities = [...(route.capabilities?.values() ?? [])]
+export const binarySessionStatus = ({ target, route, router, runtimeUnavailability, runId, runtimeLineageSnapshots, requestActivitySnapshots, providerOperationHealth, }) => {
+    const capabilities = [...route.capabilities.values()]
         .filter(({ operation }) => operation !== "inventory_artifact")
         .sort((left, right) => left.operation.localeCompare(right.operation))
         .map((descriptor) => {
@@ -38,8 +35,6 @@ export const binarySessionStatus = ({ target, route, router, runtimeUnavailabili
             .map(capabilityStatus),
     }));
     const common = {
-        provider,
-        providers,
         capabilities,
         analysis_provider_binding: analysisProviderBinding,
         analysis_provider_candidates: analysisProviderCandidates,
@@ -50,6 +45,7 @@ export const binarySessionStatus = ({ target, route, router, runtimeUnavailabili
                 process_lineage: processLineageStatus(runtimeLineageSnapshots),
             },
         analysis_activity: requestActivityStatus(requestActivitySnapshots),
+        provider_operation_health: providerOperationHealthStatus(providerOperationHealth),
     };
     return target === undefined
         ? { open: false, ...common }
@@ -137,3 +133,18 @@ const capabilityStatus = (descriptor) => ({
     },
     limitations: [...descriptor.limitations],
 });
+const providerOperationHealthStatus = (health) => {
+    if (health === undefined || health === null)
+        return null;
+    return {
+        state: health.state,
+        stage: health.stage,
+        retry_action: health.retryAction,
+        exit_code: health.exitCode,
+        requests: health.requests.map((request) => ({
+            request_id: request.requestId,
+            operation: request.operation,
+            stage: request.stage,
+        })),
+    };
+};