rea-agents 1.5.0 → 1.7.0

package/dist/application/BinarySession.js

@@ -1,5 +1,6 @@
 import { parseBinaryTarget } from "../domain/binaryTarget.js";
-import { AnalysisCapabilityUnavailableError, EvidenceIntegrityError, EvidenceLimitError, AnalysisCancelledError, NoBinaryOpenError, } from "../domain/errors.js";
+import { analysisProfilesEqual, } from "../domain/analysisProfile.js";
+import { AnalysisCapabilityUnavailableError, EvidenceIntegrityError, EvidenceLimitError, AnalysisCancelledError, NoBinaryOpenError, ProviderAdapterError, } from "../domain/errors.js";
 import { err, ok } from "../domain/result.js";
 import { createEvidence } from "../domain/evidence.js";
 import { evidenceBundleForTarget } from "../domain/evidenceBundle.js";
@@ -7,27 +8,25 @@ import { EvidenceLedger } from "./EvidenceLedger.js";
 import { UnknownRegistryError } from "../domain/errors.js";
 import { enhancedToolNameSchema } from "../contracts/enhancedInputs.js";
 import { OFFICIAL_TOOL_CONTRACTS } from "../contracts/toolContracts.js";
-import { snapshotMatchesTarget } from "../domain/analysisSnapshot.js";
+import { snapshotMatchesBinding, snapshotMatchesTarget, snapshotTarget, } from "../domain/analysisSnapshot.js";
 import { AnalysisSnapshotCache, isSnapshotCacheable, } from "./AnalysisSnapshotCache.js";
 import { UNKNOWN_REGISTRY_PROVIDER, unknownEvidenceLinks, unknownMutationEvidence, } from "./UnknownEvidence.js";
 import { parseInvestigationWorkspace, } from "../domain/investigationWorkspace.js";
+import { SessionProviderRouter, } from "./SessionProviderRouter.js";
 const OFFICIAL_OPERATIONS = new Set(OFFICIAL_TOOL_CONTRACTS.map(({ name }) => name));
 /**
  * Owns the single active target shared by CLI and MCP adapters.
  *
- * Target transitions are serialized because each client dispatches Hopper API
- * work on its dedicated Python thread, and switching targets tears that bridge
- * down. A failed switch recreates the previous target instead of retaining a
- * client whose bridge was already shut down.
+ * Target transitions are serialized because switching targets tears down the
+ * active provider client. A failed switch recreates the previous target instead
+ * of retaining a client whose resources were already shut down.
  */
 export class BinarySession {
     provider;
     #active;
     #transition = Promise.resolve();
     #calls = new Set();
-    #createClient;
-    #providerIdentity;
-    #capabilities;
+    #providerRouter;
     #evidence = new EvidenceLedger({
         maxRecords: 10_000,
         maxBytes: 64 * 1024 * 1024,
@@ -36,46 +35,55 @@ export class BinarySession {
     #investigationWorkspaces = new Map();
     #runtimeAvailability = new Map();
     #availabilityListeners = new Set();
-    #snapshotsEnabled;
     #snapshotInvalidated = false;
     constructor(provider, options = {}) {
         this.provider = provider;
-        this.#snapshotsEnabled = options.snapshotsEnabled ?? true;
-        this.#createClient =
-            typeof provider === "function"
+        this.#providerRouter =
+            provider instanceof SessionProviderRouter
                 ? provider
-                : (target) => provider.createClient(target);
-        this.#providerIdentity =
-            typeof provider === "function"
-                ? { id: "unidentified", name: "Unidentified provider", version: null }
-                : provider.identity();
-        this.#capabilities =
-            typeof provider === "function"
-                ? undefined
-                : new Map(provider
-                    .capabilities()
-                    .map((descriptor) => [descriptor.operation, descriptor]));
+                : SessionProviderRouter.legacy(provider, options);
     }
     /** Identify the provider producing evidence for this session. */
     providerIdentity(operation) {
+        const route = this.#currentRoute();
+        let selected = route.identity;
         if (operation !== undefined) {
-            const exact = this.#capabilities?.get(operation)?.provider;
+            const exact = route.capabilities?.get(operation)?.provider;
             if (exact !== undefined)
-                return structuredClone(exact);
-            if (enhancedToolNameSchema.safeParse(operation).success) {
+                selected = exact;
+            else if (enhancedToolNameSchema.safeParse(operation).success) {
                 const providers = new Map();
-                for (const descriptor of this.#capabilities?.values() ?? [])
+                for (const descriptor of route.capabilities?.values() ?? [])
                     if (descriptor.available &&
                         OFFICIAL_OPERATIONS.has(descriptor.operation))
                         providers.set(descriptor.provider.id, descriptor.provider);
                 if (providers.size === 1) {
                     const provider = providers.values().next().value;
                     if (provider !== undefined)
-                        return structuredClone(provider);
+                        selected = provider;
                 }
             }
         }
-        return structuredClone(this.#providerIdentity);
+        const profile = this.#active?.profile;
+        return structuredClone(profile !== null &&
+            profile !== undefined &&
+            profile.provider.id === selected.id
+            ? profile.provider
+            : selected);
+    }
+    /** Return the selected immutable profile, optionally scoped to an operation. */
+    analysisProfile(operation) {
+        const profile = this.#active?.profile;
+        if (profile === null || profile === undefined)
+            return undefined;
+        if (operation !== undefined &&
+            this.providerIdentity(operation).id !== profile.provider.id)
+            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) {
@@ -104,20 +112,24 @@ export class BinarySession {
     }
     /** Export immutable cached calls and session evidence for the active target. */
     exportAnalysisSnapshot() {
-        if (!this.#snapshotsEnabled)
-            return err(new EvidenceIntegrityError("Analysis snapshots are unavailable with custom Hopper loader arguments"));
         if (this.#snapshotInvalidated)
             return err(new EvidenceIntegrityError("Analysis snapshots are unavailable after analysis metadata mutations"));
         const target = this.#active?.target;
-        return this.#snapshot.export(target, target === undefined
+        const profile = this.#active?.profile ?? undefined;
+        if (target !== undefined && profile === undefined)
+            return err(new EvidenceIntegrityError("Analysis snapshots require a concrete provider analysis profile"));
+        return this.#snapshot.export(target, profile, target === undefined
             ? this.#evidence.export()
             : evidenceBundleForTarget(this.#evidence.export(), target.sha256));
     }
     /** Stage validated cached calls for an identical binary and merge its evidence. */
     importAnalysisSnapshot(snapshot) {
-        if (!this.#snapshotsEnabled)
-            return err(new EvidenceIntegrityError("Analysis snapshots are unavailable with custom Hopper loader arguments"));
-        return this.#snapshot.import(snapshot, this.#active?.target, (bundle) => this.#evidence.import(bundle));
+        const active = this.#active;
+        if (active?.profile === null)
+            return err(new EvidenceIntegrityError("Analysis snapshot profile_mismatch: the active target has no concrete analysis profile"));
+        return this.#snapshot.import(snapshot, active === undefined
+            ? undefined
+            : { target: active.target, profile: active.profile }, (bundle) => this.#evidence.import(bundle));
     }
     /** Retain one validated immutable workspace revision for session resources. */
     retainInvestigationWorkspace(workspace) {
@@ -187,14 +199,31 @@ export class BinarySession {
             const parsed = await parseBinaryTarget(path, process.cwd(), process.arch, options.targetKind);
             if (!parsed.ok)
                 return parsed;
+            const sameTarget = this.#active?.target.path === parsed.value.path &&
+                snapshotMatchesTarget(snapshotTarget(this.#active.target), parsed.value);
+            const resolvedRoute = sameTarget &&
+                options.providerId === undefined &&
+                this.#active !== undefined
+                ? ok(this.#active.route)
+                : await this.#providerRouter.resolve(parsed.value, options.providerId, options.signal);
+            if (!resolvedRoute.ok)
+                return resolvedRoute;
+            const route = resolvedRoute.value;
+            const { profile, compatibility } = route;
             if (options.snapshot !== undefined &&
-                !snapshotMatchesTarget(options.snapshot.target, parsed.value))
-                return err(new EvidenceIntegrityError("Analysis snapshot target does not match the requested binary"));
-            if (this.#active === undefined && !this.#snapshot.matches(parsed.value))
-                return err(new EvidenceIntegrityError("Analysis snapshot target does not match the requested binary"));
+                (profile === null ||
+                    !snapshotMatchesBinding(options.snapshot, parsed.value, profile)))
+                return err(new EvidenceIntegrityError("Analysis snapshot profile_mismatch: target, provider, or analysis profile does not match the requested binary"));
+            if (this.#active === undefined &&
+                !this.#snapshot.matches(parsed.value, profile ?? undefined))
+                return err(new EvidenceIntegrityError("Analysis snapshot profile_mismatch: staged target, provider, or analysis profile does not match"));
             if (isAborted(options.signal))
                 return err(new AnalysisCancelledError("open_binary"));
-            if (this.#active?.target.path === parsed.value.path) {
+            const activeProfile = this.#active?.profile;
+            const sameProfile = activeProfile === null || activeProfile === undefined
+                ? profile === null
+                : profile !== null && analysisProfilesEqual(activeProfile, profile);
+            if (sameTarget && sameProfile) {
                 if (options.snapshot !== undefined) {
                     const imported = this.importAnalysisSnapshot(options.snapshot);
                     if (!imported.ok)
@@ -206,7 +235,7 @@ export class BinarySession {
             const previous = this.#active;
             this.#active = undefined;
             await previous?.client.close();
-            const client = this.#createClient(parsed.value);
+            const client = route.createClient(parsed.value);
             const started = await client.execute("health", {}, options);
             if (!started.ok) {
                 await client.close();
@@ -218,9 +247,18 @@ export class BinarySession {
                 await this.#restore(previous);
                 return err(new AnalysisCancelledError("open_binary"));
             }
-            this.#active = { target: parsed.value, client };
+            this.#active = {
+                target: parsed.value,
+                client,
+                profile,
+                compatibility: structuredClone(compatibility),
+                route,
+            };
             this.#clearRuntimeAvailability();
-            this.#snapshot.select(parsed.value);
+            if (profile === null)
+                this.#snapshot.clear();
+            else
+                this.#snapshot.select(parsed.value, profile);
             if (options.snapshot !== undefined) {
                 const imported = this.importAnalysisSnapshot(options.snapshot);
                 if (!imported.ok) {
@@ -251,59 +289,74 @@ export class BinarySession {
     /** Describe the active binary session. */
     status() {
         const target = this.#active?.target;
+        const route = this.#currentRoute();
+        const configuredProvider = this.#providerRouter.configuredIdentity();
         const provider = {
-            id: this.#providerIdentity.id,
-            name: this.#providerIdentity.name,
-            version: this.#providerIdentity.version,
+            id: configuredProvider.id,
+            name: configuredProvider.name,
+            version: configuredProvider.version,
         };
-        const providers = new Map();
-        if (this.#capabilities === undefined)
-            providers.set(provider.id, provider);
-        else
-            for (const descriptor of this.#capabilities.values())
-                providers.set(descriptor.provider.id, descriptor.provider);
-        const providerList = [...providers.values()]
-            .sort((left, right) => left.id.localeCompare(right.id))
+        const providerList = this.#providerRouter
+            .providerIdentities(route)
             .map(({ id, name, version }) => ({ id, name, version }));
-        const capabilities = this.#capabilities === undefined
+        const capabilities = route.capabilities === undefined
             ? []
-            : [...this.#capabilities.values()]
+            : [...route.capabilities.values()]
                 .sort((left, right) => left.operation.localeCompare(right.operation))
                 .map((descriptor) => ({
                 ...descriptor,
                 ...this.#runtimeAvailability.get(descriptor.operation),
             }))
-                .map((descriptor) => ({
-                operation: descriptor.operation,
-                available: descriptor.available,
-                reason: descriptor.reason,
-                input_contract_version: descriptor.inputContractVersion,
-                output_contract_version: descriptor.outputContractVersion,
-                pagination: descriptor.pagination,
-                exhaustive: descriptor.exhaustive,
-                effects: {
-                    mutates_artifact: descriptor.effects.mutatesArtifact,
-                    launches_process: descriptor.effects.launchesProcess,
-                    may_show_ui: descriptor.effects.mayShowUi,
-                    may_access_network: descriptor.effects.mayAccessNetwork,
-                    may_write_filesystem: descriptor.effects.mayWriteFilesystem,
-                    changes_permissions: descriptor.effects.changesPermissions,
-                    requires_root: descriptor.effects.requiresRoot,
-                },
-                limits: {
-                    max_results: descriptor.limits.maxResults,
-                    max_payload_bytes: descriptor.limits.maxPayloadBytes,
-                    timeout_ms: descriptor.limits.timeoutMs,
+                .map((descriptor) => capabilityStatus(descriptor));
+        const analysisProviderBinding = route.binding === null
+            ? null
+            : {
+                provider: {
+                    id: route.binding.identity.id,
+                    name: route.binding.identity.name,
+                    version: route.binding.identity.version,
                 },
-                limitations: [...descriptor.limitations],
-            }));
+                selection_source: route.binding.selectionSource,
+                analysis_profile: structuredClone(route.binding.profile),
+            };
+        const analysisProviderCandidates = this.#providerRouter
+            .candidateStatuses(route)
+            .map((candidate) => ({
+            provider: {
+                id: candidate.provider.id,
+                name: candidate.provider.name,
+                version: candidate.provider.version,
+            },
+            availability: {
+                status: candidate.availability.status,
+                code: candidate.availability.code,
+                reason: candidate.availability.reason,
+                diagnostics: structuredClone(candidate.availability.diagnostics),
+            },
+            target_support: {
+                status: candidate.targetSupport.status,
+                code: candidate.targetSupport.code,
+                reason: candidate.targetSupport.reason,
+                diagnostics: structuredClone(candidate.targetSupport.diagnostics),
+            },
+            selected: candidate.selected,
+            capabilities: candidate.capabilities
+                .slice()
+                .sort((left, right) => left.operation.localeCompare(right.operation))
+                .map((descriptor) => capabilityStatus(descriptor)),
+        }));
+        const common = {
+            provider,
+            providers: providerList,
+            capabilities,
+            analysis_provider_binding: analysisProviderBinding,
+            analysis_provider_candidates: analysisProviderCandidates,
+        };
         return target === undefined
-            ? { open: false, provider, providers: providerList, capabilities }
+            ? { open: false, ...common }
             : {
                 open: true,
-                provider,
-                providers: providerList,
-                capabilities,
+                ...common,
                 path: target.path,
                 sha256: target.sha256,
                 format: target.format,
@@ -311,14 +364,14 @@ export class BinarySession {
                 architecture: target.architecture ?? null,
             };
     }
-    /** Return the immutable artifact identity captured before Hopper launched. */
+    /** Return the immutable artifact identity captured before its provider started. */
     activeTarget() {
         return this.#active === undefined
             ? undefined
             : structuredClone(this.#active.target);
     }
     /**
-     * Invoke a Hopper tool against the active target.
+     * Invoke a provider operation against the active target.
      * Calls may overlap, but a pending target transition prevents new calls from
      * entering until the transition has settled.
      */
@@ -326,15 +379,26 @@ export class BinarySession {
         const transitioned = await this.#waitForTransition(name, options?.signal);
         if (!transitioned.ok)
             return transitioned;
-        const capability = this.#capabilities?.get(name);
-        if (this.#capabilities !== undefined && capability?.available !== true)
-            return err(new AnalysisCapabilityUnavailableError(this.#providerIdentity.id, name, capability?.reason ?? "operation is not declared by this provider"));
         const active = this.#active;
         if (active === undefined)
             return err(new NoBinaryOpenError());
-        const cacheable = isSnapshotCacheable(name, capability, arguments_);
+        const capability = active.route.capabilities?.get(name);
+        if (active.route.capabilities !== undefined &&
+            capability?.available !== true) {
+            const selectionError = this.#providerRouter.unboundOperationError(name, active.route);
+            if (selectionError !== undefined)
+                return err(selectionError);
+            return err(new AnalysisCapabilityUnavailableError(active.route.binding?.identity.id ?? active.route.identity.id, name, capability?.reason ?? "operation is not declared by this provider"));
+        }
+        const profile = active.profile !== null &&
+            (capability === undefined ||
+                capability.provider.id === active.profile.provider.id)
+            ? active.profile
+            : undefined;
+        const cacheable = profile !== undefined &&
+            isSnapshotCacheable(name, capability, arguments_);
         const cached = cacheable
-            ? this.#snapshot.lookup(active.target, name, arguments_, capability.provider)
+            ? this.#snapshot.lookup(active.target, profile, name, arguments_)
             : undefined;
         if (cached !== undefined)
             return ok(cached);
@@ -342,14 +406,21 @@ export class BinarySession {
         this.#calls.add(call);
         try {
             const result = await call;
-            this.#observeRuntimeAvailability(name, result);
-            if (result.ok && cacheable)
-                this.#snapshot.record(active.target, name, arguments_, result.value);
-            else if (result.ok && capability?.effects.mutatesArtifact === true) {
+            const profiled = commitExecutionProfile(name, result, profile);
+            this.#observeRuntimeAvailability(name, profiled);
+            if (profiled.ok && cacheable)
+                this.#snapshot.record({
+                    target: active.target,
+                    profile,
+                    operation: name,
+                    parameters: arguments_,
+                    execution: profiled.value,
+                });
+            else if (profiled.ok && capability?.effects.mutatesArtifact === true) {
                 this.#snapshot.clear();
                 this.#snapshotInvalidated = true;
             }
-            return result;
+            return profiled;
         }
         finally {
             this.#calls.delete(call);
@@ -372,9 +443,10 @@ export class BinarySession {
             "HopperStartError",
             "HopperRemoteError",
         ].includes(result.error._tag)) {
-            const providerId = this.#capabilities?.get(operation)?.provider.id;
+            const capabilities = this.#active?.route.capabilities;
+            const providerId = capabilities?.get(operation)?.provider.id;
             let changed = false;
-            for (const descriptor of this.#capabilities?.values() ?? [])
+            for (const descriptor of capabilities?.values() ?? [])
                 if (providerId !== undefined && descriptor.provider.id === providerId)
                     changed =
                         this.#setRuntimeAvailability(descriptor.operation, false, "Provider became unavailable during this session.") || changed;
@@ -401,8 +473,20 @@ export class BinarySession {
         this.#emitAvailabilityChanged();
     }
     #emitAvailabilityChanged() {
-        for (const listener of this.#availabilityListeners)
-            listener();
+        for (const listener of this.#availabilityListeners) {
+            try {
+                const notification = listener();
+                if (notification !== undefined)
+                    void notification.catch(() => undefined);
+            }
+            catch {
+                // External observers are best-effort notifications. Contain only the
+                // callback failure so state transitions and other listeners continue.
+            }
+        }
+    }
+    #currentRoute() {
+        return this.#active?.route ?? this.#providerRouter.initialRoute();
     }
     #serialize(operation) {
         const result = this.#transition.then(operation, operation);
@@ -415,10 +499,16 @@ export class BinarySession {
     async #restore(previous) {
         if (previous === undefined)
             return;
-        const client = this.#createClient(previous.target);
+        const client = previous.route.createClient(previous.target);
         const started = await client.execute("health", {});
         if (started.ok)
-            this.#active = { target: previous.target, client };
+            this.#active = {
+                target: previous.target,
+                client,
+                profile: previous.profile,
+                compatibility: previous.compatibility,
+                route: previous.route,
+            };
         else
             await client.close();
     }
@@ -449,3 +539,40 @@ export class BinarySession {
     }
 }
 const isAborted = (signal) => signal?.aborted === true;
+const commitExecutionProfile = (operation, result, profile) => {
+    if (!result.ok || profile === undefined)
+        return result;
+    const provider = result.value.provider;
+    if (provider.id !== profile.provider.id ||
+        provider.name !== profile.provider.name ||
+        provider.version !== profile.provider.version)
+        return err(new ProviderAdapterError(profile.provider.id, `${operation}:profile`));
+    return ok({
+        ...result.value,
+        analysisProfile: structuredClone(profile),
+    });
+};
+const capabilityStatus = (descriptor) => ({
+    operation: descriptor.operation,
+    available: descriptor.available,
+    reason: descriptor.reason,
+    input_contract_version: descriptor.inputContractVersion,
+    output_contract_version: descriptor.outputContractVersion,
+    pagination: descriptor.pagination,
+    exhaustive: descriptor.exhaustive,
+    effects: {
+        mutates_artifact: descriptor.effects.mutatesArtifact,
+        launches_process: descriptor.effects.launchesProcess,
+        may_show_ui: descriptor.effects.mayShowUi,
+        may_access_network: descriptor.effects.mayAccessNetwork,
+        may_write_filesystem: descriptor.effects.mayWriteFilesystem,
+        changes_permissions: descriptor.effects.changesPermissions,
+        requires_root: descriptor.effects.requiresRoot,
+    },
+    limits: {
+        max_results: descriptor.limits.maxResults,
+        max_payload_bytes: descriptor.limits.maxPayloadBytes,
+        timeout_ms: descriptor.limits.timeoutMs,
+    },
+    limitations: [...descriptor.limitations],
+});

package/dist/application/BrowserEvidence.js

@@ -2,15 +2,13 @@ import { createEvidence, } from "../domain/evidence.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
 /** Create Evidence v2 for a policy-scoped external browser observation. */
 export const createBrowserEvidence = (operation, input, result, provider) => createEvidence(undefined, provider, {
-    predicateType: operation === "list_browser_targets"
-        ? "rea.browser-target-list/v1"
-        : "rea.web-page-inspection/v1",
+    predicateType: browserPredicate(operation),
     operation,
     parameters: browserParameters(input),
     result: jsonValueSchema.parse(result),
     confidence: "observed",
     authority: "external-service",
-    environment: "target" in result
+    environment: "browser" in result
         ? {
             id: `${result.browser.product}@${result.browser.revision}`,
             platform: process.platform,
@@ -20,16 +18,90 @@ export const createBrowserEvidence = (operation, input, result, provider) => cre
         : null,
     limitations: result.limitations,
 });
-const browserParameters = (input) => ({
-    cdp_endpoint: input.cdp_endpoint,
-    allowed_origins: input.allowed_origins,
-    ...("target_id" in input
-        ? {
+const browserParameters = (input) => {
+    if (!("cdp_endpoint" in input)) {
+        if ("max_changes" in input)
+            return {
+                before_target_id: input.before.inspection.target.target_id,
+                before_capture_ended_at: input.before.inspection.capture_window.ended_at,
+                after_target_id: input.after.inspection.target.target_id,
+                after_capture_ended_at: input.after.inspection.capture_window.ended_at,
+                max_changes: input.max_changes,
+            };
+        return {
+            before_artifact_uri: input.before.uri,
+            after_artifact_uri: input.after.uri,
+            channel_threshold: input.channel_threshold,
+            maximum_pixels: input.maximum_pixels,
+        };
+    }
+    const scope = {
+        cdp_endpoint: input.cdp_endpoint,
+        allowed_origins: input.allowed_origins,
+    };
+    if (!("target_id" in input))
+        return { ...scope, offset: input.offset, limit: input.limit };
+    if ("screenshot_approved" in input)
+        return {
+            ...scope,
+            target_id: input.target_id,
+            maximum_image_bytes: input.maximum_image_bytes,
+        };
+    if ("max_tools" in input)
+        return {
+            ...scope,
             target_id: input.target_id,
             observation_ms: input.observation_ms,
-            include_script_sources: input.include_script_sources,
-            include_storage_keys: input.include_storage_keys,
-            limits: input.limits,
-        }
-        : { offset: input.offset, limit: input.limit }),
-});
+            max_tools: input.max_tools,
+            max_schema_bytes: input.max_schema_bytes,
+            max_schema_nodes: input.max_schema_nodes,
+            max_schema_depth: input.max_schema_depth,
+        };
+    if (!("include_accessibility_text" in input))
+        return {
+            ...scope,
+            target_id: input.target_id,
+            observation_ms: input.observation_ms,
+            max_timeline_events: input.max_timeline_events,
+        };
+    return {
+        ...scope,
+        target_id: input.target_id,
+        observation_ms: input.observation_ms,
+        include_accessibility_text: input.include_accessibility_text,
+        include_console_text: input.include_console_text,
+        include_json_body_shapes: input.include_json_body_shapes,
+        include_websocket_shapes: input.include_websocket_shapes,
+        include_script_sources: input.include_script_sources,
+        include_storage_keys: input.include_storage_keys,
+        limits: input.limits,
+        ...(input.include_script_sources && "source_capture_approved" in input
+            ? {
+                source_capture_approved: input.source_capture_approved,
+                fetch_source_maps: input.fetch_source_maps,
+                source_map_fetch_approved: input.source_map_fetch_approved,
+                analysis_limits: input.analysis_limits,
+            }
+            : {}),
+    };
+};
+const browserPredicate = (operation) => {
+    switch (operation) {
+        case "list_browser_targets":
+            return "rea.browser-target-list/v1";
+        case "inspect_web_page":
+            return "rea.web-page-inspection/v2";
+        case "analyze_web_bundle":
+            return "rea.web-bundle-analysis/v1";
+        case "observe_web_session":
+            return "rea.web-observation-session/v1";
+        case "discover_webmcp_tools":
+            return "rea.webmcp-discovery/v1";
+        case "compare_web_captures":
+            return "rea.web-capture-diff/v1";
+        case "capture_web_screenshot":
+            return "rea.web-screenshot/v1";
+        case "compare_web_screenshots":
+            return "rea.web-screenshot-diff/v1";
+    }
+};