mirror of
https://github.com/morluto/rea.git
synced 2026-11-21 06:04:03 +00:00
* feat(cli): expose provider selection diagnostics in session status The registry now records how each deep provider became selected and why a candidate was rejected, but the session status projection dropped both fields. CLI providers/capabilities and MCP binary_session therefore showed a candidate list that could not explain an automatic or explicit choice, so users had to re-derive the reason from prose in selection errors. Project selection_source and rejections for every candidate. Complete detail keeps the rejection remediation and diagnostics; summary keeps the stable origin, code and reason and lists the dropped fields in omitted_fields. Existing candidate fields are unchanged, so both projections stay additive. * test(javascript): distinguish package scope in route fixtures * test(apple): separate identity and refusal fixture groups * fix(session): preserve binding source in refreshed candidates --------- Co-authored-by: 2SinceJuly <202121119+2SinceJuly@users.noreply.github.com> Co-authored-by: morluto <76467478+morluto@users.noreply.github.com>
1060 lines
33 KiB
TypeScript
1060 lines
33 KiB
TypeScript
import type { BinaryTarget } from "../../domain/binaryTargetTypes.js";
|
|
import { describe, expect, it } from "vitest";
|
|
|
|
import type {
|
|
CapabilityDescriptor,
|
|
ProviderIdentity,
|
|
} from "../AnalysisProvider.js";
|
|
import { z } from "zod";
|
|
import {
|
|
analysisProviderCandidate,
|
|
analysisProviderCandidateSummary,
|
|
expandProviderCapabilities,
|
|
expandToolAvailability,
|
|
sessionProviderFacts,
|
|
type ProviderCapabilitySet,
|
|
} from "../../contracts/toolOutputSchemaPrimitives.js";
|
|
import { compareUnicodeCodePoints } from "../../domain/unicodeCodePointOrder.js";
|
|
import type { AnalysisProviderCandidateStatus } from "./AnalysisProviderRegistry.js";
|
|
import type {
|
|
SessionProviderRoute,
|
|
SessionProviderRouter,
|
|
} from "./SessionProviderRouter.js";
|
|
import {
|
|
binarySessionStatus,
|
|
restrictAdvertisedCapabilities,
|
|
} from "./BinarySessionStatus.js";
|
|
import {
|
|
APPLE_DISPATCH_METADATA_ANALYSIS_PROFILE,
|
|
nativeMacOSCapabilities,
|
|
} from "../../native/NativeMacOSProviderMetadata.js";
|
|
import { NATIVE_MACOS_PROVIDER_IDENTITY } from "../../native/NativeMacosProviderIdentity.js";
|
|
import {
|
|
buildCapabilityInventory,
|
|
compactToolAvailability,
|
|
} from "../CapabilityInventory.js";
|
|
|
|
const projectedStatusSchema = z.object({
|
|
capabilities: sessionProviderFacts.shape.capabilities,
|
|
analysis_provider_candidates: z.array(analysisProviderCandidate),
|
|
});
|
|
const summaryStatusSchema = z.object({
|
|
capabilities: sessionProviderFacts.shape.capabilities,
|
|
analysis_provider_candidates: z.array(analysisProviderCandidateSummary),
|
|
});
|
|
|
|
const providerA: ProviderIdentity = {
|
|
id: "provider-a",
|
|
name: "Provider A",
|
|
version: "1.0",
|
|
};
|
|
const providerB: ProviderIdentity = {
|
|
id: "provider-b",
|
|
name: "Provider B",
|
|
version: "2.0",
|
|
};
|
|
|
|
const MUTATING_EFFECTS = {
|
|
mutates_artifact: true,
|
|
launches_process: false,
|
|
may_show_ui: false,
|
|
may_access_network: false,
|
|
may_write_filesystem: false,
|
|
changes_permissions: false,
|
|
requires_root: false,
|
|
};
|
|
|
|
type DescriptorOptions = {
|
|
readonly launchesProcess?: boolean;
|
|
} & (
|
|
| {
|
|
readonly available?: true;
|
|
readonly reason?: never;
|
|
readonly availabilityCode?: never;
|
|
}
|
|
| {
|
|
readonly available: false;
|
|
readonly reason?: string;
|
|
readonly availabilityCode?:
|
|
| "architecture_unsupported"
|
|
| "unsupported_host";
|
|
}
|
|
);
|
|
|
|
const descriptor = (
|
|
provider: ProviderIdentity,
|
|
operation: CapabilityDescriptor["operation"],
|
|
limitations: readonly string[],
|
|
options: DescriptorOptions = {},
|
|
): CapabilityDescriptor => {
|
|
const availability =
|
|
options.available === false
|
|
? {
|
|
available: false as const,
|
|
reason: options.reason ?? "Unavailable",
|
|
...(options.availabilityCode === undefined
|
|
? {}
|
|
: { availabilityCode: options.availabilityCode }),
|
|
}
|
|
: { available: true as const, reason: null };
|
|
return {
|
|
provider,
|
|
operation,
|
|
...availability,
|
|
effects: {
|
|
mutatesArtifact: true,
|
|
launchesProcess: options.launchesProcess ?? false,
|
|
mayShowUi: false,
|
|
mayAccessNetwork: false,
|
|
mayWriteFilesystem: false,
|
|
changesPermissions: false,
|
|
requiresRoot: false,
|
|
},
|
|
limitations,
|
|
};
|
|
};
|
|
|
|
const candidate = (
|
|
provider: ProviderIdentity,
|
|
capabilities: readonly CapabilityDescriptor[],
|
|
): AnalysisProviderCandidateStatus => ({
|
|
provider,
|
|
availability: {
|
|
status: "available",
|
|
code: null,
|
|
reason: null,
|
|
diagnostics: {},
|
|
},
|
|
targetSupport: {
|
|
status: "unknown",
|
|
code: null,
|
|
reason: "No target is open.",
|
|
diagnostics: {},
|
|
},
|
|
selected: true,
|
|
capabilities,
|
|
selectionSource: "auto-single-candidate",
|
|
rejections: [],
|
|
});
|
|
|
|
const project = async (
|
|
routeCapabilities: readonly CapabilityDescriptor[],
|
|
candidates: readonly AnalysisProviderCandidateStatus[],
|
|
runtimeUnavailability: ReadonlyMap<
|
|
string,
|
|
{ readonly reason: string }
|
|
> = new Map(),
|
|
target?: BinaryTarget,
|
|
) =>
|
|
projectedStatusSchema.parse(
|
|
await projectStatus(routeCapabilities, candidates, {
|
|
runtimeUnavailability,
|
|
...(target === undefined ? {} : { target }),
|
|
}),
|
|
);
|
|
|
|
const projectStatus = async (
|
|
routeCapabilities: readonly CapabilityDescriptor[],
|
|
candidates: readonly AnalysisProviderCandidateStatus[],
|
|
options: {
|
|
readonly runtimeUnavailability?: ReadonlyMap<
|
|
string,
|
|
{ readonly reason: string }
|
|
>;
|
|
readonly target?: BinaryTarget;
|
|
readonly detail?: "summary" | "complete";
|
|
} = {},
|
|
) => {
|
|
const route: SessionProviderRoute = {
|
|
identity: providerA,
|
|
profile: null,
|
|
selection: undefined,
|
|
createClient: () => {
|
|
throw new Error("Projection does not create clients");
|
|
},
|
|
capabilities: new Map(
|
|
routeCapabilities.map((capability) => [capability.operation, capability]),
|
|
),
|
|
binding: null,
|
|
};
|
|
const router: Pick<SessionProviderRouter, "candidateStatuses"> = {
|
|
candidateStatuses: async () => candidates,
|
|
};
|
|
return binarySessionStatus({
|
|
investigation: {
|
|
evidence_records: 0,
|
|
unknown_revisions: 0,
|
|
unknown_heads: 0,
|
|
retained_representation_bytes: 0,
|
|
maximum_representation_bytes: 0,
|
|
persistence: "memory",
|
|
},
|
|
target: options.target,
|
|
route,
|
|
router,
|
|
runtimeUnavailability: options.runtimeUnavailability ?? new Map(),
|
|
runId: undefined,
|
|
runtimeLineageSnapshots: [],
|
|
requestActivitySnapshots: [],
|
|
...(options.detail === undefined ? {} : { detail: options.detail }),
|
|
});
|
|
};
|
|
|
|
const expandCanonicalCapabilities = (sets: readonly ProviderCapabilitySet[]) =>
|
|
[...expandProviderCapabilities(sets)].sort((left, right) =>
|
|
compareUnicodeCodePoints(left.operation, right.operation),
|
|
);
|
|
|
|
const selectedCapabilities = [
|
|
descriptor(providerA, "xrefs", ["Shared limitation"]),
|
|
descriptor(providerA, "procedure_info", ["Shared limitation"]),
|
|
descriptor(providerA, "read_bytes", ["Shared limitation", "beta detail"]),
|
|
];
|
|
const otherCapabilities = [
|
|
descriptor(providerB, "read_bytes", ["Different limitation"], {
|
|
launchesProcess: true,
|
|
available: false,
|
|
reason: "Architecture unsupported",
|
|
availabilityCode: "architecture_unsupported",
|
|
}),
|
|
];
|
|
|
|
const expectedRouteCapabilities: ProviderCapabilitySet[] = [
|
|
{
|
|
provider: providerA,
|
|
shared_limitations: ["Shared limitation"],
|
|
groups: [
|
|
{
|
|
operations: ["procedure_info"],
|
|
effects: ["mutates_artifact"],
|
|
limitations: [],
|
|
available: false,
|
|
reason: "Runtime operation failure",
|
|
availability_code: null,
|
|
runtime_unavailable: true,
|
|
},
|
|
{
|
|
operations: ["read_bytes"],
|
|
effects: ["mutates_artifact"],
|
|
limitations: ["beta detail"],
|
|
available: true,
|
|
reason: null,
|
|
availability_code: null,
|
|
},
|
|
{
|
|
operations: ["xrefs"],
|
|
effects: ["mutates_artifact"],
|
|
limitations: [],
|
|
available: true,
|
|
reason: null,
|
|
availability_code: null,
|
|
},
|
|
],
|
|
},
|
|
];
|
|
const expectedExpandedRouteCapabilities = [
|
|
{
|
|
provider: providerA,
|
|
operation: "procedure_info",
|
|
available: false,
|
|
reason: "Runtime operation failure",
|
|
availability_code: null,
|
|
runtime_unavailable: true,
|
|
effects: MUTATING_EFFECTS,
|
|
limitations: ["Shared limitation"],
|
|
},
|
|
{
|
|
provider: providerA,
|
|
operation: "read_bytes",
|
|
available: true,
|
|
reason: null,
|
|
availability_code: null,
|
|
effects: MUTATING_EFFECTS,
|
|
limitations: ["Shared limitation", "beta detail"],
|
|
},
|
|
{
|
|
provider: providerA,
|
|
operation: "xrefs",
|
|
available: true,
|
|
reason: null,
|
|
availability_code: null,
|
|
effects: MUTATING_EFFECTS,
|
|
limitations: ["Shared limitation"],
|
|
},
|
|
];
|
|
const expectedCandidateCapabilities: ProviderCapabilitySet[] = [
|
|
{
|
|
provider: providerA,
|
|
shared_limitations: ["Shared limitation"],
|
|
groups: [
|
|
{
|
|
operations: ["procedure_info", "xrefs"],
|
|
effects: ["mutates_artifact"],
|
|
limitations: [],
|
|
available: true,
|
|
reason: null,
|
|
availability_code: null,
|
|
},
|
|
{
|
|
operations: ["read_bytes"],
|
|
effects: ["mutates_artifact"],
|
|
limitations: ["beta detail"],
|
|
available: true,
|
|
reason: null,
|
|
availability_code: null,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
provider: providerB,
|
|
shared_limitations: ["Different limitation"],
|
|
groups: [
|
|
{
|
|
operations: ["read_bytes"],
|
|
effects: ["mutates_artifact", "launches_process"],
|
|
limitations: [],
|
|
available: false,
|
|
reason: "Architecture unsupported",
|
|
availability_code: "architecture_unsupported",
|
|
},
|
|
],
|
|
},
|
|
];
|
|
const expectedCandidateStatusFacts = [
|
|
expect.objectContaining({
|
|
provider: providerA,
|
|
target_support: {
|
|
status: "unknown",
|
|
code: null,
|
|
reason: "No target is open.",
|
|
diagnostics: {},
|
|
},
|
|
capabilities: [expectedCandidateCapabilities[0]],
|
|
}),
|
|
expect.objectContaining({
|
|
provider: providerB,
|
|
capabilities: [expectedCandidateCapabilities[1]],
|
|
}),
|
|
];
|
|
const expectedExpandedCandidateCapabilities = [
|
|
[
|
|
{
|
|
provider: providerA,
|
|
operation: "procedure_info",
|
|
available: true,
|
|
reason: null,
|
|
availability_code: null,
|
|
effects: MUTATING_EFFECTS,
|
|
limitations: ["Shared limitation"],
|
|
},
|
|
{
|
|
provider: providerA,
|
|
operation: "read_bytes",
|
|
available: true,
|
|
reason: null,
|
|
availability_code: null,
|
|
effects: MUTATING_EFFECTS,
|
|
limitations: ["Shared limitation", "beta detail"],
|
|
},
|
|
{
|
|
provider: providerA,
|
|
operation: "xrefs",
|
|
available: true,
|
|
reason: null,
|
|
availability_code: null,
|
|
effects: MUTATING_EFFECTS,
|
|
limitations: ["Shared limitation"],
|
|
},
|
|
],
|
|
[
|
|
{
|
|
provider: providerB,
|
|
operation: "read_bytes",
|
|
available: false,
|
|
reason: "Architecture unsupported",
|
|
availability_code: "architecture_unsupported",
|
|
effects: { ...MUTATING_EFFECTS, launches_process: true },
|
|
limitations: ["Different limitation"],
|
|
},
|
|
],
|
|
];
|
|
|
|
describe("binary session provider capability projection", () => {
|
|
it("keeps the private dispatch reader profile out of public capability status", async () => {
|
|
const capabilities = nativeMacOSCapabilities("darwin");
|
|
const projected = await project(capabilities, [
|
|
candidate(NATIVE_MACOS_PROVIDER_IDENTITY, capabilities),
|
|
]);
|
|
const serialized = JSON.stringify(projected);
|
|
expect(serialized).not.toContain(
|
|
APPLE_DISPATCH_METADATA_ANALYSIS_PROFILE.provider.version,
|
|
);
|
|
expect(serialized).not.toContain(
|
|
APPLE_DISPATCH_METADATA_ANALYSIS_PROFILE.digest,
|
|
);
|
|
expect(projectedStatusSchema.parse(projected)).toEqual(projected);
|
|
});
|
|
|
|
it("preserves provider scope and route overlays while factoring exact prefixes", async () => {
|
|
const selectedBefore = structuredClone(selectedCapabilities);
|
|
const otherBefore = structuredClone(otherCapabilities);
|
|
const status = await project(
|
|
selectedCapabilities,
|
|
[
|
|
candidate(providerA, selectedCapabilities),
|
|
candidate(providerB, otherCapabilities),
|
|
],
|
|
new Map([["procedure_info", { reason: "Runtime operation failure" }]]),
|
|
);
|
|
expect(selectedCapabilities).toEqual(selectedBefore);
|
|
expect(otherCapabilities).toEqual(otherBefore);
|
|
expect(status.capabilities).toEqual(expectedRouteCapabilities);
|
|
expect(expandCanonicalCapabilities(status.capabilities)).toEqual(
|
|
expectedExpandedRouteCapabilities,
|
|
);
|
|
expect(status.analysis_provider_candidates).toEqual(
|
|
expectedCandidateStatusFacts,
|
|
);
|
|
const selectedCandidate = status.analysis_provider_candidates[0];
|
|
const otherCandidate = status.analysis_provider_candidates[1];
|
|
expect(selectedCandidate).toBeDefined();
|
|
expect(otherCandidate).toBeDefined();
|
|
expect(
|
|
expandCanonicalCapabilities(selectedCandidate?.capabilities ?? []),
|
|
).toEqual(expectedExpandedCandidateCapabilities[0]);
|
|
expect(
|
|
expandCanonicalCapabilities(otherCandidate?.capabilities ?? []),
|
|
).toEqual(expectedExpandedCandidateCapabilities[1]);
|
|
});
|
|
|
|
it("restricts the public report without erasing provider facts", async () => {
|
|
const status = await project(selectedCapabilities, [
|
|
candidate(providerA, selectedCapabilities),
|
|
candidate(providerB, otherCapabilities),
|
|
]);
|
|
const restricted = projectedStatusSchema.parse(
|
|
restrictAdvertisedCapabilities(
|
|
structuredClone(status),
|
|
(operation) => operation !== "read_bytes",
|
|
),
|
|
);
|
|
|
|
// The complete facts remain available for availability checks: a composed
|
|
// tool can depend on an operation the public report hides.
|
|
expect(
|
|
expandCanonicalCapabilities(status.capabilities).map(
|
|
({ operation }) => operation,
|
|
),
|
|
).toContain("read_bytes");
|
|
// A scoped registration hides these tools from `tools/list`, so naming
|
|
// them in the public report would direct the agent to a failing call.
|
|
expect(
|
|
expandCanonicalCapabilities(restricted.capabilities).map(
|
|
({ operation }) => operation,
|
|
),
|
|
).toEqual(["procedure_info", "xrefs"]);
|
|
expect(
|
|
expandCanonicalCapabilities(
|
|
restricted.analysis_provider_candidates[0]?.capabilities ?? [],
|
|
).map(({ operation }) => operation),
|
|
).toEqual(["procedure_info", "xrefs"]);
|
|
expect(restricted.analysis_provider_candidates[1]?.capabilities).toEqual(
|
|
[],
|
|
);
|
|
});
|
|
|
|
it("keeps empty route and candidate capability collections empty", async () => {
|
|
const status = await project([], [candidate(providerA, [])]);
|
|
expect(status.capabilities).toEqual([]);
|
|
expect(status.analysis_provider_candidates[0]?.capabilities).toEqual([]);
|
|
});
|
|
|
|
it("preserves repeated limitations in their original order", async () => {
|
|
const capabilities = [
|
|
descriptor(providerA, "procedure_info", [
|
|
"Repeated",
|
|
"Repeated",
|
|
"left detail",
|
|
]),
|
|
descriptor(providerA, "xrefs", ["Repeated", "Repeated", "right detail"]),
|
|
];
|
|
const status = await project(capabilities, []);
|
|
|
|
expect(status.capabilities[0]).toMatchObject({
|
|
shared_limitations: ["Repeated", "Repeated"],
|
|
groups: [
|
|
{ operations: ["procedure_info"], limitations: ["left detail"] },
|
|
{ operations: ["xrefs"], limitations: ["right detail"] },
|
|
],
|
|
});
|
|
expect(
|
|
expandCanonicalCapabilities(status.capabilities).map(
|
|
({ limitations }) => limitations,
|
|
),
|
|
).toEqual([
|
|
["Repeated", "Repeated", "left detail"],
|
|
["Repeated", "Repeated", "right detail"],
|
|
]);
|
|
});
|
|
});
|
|
|
|
it.each(["elf", "pe"] as const)(
|
|
"reports format rejection for %s dylib discovery",
|
|
async (format) => {
|
|
const target: BinaryTarget = {
|
|
kind: "executable",
|
|
format,
|
|
path: "/fixture",
|
|
sha256: "a".repeat(64),
|
|
architecture: "x86_64",
|
|
availableArchitectures: ["x86_64"],
|
|
...(format === "pe"
|
|
? { executableRole: "application" as const, managed: false }
|
|
: {}),
|
|
} as BinaryTarget;
|
|
const status = await project(
|
|
[descriptor(providerA, "trace_dylib_resolution", [])],
|
|
[],
|
|
new Map(),
|
|
target,
|
|
);
|
|
expect(expandCanonicalCapabilities(status.capabilities)).toMatchObject([
|
|
{
|
|
operation: "trace_dylib_resolution",
|
|
available: false,
|
|
availability_code: "target_format_unsupported",
|
|
},
|
|
]);
|
|
},
|
|
);
|
|
|
|
const dispatchTarget = (format: "elf" | "mach-o"): BinaryTarget => ({
|
|
kind: "executable",
|
|
format,
|
|
path: "/fixture",
|
|
sha256: "a".repeat(64),
|
|
architecture: "x86_64",
|
|
availableArchitectures: ["x86_64"],
|
|
});
|
|
|
|
it.each([
|
|
{ format: "elf", symbols: false, nativeAvailable: false, route: false },
|
|
{ format: "elf", symbols: true, nativeAvailable: false, route: true },
|
|
{ format: "mach-o", symbols: false, nativeAvailable: true, route: true },
|
|
] as const)(
|
|
"projects $format dispatch applicability and symbol fallback ($symbols)",
|
|
async ({ format, symbols, nativeAvailable, route }) => {
|
|
const target = dispatchTarget(format);
|
|
const native = nativeMacOSCapabilities("darwin").find(
|
|
(item) => item.operation === "inspect_native_dispatch_metadata",
|
|
);
|
|
if (native === undefined) throw new Error("Missing native dispatch reader");
|
|
const capabilities = [
|
|
native,
|
|
descriptor(providerA, "decode_interface_builder", []),
|
|
descriptor(providerA, "procedure_address", []),
|
|
descriptor(providerA, "procedure_callees", []),
|
|
...(symbols ? [descriptor(providerA, "list_names", [])] : []),
|
|
];
|
|
const status = await projectStatus(capabilities, [], { target });
|
|
const parsed = projectedStatusSchema.parse(status);
|
|
const projected = expandCanonicalCapabilities(parsed.capabilities).find(
|
|
(item) => item.operation === "inspect_native_dispatch_metadata",
|
|
);
|
|
expect(projected).toMatchObject({
|
|
available: nativeAvailable,
|
|
availability_code: nativeAvailable ? null : "target_format_unsupported",
|
|
});
|
|
const inventory = buildCapabilityInventory(status, {
|
|
processCaptureEnabled: false,
|
|
});
|
|
const dispatch = inventory.find(
|
|
(item) => item.name === "inspect_native_dispatch_metadata",
|
|
);
|
|
expect(dispatch?.available).toBe(route);
|
|
const trace = inventory.find(
|
|
(item) => item.name === "trace_native_ui_action",
|
|
);
|
|
expect(
|
|
trace?.modes?.find((mode) => mode.name === "native_seed_call_trace"),
|
|
).toMatchObject({
|
|
available: route,
|
|
missing_operations: route
|
|
? []
|
|
: ["inspect_native_dispatch_metadata", "list_names"],
|
|
});
|
|
if (!route) {
|
|
expect(trace?.remediation).toMatch(
|
|
/no mode.*inspect each mode.*missing operations and remediation/iu,
|
|
);
|
|
const authored = trace?.modes?.find(
|
|
(mode) => mode.name === "authored_ui_dispatch",
|
|
);
|
|
const nativeSeed = trace?.modes?.find(
|
|
(mode) => mode.name === "native_seed_call_trace",
|
|
);
|
|
expect(authored?.remediation).not.toBe(nativeSeed?.remediation);
|
|
expect(authored?.missing_operations).toContain(
|
|
"decode_interface_builder",
|
|
);
|
|
}
|
|
},
|
|
);
|
|
|
|
it("does not impose the Apple reader's target rule on another provider", async () => {
|
|
const target = dispatchTarget("elf");
|
|
const status = await projectStatus(
|
|
[descriptor(providerA, "inspect_native_dispatch_metadata", [])],
|
|
[],
|
|
{ target },
|
|
);
|
|
const projected = expandCanonicalCapabilities(
|
|
projectedStatusSchema.parse(status).capabilities,
|
|
);
|
|
expect(projected).toMatchObject([
|
|
{ operation: "inspect_native_dispatch_metadata", available: true },
|
|
]);
|
|
const inventory = buildCapabilityInventory(status, {
|
|
processCaptureEnabled: false,
|
|
});
|
|
expect(
|
|
inventory.find((item) => item.name === "inspect_native_dispatch_metadata"),
|
|
).toMatchObject({ available: true });
|
|
});
|
|
|
|
it("keeps distinct recovery for an unbound non-bundle session", async () => {
|
|
const native = nativeMacOSCapabilities("darwin").find(
|
|
(item) => item.operation === "inspect_native_dispatch_metadata",
|
|
);
|
|
if (native === undefined) throw new Error("Missing native dispatch reader");
|
|
const status = await projectStatus(
|
|
[native, descriptor(providerA, "decode_interface_builder", [])],
|
|
[],
|
|
{ target: dispatchTarget("mach-o") },
|
|
);
|
|
const inventory = buildCapabilityInventory(status, {
|
|
processCaptureEnabled: false,
|
|
});
|
|
const trace = inventory.find(
|
|
(item) => item.name === "trace_native_ui_action",
|
|
);
|
|
expect(trace).toMatchObject({
|
|
available: false,
|
|
reason: "provider_unavailable",
|
|
remediation: expect.stringMatching(
|
|
/no mode.*inspect each mode.*missing operations and remediation/iu,
|
|
),
|
|
});
|
|
const authored = trace?.modes?.find(
|
|
(mode) => mode.name === "authored_ui_dispatch",
|
|
);
|
|
const nativeSeed = trace?.modes?.find(
|
|
(mode) => mode.name === "native_seed_call_trace",
|
|
);
|
|
expect(authored?.missing_operations).toContain("decode_interface_builder");
|
|
expect(nativeSeed?.missing_operations).toContain("procedure_address");
|
|
expect(authored?.remediation).not.toBe(nativeSeed?.remediation);
|
|
});
|
|
|
|
it("keeps host unavailability ahead of target applicability", async () => {
|
|
const native = nativeMacOSCapabilities("linux").find(
|
|
(item) => item.operation === "inspect_native_dispatch_metadata",
|
|
);
|
|
if (native === undefined) throw new Error("Missing native dispatch reader");
|
|
const target = dispatchTarget("elf");
|
|
const projected = await project([native], [], new Map(), target);
|
|
expect(expandCanonicalCapabilities(projected.capabilities)).toMatchObject([
|
|
{
|
|
operation: "inspect_native_dispatch_metadata",
|
|
available: false,
|
|
availability_code: "unsupported_host",
|
|
},
|
|
]);
|
|
});
|
|
|
|
/** A rejected candidate whose diagnostic text must not reach the summary. */
|
|
const unavailableReport = {
|
|
provider: providerB,
|
|
status: {
|
|
code: "not_configured" as const,
|
|
reason: "PROVIDER_B_HOME is not set.",
|
|
remediation: "Set PROVIDER_B_HOME; see docs/provider-b.md.",
|
|
},
|
|
support: {
|
|
code: "architecture_unsupported" as const,
|
|
reason: "Provider B cannot select this slice.",
|
|
},
|
|
};
|
|
const rejectedCandidate = (
|
|
report: typeof unavailableReport,
|
|
): AnalysisProviderCandidateStatus => ({
|
|
...candidate(providerB, otherCapabilities),
|
|
availability: {
|
|
status: "unavailable",
|
|
code: report.status.code,
|
|
reason: report.status.reason,
|
|
remediation: report.status.remediation,
|
|
diagnostics: { checks: [{ name: "configuration", ok: false }] },
|
|
},
|
|
targetSupport: {
|
|
status: "unsupported",
|
|
code: report.support.code,
|
|
reason: report.support.reason,
|
|
diagnostics: { architecture: "arm64" },
|
|
},
|
|
selected: false,
|
|
selectionSource: null,
|
|
rejections: [
|
|
{
|
|
providerId: providerB.id,
|
|
origin: "availability",
|
|
code: report.status.code,
|
|
reason: report.status.reason,
|
|
remediation: report.status.remediation,
|
|
diagnostics: { checks: [{ name: "configuration", ok: false }] },
|
|
},
|
|
{
|
|
providerId: providerB.id,
|
|
origin: "target",
|
|
code: report.support.code,
|
|
reason: report.support.reason,
|
|
diagnostics: { architecture: "arm64" },
|
|
},
|
|
],
|
|
});
|
|
|
|
describe("binary session summary projection", () => {
|
|
it("keeps each candidate's status, code and reason in summary without diagnostics or capability sets", async () => {
|
|
const pending: AnalysisProviderCandidateStatus = {
|
|
...candidate(providerA, selectedCapabilities),
|
|
availability: {
|
|
status: "unknown",
|
|
code: null,
|
|
reason: "Provider A startup is still pending.",
|
|
diagnostics: { startup: "pending" },
|
|
},
|
|
};
|
|
const candidates = [pending, rejectedCandidate(unavailableReport)];
|
|
const before = structuredClone(candidates);
|
|
const runtimeUnavailability = new Map([
|
|
["procedure_info", { reason: "Runtime operation failure" }],
|
|
]);
|
|
const complete = projectedStatusSchema.parse(
|
|
await projectStatus(selectedCapabilities, candidates, {
|
|
runtimeUnavailability,
|
|
}),
|
|
);
|
|
const raw = await projectStatus(selectedCapabilities, candidates, {
|
|
runtimeUnavailability,
|
|
detail: "summary",
|
|
});
|
|
const summary = summaryStatusSchema.parse(raw);
|
|
const { status, support } = unavailableReport;
|
|
|
|
expect(candidates).toEqual(before);
|
|
expect(summary.capabilities).toEqual(complete.capabilities);
|
|
expect(summary.analysis_provider_candidates).toEqual([
|
|
{
|
|
provider: providerA,
|
|
availability: {
|
|
status: "unknown",
|
|
code: null,
|
|
reason: "Provider A startup is still pending.",
|
|
},
|
|
target_support: {
|
|
status: "unknown",
|
|
code: null,
|
|
reason: "No target is open.",
|
|
},
|
|
selected: true,
|
|
selection_source: "auto-single-candidate",
|
|
rejections: [],
|
|
},
|
|
{
|
|
provider: providerB,
|
|
availability: {
|
|
status: "unavailable",
|
|
code: status.code,
|
|
reason: status.reason,
|
|
},
|
|
target_support: {
|
|
status: "unsupported",
|
|
code: support.code,
|
|
reason: support.reason,
|
|
},
|
|
selected: false,
|
|
selection_source: null,
|
|
rejections: [
|
|
{
|
|
provider_id: providerB.id,
|
|
origin: "availability",
|
|
code: status.code,
|
|
reason: status.reason,
|
|
},
|
|
{
|
|
provider_id: providerB.id,
|
|
origin: "target",
|
|
code: support.code,
|
|
reason: support.reason,
|
|
},
|
|
],
|
|
},
|
|
]);
|
|
expect(JSON.stringify(raw)).not.toContain("diagnostics");
|
|
// Complete detail keeps the owner's repair copy on each rejection.
|
|
expect(complete.analysis_provider_candidates[1]?.rejections).toEqual([
|
|
{
|
|
provider_id: providerB.id,
|
|
origin: "availability",
|
|
code: status.code,
|
|
reason: status.reason,
|
|
remediation: status.remediation,
|
|
diagnostics: { checks: [{ name: "configuration", ok: false }] },
|
|
},
|
|
{
|
|
provider_id: providerB.id,
|
|
origin: "target",
|
|
code: support.code,
|
|
reason: support.reason,
|
|
diagnostics: { architecture: "arm64" },
|
|
},
|
|
]);
|
|
// Complete detail keeps the owner's repair; summary omits it.
|
|
expect(
|
|
complete.analysis_provider_candidates[1]?.availability,
|
|
).toMatchObject({ remediation: status.remediation });
|
|
expect(JSON.stringify(raw)).not.toContain("PROVIDER_B_HOME;");
|
|
// Summary keeps every rejection code and reason but never its repair text.
|
|
expect(
|
|
summary.analysis_provider_candidates[1]?.rejections.map(
|
|
({ origin, code, reason }) => ({ origin, code, reason }),
|
|
),
|
|
).toEqual([
|
|
{ origin: "availability", code: status.code, reason: status.reason },
|
|
{ origin: "target", code: support.code, reason: support.reason },
|
|
]);
|
|
expect(
|
|
analysisProviderCandidate
|
|
.array()
|
|
.safeParse(summary.analysis_provider_candidates).success,
|
|
).toBe(false);
|
|
});
|
|
});
|
|
|
|
it("narrows summary capabilities without inventing omitted candidate facts", async () => {
|
|
const source = await projectStatus(
|
|
selectedCapabilities,
|
|
[candidate(providerA, selectedCapabilities)],
|
|
{ detail: "summary" },
|
|
);
|
|
const summary = summaryStatusSchema.parse(source);
|
|
const selected = summaryStatusSchema.parse(
|
|
restrictAdvertisedCapabilities(
|
|
source,
|
|
(operation) => operation === "read_bytes",
|
|
),
|
|
);
|
|
expect(
|
|
expandCanonicalCapabilities(selected.capabilities).map(
|
|
({ operation }) => operation,
|
|
),
|
|
).toEqual(["read_bytes"]);
|
|
expect(selected.analysis_provider_candidates).toEqual(
|
|
summary.analysis_provider_candidates,
|
|
);
|
|
expect(selected.analysis_provider_candidates[0]).not.toHaveProperty(
|
|
"capabilities",
|
|
);
|
|
expect(selected.analysis_provider_candidates[0]!.target_support).toEqual({
|
|
status: "unknown",
|
|
code: null,
|
|
reason: "No target is open.",
|
|
});
|
|
});
|
|
|
|
it("groups readiness repairs exactly and drops one replaced by a runtime observation", async () => {
|
|
const unavailable = (
|
|
operation: CapabilityDescriptor["operation"],
|
|
remediation: string,
|
|
): CapabilityDescriptor => {
|
|
const declared = descriptor(providerA, operation, [], {
|
|
available: false,
|
|
reason: "Configured registration is invalid.",
|
|
});
|
|
if (declared.available) throw new Error("Expected an unavailable fixture");
|
|
return { ...declared, remediation };
|
|
};
|
|
const status = await project(
|
|
[
|
|
unavailable("procedure_info", "Correct REA_FIXTURE_CONFIG."),
|
|
unavailable("read_bytes", "Correct REA_FIXTURE_CONFIG."),
|
|
unavailable("list_names", "Unset REA_FIXTURE_CACHE."),
|
|
unavailable("xrefs", "Correct REA_FIXTURE_CONFIG."),
|
|
],
|
|
[],
|
|
new Map([["xrefs", { reason: "Runtime operation failure" }]]),
|
|
);
|
|
const groups = status.capabilities.flatMap(({ groups }) => groups);
|
|
expect(groups).toEqual([
|
|
expect.objectContaining({
|
|
operations: ["list_names"],
|
|
remediation: "Unset REA_FIXTURE_CACHE.",
|
|
}),
|
|
expect.objectContaining({
|
|
operations: ["procedure_info", "read_bytes"],
|
|
reason: "Configured registration is invalid.",
|
|
remediation: "Correct REA_FIXTURE_CONFIG.",
|
|
}),
|
|
expect.not.objectContaining({ remediation: expect.anything() }),
|
|
]);
|
|
expect(groups[2]).toMatchObject({
|
|
operations: ["xrefs"],
|
|
reason: "Runtime operation failure",
|
|
});
|
|
const inventory = new Map(
|
|
buildCapabilityInventory(
|
|
{ open: true, kind: "executable", capabilities: status.capabilities },
|
|
{ processCaptureEnabled: true },
|
|
).map((entry) => [entry.name, entry]),
|
|
);
|
|
expect(inventory.get("procedure_info")?.remediation).toBe(
|
|
"Correct REA_FIXTURE_CONFIG.",
|
|
);
|
|
// A static or runtime-only refusal has no separate repair to prefer.
|
|
expect(inventory.get("xrefs")?.remediation).toBe("Runtime operation failure");
|
|
// A scoped registration narrows operations without dropping their repair.
|
|
const scoped = projectedStatusSchema.parse(
|
|
restrictAdvertisedCapabilities(
|
|
status,
|
|
(operation) => operation === "procedure_info",
|
|
),
|
|
);
|
|
expect(scoped.capabilities.flatMap(({ groups }) => groups)).toEqual([
|
|
expect.objectContaining({
|
|
operations: ["procedure_info"],
|
|
remediation: "Correct REA_FIXTURE_CONFIG.",
|
|
}),
|
|
]);
|
|
});
|
|
|
|
it("keeps independent decompilation and value flow in distinct capability groups", async () => {
|
|
const status = await projectStatus(
|
|
[
|
|
{
|
|
...descriptor(providerA, "procedure_pseudo_code", []),
|
|
independentDecompile: true,
|
|
},
|
|
{
|
|
...descriptor(providerA, "analyze_function", []),
|
|
nativeValueFlow: { status: "supported" as const },
|
|
},
|
|
descriptor(providerA, "xrefs", []),
|
|
],
|
|
[],
|
|
);
|
|
const projected = z
|
|
.object({ capabilities: sessionProviderFacts.shape.capabilities })
|
|
.parse(status);
|
|
const capabilities = expandProviderCapabilities(projected.capabilities);
|
|
expect(
|
|
capabilities.find((item) => item.operation === "procedure_pseudo_code"),
|
|
).toMatchObject({ independent_decompile: true });
|
|
expect(
|
|
capabilities.find((item) => item.operation === "analyze_function"),
|
|
).toMatchObject({ native_value_flow: { status: "supported" } });
|
|
expect(
|
|
capabilities.find((item) => item.operation === "xrefs"),
|
|
).not.toHaveProperty("independent_decompile");
|
|
expect(
|
|
capabilities.find((item) => item.operation === "xrefs"),
|
|
).not.toHaveProperty("native_value_flow");
|
|
});
|
|
|
|
it.each([
|
|
{ detail: "summary", supported: true },
|
|
{ detail: "complete", supported: true },
|
|
{ detail: "summary", supported: false },
|
|
{ detail: "complete", supported: false },
|
|
] as const)(
|
|
"retains routed value-flow ownership and runtime failures in $detail discovery when supported=$supported",
|
|
async ({ detail, supported }) => {
|
|
const source = {
|
|
...descriptor(providerA, "analyze_function", []),
|
|
nativeValueFlow: supported
|
|
? { status: "supported" as const }
|
|
: { status: "unavailable" as const, reason: "No value flow." },
|
|
};
|
|
const resolver = descriptor(providerB, "resolve_native_call_targets", []);
|
|
const providerC = { id: "provider-c", name: "Provider C", version: "3" };
|
|
const unselected = {
|
|
...descriptor(providerC, "analyze_function", []),
|
|
nativeValueFlow: { status: "unavailable" as const, reason: "Unselected" },
|
|
};
|
|
const status = await projectStatus(
|
|
[source, resolver],
|
|
[{ ...candidate(providerC, [unselected]), selected: false }],
|
|
{
|
|
target: dispatchTarget("elf"),
|
|
detail,
|
|
runtimeUnavailability: new Map([
|
|
["resolve_native_call_targets", { reason: "Resolver failed." }],
|
|
]),
|
|
},
|
|
);
|
|
const projected = z
|
|
.object({ capabilities: sessionProviderFacts.shape.capabilities })
|
|
.parse(status);
|
|
const route = expandProviderCapabilities(projected.capabilities);
|
|
expect(
|
|
route.find((item) => item.operation === "analyze_function"),
|
|
).toMatchObject({
|
|
provider: providerA,
|
|
native_value_flow: { status: supported ? "supported" : "unavailable" },
|
|
});
|
|
const inventory = buildCapabilityInventory(status, {
|
|
processCaptureEnabled: false,
|
|
});
|
|
const item = expandToolAvailability(
|
|
compactToolAvailability(inventory, detail),
|
|
).find((candidate) => candidate.name === "trace_native_values");
|
|
expect(item).toMatchObject({
|
|
available: false,
|
|
reason: "provider_unavailable",
|
|
remediation: expect.stringContaining("Resolver failed."),
|
|
value_flow_support: {
|
|
status: supported ? "supported" : "unavailable",
|
|
provider_id: providerA.id,
|
|
},
|
|
});
|
|
if (!supported) expect(item?.remediation).toContain("No value flow.");
|
|
},
|
|
);
|
|
|
|
it("preserves an unsupported resolver host alongside unavailable value flow", async () => {
|
|
const source = {
|
|
...descriptor(providerA, "analyze_function", []),
|
|
nativeValueFlow: {
|
|
status: "unavailable" as const,
|
|
reason: "No value flow.",
|
|
},
|
|
};
|
|
const resolver = {
|
|
...descriptor(providerB, "resolve_native_call_targets", [], {
|
|
available: false,
|
|
reason: "Resolver host is unsupported.",
|
|
availabilityCode: "unsupported_host",
|
|
}),
|
|
remediation: "Use a supported resolver host.",
|
|
};
|
|
const status = await projectStatus([source, resolver], [], {
|
|
target: dispatchTarget("elf"),
|
|
detail: "summary",
|
|
});
|
|
const item = buildCapabilityInventory(status, {
|
|
processCaptureEnabled: false,
|
|
}).find((entry) => entry.name === "trace_native_values");
|
|
expect(item).toMatchObject({ available: false, reason: "unsupported_host" });
|
|
expect(item?.remediation).toContain("No value flow.");
|
|
expect(item?.remediation).toContain("Use a supported resolver host.");
|
|
});
|