rea-agents 6.3.0 → 6.5.0

package/dist/android/JadxConfiguration.js

@@ -1,29 +1,99 @@
 import { constants } from "node:fs";
 import { access, realpath, stat } from "node:fs/promises";
 import { delimiter, isAbsolute, join, resolve } from "node:path";
+import { inspectWindowsNativeReadiness } from "../process/WindowsAuthority.js";
 import { systemWindowsNativeAuthority } from "../windows/WindowsNativeLoader.js";
 import { AnalysisCapabilityUnavailableError } from "../domain/analysisErrorCore.js";
 import { ZipArtifactReader } from "../artifacts/ZipArtifactReader.js";
 import { execFileOutput, execFileOutputFailure, } from "../process/ExecFileOutput.js";
-import { JADX_JAR_CONFIGURATION_REMEDIATION } from "./JadxRelease.js";
+import { JADX_JAR_CONFIGURATION_REMEDIATION, JADX_JAVA_PROBE_REMEDIATION, JADX_JAVA_RUNTIME_REMEDIATION, JADX_JVM_OPTIONS_REMEDIATION, JADX_UNSUPPORTED_HOST_REMEDIATION, JADX_WINDOWS_NATIVE_REMEDIATION, } from "./JadxRelease.js";
 const JAVA_MODULE_LISTING_TIMEOUT_MS = 10_000;
 const JAVA_MODULE_LISTING_MAX_OUTPUT_BYTES = 1024 * 1024;
 // Bound ZIP metadata allocation during discovery. The audited 0.7.1 JAR's
 // central directory occupies 2,294,350 bytes; class bodies are not read here.
 const JAR_METADATA_READ_MAX_BYTES = 8 * 1024 * 1024;
+/** Runtime mirror of JadxFailureKind for validating the loose diagnostics tag. */
+export const JADX_FAILURE_KINDS = [
+    "windows_native_artifact",
+    "windows_native_runtime",
+    "java_runtime",
+    "java_home",
+    "jvm_options",
+    "jar",
+    "java_probe",
+    "unsupported_host",
+];
+/**
+ * Project the boundary-owned remediation and classification for a failure
+ * kind. A null kind (missing or corrupt tag) keeps JAR guidance, matching
+ * the previous fallthrough for unclassified failures.
+ */
+export const projectJadxFailureOutcome = (kind, configured) => {
+    const drift = configured ? "config_drift" : "missing_analysis_engine";
+    switch (kind) {
+        case "windows_native_artifact":
+            return {
+                remediation: JADX_WINDOWS_NATIVE_REMEDIATION,
+                classification: "missing_dependency",
+            };
+        case "windows_native_runtime":
+            return {
+                remediation: JADX_WINDOWS_NATIVE_REMEDIATION,
+                classification: "runtime_failure",
+            };
+        case "java_runtime":
+            return {
+                remediation: JADX_JAVA_RUNTIME_REMEDIATION,
+                classification: "missing_dependency",
+            };
+        case "java_home":
+            return {
+                remediation: JADX_JAVA_RUNTIME_REMEDIATION,
+                classification: drift,
+            };
+        case "jvm_options":
+            return {
+                remediation: JADX_JVM_OPTIONS_REMEDIATION,
+                classification: drift,
+            };
+        case "jar":
+            return {
+                remediation: JADX_JAR_CONFIGURATION_REMEDIATION,
+                classification: drift,
+            };
+        case "java_probe":
+            return {
+                remediation: JADX_JAVA_PROBE_REMEDIATION,
+                classification: drift,
+            };
+        case "unsupported_host":
+            return {
+                remediation: JADX_UNSUPPORTED_HOST_REMEDIATION,
+                classification: "unsupported_host",
+            };
+        case null:
+            return {
+                remediation: JADX_JAR_CONFIGURATION_REMEDIATION,
+                classification: drift,
+            };
+    }
+};
 class JadxConfigurationFailure extends Error {
     code;
     diagnostics;
-    constructor(code, message, diagnostics, options) {
+    kind;
+    constructor(code, message, diagnostics, kind, options) {
         super(message, options);
         this.code = code;
         this.diagnostics = diagnostics;
+        this.kind = kind;
     }
 }
 /** Inspect the same JAR and Java prerequisites that gate actual execution. */
 export const inspectJadxAvailability = async (environment, signal) => {
     try {
-        const configuration = await readJadxConfiguration(environment, signal);
+        const configuration = await readJadxConfigurationInputs(environment, signal);
+        await validateJadxConfigurationContents(configuration, environment, signal);
         return {
             status: "available",
             code: null,
@@ -44,47 +114,66 @@ export const inspectJadxAvailability = async (environment, signal) => {
                 status: "unavailable",
                 code: cause.code,
                 reason: cause.message,
-                diagnostics: cause.diagnostics,
+                diagnostics: { ...cause.diagnostics, failure_kind: cause.kind },
             };
         throw cause;
     }
 };
-/** Resolve caller-selected tools and preserve the same prerequisite diagnostics. */
-export const resolveJadxConfiguration = async (environment, operation, signal) => {
+/** Resolve caller-selected paths and JVM options without probing their contents. */
+export const resolveJadxConfigurationInputs = async (environment, operation, signal) => {
     try {
-        return await readJadxConfiguration(environment, signal);
+        return await readJadxConfigurationInputs(environment, signal);
     }
     catch (cause) {
         if (signal?.aborted === true)
             throw cause;
         if (!(cause instanceof JadxConfigurationFailure))
             throw cause;
-        const output = cause.diagnostics;
-        throw new AnalysisCapabilityUnavailableError("jadx", operation, cause.message, {
-            cause,
-            userMessage: cause.message,
-            ...(typeof output.stdout === "string" &&
-                typeof output.stderr === "string"
-                ? {
-                    capturedOutput: {
-                        stdout: output.stdout,
-                        stderr: output.stderr,
-                        truncated: output.output_truncated === true,
-                    },
-                }
-                : {}),
-        });
+        throw projectConfigurationFailure(operation, cause);
     }
 };
-const readJadxConfiguration = async (environment, signal) => {
+/** Probe Java and archive prerequisites before starting a new engine session. */
+export const validateJadxConfiguration = async (configuration, environment, operation, signal) => {
+    try {
+        await validateJadxConfigurationContents(configuration, environment, signal);
+    }
+    catch (cause) {
+        if (signal?.aborted === true)
+            throw cause;
+        if (!(cause instanceof JadxConfigurationFailure))
+            throw cause;
+        throw projectConfigurationFailure(operation, cause);
+    }
+};
+const readJadxConfigurationInputs = async (environment, signal) => {
+    signal?.throwIfAborted();
     requireSupportedHost();
     const jar = await resolveJar(environment);
     const java = await resolveJava(environment, signal);
     await requireJavaHomeExecutable(environment.JAVA_HOME, java);
-    const jvmArguments = resolveJvmArguments(environment);
-    await inspectJavaRuntime(java, environment, signal);
-    await requireEngineArchive(jar, signal);
-    return { jar, java, jvmArguments };
+    signal?.throwIfAborted();
+    return { jar, java, jvmArguments: resolveJvmArguments(environment) };
+};
+const validateJadxConfigurationContents = async (configuration, environment, signal) => {
+    signal?.throwIfAborted();
+    await inspectJavaRuntime(configuration.java, environment, signal);
+    await requireEngineArchive(configuration.jar, signal);
+};
+const projectConfigurationFailure = (operation, cause) => {
+    const output = cause.diagnostics;
+    return new AnalysisCapabilityUnavailableError("jadx", operation, cause.message, {
+        cause,
+        userMessage: cause.message,
+        ...(typeof output.stdout === "string" && typeof output.stderr === "string"
+            ? {
+                capturedOutput: {
+                    stdout: output.stdout,
+                    stderr: output.stderr,
+                    truncated: output.output_truncated === true,
+                },
+            }
+            : {}),
+    });
 };
 const requireEngineArchive = async (jar, signal) => {
     // These classes are consumed directly by ReaJadxBridge.java. This checks the
@@ -114,45 +203,66 @@ const requireEngineArchive = async (jar, signal) => {
             phase: "jar-inspection",
             archive_error: reason,
             maximum_metadata_read_bytes: JAR_METADATA_READ_MAX_BYTES,
-        }, cause);
+        }, "jar", cause);
     }
     finally {
         await reader.close();
     }
-    throw configurationFailure("unsupported_version", `REA_JADX_MCP_JAR ${jar} does not contain the required metadata bridge classes: ${[...missing].join(", ")}. ${JADX_JAR_CONFIGURATION_REMEDIATION}`, { jar_path: jar, phase: "jar-inspection", missing_classes: [...missing] });
+    throw configurationFailure("unsupported_version", `REA_JADX_MCP_JAR ${jar} does not contain the required metadata bridge classes: ${[...missing].join(", ")}. ${JADX_JAR_CONFIGURATION_REMEDIATION}`, { jar_path: jar, phase: "jar-inspection", missing_classes: [...missing] }, "jar");
 };
 const requireSupportedHost = () => {
     if (process.platform === "linux" || process.platform === "darwin")
         return;
     if (process.platform === "win32" && process.arch === "x64") {
         const loaded = systemWindowsNativeAuthority();
-        if (loaded.available && loaded.authority.inspection.protocolStdin === true)
-            return;
-        throw configurationFailure("runtime_missing", loaded.available
-            ? "The bundled Windows native artifact lacks owned protocol stdin; use a matching current Windows x64 REA package."
-            : loaded.reason, {
+        if (loaded.available) {
+            if (loaded.authority.inspection.protocolStdin === true)
+                return;
+            throw configurationFailure("runtime_missing", "The bundled Windows native artifact lacks owned protocol stdin; use a matching current Windows x64 REA package.", {
+                platform: process.platform,
+                architecture: process.arch,
+                phase: "process-ownership",
+                owned_protocol_stdin: false,
+            }, "windows_native_artifact");
+        }
+        const readiness = inspectWindowsNativeReadiness(process.platform, loaded);
+        throw configurationFailure(readiness.available ? "runtime_unavailable" : readiness.code, readiness.available
+            ? "Windows native readiness disagreed with the native loader result."
+            : readiness.reason, {
             platform: process.platform,
             architecture: process.arch,
             phase: "process-ownership",
             owned_protocol_stdin: false,
-        });
+            ...(readiness.available
+                ? {}
+                : {
+                    failure_stage: readiness.failureStage,
+                    remediation: readiness.remediation,
+                }),
+        }, readiness.available
+            ? "windows_native_runtime"
+            : readiness.code === "unsupported_host"
+                ? "unsupported_host"
+                : readiness.code === "runtime_missing"
+                    ? "windows_native_artifact"
+                    : "windows_native_runtime");
     }
-    throw configurationFailure("unsupported_host", `Android JADX subprocess ownership is unsupported on ${process.platform}/${process.arch}; use Linux, macOS, or Windows x64 with its bundled native controls.`, { platform: process.platform });
+    throw configurationFailure("unsupported_host", `Android JADX subprocess ownership is unsupported on ${process.platform}/${process.arch}; use Linux, macOS, or Windows x64 with its bundled native controls.`, { platform: process.platform }, "unsupported_host");
 };
 const resolveJar = async (environment) => {
     const jar = environment.REA_JADX_MCP_JAR;
     if (jar === undefined || !isAbsolute(jar))
-        throw configurationFailure("not_configured", JADX_JAR_CONFIGURATION_REMEDIATION, { jar_configured: false });
+        throw configurationFailure("not_configured", JADX_JAR_CONFIGURATION_REMEDIATION, { jar_configured: false }, "jar");
     try {
         await access(jar, constants.R_OK);
         if (!(await stat(jar)).isFile())
-            throw configurationFailure("executable_missing", `REA_JADX_MCP_JAR is not a regular file: ${jar}`, { jar_path: jar });
+            throw configurationFailure("executable_missing", `REA_JADX_MCP_JAR is not a regular file: ${jar}`, { jar_path: jar }, "jar");
         return await realpath(jar);
     }
     catch (cause) {
         if (cause instanceof JadxConfigurationFailure)
             throw cause;
-        throw configurationFailure("executable_missing", `Cannot read REA_JADX_MCP_JAR ${jar}: ${cause instanceof Error ? cause.message : String(cause)}`, { jar_path: jar }, cause);
+        throw configurationFailure("executable_missing", `Cannot read REA_JADX_MCP_JAR ${jar}: ${cause instanceof Error ? cause.message : String(cause)}`, { jar_path: jar }, "jar", cause);
     }
 };
 const resolveJava = async (environment, signal) => {
@@ -179,14 +289,14 @@ const resolveJava = async (environment, signal) => {
                     "code" in cause &&
                     (cause.code === "ENOENT" || cause.code === "ENOTDIR"))
                     continue;
-                throw configurationFailure("runtime_missing", `Cannot inspect selected Java executable ${candidate}: ${errorText(cause)}`, { java_executable: candidate }, cause);
+                throw configurationFailure("runtime_missing", `Cannot inspect selected Java executable ${candidate}: ${errorText(cause)}`, { java_executable: candidate }, "java_runtime", cause);
             }
         }
-        throw configurationFailure("runtime_missing", "Cannot find java.exe on the selected Windows PATH. Select a full JDK with JAVA_HOME or PATH, then verify it with java --list-modules. REA does not install Java.", { java_executable: executable });
+        throw configurationFailure("runtime_missing", "Cannot find java.exe on the selected Windows PATH. Select a full JDK with JAVA_HOME or PATH, then verify it with java --list-modules. REA does not install Java.", { java_executable: executable }, "java_runtime");
     }
     if (isAbsolute(environment.JAVA_HOME))
         return join(environment.JAVA_HOME, "bin", executable);
-    throw configurationFailure("open_options_invalid", "JAVA_HOME must select an existing JDK by absolute path; omit it to use java on PATH.", { java_home: environment.JAVA_HOME });
+    throw configurationFailure("open_options_invalid", "JAVA_HOME must select an existing JDK by absolute path; omit it to use java on PATH.", { java_home: environment.JAVA_HOME }, "java_home");
 };
 const requireJavaHomeExecutable = async (javaHome, java) => {
     if (javaHome === undefined)
@@ -195,12 +305,12 @@ const requireJavaHomeExecutable = async (javaHome, java) => {
         await access(java, constants.R_OK | constants.X_OK);
         if ((await stat(java)).isFile())
             return;
-        throw configurationFailure("runtime_missing", `JAVA_HOME java is not a regular file: ${java}`, { java_executable: java });
+        throw configurationFailure("runtime_missing", `JAVA_HOME java is not a regular file: ${java}`, { java_executable: java }, "java_runtime");
     }
     catch (cause) {
         if (cause instanceof JadxConfigurationFailure)
             throw cause;
-        throw configurationFailure("runtime_missing", `Cannot execute JAVA_HOME java ${java}: ${cause instanceof Error ? cause.message : String(cause)}`, { java_executable: java }, cause);
+        throw configurationFailure("runtime_missing", `Cannot execute JAVA_HOME java ${java}: ${cause instanceof Error ? cause.message : String(cause)}`, { java_executable: java }, "java_runtime", cause);
     }
 };
 const resolveJvmArguments = (environment) => {
@@ -213,10 +323,10 @@ const resolveJvmArguments = (environment) => {
         if (value === undefined)
             continue;
         if (!/^[1-9]\d*$/u.test(value) || !Number.isSafeInteger(Number(value)))
-            throw configurationFailure("open_options_invalid", `${name} must be a positive safe integer; received ${value}.`, { setting: name, value });
+            throw configurationFailure("open_options_invalid", `${name} must be a positive safe integer; received ${value}.`, { setting: name, value }, "jvm_options");
         if (name === "REA_JADX_ACTIVE_PROCESSOR_COUNT" &&
             Number(value) > 2_147_483_647)
-            throw configurationFailure("open_options_invalid", `${name} exceeds the JVM's signed 32-bit processor-count range.`, { setting: name, value });
+            throw configurationFailure("open_options_invalid", `${name} exceeds the JVM's signed 32-bit processor-count range.`, { setting: name, value }, "jvm_options");
         result.push(`${prefix}${value}${suffix}`);
     }
     return result;
@@ -255,14 +365,14 @@ const inspectJavaRuntime = async (java, environment, signal) => {
                 ...diagnostics,
                 failure: "output_limit",
                 output_limit_bytes: JAVA_MODULE_LISTING_MAX_OUTPUT_BYTES,
-            }, cause);
+            }, "java_probe", cause);
         if (output.killed)
             throw configurationFailure("version_unresolved", `The selected Java launcher ${java} was terminated or did not finish the module-listing probe within ${JAVA_MODULE_LISTING_TIMEOUT_MS / 1000} seconds. Inspect the launcher and its startup responsiveness, then verify it returns compiler and version modules with java --list-modules.`, {
                 ...diagnostics,
                 failure: "probe_terminated",
                 deadline_ms: JAVA_MODULE_LISTING_TIMEOUT_MS,
-            }, cause);
-        throw configurationFailure("runtime_missing", `Cannot inspect selected Java runtime ${java}: ${output.stderr.trim() || errorText(cause)}. Select a full JDK including jdk.compiler via JAVA_HOME or PATH; verify it with java --list-modules.`, diagnostics, cause);
+            }, "java_probe", cause);
+        throw configurationFailure("runtime_missing", `Cannot inspect selected Java runtime ${java}: ${output.stderr.trim() || errorText(cause)}. Select a full JDK including jdk.compiler via JAVA_HOME or PATH; verify it with java --list-modules.`, diagnostics, "java_runtime", cause);
     }
     const compiler = /^jdk\.compiler(?:@|$)/mu.test(stdout);
     if (!compiler)
@@ -273,7 +383,7 @@ const inspectJavaRuntime = async (java, environment, signal) => {
             stdout,
             stderr,
             output_truncated: false,
-        });
+        }, "java_runtime");
     const major = /^java\.base@(\d+)(?:[.+_-]|$)/mu.exec(stdout)?.[1];
     if (major === undefined)
         throw configurationFailure("version_unresolved", `The selected Java launcher ${java} did not report a parseable java.base version in its module listing. Inspect the launcher output and verify it with java --list-modules.`, {
@@ -284,7 +394,7 @@ const inspectJavaRuntime = async (java, environment, signal) => {
             stdout,
             stderr,
             output_truncated: false,
-        });
+        }, "java_probe");
     if (Number(major) < 17)
         throw configurationFailure("unsupported_version", `Selected Java runtime ${java} must be JDK 17 or newer and include jdk.compiler; verify it with java --list-modules.`, {
             java_executable: java,
@@ -294,7 +404,7 @@ const inspectJavaRuntime = async (java, environment, signal) => {
             stdout,
             stderr,
             output_truncated: false,
-        });
+        }, "java_runtime");
 };
-const configurationFailure = (code, message, diagnostics, cause) => new JadxConfigurationFailure(code, message, diagnostics, cause === undefined ? undefined : { cause });
+const configurationFailure = (code, message, diagnostics, kind, cause) => new JadxConfigurationFailure(code, message, diagnostics, kind, cause === undefined ? undefined : { cause });
 const errorText = (cause) => cause instanceof Error ? cause.message : String(cause);

package/dist/android/JadxDoctor.js

@@ -0,0 +1,115 @@
+import { inspectJadxAvailability, JADX_FAILURE_KINDS, projectJadxFailureOutcome, } from "./JadxConfiguration.js";
+/** Project the validated JADX configuration into the doctor contract. */
+export const inspectJadxProvider = async (environment) => {
+    const configured = environment.REA_JADX_MCP_JAR !== undefined;
+    const availability = await inspectJadxAvailability(environment);
+    // diagnostics is a loosely-typed JsonValue map; guard the published path
+    // even though the success path always sets jar_path today.
+    const jarPath = availability.status === "available" &&
+        typeof availability.diagnostics["jar_path"] === "string"
+        ? availability.diagnostics["jar_path"]
+        : undefined;
+    const available = availability.status === "available" && jarPath !== undefined;
+    // Preserve the caller-selected JAR path (it may be a stable symlink) and
+    // the validated JAVA_HOME selection; the resolved jarPath stays in
+    // diagnostics as inspection evidence.
+    const configuredJar = environment.REA_JADX_MCP_JAR;
+    return {
+        id: "jadx",
+        configured,
+        available,
+        providerVersion: null,
+        registrationEnvironment: jarPath === undefined || configuredJar === undefined
+            ? {}
+            : {
+                REA_JADX_MCP_JAR: configuredJar,
+                ...optionalEntry("JAVA_HOME", environment.JAVA_HOME),
+                ...optionalEntry("REA_JADX_HEAP_MIB", environment.REA_JADX_HEAP_MIB),
+                ...optionalEntry("REA_JADX_ACTIVE_PROCESSOR_COUNT", environment.REA_JADX_ACTIVE_PROCESSOR_COUNT),
+            },
+        checks: [configurationCheck(configured, availability, jarPath)],
+    };
+};
+/**
+ * Publish a caller-selected variable only when explicitly set; never persist
+ * ambient inheritance. Values are validated before this point.
+ */
+const optionalEntry = (name, value) => (value === undefined ? {} : { [name]: value });
+const configurationCheck = (configured, availability, jarPath) => {
+    const code = availability.status === "unavailable" ? availability.code : null;
+    if (availability.status === "available" && jarPath !== undefined) {
+        return {
+            name: "configuration",
+            ok: true,
+            code: null,
+            detail: `JADX MCP bridge JAR validated at ${jarPath}; its path is recorded for agent registrations.`,
+            remediation: null,
+            classification: "config_drift",
+        };
+    }
+    // The failure kind is tagged at the configuration boundary; project its
+    // remediation and classification here instead of reinterpreting the
+    // phase/setting evidence. Every failed check keeps a remediation.
+    const kind = availability.status === "unavailable"
+        ? asFailureKind(availability.diagnostics["failure_kind"])
+        : null;
+    const outcome = projectJadxFailureOutcome(kind, configured);
+    return {
+        name: "configuration",
+        ok: false,
+        code,
+        detail: availability.status === "available"
+            ? "Validated JADX configuration reported no JAR path."
+            : availability.reason,
+        remediation: outcome.remediation,
+        classification: outcome.classification,
+        ...(kind === "java_probe" && availability.status === "unavailable"
+            ? { details: probeDetails(availability.diagnostics) }
+            : kind !== null &&
+                kind.startsWith("windows_native_") &&
+                availability.status === "unavailable"
+                ? { details: windowsNativeFailureDetails(availability.diagnostics) }
+                : {}),
+    };
+};
+const windowsNativeFailureDetails = (diagnostics) => {
+    const details = {};
+    for (const key of ["failure_stage", "remediation"]) {
+        const value = diagnostics[key];
+        if (value !== undefined)
+            details[key] = value;
+    }
+    return details;
+};
+/** Validate the loose diagnostics tag against the boundary's failure kinds. */
+const asFailureKind = (value) => typeof value === "string" &&
+    JADX_FAILURE_KINDS.includes(value)
+    ? value
+    : null;
+/**
+ * Project bounded Java probe metadata for the doctor report. The full
+ * stdout/stderr can reach the 1 MiB probe budget, so only the bounded
+ * outcome metadata is carried; the message already references the retained
+ * output.
+ */
+const probeDetails = (diagnostics) => {
+    const details = {};
+    for (const key of [
+        "java_executable",
+        "failure",
+        "output_truncated",
+        "exit_code",
+        "process_error_code",
+        "signal",
+        "killed",
+        "output_limit_bytes",
+        "deadline_ms",
+        "jdk_compiler",
+        "java_major",
+    ]) {
+        const value = diagnostics[key];
+        if (value !== undefined)
+            details[key] = value;
+    }
+    return details;
+};

package/dist/android/JadxMcpTransport.js

@@ -155,9 +155,11 @@ export class JadxMcpTransport {
                 this.#appendFrame(fragment, frameBytes);
                 if (newline === -1)
                     return;
-                const line = this.#frameBuffer
-                    .subarray(0, this.#frameLength)
-                    .toString("utf8");
+                const line = new TextDecoder("utf-8", {
+                    fatal: true,
+                    // Preserve a leading BOM so the JSON-RPC parser can reject it.
+                    ignoreBOM: true,
+                }).decode(this.#frameBuffer.subarray(0, this.#frameLength));
                 this.#frameBuffer = Buffer.alloc(0);
                 this.#frameLength = 0;
                 this.onmessage?.(deserializeMessage(line));

package/dist/android/JadxProtocol.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { AnalysisOutputError } from "../domain/analysisErrorCore.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
+import { dexDescriptorSchema } from "../domain/android/androidAnalysis.js";
 const count = z.number().int().nonnegative();
 /** Selector failures authored by REA's bridge, separate from arbitrary engine errors. */
 export const jadxInputFailureSchema = z.strictObject({
@@ -47,6 +48,7 @@ export const jadxClassSchema = z.object({
     methods: z.array(z.object({
         name: z.string(),
         signature: z.string(),
+        dex_descriptor: dexDescriptorSchema,
         is_constructor: z.boolean(),
         def_pos: z.number().int(),
     })),
@@ -66,6 +68,8 @@ export const jadxMethodSchema = z.object({
 });
 export const jadxXrefsSchema = z.object({
     target: z.string(),
+    overload_index: count.optional(),
+    reported_signature: z.string().optional(),
     total: count,
     count,
     resolve_line: z.literal(false),
@@ -76,6 +80,16 @@ export const jadxXrefsSchema = z.object({
         containing_class: z.string(),
         top_class: z.string(),
         def_pos: z.number().int(),
+        direct_invokes_exhaustive: z.boolean().optional(),
+        direct_invokes: z
+            .array(z.object({
+            dex_entry: z.string().min(1),
+            source_raw_method_id: z.string().min(1),
+            dex_code_unit_offset: count,
+            dex_method_index: count,
+            opcode: z.string().regex(/^INVOKE_/u),
+        }))
+            .optional(),
     })),
 });
 const toolResponse = z.object({