@cueai/omni-reader-mcp 1.5.4 → 1.6.0

package/README.md

@@ -48,31 +48,25 @@ agent workspace remains the default allowed scope.
 For a local file, Bridge requests a Cube parse grant and uses the returned controlled
 granted-data-plane URL to upload the file and stream the result. A `BRIDGE_UPGRADE_REQUIRED`
 error means the running Bridge release is not accepted for direct local-file parsing —
-install `@cueai/omni-reader-mcp@1.5.4` using the official setup instructions, then retry the
+install `@cueai/omni-reader-mcp@1.6.0` using the official setup instructions, then retry the
 same parse. Always run `doctor --json` first when diagnosing a parse failure.
 
 ## Free credits
 
-As of 2026-08-14:
+The server-side onboarding policy is the authority for the current first-registration gift
+and daily grant. When reachable, `doctor` reports those live policy values; when unavailable,
+it reports that status instead of copying a stale number.
 
-- every account receives 10 free credits daily — roughly 150 pages of ordinary documents,
-  75 pages of scanned images or charts, 30 minutes of audio, or 4 minutes of video;
-- new accounts receive a one-time 50-credit gift when obtaining `CUE_API_KEY` (60 credits
-  available on day one, including the daily grant);
-- inviting a new user who registers gives both the inviter and the invitee 50 credits, with
-  no invite limit; when an invited user subscribes, the inviter additionally receives 10% of
-  the invitee's first-month credit quota as a bonus.
-
-When available, the `doctor` output reports the live first-registration gift and daily grant;
-referral rules and conversion ratios follow the server-side onboarding policy. If live values
-differ from the numbers above, report the live values.
+Bridge does not publish static document-page or media-duration conversions. Rates can change,
+and Phase 1 has no public rate response carrying an `effective_at` timestamp. Use only current
+authoritative billing/policy facts rather than estimating a charge from copied arithmetic.
 
 ## Installation and configuration
 
 Always use an audited exact version, never an implicit `latest`:
 
 ```sh
-npx -y @cueai/omni-reader-mcp@1.5.4 setup
+npx -y @cueai/omni-reader-mcp@1.6.0 setup
 ```
 
 The interactive setup supports Hermes, Cursor, Claude Desktop, and generic stdio
@@ -80,9 +74,9 @@ configuration. Non-interactive installation uses the same argument parsing and w
 logic:
 
 ```sh
-npx -y @cueai/omni-reader-mcp@1.5.4 setup --client hermes --allowed-root /absolute/minimum/root --yes --json
-npx -y @cueai/omni-reader-mcp@1.5.4 setup --client cursor --add-root /absolute/minimum/root --yes --json
-npx -y @cueai/omni-reader-mcp@1.5.4 setup --client claude-desktop --allowed-root /absolute/minimum/root --yes --json
+npx -y @cueai/omni-reader-mcp@1.6.0 setup --client hermes --allowed-root /absolute/minimum/root --yes --json
+npx -y @cueai/omni-reader-mcp@1.6.0 setup --client cursor --add-root /absolute/minimum/root --yes --json
+npx -y @cueai/omni-reader-mcp@1.6.0 setup --client claude-desktop --allowed-root /absolute/minimum/root --yes --json
 ```
 
 When an agent or script runs under a pty (stdin is still a TTY), declare non-interactive
@@ -90,7 +84,7 @@ mode explicitly with `--headless` (alias `--non-interactive`): no `--yes` is req
 stdin is never read:
 
 ```sh
-npx -y @cueai/omni-reader-mcp@1.5.4 setup --client cursor --allowed-root /absolute/minimum/root --headless --json
+npx -y @cueai/omni-reader-mcp@1.6.0 setup --client cursor --allowed-root /absolute/minimum/root --headless --json
 ```
 
 ## Windows configuration
@@ -109,14 +103,14 @@ automatically; the second is the most robust when you configure by hand.
 1. **`cmd` + `npx` (what `setup` writes on Windows)** — `cmd.exe` is a real executable,
    so a client's no-shell spawn works:
    ```json
-   { "command": "cmd", "args": ["/d", "/c", "npx", "-y", "@cueai/omni-reader-mcp@1.5.4"] }
+   { "command": "cmd", "args": ["/d", "/c", "npx", "-y", "@cueai/omni-reader-mcp@1.6.0"] }
    ```
 2. **`node` + the package entry (most robust)** — skips `npx` entirely; the absolute
    path must be a stable install you control:
    ```json
    { "command": "node", "args": ["C:\\path\\to\\node_modules\\@cueai\\omni-reader-mcp\\dist\\index.js"] }
    ```
-   A deliberate local `npm install @cueai/omni-reader-mcp@1.5.4` gives you that stable
+   A deliberate local `npm install @cueai/omni-reader-mcp@1.6.0` gives you that stable
    path. Do not point the entry at an `_npx` cache directory — its hash subdirectory
    changes between installs.
 3. **Never use a session/timestamp directory** — such paths are cleaned up, and the
@@ -165,6 +159,31 @@ Agents pass the user-provided source string directly to `parse(source)`:
 - Prefer the existing `operation_id` for status recovery; never re-upload or duplicate a
   parse for a timeout.
 
+Use the result contract in this order:
+
+```text
+Answer directly → use inline text when present; otherwise read_result
+Find one section → read_outline, then pass its cursor to read_result
+Read all content → read_result until next_cursor is absent
+Deliver a file → save_result
+```
+
+Outline navigation does not require `save_result`: call `read_outline`, then pass a selected
+node cursor directly to `read_result`. `result_delivery="artifact"` is appropriate for saving, section navigation, multiple documents, or strict context control; omitted or `auto` preserves
+inline delivery when possible. For multiple sources, use bounded concurrent independent `parse` calls and keep each operation/result handle separate. There is no `batch_parse` tool,
+and Bridge does not invent one universal concurrency number before client evidence exists.
+
+Client capabilities are classified exactly as `supported | unsupported | unknown`; they are
+discovered from the actual initialize exchange, client documentation/settings, a local
+non-billable harness, or explicit redacted config facts—not guessed from another MCP host.
+Safe fallbacks are:
+
+- Tasks unknown → ordinary `parse` / `get_parse_status` polling.
+- Roots unknown → process cwd and explicitly configured roots only.
+- Host timeout unknown → retain the bounded 20-second status wait.
+- Process cwd versus active workspace unknown → do not widen authorization; use cwd and
+  explicit roots until the client provides evidence.
+
 The public tools are fixed:
 
 - `parse`
@@ -261,37 +280,50 @@ satisfies the constraints.
 ## Commands
 
 ```sh
-npx -y @cueai/omni-reader-mcp@1.5.4 doctor
-npx -y @cueai/omni-reader-mcp@1.5.4 doctor --json
-npx -y @cueai/omni-reader-mcp@1.5.4 clean
-npx -y @cueai/omni-reader-mcp@1.5.4 uninstall --yes --json
+npx -y @cueai/omni-reader-mcp@1.6.0 doctor
+npx -y @cueai/omni-reader-mcp@1.6.0 doctor --json
+npx -y @cueai/omni-reader-mcp@1.6.0 clean
+npx -y @cueai/omni-reader-mcp@1.6.0 uninstall --yes --json
 ```
 
 Running the pinned version without a command starts the stdio MCP server:
 
 ```sh
-npx -y @cueai/omni-reader-mcp@1.5.4
+npx -y @cueai/omni-reader-mcp@1.6.0
+```
+
+Default `doctor --json` reports `inspection_scope: "current_process_env"`: its Key and
+allowed-root facts describe the doctor process, not a separately running agent child. To
+inspect one caller-selected JSON entry without scanning or writing configuration, use:
+
+```sh
+npx -y @cueai/omni-reader-mcp@1.6.0 doctor --json --config-path /absolute/client-config.json --server-name omni-reader
 ```
 
-`doctor --json` returns package/npm/client adapter, Key present/absent, allowed-root
-safety status, the authenticated Cube control/configuration facts, artifacts, cache
-mode, onboarding, and reload status; it never prints the Key, private source paths,
-or content. The `endpoints.direct_upload` field is a fact about the release, not a
-probe: the granted data plane is reached only through a Cube grant and is never
+The optional `explicit_config` block reports only closed redacted facts: entry/transport
+shape, command basename/category, exact package version when derivable, Key configuration
+shape, and allowed-root count/safety. It never resolves or prints a Key, uses a configured
+Key for a network call, prints the config path, scans unrelated entries, or claims that the
+running child process can use the selected entry.
+
+`doctor --json` also returns package/npm/client adapter, authenticated Cube
+control/configuration facts, artifacts, cache mode, onboarding, and reload status. The
+`endpoints.direct_upload` field is a fact about the release, not a probe: the granted data
+plane is reached only through a Cube grant and is never
 definitively "available" until a real local-file parse validates the route.
 
 
 ## Network diagnostics
 
-Run `npx -y @cueai/omni-reader-mcp@1.5.4 doctor --json` first. Diagnose failures by
+Run `npx -y @cueai/omni-reader-mcp@1.6.0 doctor --json` first. Diagnose failures by
 stage instead of guessing an endpoint:
 
-| Code | Stage | Meaning |
+| Failure | Stage | Meaning |
 |---|---|---|
 | `CUBE_UNAVAILABLE` | before upload | the control plane could not create a parse grant |
 | `PRINCIPAL_CONCURRENCY_LIMIT` | before upload | the principal already has the maximum active parses; wait for `retry_after`, then retry the same parse |
-| `BRIDGE_UPGRADE_REQUIRED` | before upload | this Bridge release is too old; install `@cueai/omni-reader-mcp@1.5.4` via the official setup, then retry the same parse |
-| `IIIS_UNAVAILABLE` | after grant creation | the granted upload stage could not complete |
+| `BRIDGE_UPGRADE_REQUIRED` | before upload | this Bridge release is too old; install `@cueai/omni-reader-mcp@1.6.0` via the official setup, then retry the same parse |
+| a secure upload-stage failure | after grant creation | the file was granted, but the secure upload stage did not complete |
 | `CUBE_PROTOCOL_ERROR` | control-plane response | the response did not match the required contract |
 | `MCP error -32000: Connection closed` | before Bridge starts | the client launcher shape is invalid; see Windows configuration |
 
@@ -309,15 +341,16 @@ the same way from every client.
 
 ## Uninstall and rollback
 
-`uninstall --yes --json` removes only a trusted 1.5.3 or 1.5.4 Bridge entry, plus
+`uninstall --yes --json` removes only a trusted 1.5.5 or 1.6.0 Bridge entry, plus
 the exact broken bare-`npx` Windows entry written by 1.5.1. When a matching trusted
 backup exists, it restores the original URL-only `omni-reader` entry. Uninstall never
 deletes user source files and never silently removes unexpired local results.
 
-To roll back from 1.5.4:
+To roll back from 1.6.0 to 1.5.5:
 
-1. stop recommending or installing that version;
+1. stop recommending or installing 1.6.0;
 2. run `uninstall --yes --json` to restore the trusted URL-only entry;
-3. for already-uploaded operations, continue using status recovery so settlement and
+3. if the local facade is still required, run `npx -y @cueai/omni-reader-mcp@1.5.5 setup`;
+4. for already-uploaded operations, continue using status recovery so settlement and
    cleanup complete;
-4. keep local results, or have the user explicitly run `discard_result` / `clean`.
+5. keep local results, or have the user explicitly run `discard_result` / `clean`.

package/dist/artifact-store.d.ts

@@ -109,8 +109,10 @@ export declare class ArtifactStore {
     static open(options?: ArtifactStoreOptions): Promise<ArtifactStore>;
     get rootDirectory(): string;
     createRetention(): LocalResultRetention;
+    preflightWrite(): Promise<void>;
     read(resultId: string, cursor?: string, maxBytes?: number): Promise<ArtifactReadResult>;
     readOutline(resultId: string): Promise<OutlineResult>;
+    mintReadCursor(resultId: string, byteOffset: number): Promise<string>;
     mintOutlineCursor(resultId: string, byteOffset: number): Promise<string>;
     exportResult(resultId: string): Promise<{
         path: string;

package/dist/artifact-store.js

@@ -5,7 +5,7 @@ import os from "node:os";
 import path from "node:path";
 import { z } from "zod";
 import { ARTIFACT_TTL_MS, INLINE_RESULT_MAX_BYTES, RESULT_CHUNK_MAX_BYTES } from "./constants.js";
-import { CursorCodec } from "./cursor.js";
+import { CursorCodec, CursorCodecError } from "./cursor.js";
 import { OmniBridgeError } from "./errors.js";
 import { extractOutline } from "./outline.js";
 import { GROUNDING_SCHEMA_VERSION, RESULT_BUNDLE_PROTOCOL_VERSION } from "./protocol.js";
@@ -28,11 +28,11 @@ function artifactError(code, message, retryable = false) {
     return new OmniBridgeError({
         code,
         message,
-        operationCreated: true,
-        fileUploaded: true,
-        parserStarted: true,
-        billed: true,
-        contentReleased: true,
+        operationCreated: false,
+        fileUploaded: false,
+        parserStarted: false,
+        billed: false,
+        contentReleased: false,
         retryable,
     });
 }
@@ -48,6 +48,17 @@ function cacheError(code, message) {
         retryable: false,
     });
 }
+function decodeCursor(action) {
+    try {
+        return action();
+    }
+    catch (error) {
+        if (error instanceof CursorCodecError) {
+            throw artifactError(error.code, error.message);
+        }
+        throw error;
+    }
+}
 function errno(error, code) {
     return error instanceof Error && error.code === code;
 }
@@ -475,6 +486,27 @@ export class ArtifactStore {
         this.#requireOpen();
         return new LocalResultRetention(this);
     }
+    async preflightWrite() {
+        this.#requireOpen();
+        const probePath = path.join(this.#resultsDirectory, `.tmp-preflight-${randomBytes(18).toString("base64url")}`);
+        let handle;
+        try {
+            handle = await open(probePath, "wx", 0o600);
+            await handle.writeFile("omni-artifact-preflight-v1\n", "utf8");
+            await handle.sync();
+            await handle.close();
+            handle = undefined;
+            await removeIfPresent(probePath);
+            await syncDirectory(this.#resultsDirectory);
+        }
+        catch (error) {
+            await handle?.close().catch(() => undefined);
+            await removeIfPresent(probePath).catch(() => false);
+            if (error instanceof OmniBridgeError)
+                throw error;
+            throw artifactError("ARTIFACT_PREFLIGHT_FAILED", "The local result cache is not writable.", true);
+        }
+    }
     async read(resultId, cursor, maxBytes = RESULT_CHUNK_MAX_BYTES) {
         this.#requireOpen();
         let metadata;
@@ -496,7 +528,7 @@ export class ArtifactStore {
         }
         let offset = 0;
         if (cursor !== undefined) {
-            const payload = this.#cursor.decode(cursor);
+            const payload = decodeCursor(() => this.#cursor.decode(cursor));
             if (payload.resultId !== resultId || payload.expiresAt !== metadata.expiresAt) {
                 throw artifactError("RESULT_CURSOR_MISMATCH", "The result cursor does not match this artifact.");
             }
@@ -559,7 +591,7 @@ export class ArtifactStore {
         }
         return extractOutline(fullText);
     }
-    async mintOutlineCursor(resultId, byteOffset) {
+    async mintReadCursor(resultId, byteOffset) {
         this.#requireOpen();
         const metadata = await this.#loadMetadata(resultId);
         if (Date.parse(metadata.expiresAt) <= this.#now().getTime()) {
@@ -567,10 +599,13 @@ export class ArtifactStore {
             throw artifactError("RESULT_EXPIRED", "The local result artifact has expired.");
         }
         if (!Number.isSafeInteger(byteOffset) || byteOffset < 0 || byteOffset > metadata.resultBytes) {
-            throw artifactError("INVALID_RESULT_CURSOR", "The outline node offset is invalid.");
+            throw artifactError("INVALID_RESULT_CURSOR", "The result cursor offset is invalid.");
         }
         return this.#cursor.encode({ resultId, offset: byteOffset, expiresAt: metadata.expiresAt });
     }
+    async mintOutlineCursor(resultId, byteOffset) {
+        return this.mintReadCursor(resultId, byteOffset);
+    }
     // The full content text in one read, regardless of storage shape (a flat
     // v1 artifact, or a v2 bundle's "content" part). save_result's only
     // consumer: read_result's chunked/cursor contract stays the single way an
@@ -657,7 +692,7 @@ export class ArtifactStore {
     // against the actual bytes before any chunk is returned.
     async readBundlePart(resultId, cursor, maxBytes = RESULT_CHUNK_MAX_BYTES) {
         this.#requireOpen();
-        const payload = this.#cursor.decodeBundle(cursor);
+        const payload = decodeCursor(() => this.#cursor.decodeBundle(cursor));
         if (payload.resultId !== resultId) {
             throw artifactError("RESULT_CURSOR_MISMATCH", "The result cursor does not match this artifact.");
         }

package/dist/cli/agent-config.js

@@ -7,7 +7,7 @@ const PACKAGE_SPEC = `@cueai/omni-reader-mcp@${BRIDGE_RELEASE_VERSION}`;
 // The release that the current version is a trusted upgrade from: normal upgrade,
 // uninstall, and rollback recognize exactly {previous, current}. Bump this to the
 // version we just published when BRIDGE_RELEASE_VERSION advances.
-const PREVIOUS_RELEASE_VERSION = "1.5.3";
+const PREVIOUS_RELEASE_VERSION = "1.5.5";
 const PREVIOUS_PACKAGE_SPEC = `@cueai/omni-reader-mcp@${PREVIOUS_RELEASE_VERSION}`;
 // Preserve the one evidenced two-release migration exception: 1.5.1 setup wrote a
 // bare `npx` launcher on Windows, so later setup/uninstall versions must still be able
@@ -641,7 +641,7 @@ export function expectedBridgeVersion(target, value, platform) {
 }
 function isLegacyBridgeEntry(target, value, platform) {
     // Defer the entire invocation-shape decision to the single platform policy:
-    // exact pinned {1.5.3 previous, 1.5.4 current} plus the exact Windows 1.5.1
+    // exact pinned {1.5.5 previous, 1.6.0 current} plus the exact Windows 1.5.1
     // bare-npx migration source. The historical platform-agnostic acceptance of a
     // bare unpinned `npx -y @cueai/omni-reader-mcp` is removed: it widened the
     // frozen trust set to a floating latest on every OS, which expectedBridgeVersion

package/dist/cli/arguments.d.ts

@@ -7,18 +7,22 @@ export interface SetupArguments {
     readonly headless: boolean;
     readonly json: boolean;
 }
+export interface DoctorArguments {
+    readonly json: boolean;
+    readonly configPath?: string;
+    readonly serverName?: string;
+}
 export type ParsedCommand = {
     readonly command: "server";
 } | {
     readonly command: "help";
 } | {
     readonly command: "version";
-} | {
+} | ({
+    readonly command: "doctor";
+} & DoctorArguments) | {
     readonly command: "setup";
     readonly arguments: SetupArguments;
-} | {
-    readonly command: "doctor";
-    readonly json: boolean;
 } | {
     readonly command: "clean";
 } | {

package/dist/cli/arguments.js

@@ -1,4 +1,5 @@
 import path from "node:path";
+import { PathNormalizationError, normalizePlatformPath, } from "../path-normalization.js";
 import { parseAgentTarget } from "./agent-config.js";
 export class CliUsageError extends Error {
     exitCode = 2;
@@ -10,6 +11,26 @@ export class CliUsageError extends Error {
 function pathsFor(platform) {
     return platform === "win32" ? path.win32 : path.posix;
 }
+function normalizeAbsoluteCliPath(raw, flag, platform) {
+    if (raw.length === 0 || raw.includes("\0")) {
+        throw new CliUsageError(`${flag} requires one valid absolute path.`);
+    }
+    let normalizedInput;
+    try {
+        normalizedInput = normalizePlatformPath(raw, platform);
+    }
+    catch (error) {
+        if (error instanceof PathNormalizationError) {
+            throw new CliUsageError(error.message);
+        }
+        throw error;
+    }
+    const paths = pathsFor(platform);
+    if (!paths.isAbsolute(normalizedInput)) {
+        throw new CliUsageError(`${flag} requires an absolute path.`);
+    }
+    return paths.normalize(normalizedInput);
+}
 function requireNoArguments(command, values) {
     if (values.length > 0)
         throw new CliUsageError(`${command} does not accept arguments.`);
@@ -35,7 +56,6 @@ function parseSetupArguments(values, platform) {
     let headless = false;
     let json = false;
     const seen = new Set();
-    const paths = pathsFor(platform);
     for (let index = 0; index < values.length; index += 1) {
         const flag = values[index];
         if (!["--client", "--allowed-root", "--add-root", "--yes", "--headless", "--non-interactive", "--json"].includes(flag)) {
@@ -71,10 +91,7 @@ function parseSetupArguments(values, platform) {
             client = parsed;
             continue;
         }
-        if (!paths.isAbsolute(raw)) {
-            throw new CliUsageError(`${flag} requires an absolute path.`);
-        }
-        const normalized = paths.normalize(raw);
+        const normalized = normalizeAbsoluteCliPath(raw, flag, platform);
         if (flag === "--allowed-root")
             allowedRoot = normalized;
         if (flag === "--add-root")
@@ -92,6 +109,45 @@ function parseSetupArguments(values, platform) {
         json,
     };
 }
+function parseDoctorArguments(values, platform) {
+    let json = false;
+    let configPath;
+    let serverName;
+    const seen = new Set();
+    for (let index = 0; index < values.length; index += 1) {
+        const flag = values[index];
+        if (!["--json", "--config-path", "--server-name"].includes(flag)) {
+            throw new CliUsageError(`Unknown doctor flag: ${flag}`);
+        }
+        if (seen.has(flag))
+            throw new CliUsageError(`Duplicate doctor flag: ${flag}`);
+        seen.add(flag);
+        if (flag === "--json") {
+            json = true;
+            continue;
+        }
+        const raw = values[index + 1];
+        if (raw === undefined || raw.startsWith("--")) {
+            throw new CliUsageError(`${flag} requires a value.`);
+        }
+        index += 1;
+        if (flag === "--config-path") {
+            configPath = normalizeAbsoluteCliPath(raw, flag, platform);
+            continue;
+        }
+        if (raw.length === 0 || raw.includes("\0")) {
+            throw new CliUsageError("--server-name requires one valid entry name.");
+        }
+        serverName = raw;
+    }
+    if ((configPath === undefined) !== (serverName === undefined)) {
+        throw new CliUsageError("--config-path and --server-name must be provided together.");
+    }
+    return {
+        json,
+        ...(configPath === undefined ? {} : { configPath, serverName: serverName }),
+    };
+}
 export function parseCliArguments(argv, platform = process.platform) {
     if (argv.length === 0)
         return { command: "server" };
@@ -108,8 +164,7 @@ export function parseCliArguments(argv, platform = process.platform) {
         return { command: "setup", arguments: parseSetupArguments(values, platform) };
     }
     if (command === "doctor") {
-        const flags = parseBooleanFlags("doctor", values, new Set(["--json"]));
-        return { command: "doctor", json: flags.has("--json") };
+        return { command: "doctor", ...parseDoctorArguments(values, platform) };
     }
     if (command === "clean") {
         requireNoArguments("clean", values);

package/dist/cli/config-inspection.d.ts

@@ -0,0 +1,59 @@
+import { type BigIntStats } from "node:fs";
+export interface ConfigInspectionHandle {
+    stat(options: {
+        bigint: true;
+    }): Promise<BigIntStats>;
+    read(buffer: Buffer, offset: number, length: number, position: number): Promise<{
+        bytesRead: number;
+        buffer: Buffer;
+    }>;
+    close(): Promise<void>;
+}
+export interface ConfigInspectionFileSystem {
+    lstat(candidate: string): Promise<BigIntStats>;
+    open(candidate: string, flags: number): Promise<ConfigInspectionHandle>;
+}
+export declare class ConfigInspectionError extends Error {
+    readonly code: string;
+    readonly constraints?: {
+        readonly max_bytes: number;
+    };
+    constructor(code: string, message: string, constraints?: {
+        readonly max_bytes: number;
+    });
+}
+export type ConfigEntryStatus = "present" | "missing" | "invalid";
+export type ConfigTransportShape = "local_command" | "remote_url" | "unknown";
+export type ConfiguredApiKeyStatus = "literal_present" | "reference_present" | "absent" | "unknown";
+export type AllowedRootSafety = "safe" | "unsafe" | "unknown";
+export type CommandCategory = "package_runner" | "shell" | "runtime" | "executable";
+export interface ExplicitConfigInspection {
+    readonly inspection_scope: "explicit_config";
+    readonly entry: {
+        readonly status: ConfigEntryStatus;
+    };
+    readonly transport: {
+        readonly shape: ConfigTransportShape;
+        readonly command?: {
+            readonly basename: string;
+            readonly category: CommandCategory;
+        };
+    };
+    readonly package_version?: string;
+    readonly api_key: {
+        readonly status: ConfiguredApiKeyStatus;
+    };
+    readonly allowed_roots: {
+        readonly count: number;
+        readonly safety: Exclude<AllowedRootSafety, "unknown">;
+    } | {
+        readonly safety: "unknown";
+    };
+}
+export interface InspectExplicitConfigOptions {
+    readonly configPath: string;
+    readonly serverName: string;
+    readonly platform?: NodeJS.Platform;
+    readonly fileSystem?: ConfigInspectionFileSystem;
+}
+export declare function inspectExplicitConfig(options: InspectExplicitConfigOptions): Promise<ExplicitConfigInspection>;