rea-agents 6.5.0 → 6.7.0

package/dist/hopper/HopperClient.js

@@ -4,16 +4,20 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import writeFileAtomic from "write-file-atomic";
 import { analysisErrorWithCleanupFailure } from "../domain/analysisErrorCleanup.js";
+import { analysisClientFailureContext } from "../providers/AnalysisClientFailure.js";
 import { AnalysisCapabilityUnavailableError } from "../domain/analysisErrorCore.js";
 import { HopperCancelledError, HopperProcessError, HopperProtocolError, HopperRemoteError, HopperStartError, HopperTimeoutError, } from "../domain/hopperErrors.js";
 import { hopperStartupFailure, } from "../domain/hopperStartupFailure.js";
 import { providerRetryAction, sharedProviderFailureStage, } from "../domain/providerOperationHealth.js";
 import { err, ok } from "../domain/result.js";
+import { ProviderCleanupError } from "../domain/providerCleanupError.js";
 import { silentLogger } from "../logger.js";
 import { PrivateRuntimeRoot } from "../process/PrivateRuntimeRoot.js";
 import { ProviderStartupDeadline, waitForAbortableDelay, } from "../process/ProviderDeadline.js";
 import { redactCapturedTransportCredential } from "../process/ProviderDiagnosticRedaction.js";
 import { ProviderRunLineage } from "../process/ProviderRunLineage.js";
+import { ABORTED, waitForAbortable } from "../process/AbortablePromise.js";
+import { SharedStartupAttempt, STARTUP_OWNER_CLOSED, } from "../process/SharedStartupAttempt.js";
 import { ProviderProcessSupervisor, } from "../process/ProviderProcess.js";
 import { observeProcessStartIdentity } from "../process/ProcessOwnershipObservation.js";
 import { hopperOperationStage } from "./HopperOperationStage.js";
@@ -56,11 +60,9 @@ export class HopperClient {
     #launcherExitCode;
     #launcherFailureDiagnostic;
     #operationFailure;
-    #startupController;
-    #ready = false;
     #startupFailureResult;
     #runId;
-    #startPromise;
+    #startupAttempt;
     #closePromise;
     #onSocketData = (chunk) => {
         this.#responses.push(chunk);
@@ -73,8 +75,10 @@ export class HopperClient {
         this.#rememberProcessFailure(error, []);
     };
     #onSocketClose = () => {
-        if (this.#closing)
+        if (this.#closing) {
+            this.#failAll(new HopperProcessError(null, { providerState: "unreachable" }));
             return;
+        }
         const launch = this.#resources.launch;
         if (launch?.providerLifetime === "launcher-process" &&
             this.#launcherExitCode !== undefined)
@@ -137,6 +141,21 @@ export class HopperClient {
      * A recorded exit remains visible after request activity returns to idle.
      */
     operationHealth() {
+        if (this.#closing ||
+            this.#closePromise !== undefined ||
+            (!this.#startupSucceeded() &&
+                this.#startupAttempt !== undefined &&
+                this.#operationFailure === undefined)) {
+            return {
+                state: "busy",
+                stage: this.#closing || this.#closePromise !== undefined
+                    ? "connection"
+                    : "launch",
+                retryAction: "wait",
+                exitCode: null,
+                requests: [],
+            };
+        }
         const failure = this.#operationFailure;
         if (failure !== undefined) {
             const requests = failure.requests.map((request) => ({
@@ -182,70 +201,86 @@ export class HopperClient {
             requests: [],
         };
     }
+    /** Read completion from the current attempt; no independent readiness flag. */
+    #startupSucceeded() {
+        const startup = this.#startupAttempt?.settlement;
+        return startup?.status === "completed" && startup.value.ok;
+    }
     /** True only after the authenticated health handshake has completed. */
     isReady() {
-        return (this.#ready &&
+        return (this.#startupSucceeded() &&
             this.#socket !== undefined &&
             !this.#socket.destroyed &&
+            !this.#closing &&
             this.#closePromise === undefined);
     }
-    /** Launch the bridge once and complete its authenticated health handshake. */
+    /** Launch the bridge once while each caller retains its own cancellation. */
     start(signal) {
-        if (this.#closePromise !== undefined) {
-            return this.#closePromise.then((closed) => closed.ok ? this.start(signal) : closed);
-        }
-        if (this.#startPromise !== undefined)
-            return this.#startPromise;
-        const controller = new AbortController();
-        const onAbort = () => controller.abort(signal?.reason);
-        if (signal?.aborted === true)
-            onAbort();
-        else
-            signal?.addEventListener("abort", onAbort, { once: true });
-        const started = this.#start(controller.signal);
-        this.#startupController = controller;
-        this.#startPromise = started;
-        const release = () => {
-            signal?.removeEventListener("abort", onAbort);
-        };
-        const reset = () => {
-            if (this.#startPromise === started) {
-                this.#startPromise = undefined;
-                if (this.#startupController === controller) {
-                    this.#startupController = undefined;
-                }
-            }
-        };
-        void started.then((result) => {
-            release();
+        if (isAborted(signal))
+            return Promise.resolve(err(new HopperCancelledError()));
+        if (this.#closePromise !== undefined)
+            return waitForAbortable(this.#closePromise, signal).then((closed) => closed === ABORTED
+                ? err(new HopperCancelledError())
+                : closed.ok
+                    ? this.start(signal)
+                    : closed);
+        const current = this.#startupAttempt;
+        if (current !== undefined)
+            return current.signal.aborted
+                ? this.#retryAfterAbortedStartup(current, signal)
+                : this.#waitForStartup(current, signal);
+        const attempt = new SharedStartupAttempt((signal) => this.#start(signal));
+        this.#startupAttempt = attempt;
+        void attempt.promise.then((result) => {
             if (!result.ok) {
                 this.#rememberStartupFailure(result.error);
-                reset();
+                if (this.#startupAttempt === attempt)
+                    this.#startupAttempt = undefined;
             }
-            else
-                this.#ready = true;
         }, (cause) => {
             this.#logger.debug({ error: cause instanceof Error ? cause.message : String(cause) }, "Hopper startup promise rejected during bookkeeping");
-            release();
-            reset();
+            if (this.#startupAttempt === attempt)
+                this.#startupAttempt = undefined;
         });
-        return started;
+        return this.#waitForStartup(attempt, signal);
+    }
+    async #waitForStartup(attempt, signal) {
+        const waited = await attempt.wait(signal);
+        if (waited.status === "completed")
+            return waited.value;
+        if (waited.status === "stopped" && !waited.value.ok)
+            return waited.value;
+        return err(new HopperCancelledError());
+    }
+    /** Cleanup belongs to the abandoned attempt, never to a prospective retry. */
+    async #retryAfterAbortedStartup(attempt, signal) {
+        const waited = await waitForAbortable(attempt.promise, signal);
+        if (waited === ABORTED || (waited.ok && isAborted(signal)))
+            return err(new HopperCancelledError());
+        if (waited.ok || waited.error.cleanupIncomplete)
+            return waited;
+        return this.start(signal);
     }
     async #start(signal) {
         if (isAborted(signal))
             return err(new HopperCancelledError());
         if (this.#socket !== undefined ||
             this.#resources.launch !== undefined ||
-            this.#resources.runtimeRoot !== undefined) {
+            this.#resources.runtimeRoot !== undefined ||
+            this.#startupFailureResult?.cleanupIncomplete === true) {
             return err(this.#startupFailureResult ??
                 new HopperProtocolError("Hopper client is already started"));
         }
         this.#operationFailure = undefined;
         this.#startupFailureResult = undefined;
         this.#resources.shutdownConfirmed = false;
+        this.#resources.externalApplication = undefined;
         const deadline = new ProviderStartupDeadline(this.#options.startupTimeoutMs, signal);
         try {
-            return await this.#startWithin(deadline);
+            const result = await this.#startWithin(deadline);
+            return result.ok && deadline.signal.aborted
+                ? this.#startupFailure(await this.#startupInterruption(deadline))
+                : result;
         }
         finally {
             deadline.dispose();
@@ -319,10 +354,33 @@ export class HopperClient {
                 ? await this.#startupInterruption(deadline)
                 : health.error);
         }
-        const parsed = parseHopperServerInfo(health.value, runId);
+        const parsed = await this.#authenticateServerInfo(health.value, runId);
         if (!parsed.ok)
             return this.#startupFailure(parsed.error);
+        try {
+            await this.#lineage.observe(this.#resources.launch);
+        }
+        catch (cause) {
+            return this.#startupFailure(deadline.signal.aborted
+                ? await this.#startupInterruption(deadline)
+                : new HopperStartError({ cause }));
+        }
+        if (deadline.signal.aborted)
+            return this.#startupFailure(await this.#startupInterruption(deadline));
+        return parsed;
+    }
+    /** Bind process identity for both initial and late cleanup handshakes. */
+    async #authenticateServerInfo(value, runId) {
+        const parsed = parseHopperServerInfo(value, runId);
+        if (!parsed.ok)
+            return parsed;
         if (this.#resources.launch?.providerLifetime === "external-application") {
+            const application = this.#resources.externalApplication;
+            if (application !== undefined &&
+                application.pid !== parsed.value.processId)
+                return err(new HopperProtocolError("Hopper bridge process changed within the same run"));
+            if (application?.identity.state === "readable")
+                return parsed;
             let identity;
             try {
                 identity = await observeProcessStartIdentity(parsed.value.processId);
@@ -343,7 +401,6 @@ export class HopperClient {
                 },
             };
         }
-        await this.#lineage.observe(this.#resources.launch);
         return parsed;
     }
     async #startupFailure(primary) {
@@ -382,35 +439,38 @@ export class HopperClient {
         return this.#request(name, arguments_, options).then((result) => this.#normalizeToolResult(name, result));
     }
     #normalizeToolResult(name, result) {
-        return !result.ok &&
-            result.error instanceof HopperRemoteError &&
-            result.error.diagnosticType === "capability_unavailable"
-            ? err(new AnalysisCapabilityUnavailableError("hopper", name, result.error.safeMessage))
-            : result;
+        if (result.ok ||
+            !(result.error instanceof HopperRemoteError) ||
+            result.error.diagnosticType !== "capability_unavailable")
+            return result;
+        const source = result.error;
+        const failure = new AnalysisCapabilityUnavailableError("hopper", name, source.safeMessage, analysisClientFailureContext(source, "hopper", name));
+        return err(source.cleanupIncomplete
+            ? failure.bindCleanupDependencies([source])
+            : failure);
     }
     /** Stop the bridge and report whether every owned resource was verified clean. */
     close(options = {}) {
-        const starting = this.#startPromise;
-        const controller = this.#startupController;
-        controller?.abort();
-        this.#closePromise ??= Promise.resolve().then(() => this.#close(starting, controller, options));
+        const starting = this.#startupAttempt;
+        starting?.close();
+        this.#closePromise ??= Promise.resolve().then(() => this.#close(starting, options));
         return this.#closePromise;
     }
-    async #close(starting, controller, options) {
+    async #close(starting, options) {
         try {
             // best-effort cleanup: a rejected startup must not mask close/cleanup;
             // #cleanup reports the authoritative close result.
-            await starting?.catch(() => undefined);
+            await starting?.promise.catch(() => undefined);
             await confirmExternalApplicationExit(this.#resources, this.#socket, () => this.#releaseTransport());
             await this.#reconnectForCleanup();
-            return await this.#cleanup(options);
+            const closed = await this.#cleanup(options);
+            if (closed.ok)
+                this.#startupFailureResult = undefined;
+            return closed;
         }
         finally {
-            if (this.#startPromise === starting)
-                this.#startPromise = undefined;
-            if (this.#startupController === controller) {
-                this.#startupController = undefined;
-            }
+            if (this.#startupAttempt === starting)
+                this.#startupAttempt = undefined;
             this.#closePromise = undefined;
         }
     }
@@ -450,7 +510,8 @@ export class HopperClient {
                 signal: controller.signal,
                 timeoutMs: HOPPER_SHUTDOWN_TIMEOUT_MS,
             });
-            if (health.ok && parseHopperServerInfo(health.value, runId).ok)
+            if (health.ok &&
+                (await this.#authenticateServerInfo(health.value, runId)).ok)
                 return;
             this.#releaseTransport();
         }
@@ -461,9 +522,8 @@ export class HopperClient {
     }
     async #cleanup(options = {}) {
         this.#closing = true;
-        this.#ready = false;
         try {
-            return await cleanupHopperSession({
+            const closed = await cleanupHopperSession({
                 socket: this.#socket,
                 resources: this.#resources,
                 activeRequest: this.#requests.activity(),
@@ -474,6 +534,16 @@ export class HopperClient {
                 retainDocument: options.retainDocument === true,
                 releaseTransport: () => this.#releaseTransport(),
             });
+            const launcherClosed = await this.#options.launcher
+                .cleanup?.()
+                .catch((cause) => err(new ProviderCleanupError("hopper", ["hopper-launcher"], {
+                reason: cause instanceof Error ? cause.message : String(cause),
+            }, { cause })));
+            if (launcherClosed === undefined || launcherClosed.ok)
+                return closed;
+            return closed.ok
+                ? launcherClosed
+                : err(analysisErrorWithCleanupFailure(closed.error, launcherClosed.error));
         }
         finally {
             if (this.#socket?.destroyed === true)
@@ -529,6 +599,8 @@ export class HopperClient {
         return err(await this.#startupInterruption(deadline));
     }
     async #startupInterruption(deadline) {
+        if (deadline.signal.reason === STARTUP_OWNER_CLOSED)
+            return new HopperProtocolError("Hopper session closed during startup");
         if (deadline.interruption === "cancelled")
             return new HopperCancelledError();
         return new HopperTimeoutError(deadline.timeoutMs, undefined, undefined, "not_started", "launch", this.#launcherOutcome((await this.#resources.processSupervisor?.waitForOutputClose(0)) ??

package/dist/hopper/HopperProvider.js

@@ -6,7 +6,7 @@ import { isElfMetadataArchitecture, } from "../domain/binaryTargetTypes.js";
 import { AnalysisCapabilityUnavailableError } from "../domain/analysisErrorCore.js";
 import { err, ok } from "../domain/result.js";
 import { HopperApplicationLauncher } from "./BridgeLauncher.js";
-import { hopperLoaderArgsForTarget, resolveHopperAnalysisProfile, } from "./HopperAnalysisProfile.js";
+import { hopperDeclinedArchitectureReason, hopperLoaderArgsForTarget, resolveHopperAnalysisProfile, } from "./HopperAnalysisProfile.js";
 import { mapHopperFileOffset } from "./HopperFileOffset.js";
 import { HopperRegexSearch } from "./HopperRegexSearch.js";
 import { HopperClient } from "./HopperClient.js";
@@ -98,15 +98,12 @@ export class HopperProvider {
                 reason: null,
                 diagnostics,
             };
-        if (isElfMetadataArchitecture(target.architecture))
+        if (isElfMetadataArchitecture(target.architecture) ||
+            target.architecture === "hexagon")
             return {
                 status: "unsupported",
                 code: "architecture_unsupported",
-                reason: `REA's Hopper adapter does not admit ${target.architecture === "mips"
-                    ? "MIPS"
-                    : target.architecture === "riscv"
-                        ? "RISC-V"
-                        : "PowerPC"} targets.`,
+                reason: hopperDeclinedArchitectureReason(target.architecture),
                 diagnostics,
             };
         if (target.format === "raw-binary")

package/dist/hopper/HopperProviderCapabilities.js

@@ -1,3 +1,4 @@
+import { REGEX_MATCHING_LIMITATION } from "../process/RegexMatcher.js";
 /** Public identity committed by every Hopper-backed observation. */
 export const HOPPER_PROVIDER_IDENTITY = Object.freeze({
     id: "hopper",
@@ -79,7 +80,7 @@ export const CAPABILITIES = Object.freeze([...HOPPER_OPERATIONS, "search_bytes"]
             : []),
         ...(operation === "search_strings" || operation === "search_procedures"
             ? [
-                "Regex mode uses ECMAScript Unicode semantics in a supervised worker with a five-second matching deadline. Cancellation or deadline failure stops matching without blocking Hopper; literal mode retains native casefold semantics.",
+                `${REGEX_MATCHING_LIMITATION} Literal mode retains native casefold semantics.`,
             ]
             : []),
         ...(operation === "list_strings" ||

package/dist/hopper/HopperRegexSearch.js

@@ -1,22 +1,15 @@
-import { Worker } from "node:worker_threads";
 import { z } from "zod";
-import { AnalysisCancelledError, AnalysisOutputError, AnalysisResourceConstraintError, } from "../domain/analysisErrorCore.js";
+import { AnalysisCancelledError, AnalysisOutputError, } from "../domain/analysisErrorCore.js";
 import { analysisStringSchema } from "../domain/hopperValues.js";
 import { HopperRemoteError } from "../domain/hopperErrors.js";
 import { err, ok } from "../domain/result.js";
 import { analysisSearchInput } from "../contracts/analysisSearchContract.js";
-const MATCHING_DEADLINE_MS = 5_000;
+import { matchRegexValues } from "../process/RegexMatcher.js";
+import { analysisClientFailureForOperation } from "../providers/AnalysisClientFailure.js";
 const inputSchema = z.strictObject({
     ...analysisSearchInput,
     mode: z.literal("regex"),
 });
-const replySchema = z.discriminatedUnion("status", [
-    z.strictObject({
-        status: z.literal("matched"),
-        indices: z.array(z.number().int().nonnegative()),
-    }),
-    z.strictObject({ status: z.literal("invalid_pattern"), reason: z.string() }),
-]);
 /** Match collected native facts off Hopper's API thread, with cancellable lifetime. */
 export class HopperRegexSearch {
     client;
@@ -67,12 +60,12 @@ export class HopperRegexSearch {
             ? {}
             : { document: input.data.document }, inventoryOptions);
         if (!inventory.ok)
-            return inventory;
+            return err(analysisClientFailureForOperation(inventory.error, "hopper", operation));
         const parsed = z.array(analysisStringSchema).safeParse(inventory.value);
         if (!parsed.success)
             return err(new AnalysisOutputError(operation, "Hopper search inventory is malformed"));
         if (options.signal?.aborted)
-            return err(new AnalysisCancelledError(operation));
+            return err(new AnalysisCancelledError(operation, { cause: options.signal.reason }));
         await options.progress
             ?.report({
             phase: "hopper_regex",
@@ -82,53 +75,21 @@ export class HopperRegexSearch {
         })
             .catch(() => undefined);
         if (options.signal?.aborted)
-            return err(new AnalysisCancelledError(operation));
-        let worker;
-        try {
-            worker = new Worker(new URL("./HopperRegexWorker.js", import.meta.url), {
-                workerData: {
-                    pattern: input.data.pattern,
-                    caseSensitive: input.data.case_sensitive,
-                    values: parsed.data.map((item) => item.value),
-                },
-            });
-        }
-        catch (cause) {
-            return err(new AnalysisOutputError(operation, `Cannot start regex worker: ${cause instanceof Error ? cause.message : String(cause)}`, { cause }));
-        }
-        try {
-            return await new Promise((resolve) => {
-                const finish = (result) => {
-                    clearTimeout(timer);
-                    options.signal?.removeEventListener("abort", onAbort);
-                    resolve(result);
-                };
-                const onAbort = () => finish(err(new AnalysisCancelledError(operation)));
-                const timer = setTimeout(() => finish(err(new AnalysisResourceConstraintError(operation, "cpu", "Regex matching exceeded its supervised deadline; the Hopper API thread remains available.", { matching_deadline_ms: MATCHING_DEADLINE_MS }, {
-                    remediationAction: "Simplify the ECMAScript Unicode regex or use literal mode, then retry in the same session.",
-                }))), MATCHING_DEADLINE_MS);
-                options.signal?.addEventListener("abort", onAbort, { once: true });
-                if (options.signal?.aborted)
-                    onAbort();
-                worker.once("message", (message) => {
-                    const reply = replySchema.safeParse(message);
-                    if (!reply.success)
-                        return finish(err(new AnalysisOutputError(operation, "Regex worker reply is malformed")));
-                    if (reply.data.status === "invalid_pattern")
-                        return finish(err(new HopperRemoteError(-32000, `Invalid regex pattern: ${reply.data.reason}`, { diagnosticType: "invalid_request", operation })));
-                    const indices = reply.data.indices;
-                    if (indices.some((index, position) => index >= parsed.data.length ||
-                        (position > 0 && index <= (indices[position - 1] ?? -1))))
-                        return finish(err(new AnalysisOutputError(operation, "Regex worker returned invalid inventory indices")));
-                    const selected = new Set(indices);
-                    finish(ok(parsed.data.filter((_, index) => selected.has(index))));
-                });
-                worker.once("error", (cause) => finish(err(new AnalysisOutputError(operation, `Regex worker failed: ${cause.message}`, { cause }))));
-                worker.once("exit", (code) => finish(err(new AnalysisOutputError(operation, `Regex worker exited without a result (${code})`))));
-            });
-        }
-        finally {
-            await worker.terminate();
-        }
+            return err(new AnalysisCancelledError(operation, { cause: options.signal.reason }));
+        const matched = await matchRegexValues({
+            operation,
+            pattern: input.data.pattern,
+            caseSensitive: input.data.case_sensitive,
+            values: parsed.data.map((item) => item.value),
+            signal: options.signal,
+            invalidPattern: (reason) => new HopperRemoteError(-32000, `Invalid regex pattern: ${reason}`, {
+                diagnosticType: "invalid_request",
+                operation,
+            }),
+        });
+        if (!matched.ok)
+            return matched;
+        const selected = new Set(matched.value);
+        return ok(parsed.data.filter((_, index) => selected.has(index)));
     }
 }

package/dist/ida/IdaBusyHealth.js

@@ -25,15 +25,46 @@ const isBusyStatus = (raw) => typeof raw === "object" &&
 export const readSettledHealth = async (connection, { database, timeoutMs, signal, clock = monotonicClock, }) => {
     const started = clock.now();
     const remaining = () => timeoutMs - (clock.now() - started);
+    let lastBusy;
     for (;;) {
-        const raw = await connection.call("server_health", { database });
+        const budgetMs = remaining();
+        if (budgetMs <= 0)
+            throw lastBusy === undefined
+                ? new AnalysisTimeoutError("server_health", timeoutMs)
+                : busyTimeout(lastBusy, timeoutMs);
+        const requestTimeoutMs = Math.min(timeoutMs, Math.ceil(budgetMs));
+        let raw;
+        try {
+            raw = await connection.call("server_health", { database }, { timeoutMs: requestTimeoutMs });
+        }
+        catch (cause) {
+            if (lastBusy !== undefined &&
+                cause instanceof AnalysisTimeoutError &&
+                cause.timeoutMs === requestTimeoutMs &&
+                requestTimeoutMs < timeoutMs) {
+                throw new AnalysisTimeoutError(lastBusy.operation, timeoutMs, {
+                    cause: lastBusy.raw,
+                    capturedOutput: cause.capturedOutput,
+                    diagnostics: {
+                        health_request_operation: cause.operation,
+                        health_request_timeout_ms: cause.timeoutMs,
+                    },
+                });
+            }
+            throw cause;
+        }
         const busy = busyHealthSchema.safeParse(raw);
         if (!busy.success) {
             if (isBusyStatus(raw))
                 throw busy.error;
             return raw;
         }
-        const expired = () => new AnalysisTimeoutError(`server_health: headless worker still busy in ${busyToolName(busy.data.busy_tool)}`, timeoutMs, { cause: raw });
+        const observedBusy = {
+            raw,
+            operation: `server_health: headless worker still busy in ${busyToolName(busy.data.busy_tool)}`,
+        };
+        lastBusy = observedBusy;
+        const expired = () => busyTimeout(observedBusy, timeoutMs);
         if (remaining() <= 0)
             throw expired();
         await clock.delay(Math.min(BUSY_HEALTH_RETRY_MS, remaining()), signal);
@@ -42,3 +73,6 @@ export const readSettledHealth = async (connection, { database, timeoutMs, signa
             throw expired();
     }
 };
+const busyTimeout = (lastBusy, timeoutMs) => new AnalysisTimeoutError(lastBusy.operation, timeoutMs, {
+    cause: lastBusy.raw,
+});

package/dist/ida/IdaMcpConnection.js

@@ -3,12 +3,12 @@ import { IdaDiagnosticResourceError } from "./IdaDiagnosticWriter.js";
 import { ChildProcess } from "node:child_process";
 import { Socket } from "node:net";
 import { snapshotEnvironment } from "../process/snapshotEnvironment.js";
-import { Client, ProtocolError, SdkErrorCode, SdkHttpError, StreamableHTTPClientTransport, } from "@modelcontextprotocol/client";
+import { Client, ProtocolError, SdkError, SdkErrorCode, SdkHttpError, StreamableHTTPClientTransport, } from "@modelcontextprotocol/client";
 import { DEFAULT_INHERITED_ENV_VARS, StdioClientTransport, } from "@modelcontextprotocol/client/stdio";
 import { z } from "zod";
 import { jsonValueSchema } from "../domain/jsonValue.js";
 import { err, ok } from "../domain/result.js";
-import { AnalysisProtocolError, AnalysisResourceConstraintError, } from "../domain/analysisErrorCore.js";
+import { AnalysisTimeoutError, AnalysisProtocolError, AnalysisResourceConstraintError, } from "../domain/analysisErrorCore.js";
 import { ProviderAdapterError } from "../domain/providerAdapterError.js";
 const toolResultSchema = z.object({
     isError: z.boolean().optional(),
@@ -251,12 +251,12 @@ const retainedTransportCause = (cause, message) => {
     return new Error(message);
 };
 /** Create a standard SDK connection to an existing upstream registration. */
-export const createIdaMcpConnection = (config, environment) => {
+export const createIdaMcpConnection = (config, environment, dependencies = {}) => {
     const client = new Client({ name: "rea-ida-provider", version: "1" });
-    const redactor = createIdaDiagnosticRedactor(config);
+    const redactor = (dependencies.createDiagnosticRedactor ?? createIdaDiagnosticRedactor)(config);
     let stderr = Buffer.alloc(0);
     let stderrBytes = 0;
-    const transportFailure = (cause, operation = "ida_mcp_response") => {
+    const transportFailure = (cause, operation = "ida_mcp_response", requestTimeoutMs = config.timeoutMs) => {
         const bufferLimit = cause instanceof Error
             ? /ReadBuffer exceeded maximum size of (\d+) bytes/u.exec(cause.message)
             : null;
@@ -297,6 +297,11 @@ export const createIdaMcpConnection = (config, environment) => {
             stdout_bytes: 0,
             stderr_bytes: stderrBytes,
         };
+        if (cause instanceof SdkError && cause.code === SdkErrorCode.RequestTimeout)
+            throw new AnalysisTimeoutError(operation, requestTimeoutMs, {
+                cause: failure,
+                capturedOutput,
+            });
         if (bufferLimit !== null)
             throw new AnalysisResourceConstraintError(operation, "transport", `Upstream IDA MCP reply exceeded the ${bufferLimit[1]}-byte transport limit; no partial Evidence was returned.`, { max_response_bytes: Number(bufferLimit[1]) }, { cause, capturedOutput });
         if (stderrBytes === 0)
@@ -337,23 +342,24 @@ export const createIdaMcpConnection = (config, environment) => {
         async connect() {
             await client
                 .connect(transport, { timeout: config.timeoutMs })
-                .catch(transportFailure);
+                .catch((cause) => transportFailure(cause, "ida_mcp_connect"));
             const catalog = await client
                 .listTools(undefined, {
                 timeout: config.timeoutMs,
             })
-                .catch(transportFailure);
+                .catch((cause) => transportFailure(cause, "ida_mcp_catalog"));
             return catalog.tools.map(({ name }) => name);
         },
-        async call(name, args) {
+        async call(name, args, options) {
+            const requestTimeoutMs = Math.min(config.timeoutMs, options?.timeoutMs ?? config.timeoutMs);
             return decodeIdaToolResult(await client
-                .callTool({ name, arguments: args }, { timeout: config.timeoutMs })
-                .catch((cause) => transportFailure(cause, name)), config.protocol, redactor);
+                .callTool({ name, arguments: args }, { timeout: requestTimeoutMs })
+                .catch((cause) => transportFailure(cause, name, requestTimeoutMs)), config.protocol, redactor);
         },
         async readResource(uri) {
             const response = await client
                 .readResource({ uri }, { timeout: config.timeoutMs })
-                .catch(transportFailure);
+                .catch((cause) => transportFailure(cause, "ida_mcp_read_resource"));
             const resource = z
                 .object({
                 contents: z

package/dist/ida/IdaNativeProtocol.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { AnalysisProtocolError } from "../domain/analysisErrorCore.js";
-import { cursorSchema, disassemblySchema, idaAddressSchema, modernCalleesSchema, modernStringsSchema, modernXrefsSchema, } from "./IdaProtocolValues.js";
+import { cursorSchema, disassemblySchema, idaAddressSchema, modernCalleesSchema, modernXrefsSchema, } from "./IdaProtocolValues.js";
 /** Native MCP renders an assembly header followed by bare hexadecimal coordinates. */
 const nativeAssemblySchema = disassemblySchema
     .omit({ lines: true })
@@ -59,14 +59,6 @@ export const nativeCalleesSchema = z
 export const nativeXrefsSchema = z
     .array(modernXrefsSchema.element.extend({ error: nativeErrorSchema }))
     .length(1);
-/** Native regex failures carry an empty page, which must not imply absence. */
-export const nativeStringsSchema = modernStringsSchema
-    .extend({ error: z.string().optional() })
-    .transform((page) => {
-    if (page.error !== undefined)
-        throw new AnalysisProtocolError(`Native IDA string search failed: ${page.error}`);
-    return page;
-});
 /**
  * Native regexes fold bytes, while REA's insensitive literal search folds
  * Unicode strings. Include every non-ASCII value as a candidate, then apply