rea-agents 4.0.1 → 5.0.0

package/dist/hopper/HopperClient.js

@@ -2,7 +2,10 @@ import { randomBytes, randomUUID } from "node:crypto";
 import { access } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { AnalysisCapabilityUnavailableError, HopperCancelledError, HopperProcessError, HopperProtocolError, HopperRemoteError, HopperStartError, hopperStartupFailure, HopperTimeoutError, } from "../domain/errors.js";
+import { AnalysisCapabilityUnavailableError } from "../domain/analysisErrorCore.js";
+import { HopperCancelledError, HopperProcessError, HopperProtocolError, HopperRemoteError, HopperStartError, HopperTimeoutError, } from "../domain/hopperErrors.js";
+import {} from "../domain/analysisErrorBase.js";
+import { hopperStartupFailure, } from "../domain/hopperStartupFailure.js";
 import { err, ok } from "../domain/result.js";
 import { silentLogger } from "../logger.js";
 import { PrivateRuntimeRoot } from "../process/PrivateRuntimeRoot.js";
@@ -119,7 +122,8 @@ export class HopperClient {
             release();
             if (!result.ok)
                 reset();
-        }, () => {
+        }, (cause) => {
+            this.#logger.debug({ error: cause instanceof Error ? cause.message : String(cause) }, "Hopper startup promise rejected during bookkeeping");
             release();
             reset();
         });
@@ -228,6 +232,8 @@ export class HopperClient {
     }
     async #close(starting, controller, options) {
         try {
+            // best-effort cleanup: a rejected startup must not mask close/cleanup;
+            // #cleanup reports the authoritative close result.
             await starting?.catch(() => undefined);
             return await this.#cleanup(options);
         }
@@ -286,7 +292,9 @@ export class HopperClient {
             try {
                 await access(socketPath);
             }
-            catch {
+            catch (cause) {
+                // best-effort cleanup: socket polling; absence means keep waiting.
+                void cause;
                 if ((await deadline.wait(50)) === "aborted")
                     return err(startupInterruption(deadline));
                 continue;
@@ -350,7 +358,9 @@ export class HopperClient {
                 message: message.event.error.message,
             });
         }
-        catch {
+        catch (cause) {
+            // best-effort cleanup: diagnostic consumers must not break the client.
+            void cause;
             this.#logger.warn({ requestId: message.id }, "Hopper bridge diagnostic consumer rejected an event");
         }
     }

package/dist/hopper/HopperProcessDiagnostic.js

@@ -1,4 +1,4 @@
-import { hopperStartupFailure, } from "../domain/errors.js";
+import { hopperStartupFailure, } from "../domain/hopperStartupFailure.js";
 import { parseLinuxPrivateDisplayDiagnostic } from "./LinuxPrivateDisplayDiagnostic.js";
 /** Extract only a matching Linux adapter failure record. */
 export const hopperLauncherFailureDiagnostic = (event) => {

package/dist/hopper/HopperProvider.js

@@ -1,58 +1,14 @@
 import { fileURLToPath } from "node:url";
 import { accessSync, constants } from "node:fs";
 import { createAnalysisExecution } from "../application/AnalysisProvider.js";
-import { AnalysisCapabilityUnavailableError } from "../domain/errors.js";
+import { AnalysisCapabilityUnavailableError } from "../domain/analysisErrorCore.js";
 import { err } from "../domain/result.js";
-import { GENERATED_MCP_TOOL_CATALOG } from "../generatedMcpToolCatalog.js";
 import { HopperApplicationLauncher } from "./BridgeLauncher.js";
 import { hopperLoaderArgsForTarget, resolveHopperAnalysisProfile, } from "./HopperAnalysisProfile.js";
 import { HopperClient } from "./HopperClient.js";
-/** Public identity committed by every Hopper-backed observation. */
-export const HOPPER_PROVIDER_IDENTITY = Object.freeze({
-    id: "hopper",
-    name: "Hopper Disassembler",
-    version: null,
-});
+import { CAPABILITIES, HOPPER_PROVIDER_IDENTITY, } from "./HopperProviderCapabilities.js";
+export { HOPPER_PROVIDER_IDENTITY, HOPPER_OPERATIONS, } from "./HopperProviderCapabilities.js";
 const IDENTITY = HOPPER_PROVIDER_IDENTITY;
-const MUTATING_OPERATIONS = new Set([
-    "set_address_name",
-    "set_addresses_names",
-    "set_bookmark",
-    "set_comment",
-    "set_inline_comment",
-    "unset_bookmark",
-]);
-/** Tool contracts implemented directly by the Hopper adapter. */
-export const HOPPER_PROVIDER_TOOL_CONTRACTS = Object.freeze([
-    ...GENERATED_MCP_TOOL_CATALOG.filter(({ kind, name }) => kind === "official-proxy" &&
-        name !== "inspect_native_data_type" &&
-        name !== "inspect_native_instruction" &&
-        name !== "resolve_native_call_targets"),
-    ...GENERATED_MCP_TOOL_CATALOG.filter(({ name }) => name === "analyze_function"),
-]);
-const CAPABILITIES = Object.freeze(HOPPER_PROVIDER_TOOL_CONTRACTS.map((contract) => {
-    const operation = contract.analysisOperation;
-    if (operation === null)
-        throw new TypeError(`Missing analysis operation for ${contract.name}`);
-    return Object.freeze({
-        provider: IDENTITY,
-        operation,
-        available: true,
-        reason: null,
-        effects: Object.freeze({
-            mutatesArtifact: MUTATING_OPERATIONS.has(contract.name),
-            launchesProcess: true,
-            mayShowUi: true,
-            mayAccessNetwork: false,
-            mayWriteFilesystem: MUTATING_OPERATIONS.has(contract.name),
-            changesPermissions: false,
-            requiresRoot: false,
-        }),
-        limitations: Object.freeze([
-            "Results depend on Hopper's completed static analysis.",
-        ]),
-    });
-}));
 /** Concrete analysis provider backed by REA's private Hopper bridge. */
 export class HopperProvider {
     config;
@@ -96,7 +52,9 @@ export class HopperProvider {
                 diagnostics,
             };
         }
-        catch {
+        catch (cause) {
+            // best-effort cleanup: optional launcher probing; failure means unavailable.
+            void cause;
             return {
                 status: "unavailable",
                 code: "executable_missing",
@@ -125,11 +83,11 @@ export class HopperProvider {
                 reason: null,
                 diagnostics,
             };
-        if (target.format === "dos-mz")
+        if (target.format === "dos-mz" || target.format === "dos-com")
             return {
                 status: "unsupported",
                 code: "target_format_unsupported",
-                reason: "DOS MZ analysis requires the Ghidra 16-bit real-mode adapter.",
+                reason: "DOS MZ/COM analysis requires the Ghidra 16-bit real-mode adapter.",
                 diagnostics,
             };
         return {

package/dist/hopper/HopperProviderCapabilities.js

@@ -0,0 +1,73 @@
+/** Public identity committed by every Hopper-backed observation. */
+export const HOPPER_PROVIDER_IDENTITY = Object.freeze({
+    id: "hopper",
+    name: "Hopper Disassembler",
+    version: null,
+});
+/** Analyst operations implemented by REA's private Hopper bridge. */
+export const HOPPER_OPERATIONS = Object.freeze([
+    "address_name",
+    "comment",
+    "current_address",
+    "current_procedure",
+    "current_document",
+    "goto_address",
+    "inline_comment",
+    "list_bookmarks",
+    "list_documents",
+    "list_names",
+    "list_procedures",
+    "list_segments",
+    "list_strings",
+    "next_address",
+    "prev_address",
+    "procedure_address",
+    "procedure_assembly",
+    "procedure_callees",
+    "procedure_callers",
+    "procedure_info",
+    "read_function_instructions",
+    "read_bytes",
+    "address_to_file_offset",
+    "procedure_references",
+    "procedure_pseudo_code",
+    "resolve_containing_procedure",
+    "search_procedures",
+    "search_strings",
+    "set_address_name",
+    "set_addresses_names",
+    "set_bookmark",
+    "set_comment",
+    "set_current_document",
+    "set_inline_comment",
+    "unset_bookmark",
+    "xrefs",
+    "analyze_function",
+]);
+const MUTATING_OPERATIONS = new Set([
+    "set_address_name",
+    "set_addresses_names",
+    "set_bookmark",
+    "set_comment",
+    "set_inline_comment",
+    "unset_bookmark",
+]);
+/** Source-owned capabilities without acquiring or probing a Hopper session. */
+export const CAPABILITIES = Object.freeze(HOPPER_OPERATIONS.map((operation) => Object.freeze({
+    provider: HOPPER_PROVIDER_IDENTITY,
+    operation,
+    available: true,
+    reason: null,
+    effects: Object.freeze({
+        mutatesArtifact: MUTATING_OPERATIONS.has(operation),
+        launchesProcess: true,
+        mayShowUi: true,
+        mayAccessNetwork: false,
+        mayWriteFilesystem: MUTATING_OPERATIONS.has(operation),
+        changesPermissions: false,
+        requiresRoot: false,
+    }),
+    limitations: Object.freeze([
+        "Results depend on Hopper's completed static analysis.",
+    ]),
+})));

package/dist/hopper/HopperRequestQueue.js

@@ -1,4 +1,4 @@
-import { HopperCancelledError, HopperProcessError, HopperProtocolError, HopperRemoteError, } from "../domain/errors.js";
+import { HopperCancelledError, HopperProcessError, HopperProtocolError, HopperRemoteError, } from "../domain/hopperErrors.js";
 import { err } from "../domain/result.js";
 /** FIFO that keeps the wire serialized until Hopper actually replies. */
 export class HopperRequestQueue {
@@ -184,10 +184,14 @@ export class HopperRequestQueue {
     }
     #reportUpdate(entry, update) {
         try {
-            void Promise.resolve(entry.progress?.report(update)).catch(() => undefined);
+            void Promise.resolve(entry.progress?.report(update)).catch((cause) => {
+                // best-effort cleanup: progress rejection bookkeeping only.
+                void cause;
+            });
         }
-        catch {
+        catch (cause) {
             // Progress observation cannot change the request outcome.
+            void cause;
         }
     }
 }

package/dist/hopper/HopperResponseStream.js

@@ -3,11 +3,16 @@ import { parseBridgeMessageLine, } from "./protocol.js";
 export class HopperResponseStream {
     options;
     #buffer = "";
+    #fragments = [];
     constructor(options) {
         this.options = options;
     }
     push(chunk) {
-        this.#buffer += chunk;
+        this.#fragments.push(chunk);
+        if (!chunk.includes("\n"))
+            return;
+        this.#buffer += this.#fragments.join("");
+        this.#fragments = [];
         let newline = this.#buffer.indexOf("\n");
         while (newline >= 0) {
             const line = this.#buffer.slice(0, newline).trim();
@@ -19,6 +24,7 @@ export class HopperResponseStream {
     }
     reset() {
         this.#buffer = "";
+        this.#fragments = [];
     }
     #acceptLine(line) {
         const parsed = parseBridgeMessageLine(line);

package/dist/hopper/HopperSessionValues.js

@@ -1,4 +1,4 @@
-import { HopperProtocolError } from "../domain/errors.js";
+import { HopperProtocolError } from "../domain/hopperErrors.js";
 import { err, ok } from "../domain/result.js";
 /** Validate the bridge identity and exact per-launch run identifier. */
 export const parseHopperServerInfo = (value, expectedRunId) => {

package/dist/hopper/HopperSocketConnection.js

@@ -1,5 +1,5 @@
 import { createConnection } from "node:net";
-import { HopperCancelledError, HopperStartError } from "../domain/errors.js";
+import { HopperCancelledError, HopperStartError, } from "../domain/hopperErrors.js";
 import { err, ok } from "../domain/result.js";
 /** Open one abort-aware Hopper Unix-socket connection attempt. */
 export const connectHopperSocketOnce = (socketPath, signal) => new Promise((resolve) => {

package/dist/hopper/HopperTargetLease.js

@@ -2,12 +2,20 @@ import { createHash } from "node:crypto";
 import { chmod, lstat, mkdir, realpath, rm } from "node:fs/promises";
 import { createConnection, createServer, } from "node:net";
 import { join, resolve } from "node:path";
-import { HopperStartError } from "../domain/errors.js";
+import { HopperStartError } from "../domain/hopperErrors.js";
+import { safeParseJson } from "../domain/safeJson.js";
 const leaseDirectory = join("/tmp", `rea-hopper-${process.getuid?.() ?? 0}`);
 /** Keep two REA processes from opening duplicate Hopper documents for one target/profile. */
 export const acquireHopperTargetLease = async (input) => {
     const directory = input.directory ?? leaseDirectory;
     await ensureLeaseDirectory(directory);
+    // The canonical path only derives the lease key; it never authorizes access.
+    // Common expected `realpath` failures include a missing target or path
+    // component (ENOENT, ENOTDIR), an unreadable component (EACCES), or a
+    // symlink loop (ELOOP). This catch also falls back for every other error,
+    // which may hide a real filesystem problem. The lexical `resolve` fallback
+    // still yields a deterministic key, but aliases may take separate leases
+    // whenever `realpath` cannot resolve them.
     const targetPath = await realpath(input.targetPath).catch(() => resolve(input.targetPath));
     const key = createHash("sha256")
         .update(JSON.stringify({
@@ -104,22 +112,22 @@ const readOwner = (socketPath) => new Promise((resolveOwner) => {
         const newline = response.indexOf("\n");
         if (newline < 0)
             return;
-        try {
-            const value = JSON.parse(response.slice(0, newline));
-            if (typeof value === "object" &&
-                value !== null &&
-                typeof Reflect.get(value, "runId") === "string" &&
-                typeof Reflect.get(value, "processId") === "number")
-                finish({
-                    runId: Reflect.get(value, "runId"),
-                    processId: Reflect.get(value, "processId"),
-                });
-            else
-                finish(undefined);
-        }
-        catch {
+        const parsed = safeParseJson(response.slice(0, newline));
+        if (!parsed.ok) {
             finish(undefined);
+            return;
         }
+        const value = parsed.value;
+        if (typeof value === "object" &&
+            value !== null &&
+            typeof Reflect.get(value, "runId") === "string" &&
+            typeof Reflect.get(value, "processId") === "number")
+            finish({
+                runId: Reflect.get(value, "runId"),
+                processId: Reflect.get(value, "processId"),
+            });
+        else
+            finish(undefined);
     });
     socket.on("error", () => finish(undefined));
     socket.on("end", () => finish(undefined));

package/dist/hopper/LinuxPrivateDisplayDiagnostic.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import { isHopperStartupFailureCode, } from "../domain/hopperStartupFailure.js";
+import { safeParseJson } from "../domain/safeJson.js";
 export const LINUX_PRIVATE_DISPLAY_DIAGNOSTIC_PREFIX = "REA_X11_DIAGNOSTIC=";
 const diagnosticContextSchema = z.object({
     component: z.literal("hopper_private_display"),
@@ -53,13 +54,11 @@ export const parseLinuxPrivateDisplayDiagnostic = (stderr) => {
     const record = records[0];
     if (record === undefined)
         return { ok: false, reason: "diagnostic_missing" };
-    try {
-        const parsed = diagnosticSchema.safeParse(JSON.parse(record.slice(LINUX_PRIVATE_DISPLAY_DIAGNOSTIC_PREFIX.length)));
-        if (!parsed.success)
-            return { ok: false, reason: "diagnostic_malformed" };
-        return { ok: true, value: parsed.data };
-    }
-    catch {
+    const decoded = safeParseJson(record.slice(LINUX_PRIVATE_DISPLAY_DIAGNOSTIC_PREFIX.length));
+    if (!decoded.ok)
         return { ok: false, reason: "diagnostic_malformed" };
-    }
+    const parsed = diagnosticSchema.safeParse(decoded.value);
+    if (!parsed.success)
+        return { ok: false, reason: "diagnostic_malformed" };
+    return { ok: true, value: parsed.data };
 };

package/dist/hopper/LinuxPrivateDisplayProbe.js

@@ -51,7 +51,9 @@ export const runLinuxPrivateDisplayProbe = async (strategy, options) => {
             expectedCommand: null,
         });
     }
-    catch {
+    catch (cause) {
+        // best-effort cleanup: probe spawn failure is reported as launch-failed.
+        void cause;
         return emptyProcessResult("launch-failed");
     }
     const launch = {
@@ -60,7 +62,7 @@ export const runLinuxPrivateDisplayProbe = async (strategy, options) => {
         cleanup: () => cleanupOwnedProcessGroup(started.ownership),
     };
     const supervisor = new ProviderProcessSupervisor(launch);
-    const outcome = await waitForProbeExit(supervisor, options.timeoutMs, options.signal);
+    const outcome = await waitForProbeOutputClose(supervisor, options.timeoutMs, options.signal);
     let cleanupIncomplete = false;
     if (outcome !== "exit") {
         const stopped = await supervisor.stop();
@@ -111,7 +113,9 @@ const evaluatedProbe = async (strategy, options, timeoutMs, runner) => {
             ...(options.signal === undefined ? {} : { signal: options.signal }),
         });
     }
-    catch {
+    catch (cause) {
+        // Runner failure is reported with the synthetic probe_failed diagnostic.
+        void cause;
         return {
             ok: false,
             diagnostic: syntheticDiagnostic(strategy, "probe_failed"),
@@ -187,7 +191,7 @@ const emptyProcessResult = (outcome) => ({
     stderrBytes: 0,
     cleanupIncomplete: false,
 });
-const waitForProbeExit = async (supervisor, timeoutMs, signal) => {
+const waitForProbeOutputClose = async (supervisor, timeoutMs, signal) => {
     if (signal?.aborted === true)
         return "cancelled";
     let releaseAbort;
@@ -201,8 +205,8 @@ const waitForProbeExit = async (supervisor, timeoutMs, signal) => {
     try {
         return await Promise.race([
             supervisor
-                .waitForExit(Math.max(1, timeoutMs))
-                .then((exited) => (exited ? "exit" : "timeout")),
+                .waitForOutputClose(Math.max(1, timeoutMs))
+                .then((closed) => (closed ? "exit" : "timeout")),
             aborted,
         ]);
     }

package/dist/hopper/protocol.js

@@ -1,7 +1,8 @@
 import { z } from "zod";
-import { HopperProtocolError, HopperRemoteError } from "../domain/errors.js";
+import { HopperProtocolError, HopperRemoteError, } from "../domain/hopperErrors.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
 import { err, ok } from "../domain/result.js";
+import { safeParseJson } from "../domain/safeJson.js";
 const remoteErrorSchema = z
     .object({
     code: z.number().int(),
@@ -68,13 +69,12 @@ const eventSchema = z
 const messageSchema = z.union([responseSchema, eventSchema]);
 /** Parse one complete Hopper NDJSON response or event line. */
 export const parseBridgeMessageLine = (line) => {
-    let decoded;
-    try {
-        decoded = JSON.parse(line);
-    }
-    catch (cause) {
-        return err(new HopperProtocolError("Hopper returned malformed JSON", { cause }));
-    }
+    const decodedResult = safeParseJson(line);
+    if (!decodedResult.ok)
+        return err(new HopperProtocolError("Hopper returned malformed JSON", {
+            cause: decodedResult.cause,
+        }));
+    const decoded = decodedResult.value;
     const parsed = messageSchema.safeParse(decoded);
     return parsed.success
         ? ok(parsed.data)

package/dist/ida/IdaConfiguration.js

@@ -0,0 +1,56 @@
+import { readFileSync, statSync } from "node:fs";
+import { isAbsolute } from "node:path";
+import { z } from "zod";
+import { ConfigurationError } from "../domain/configurationErrors.js";
+import { err, ok } from "../domain/result.js";
+const common = {
+    mode: z.enum(["attached", "headless"]).default("attached"),
+    timeoutMs: z.number().int().positive().max(2_147_483_647).default(300_000),
+    workspaceRoot: z
+        .string()
+        .refine(isAbsolute, "workspaceRoot must be absolute on the REA host")
+        .optional(),
+};
+const registrationSchema = z.union([
+    z
+        .object({
+        ...common,
+        type: z.literal("stdio").optional(),
+        command: z.string().min(1),
+        args: z.array(z.string()).default([]),
+        env: z.record(z.string(), z.string()).default({}),
+    })
+        .strict(),
+    z
+        .object({
+        ...common,
+        type: z.literal("http").optional(),
+        url: z.url().refine((value) => {
+            const url = new URL(value);
+            return (["http:", "https:"].includes(url.protocol) &&
+                ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname) &&
+                url.username === "" &&
+                url.password === "");
+        }, "IDA MCP must use a local HTTP endpoint without URL credentials"),
+        headers: z.record(z.string(), z.string()).default({}),
+    })
+        .strict(),
+]);
+/** Read one explicit registration without starting or installing a provider. */
+export const readIdaConfiguration = (path) => {
+    try {
+        if (statSync(path).size > 65_536)
+            return err(new ConfigurationError("REA_IDA_MCP_CONFIG exceeds the 64 KiB registration size."));
+        const input = JSON.parse(readFileSync(path, "utf8"));
+        const envelope = z
+            .object({ mcpServers: z.object({ "ida-pro-mcp": z.unknown() }) })
+            .safeParse(input);
+        const parsed = registrationSchema.safeParse(envelope.success ? envelope.data.mcpServers["ida-pro-mcp"] : input);
+        return parsed.success
+            ? ok(parsed.data)
+            : err(new ConfigurationError("REA_IDA_MCP_CONFIG must contain an IDA MCP command/args or local url registration; see docs/ida-provider.md.", { cause: parsed.error }));
+    }
+    catch (cause) {
+        return err(new ConfigurationError(`Cannot read IDA MCP registration ${path}; provide a readable JSON configuration.`, { cause }));
+    }
+};

package/dist/ida/IdaDoctor.js

@@ -0,0 +1,53 @@
+import { readIdaConfiguration } from "./IdaConfiguration.js";
+import { privateRuntimeRootCapability } from "../process/PrivateRuntimeRoot.js";
+/** Check the registration without launching IDA, and retain only the configuration file reference. */
+export const inspectIdaRegistration = (path) => {
+    const parsed = path === undefined ? undefined : readIdaConfiguration(path);
+    const valid = parsed?.ok === true;
+    const workspaceChecks = parsed?.ok === true && parsed.value.mode === "headless"
+        ? [inspectPrivateWorkspace()]
+        : [];
+    return {
+        id: "ida",
+        configured: path !== undefined,
+        available: valid && workspaceChecks.every(({ ok }) => ok),
+        providerVersion: null,
+        registrationEnvironment: valid && path !== undefined ? { REA_IDA_MCP_CONFIG: path } : {},
+        checks: [
+            {
+                name: "registration",
+                ok: valid,
+                code: valid
+                    ? null
+                    : path === undefined
+                        ? "not_configured"
+                        : "invalid_configuration",
+                detail: valid
+                    ? "IDA MCP registration is valid. Upstream availability, compatibility, and target binding are checked when analysis starts; no IDA process was launched."
+                    : parsed !== undefined && !parsed.ok
+                        ? parsed.error.message
+                        : "IDA MCP registration is not configured.",
+                remediation: valid
+                    ? null
+                    : "Set REA_IDA_MCP_CONFIG to your upstream IDA MCP registration JSON; see docs/ida-provider.md.",
+                classification: path === undefined ? "missing_analysis_engine" : "config_drift",
+            },
+            ...workspaceChecks,
+        ],
+    };
+};
+const inspectPrivateWorkspace = () => {
+    const privacy = privateRuntimeRootCapability();
+    return {
+        name: "private_workspace",
+        ok: privacy.available,
+        code: privacy.available ? null : "unsupported_host",
+        detail: privacy.available
+            ? `Private workspace authority is available (${privacy.proof}).`
+            : privacy.reason,
+        remediation: privacy.available
+            ? null
+            : "Use the matching Windows x64 REA package and a writable local NTFS temporary directory.",
+        classification: "unsupported_host",
+    };
+};

package/dist/ida/IdaInput.js

@@ -0,0 +1,62 @@
+import { z } from "zod";
+import { TOOL_CONTRACTS } from "../contracts/toolContracts.js";
+import { AnalysisInputError } from "../domain/analysisErrorCore.js";
+import { jsonObjectSchema } from "../domain/jsonValue.js";
+import { err, ok } from "../domain/result.js";
+import { idaAddressSchema } from "./IdaProtocolValues.js";
+import { projectInputIssues } from "../domain/inputIssueProjection.js";
+/** Apply the named public contract and IDA's explicit-address boundary before startup. */
+export const parseIdaInput = (operation, parameters) => {
+    const contract = TOOL_CONTRACTS.find(({ name }) => name === operation);
+    const schema = contract?.inputSchema;
+    if (schema instanceof z.ZodObject) {
+        const shape = schema.shape;
+        parameters = Object.fromEntries(Object.entries(parameters).filter(([key, value]) => value !== null || shape[key]?.safeParse(undefined).success !== true));
+    }
+    const parsed = (schema instanceof z.ZodObject ? schema.strict() : schema)?.safeParse(parameters);
+    if (parsed?.success !== true)
+        return err(new AnalysisInputError(operation, { cause: parsed?.error }, parsed?.error === undefined
+            ? []
+            : projectInputIssues(parsed.error.issues, parameters)));
+    if (operation === "xrefs" && typeof parameters.address !== "string")
+        return err(new AnalysisInputError(operation, undefined, [
+            {
+                path: ["address"],
+                reason: "missing_argument",
+                message: "IDA requires an explicit hexadecimal address.",
+            },
+        ]));
+    if (parameters.address !== undefined &&
+        !idaAddressSchema.safeParse(parameters.address).success)
+        return err(new AnalysisInputError(operation, undefined, [
+            {
+                path: ["address"],
+                reason: "invalid_format",
+                message: "IDA requires a hexadecimal address.",
+            },
+        ]));
+    if (typeof parameters.procedure === "string" &&
+        parameters.procedure.length === 0)
+        return err(new AnalysisInputError(operation, undefined, [
+            {
+                path: ["procedure"],
+                reason: "invalid_value",
+                message: "Supply a function name or address.",
+            },
+        ]));
+    if (parameters.mode === "regex" && typeof parameters.pattern === "string") {
+        try {
+            new RegExp(parameters.pattern, parameters.case_sensitive === true ? "u" : "iu");
+        }
+        catch (cause) {
+            return err(new AnalysisInputError(operation, { cause }, [
+                {
+                    path: ["pattern"],
+                    reason: "invalid_format",
+                    message: "Supply a valid regular expression.",
+                },
+            ]));
+        }
+    }
+    return ok(jsonObjectSchema.parse(parsed.data));
+};