rea-agents 4.1.0 → 6.0.0

package/dist/javascript/sourceMaps/SourceMapCommand.js

@@ -0,0 +1,177 @@
+import { randomUUID } from "node:crypto";
+import { writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { AnalysisError } from "../../domain/analysisErrorBase.js";
+import { AnalysisCancelledError, AnalysisCapabilityUnavailableError, AnalysisOutputError, AnalysisTimeoutError, } from "../../domain/analysisErrorCore.js";
+import { ProviderAdapterError } from "../../domain/providerAdapterError.js";
+import { ProviderCleanupError } from "../../domain/providerCleanupError.js";
+import { err, ok } from "../../domain/result.js";
+import { WEB_SOURCE_MAP_LIMITS } from "../../domain/webSourceLocation.js";
+import { PrivateRuntimeRoot, PrivateRuntimeRootUnavailableError, } from "../../process/PrivateRuntimeRoot.js";
+import { ProviderStartupDeadline } from "../../process/ProviderDeadline.js";
+import { cleanupOwnedProcessGroup } from "../../process/ProcessOwnership.js";
+import { ProviderProcessSupervisor, spawnOwnedProviderProcess, } from "../../process/ProviderProcess.js";
+const OPERATION = "trace_web_source_location";
+const PROVIDER = "source-map-decoder";
+/** Run a trusted codec command and release its process/root before returning output. */
+export const runSourceMapCommand = async (request, path, options, dependencies) => {
+    const deadline = new ProviderStartupDeadline(WEB_SOURCE_MAP_LIMITS.decodeTimeoutMs, options?.signal);
+    const command = new OwnedCodec(path, dependencies, deadline);
+    let result;
+    try {
+        await command.start(request);
+        result = ok(await command.collect());
+    }
+    catch (cause) {
+        result = err(command.failure(cause));
+    }
+    finally {
+        deadline.dispose();
+    }
+    const cleanup = await command.close(result.ok ? null : result.error.message);
+    if (cleanup !== undefined)
+        return err(cleanup);
+    return result.ok && options?.signal?.aborted
+        ? err(new AnalysisCancelledError(OPERATION))
+        : result;
+};
+class OwnedCodec {
+    path;
+    dependencies;
+    deadline;
+    #runId = `rea-source-map-${randomUUID()}`;
+    #runtime;
+    #supervisor;
+    #oversized = false;
+    #processError;
+    constructor(path, dependencies, deadline) {
+        this.path = path;
+        this.dependencies = dependencies;
+        this.deadline = deadline;
+    }
+    async start(request) {
+        this.check();
+        this.#runtime = await (this.dependencies.createRuntime ??
+            (() => PrivateRuntimeRoot.create({ prefix: "rea-source-map-" })))();
+        this.check();
+        const requestPath = join(this.#runtime.path, "request.json");
+        await writeFile(requestPath, request, {
+            flag: "wx",
+            mode: 0o600,
+            signal: this.deadline.signal,
+        });
+        this.check();
+        const environment = {
+            ...(this.dependencies.environment ?? process.env),
+            UV_THREADPOOL_SIZE: "1",
+        };
+        delete environment.NODE_OPTIONS;
+        const spawned = await (this.dependencies.launcher ?? spawnOwnedProviderProcess)({
+            command: process.execPath,
+            arguments: [
+                "--max-old-space-size=192",
+                "--max-semi-space-size=8",
+                "--v8-pool-size=1",
+                "--single-threaded",
+                "--stack_size=2048",
+                fileURLToPath(new URL("./SourceMapCodecProcess.js", import.meta.url)),
+                requestPath,
+            ],
+            runId: this.#runId,
+            cwd: this.#runtime.path,
+            hostEnvironment: environment,
+            signal: this.deadline.signal,
+        });
+        this.#supervisor = new ProviderProcessSupervisor({
+            ...spawned,
+            ownsProcessLifetime: true,
+            cleanup: spawned.cleanup ??
+                (() => cleanupOwnedProcessGroup(spawned.ownership)),
+        }, {
+            onDiagnostic: (event) => {
+                if (event.type === "error")
+                    this.#processError = event.message;
+                if (event.type === "output" &&
+                    event.totalBytes >
+                        (event.stream === "stdout"
+                            ? WEB_SOURCE_MAP_LIMITS.outputBytes
+                            : 1024 * 1024))
+                    this.#oversized = true;
+            },
+        });
+    }
+    async collect() {
+        const supervisor = this.#supervisor;
+        if (supervisor === undefined)
+            throw new Error("Codec process was not acquired");
+        while (!(await supervisor.waitForOutputClose(50)))
+            this.check();
+        this.check();
+        const snapshot = supervisor.snapshot();
+        if (snapshot.exitCode !== 0 || snapshot.signal !== null)
+            throw new ProviderAdapterError(PROVIDER, OPERATION, {
+                diagnostics: {
+                    map_path: this.path,
+                    exit_code: snapshot.exitCode ?? null,
+                    signal: snapshot.signal ?? null,
+                    stderr: snapshot.stderr.text,
+                },
+            });
+        return snapshot.stdout.text;
+    }
+    check() {
+        if (this.deadline.interruption === "cancelled")
+            throw new AnalysisCancelledError(OPERATION);
+        if (this.deadline.interruption === "timeout")
+            throw new AnalysisTimeoutError(OPERATION, WEB_SOURCE_MAP_LIMITS.decodeTimeoutMs);
+        if (this.#oversized)
+            throw new AnalysisOutputError(OPERATION, "Codec output exceeds its complete-evidence or diagnostic budget.");
+        if (this.#processError !== undefined)
+            throw new ProviderAdapterError(PROVIDER, OPERATION, {
+                diagnostics: { map_path: this.path, error_message: this.#processError },
+            });
+    }
+    failure(cause) {
+        if (this.deadline.interruption === "cancelled")
+            return new AnalysisCancelledError(OPERATION);
+        if (this.deadline.interruption === "timeout")
+            return new AnalysisTimeoutError(OPERATION, WEB_SOURCE_MAP_LIMITS.decodeTimeoutMs);
+        if (cause instanceof AnalysisError)
+            return cause;
+        return cause instanceof PrivateRuntimeRootUnavailableError
+            ? new AnalysisCapabilityUnavailableError(PROVIDER, OPERATION, cause.message, { cause })
+            : new ProviderAdapterError(PROVIDER, OPERATION, {
+                cause,
+                diagnostics: { map_path: this.path, error_message: message(cause) },
+            });
+    }
+    async close(previousError) {
+        const failures = [];
+        if (this.#supervisor !== undefined) {
+            const stopped = await this.#supervisor.stop();
+            if (stopped.status === "incomplete")
+                failures.push(stopped.reason);
+        }
+        if (this.#runtime !== undefined) {
+            try {
+                await this.#runtime.close();
+            }
+            catch (cause) {
+                failures.push(message(cause));
+            }
+        }
+        return failures.length === 0
+            ? undefined
+            : new ProviderCleanupError(PROVIDER, [
+                this.#runId,
+                ...(this.#runtime === undefined ? [] : [this.#runtime.path]),
+            ], {
+                map_path: this.path,
+                cleanup_failures: failures,
+                previous_error: previousError,
+                codec_pid: this.#supervisor?.launch.process.pid ?? null,
+            }, { operation: OPERATION });
+    }
+}
+const message = (cause) => cause instanceof Error ? cause.message : String(cause);

package/dist/javascript/sourceMaps/SourceMapDecoder.js

@@ -0,0 +1,61 @@
+import { AnalysisCancelledError, AnalysisCapabilityUnavailableError, AnalysisInputError, AnalysisOutputError, } from "../../domain/analysisErrorCore.js";
+import { ArtifactOperationError } from "../../domain/artifactOperationError.js";
+import { err, ok } from "../../domain/result.js";
+import { WEB_SOURCE_MAP_LIMITS, } from "../../domain/webSourceLocation.js";
+import { sourceMapCodecInputSchema, sourceMapCodecReplySchema, } from "./SourceMapCodecProtocol.js";
+import { runSourceMapCommand, } from "./SourceMapCommand.js";
+const OPERATION = "trace_web_source_location";
+/** Integrate the pinned upstream codec through an independently bounded owned process. */
+export class SourceMapDecoder {
+    dependencies;
+    constructor(dependencies = {}) {
+        this.dependencies = dependencies;
+    }
+    /** Return complete point evidence after process and private-root cleanup. */
+    async trace(input, options) {
+        if (options?.signal?.aborted)
+            return err(new AnalysisCancelledError(OPERATION));
+        const request = sourceMapCodecInputSchema.safeParse({
+            text: input.text,
+            url: input.url,
+            position: input.position,
+        });
+        if (!request.success)
+            return err(new AnalysisInputError(OPERATION, { cause: request.error }));
+        const serialized = JSON.stringify(request.data);
+        if (Buffer.byteLength(input.text) > WEB_SOURCE_MAP_LIMITS.mapBytes ||
+            Buffer.byteLength(serialized) > WEB_SOURCE_MAP_LIMITS.outputBytes)
+            return err(new ArtifactOperationError(OPERATION, "limit", undefined, `${input.path}: Source-map input exceeds the 4 MiB map or 32 MiB encoded request budget.`));
+        const response = await runSourceMapCommand(serialized, input.path, options, this.dependencies);
+        if (!response.ok)
+            return response;
+        let value;
+        try {
+            value = JSON.parse(response.value);
+        }
+        catch (cause) {
+            return err(new AnalysisOutputError(OPERATION, `Malformed codec JSON reply: ${cause instanceof Error ? cause.message : String(cause)}`));
+        }
+        const reply = sourceMapCodecReplySchema.safeParse(value);
+        if (!reply.success)
+            return err(new AnalysisOutputError(OPERATION, `Malformed codec reply: ${reply.error.message}`));
+        if (options?.signal?.aborted)
+            return err(new AnalysisCancelledError(OPERATION));
+        if (reply.data.state === "failure")
+            return codecFailure(input.path, reply.data.reason, reply.data.message);
+        if (reply.data.report.runtime.v8_heap_limit_bytes > 256 * 1024 * 1024)
+            return err(new AnalysisOutputError(OPERATION, "Codec reported a V8 heap limit exceeding its independent process budget."));
+        return ok(reply.data.report);
+    }
+}
+const codecFailure = (path, reason, detail) => err(reason === "limit"
+    ? new ArtifactOperationError(OPERATION, "limit", undefined, `${path}: ${detail}`)
+    : reason === "unsupported"
+        ? new AnalysisCapabilityUnavailableError("source-map-decoder", OPERATION, "unsupported_source_map_profile", { userMessage: `${path}: ${detail}` })
+        : new AnalysisInputError(OPERATION, undefined, [
+            {
+                path: ["source_map", "path"],
+                reason: "invalid_format",
+                message: `${path}: ${detail}`,
+            },
+        ]));

package/dist/javascript/sourceMaps/SourceMapFormat.js

@@ -0,0 +1,185 @@
+import { z } from "zod";
+import { WEB_SOURCE_MAP_LIMITS } from "../../domain/webSourceLocation.js";
+const leafSchema = z.object({
+    version: z.literal(3),
+    file: z.string().nullable().optional(),
+    sourceRoot: z.string().nullable().optional(),
+    sources: z.array(z.string().nullable()),
+    sourcesContent: z.array(z.string().nullable()).nullable().optional(),
+    names: z.array(z.string()).default([]),
+    mappings: z.string().regex(/^[A-Za-z0-9+/,;]*$/u),
+    ignoreList: z.array(z.number().int().min(0)).optional(),
+    x_google_ignoreList: z.array(z.number().int().min(0)).optional(),
+});
+const mapHeaderSchema = z.object({
+    version: z.literal(3),
+    file: z.string().nullable().optional(),
+    sections: z.unknown().optional(),
+});
+const sectionSchema = z.object({
+    offset: z.object({
+        line: z.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
+        column: z.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
+    }),
+    map: z.unknown().optional(),
+    url: z.string().optional(),
+});
+const indexedSchema = z.object({
+    version: z.literal(3),
+    sections: z.array(sectionSchema),
+});
+/** A decoder-profile failure with an actionable producer constraint. */
+export class SourceMapFormatFailure extends Error {
+    reason;
+    constructor(reason, message) {
+        super(message);
+        this.reason = reason;
+    }
+}
+const compare = (a, b) => a.line - b.line || a.column - b.column;
+const addOffset = (base, offset) => {
+    const result = {
+        line: base.line + offset.line,
+        column: offset.column + (offset.line === 0 ? base.column : 0),
+    };
+    if (!Number.isSafeInteger(result.line) ||
+        !Number.isSafeInteger(result.column) ||
+        result.line >= WEB_SOURCE_MAP_LIMITS.decodedRows)
+        throw new SourceMapFormatFailure("limit", "Indexed offset exceeds the 262144 generated-row decoder budget.");
+    return result;
+};
+const addSections = (node, pending) => {
+    const sections = indexedSchema.parse(node.value).sections;
+    for (const [index, section] of sections.entries()) {
+        const previous = sections[index - 1];
+        if (previous !== undefined && compare(section.offset, previous.offset) <= 0)
+            throw new SourceMapFormatFailure("format", "Indexed section offsets must be strictly increasing.");
+        if (section.url !== undefined)
+            throw new SourceMapFormatFailure("unsupported", `External source-map section URL is not fetched: ${section.url}`);
+        if (section.map === undefined)
+            throw new SourceMapFormatFailure("format", "Indexed section requires an embedded map.");
+    }
+    for (let index = sections.length - 1; index >= 0; index -= 1) {
+        const section = sections[index];
+        if (section === undefined)
+            continue;
+        const next = sections[index + 1];
+        const nextOffset = next === undefined ? null : addOffset(node.offset, next.offset);
+        const stop = nextOffset === null
+            ? node.stop
+            : node.stop === null || compare(nextOffset, node.stop) < 0
+                ? nextOffset
+                : node.stop;
+        const offset = addOffset(node.offset, section.offset);
+        if (node.stop !== null && compare(offset, node.stop) >= 0)
+            throw new SourceMapFormatFailure("format", "Nested source-map section overlaps its enclosing boundary.");
+        pending.push({
+            value: section.map,
+            path: [...node.path, index],
+            offset,
+            stop,
+        });
+    }
+};
+const inspectMappingLayout = (mappings) => {
+    let lines = 1;
+    let segments = 0;
+    let components = 0;
+    let inSegment = false;
+    let continued = false;
+    let digits = 0;
+    const finish = () => {
+        if (continued)
+            throw new SourceMapFormatFailure("format", "Source-map VLQ ends with an unfinished continuation.");
+        if (inSegment && ![1, 4, 5].includes(components))
+            throw new SourceMapFormatFailure("format", "Source-map segment requires one, four or five VLQ components.");
+    };
+    for (const character of mappings) {
+        if (character === "," || character === ";") {
+            finish();
+            inSegment = false;
+            components = 0;
+            if (character === ";")
+                lines += 1;
+        }
+        else {
+            digits += 1;
+            if ((digits === 7 && !/[A-Dg-j]/u.test(character)) ||
+                (digits > 7 && character !== "A" && character !== "g"))
+                throw new SourceMapFormatFailure("format", "Source-map VLQ exceeds the format's 32-bit quantity representation.");
+            if (!inSegment)
+                segments += 1;
+            inSegment = true;
+            continued = /[g-z0-9+/]/u.test(character);
+            if (!continued) {
+                components += 1;
+                digits = 0;
+            }
+        }
+        if (segments > WEB_SOURCE_MAP_LIMITS.decodedSegments ||
+            lines > WEB_SOURCE_MAP_LIMITS.decodedRows)
+            throw new SourceMapFormatFailure("limit", "Source-map layout exceeds the 262144 segment/generated-row decoder budget.");
+    }
+    finish();
+    return { lines, segments };
+};
+/** Validate structure before allocation, retaining raw declarations and section boundaries. */
+export const inspectSourceMap = (text) => {
+    const withoutBom = text.replace(/^\uFEFF/u, "");
+    const jsonText = withoutBom.startsWith(")]}'")
+        ? withoutBom.slice(withoutBom.indexOf("\n") + 1)
+        : withoutBom;
+    const value = JSON.parse(jsonText);
+    const root = mapHeaderSchema.parse(value);
+    const declarations = [];
+    const leaves = [];
+    const pending = [
+        { value, path: [], offset: { line: 0, column: 0 }, stop: null },
+    ];
+    let segmentCount = 0;
+    while (pending.length > 0) {
+        const node = pending.pop();
+        if (node === undefined)
+            break;
+        if (node.path.length > WEB_SOURCE_MAP_LIMITS.sectionDepth)
+            throw new SourceMapFormatFailure("limit", "Indexed source-map nesting exceeds the 64-level decoder stack budget.");
+        if (mapHeaderSchema.parse(node.value).sections !== undefined) {
+            addSections(node, pending);
+            continue;
+        }
+        const leaf = leafSchema.parse(node.value);
+        const layout = inspectMappingLayout(leaf.mappings);
+        segmentCount += layout.segments;
+        if (segmentCount > WEB_SOURCE_MAP_LIMITS.decodedSegments ||
+            node.offset.line + layout.lines > WEB_SOURCE_MAP_LIMITS.decodedRows)
+            throw new SourceMapFormatFailure("limit", "Source-map layout exceeds the 262144 segment/generated-row decoder budget.");
+        leaves.push({ map: leaf, offset: node.offset, stop: node.stop });
+        for (const [sourceIndex, source] of leaf.sources.entries())
+            declarations.push({
+                sectionPath: node.path,
+                sourceIndex,
+                source,
+                root: leaf.sourceRoot ?? null,
+                content: leaf.sourcesContent?.[sourceIndex] ?? null,
+                ignored: (leaf.ignoreList ?? leaf.x_google_ignoreList ?? []).includes(sourceIndex),
+            });
+    }
+    // Absolute leaves adapt nested first-line column offsets before upstream AnyMap.
+    // Raw map bytes and the original section/source identities are retained separately.
+    const normalized = root.sections === undefined
+        ? leaves[0]?.map
+        : {
+            version: 3,
+            sections: leaves.map((leaf) => ({
+                offset: leaf.offset,
+                map: leaf.map,
+            })),
+        };
+    return {
+        jsonText: JSON.stringify(normalized),
+        format: root.sections === undefined ? "regular" : "indexed",
+        reportedFile: root.file ?? null,
+        declarations,
+        leaves,
+    };
+};

package/dist/javascript/sourceMaps/TraceSourceMap.js

@@ -0,0 +1,138 @@
+import { createHash } from "node:crypto";
+import { createRequire } from "node:module";
+import { getHeapStatistics } from "node:v8";
+import { AnyMap, TraceMap, decodedMappings, } from "@jridgewell/trace-mapping";
+import { z } from "zod";
+import { webSourceOffset } from "../../domain/webSourcePosition.js";
+import { webSourceMapReportSchema, WEB_SOURCE_MAP_LIMITS, } from "../../domain/webSourceLocation.js";
+import { inspectSourceMap, SourceMapFormatFailure, } from "./SourceMapFormat.js";
+/** Decode with the pinned upstream codec; preserve every equal-position candidate. */
+export const traceSourceMap = (text, url, position) => {
+    const inspected = inspectSourceMap(text);
+    const { map, rows } = decodeValidatedMap(inspected, url);
+    const matched = greatestPosition(rows, position);
+    const segments = matched === null
+        ? []
+        : (rows[matched.line - 1] ?? []).filter((segment) => segment[0] === matched.column);
+    let bytes = 0;
+    const matches = [];
+    for (const segment of segments) {
+        const match = originalMatch(segment, map, inspected.declarations);
+        bytes += Buffer.byteLength(JSON.stringify(match)) + 1;
+        if (bytes > WEB_SOURCE_MAP_LIMITS.outputBytes)
+            throw new SourceMapFormatFailure("limit", "Complete source-map point evidence exceeds the 32 MiB output budget; no partial evidence was returned.");
+        matches.push(match);
+    }
+    const metadata = createRequire(import.meta.url)("@jridgewell/trace-mapping/package.json");
+    const version = z
+        .object({ version: z.string().min(1) })
+        .parse(metadata).version;
+    return webSourceMapReportSchema.parse({
+        source_map_sha256: createHash("sha256").update(text).digest("hex"),
+        url_context: url,
+        engine: { id: "jridgewell-trace-mapping", version },
+        runtime: {
+            id: "node-v8",
+            version: process.version,
+            v8_heap_limit_bytes: getHeapStatistics().heap_size_limit,
+        },
+        format: inspected.format,
+        reported_file: inspected.reportedFile,
+        lookup: {
+            requested: position,
+            matched_generated_position: matched,
+            semantics: "greatest generated position <= requested, across lines; all equal-position segments",
+            location_units: "one-based lines; zero-based UTF-16 columns",
+        },
+        matches,
+        diagnostics: [],
+    });
+};
+const decodeValidatedMap = (inspected, url) => {
+    let regularRows;
+    for (const leaf of inspected.leaves) {
+        const decoded = decodedMappings(new TraceMap(JSON.stringify(leaf.map), url));
+        if (inspected.format === "regular")
+            regularRows = decoded;
+        for (const [line, row] of decoded.entries())
+            for (const segment of row) {
+                if (segment.some((value) => !Number.isSafeInteger(value) || value < 0) ||
+                    (segment.length !== 1 && segment[1] >= leaf.map.sources.length) ||
+                    (segment.length === 5 && segment[4] >= leaf.map.names.length))
+                    throw new SourceMapFormatFailure("format", "Decoded section-local position, source index or name index is invalid.");
+                const generatedLine = leaf.offset.line + line;
+                const generatedColumn = segment[0] + (line === 0 ? leaf.offset.column : 0);
+                if (leaf.stop !== null &&
+                    (generatedLine > leaf.stop.line ||
+                        (generatedLine === leaf.stop.line &&
+                            generatedColumn >= leaf.stop.column)))
+                    throw new SourceMapFormatFailure("format", "Embedded source-map mappings overlap the following section boundary.");
+            }
+    }
+    const map = new AnyMap(inspected.jsonText, url);
+    const rows = regularRows ?? decodedMappings(map);
+    for (const row of rows)
+        for (const segment of row) {
+            if (![1, 4, 5].includes(segment.length) ||
+                segment.some((v) => !Number.isSafeInteger(v) || v < 0) ||
+                (segment.length !== 1 && segment[1] >= inspected.declarations.length) ||
+                (segment.length === 5 && segment[4] >= map.names.length))
+                throw new SourceMapFormatFailure("format", "Decoded mapping has invalid component count, position, source index or name index.");
+        }
+    return { map, rows };
+};
+const greatestPosition = (rows, position) => {
+    for (let line = Math.min(position.line - 1, rows.length - 1); line >= 0; line -= 1) {
+        let column;
+        for (const segment of rows[line] ?? [])
+            if (line < position.line - 1 || segment[0] <= position.column)
+                column = segment[0];
+        if (column !== undefined)
+            return { line: line + 1, column };
+    }
+    return null;
+};
+const originalMatch = (segment, map, declarations) => {
+    if (segment.length === 1)
+        return { state: "generated-only" };
+    const declaration = declarations[segment[1]];
+    if (declaration === undefined)
+        throw new SourceMapFormatFailure("format", "Mapping references an absent source declaration.");
+    const original = { line: segment[2] + 1, column: segment[3] };
+    const offset = declaration.content === null
+        ? undefined
+        : webSourceOffset(declaration.content, original);
+    return {
+        state: "mapped",
+        flattened_source_index: segment[1],
+        section_path: [...declaration.sectionPath],
+        source_index: declaration.sourceIndex,
+        reported_source: declaration.source,
+        reported_source_root: declaration.root,
+        resolved_url: declaration.source === null
+            ? null
+            : (map.resolvedSources[segment[1]] ?? null),
+        ignored: declaration.ignored,
+        content: declaration.content === null
+            ? { state: "unavailable", reason: "sourcesContent-not-retained" }
+            : {
+                state: "embedded",
+                text: declaration.content,
+                utf8_sha256: createHash("sha256")
+                    .update(declaration.content)
+                    .digest("hex"),
+                utf8_bytes: Buffer.byteLength(declaration.content),
+                representation: "UTF-8 encoding of decoded sourcesContent text",
+            },
+        original_position: {
+            ...original,
+            offset: offset ?? null,
+            content_position: declaration.content === null
+                ? "content-unavailable"
+                : offset === undefined
+                    ? "outside-embedded-text"
+                    : "verified-in-embedded-text",
+        },
+        name: segment.length === 5 ? (map.names[segment[4]] ?? null) : null,
+    };
+};

package/dist/main/shutdown.js

@@ -7,8 +7,14 @@ export const createShutdown = (input) => {
         shutdownPromise ??= (async () => {
             unregisterReload();
             unregisterShutdown();
-            await handle.close();
-            await session.close({ retainProviderDocuments: true });
+            const results = await Promise.allSettled([
+                handle.close(),
+                input.closeAndroid?.(),
+                session.close({ retainProviderDocuments: true }),
+            ]);
+            for (const result of results)
+                if (result.status === "rejected")
+                    throw result.reason;
         })();
         return shutdownPromise;
     };

package/dist/main/transport.js

@@ -1,4 +1,5 @@
-import { createServer, } from "../server/createServer.js";
+import { createAndroidAnalysisProvider } from "../composition/android.js";
+import { createServer } from "../server/createServer.js";
 import { MCP_CONNECTION_LOST, MCP_CONNECTION_START_FAILED, } from "./messages.js";
 export const startMcpTransport = async (dependencies, session, serverContext) => {
     const { serverLogger } = serverContext;
@@ -11,12 +12,28 @@ export const startMcpTransport = async (dependencies, session, serverContext) =>
             error: cause instanceof Error ? cause.message : String(cause),
         }, "Optional MCP providers could not load; affected tools remain unavailable");
     }
+    for (const failure of Object.values(optionalProviders.optionalProviderLoadFailures ?? {})) {
+        serverLogger.warn({ providerId: failure.providerId, error: failure.reason }, "Optional MCP adapter could not load; its peers remain available");
+    }
+    const androidProviders = [];
+    const closeAndroid = async () => {
+        const results = await Promise.allSettled(androidProviders.map((provider) => provider.close()));
+        for (const result of results)
+            if (result.status === "rejected")
+                throw result.reason;
+    };
     let handle;
     try {
-        handle = dependencies.serve(() => (dependencies.createServer ?? createServer)(session, session, {
-            logger: serverContext.logger,
-            ...optionalProviders,
-        }), {
+        handle = dependencies.serve(() => {
+            // The SDK can discard a discovery probe and construct a replacement server.
+            const android = createAndroidAnalysisProvider(dependencies.env);
+            androidProviders.push(android);
+            return (dependencies.createServer ?? createServer)(session, session, {
+                logger: serverContext.logger,
+                ...optionalProviders,
+                androidAnalysis: android,
+            });
+        }, {
             onerror: () => {
                 serverLogger.error(MCP_CONNECTION_LOST);
                 dependencies.writeStderr(`${MCP_CONNECTION_LOST}\n`);
@@ -24,12 +41,12 @@ export const startMcpTransport = async (dependencies, session, serverContext) =>
         });
     }
     catch (cause) {
-        await session.close();
+        await Promise.allSettled([session.close(), closeAndroid()]);
         serverLogger.error({
             error: cause instanceof Error ? cause.message : String(cause),
         }, MCP_CONNECTION_START_FAILED);
         dependencies.writeStderr(`${MCP_CONNECTION_START_FAILED}\n`);
         return { ok: false };
     }
-    return { ok: true, handle };
+    return { ok: true, handle, closeAndroid };
 };