@cueai/omni-reader-mcp 1.5.5 → 1.7.0

package/README.md

@@ -28,7 +28,7 @@ rather than stopping at "parse done".
 
 - Node.js 20.12 or newer.
 - Cue API Key: <https://cuecue.cn/hub/api-key>.
-- New accounts can try Omni without paying; see [Free credits](#free-credits) below. The
+- New accounts can try Omni without paying; see [Free credits](#billing-and-free-credits) below. The
   server-side onboarding policy and the `doctor` output are the live authority for current
   allowances.
 - Configure `CUE_API_KEY` in the agent's secret store or local environment.
@@ -48,31 +48,45 @@ 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.5` using the official setup instructions, then retry the
+install `@cueai/omni-reader-mcp@1.7.0` using the official setup instructions, then retry the
 same parse. Always run `doctor --json` first when diagnosing a parse failure.
 
-## Free credits
+## Billing and free credits
 
-As of 2026-08-14:
+The server-side [onboarding policy](https://cuecue.cn/api/v1/billing/public/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.
+A terminal URL or local-file result may carry the operation-local settlement snapshot:
 
-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.
+```json
+{
+  "billing": {
+    "credits_charged": 0.134,
+    "credits_remaining": 42.866
+  }
+}
+```
+
+The numbers above illustrate the response shape, not a price quote. The settled result is authoritative.
+`credits_charged` is the amount deducted for that operation and
+`credits_remaining` is the balance in the same immutable settlement snapshot. Bridge never
+replaces it with a later balance lookup. Processing results have no billing block. New direct
+canceled, failed, unsupported, or denied terminals are uncharged and carry no billing block.
+Navigation and status calls preserve the same settled facts without creating another usage or
+settlement identity.
+
+Bridge does not publish static document-page or media-duration conversions. Rates can change,
+and there is 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.5 setup
+npx -y @cueai/omni-reader-mcp@1.7.0 setup
 ```
 
 The interactive setup supports Hermes, Cursor, Claude Desktop, and generic stdio
@@ -80,9 +94,9 @@ configuration. Non-interactive installation uses the same argument parsing and w
 logic:
 
 ```sh
-npx -y @cueai/omni-reader-mcp@1.5.5 setup --client hermes --allowed-root /absolute/minimum/root --yes --json
-npx -y @cueai/omni-reader-mcp@1.5.5 setup --client cursor --add-root /absolute/minimum/root --yes --json
-npx -y @cueai/omni-reader-mcp@1.5.5 setup --client claude-desktop --allowed-root /absolute/minimum/root --yes --json
+npx -y @cueai/omni-reader-mcp@1.7.0 setup --client hermes --allowed-root /absolute/minimum/root --yes --json
+npx -y @cueai/omni-reader-mcp@1.7.0 setup --client cursor --add-root /absolute/minimum/root --yes --json
+npx -y @cueai/omni-reader-mcp@1.7.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 +104,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.5 setup --client cursor --allowed-root /absolute/minimum/root --headless --json
+npx -y @cueai/omni-reader-mcp@1.7.0 setup --client cursor --allowed-root /absolute/minimum/root --headless --json
 ```
 
 ## Windows configuration
@@ -109,14 +123,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.5"] }
+   { "command": "cmd", "args": ["/d", "/c", "npx", "-y", "@cueai/omni-reader-mcp@1.7.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.5` gives you that stable
+   A deliberate local `npm install @cueai/omni-reader-mcp@1.7.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
@@ -155,6 +169,8 @@ Configuration never writes the API Key in plaintext. Hermes uses native separate
 
 ## Agent calling rules
 
+`parse` is the only first-call entry for both HTTP(S) URLs and local paths. Agents choose continuation tools automatically from the structured result instead of presenting a tool menu to the user.
+
 Agents pass the user-provided source string directly to `parse(source)`:
 
 - Only HTTP(S) is treated as a URL; a plain string is treated as a local path.
@@ -165,15 +181,40 @@ 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.
 
-The public tools are fixed:
+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:
 
-- `parse`
-- `get_parse_status`
-- `cancel_parse`
-- `read_result`
-- `read_outline`
-- `discard_result`
-- `save_result`
+- 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 physical protocol surfaces stay fixed even though the user sees one Omni Reader:
+
+- The remote-only connector advertises `parse`, `get_parse_status`, and `cancel_parse`.
+- Bridge advertises those same three plus the local-artifact continuation tools
+  `read_result`, `read_outline`, `discard_result`, and `save_result`.
+
+`parse` remains the sole first call. The other six Bridge tools are continuation and
+lifecycle primitives selected from structured operation/result state; they are not modes
+for the user to choose.
 
 Every tool returns `structuredContent` with a strict `outputSchema`, plus an equivalent
 fallback for clients that only read legacy MCP `content[].text`:
@@ -190,6 +231,8 @@ fallback for clients that only read legacy MCP `content[].text`:
   anchored at that heading, so a long result can be jumped into directly instead of only
   advancing sequentially through `next_cursor`. An empty or absent outline is reported
   explicitly, never silently — it never blocks reading the result itself with `read_result`;
+- Text output remains Markdown and may contain headings, lists, GFM tables, and raw HTML tables.
+  It omits grounding/layout sidecars, not all textual structure. An empty outline means no recognized headings; it does not mean the text has no structure;
 - the `discard_result` text JSON explicitly returns `discarded`; never claim deletion on
   call success alone;
 - the `save_result` text JSON contains the written file `path` and `bytes` count; there is
@@ -261,36 +304,52 @@ satisfies the constraints.
 ## Commands
 
 ```sh
-npx -y @cueai/omni-reader-mcp@1.5.5 doctor
-npx -y @cueai/omni-reader-mcp@1.5.5 doctor --json
-npx -y @cueai/omni-reader-mcp@1.5.5 clean
-npx -y @cueai/omni-reader-mcp@1.5.5 uninstall --yes --json
+npx -y @cueai/omni-reader-mcp@1.7.0 doctor
+npx -y @cueai/omni-reader-mcp@1.7.0 doctor --json
+npx -y @cueai/omni-reader-mcp@1.7.0 clean
+npx -y @cueai/omni-reader-mcp@1.7.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.5
+npx -y @cueai/omni-reader-mcp@1.7.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.7.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.5 doctor --json` first. Diagnose failures by
+Run `npx -y @cueai/omni-reader-mcp@1.7.0 doctor --json` first. Diagnose failures by
 stage instead of guessing an endpoint:
 
 | Failure | Stage | Meaning |
 |---|---|---|
 | `CUBE_UNAVAILABLE` | before upload | the control plane could not create a parse grant |
+| `DIRECT_UPLOAD_UNAVAILABLE` | before upload | the service's direct-upload route is unavailable; this is not an account restriction, and HTTP 403 is the account-entitlement signal |
+| `DETAIL_CAPABILITIES_UNAVAILABLE` | before grant | this service does not currently advertise grounded/layout parsing; use text only when Markdown without grounding/layout sidecars is acceptable |
+| `UNSUPPORTED_DETAIL` | before upload | the requested parsing representation/profile is unavailable; do not retry unchanged or describe the account as text-only |
 | `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.5` via the official setup, then retry the same parse |
+| `BRIDGE_UPGRADE_REQUIRED` | before upload | this Bridge release is too old; install `@cueai/omni-reader-mcp@1.7.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 +368,16 @@ the same way from every client.
 
 ## Uninstall and rollback
 
-`uninstall --yes --json` removes only a trusted 1.5.4 or 1.5.5 Bridge entry, plus
+`uninstall --yes --json` removes only a trusted 1.6.0 or 1.7.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.5:
+To roll back from 1.7.0 to 1.6.0:
 
-1. stop recommending or installing that version;
+1. stop recommending or installing 1.7.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.6.0 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/capabilities.d.ts

@@ -1,6 +1,9 @@
 import { z } from "zod";
+import { type OmniSourceKind } from "./errors.js";
 export declare const READER_CAPABILITIES_PROTOCOL = "omni.reader_capabilities.v1";
+export declare const READER_CAPABILITIES_V2_PROTOCOL = "omni.reader_capabilities.v2";
 export type RequestedDetail = "grounded" | "layout";
+export type RequestedDirectDetailV2 = "text" | RequestedDetail;
 declare const directProfileSchema: z.ZodObject<{
     profile: z.ZodLiteral<"omni.direct_grounding.v1">;
     grant_protocol: z.ZodLiteral<"omni.parse_grant.v3">;
@@ -78,15 +81,139 @@ declare const urlProfileSchema: z.ZodObject<{
     details: ["grounded", "layout"];
     max_result_bytes: 16777216;
 }>;
+export declare const DIRECT_TEXT_BILLING_PROFILE: {
+    readonly profile: "omni.direct_text_billing.v1";
+    readonly grant_protocol: "omni.parse_grant.v4";
+    readonly stream_protocol: "omni.granted_parse_stream.v3";
+    readonly operation_protocol: "omni.direct_operation.v3";
+    readonly settlement_protocol: "omni.grant_settlement.v5";
+    readonly release_protocol: "omni.release_decision.v3";
+    readonly settlement_journal_protocol: "omni.direct_settlement_journal.v3";
+    readonly usage_protocol: "omni_parse_usage.v2";
+    readonly billing_protocol: "omni_billing.v2";
+    readonly bridge_protocol: "omni.local_bridge_tools.v5";
+    readonly details: readonly ["text"];
+    readonly max_result_bytes: 268435456;
+};
+export declare const DIRECT_GROUNDING_BILLING_PROFILE: {
+    readonly profile: "omni.direct_grounding_billing.v1";
+    readonly grant_protocol: "omni.parse_grant.v4";
+    readonly stream_protocol: "omni.granted_parse_stream.v3";
+    readonly operation_protocol: "omni.direct_operation.v3";
+    readonly settlement_protocol: "omni.grant_settlement.v5";
+    readonly release_protocol: "omni.release_decision.v3";
+    readonly settlement_journal_protocol: "omni.direct_settlement_journal.v3";
+    readonly usage_protocol: "omni_parse_usage.v2";
+    readonly billing_protocol: "omni_billing.v2";
+    readonly bridge_protocol: "omni.local_bridge_tools.v5";
+    readonly bundle_protocol: "omni.result_bundle.v1";
+    readonly grounding_schema: "omni.grounding.v1";
+    readonly details: readonly ["grounded", "layout"];
+    readonly max_result_bytes: 67108864;
+};
+declare const directProfileV2Schema: z.ZodDiscriminatedUnion<"profile", [z.ZodObject<{
+    profile: z.ZodLiteral<"omni.direct_text_billing.v1">;
+    grant_protocol: z.ZodLiteral<"omni.parse_grant.v4">;
+    stream_protocol: z.ZodLiteral<"omni.granted_parse_stream.v3">;
+    operation_protocol: z.ZodLiteral<"omni.direct_operation.v3">;
+    settlement_protocol: z.ZodLiteral<"omni.grant_settlement.v5">;
+    release_protocol: z.ZodLiteral<"omni.release_decision.v3">;
+    settlement_journal_protocol: z.ZodLiteral<"omni.direct_settlement_journal.v3">;
+    usage_protocol: z.ZodLiteral<"omni_parse_usage.v2">;
+    billing_protocol: z.ZodLiteral<"omni_billing.v2">;
+    bridge_protocol: z.ZodLiteral<"omni.local_bridge_tools.v5">;
+    details: z.ZodTuple<[z.ZodLiteral<"text">], null>;
+    max_result_bytes: z.ZodLiteral<268435456>;
+}, "strict", z.ZodTypeAny, {
+    profile: "omni.direct_text_billing.v1";
+    grant_protocol: "omni.parse_grant.v4";
+    stream_protocol: "omni.granted_parse_stream.v3";
+    operation_protocol: "omni.direct_operation.v3";
+    settlement_protocol: "omni.grant_settlement.v5";
+    release_protocol: "omni.release_decision.v3";
+    settlement_journal_protocol: "omni.direct_settlement_journal.v3";
+    usage_protocol: "omni_parse_usage.v2";
+    billing_protocol: "omni_billing.v2";
+    bridge_protocol: "omni.local_bridge_tools.v5";
+    details: ["text"];
+    max_result_bytes: 268435456;
+}, {
+    profile: "omni.direct_text_billing.v1";
+    grant_protocol: "omni.parse_grant.v4";
+    stream_protocol: "omni.granted_parse_stream.v3";
+    operation_protocol: "omni.direct_operation.v3";
+    settlement_protocol: "omni.grant_settlement.v5";
+    release_protocol: "omni.release_decision.v3";
+    settlement_journal_protocol: "omni.direct_settlement_journal.v3";
+    usage_protocol: "omni_parse_usage.v2";
+    billing_protocol: "omni_billing.v2";
+    bridge_protocol: "omni.local_bridge_tools.v5";
+    details: ["text"];
+    max_result_bytes: 268435456;
+}>, z.ZodObject<{
+    profile: z.ZodLiteral<"omni.direct_grounding_billing.v1">;
+    grant_protocol: z.ZodLiteral<"omni.parse_grant.v4">;
+    stream_protocol: z.ZodLiteral<"omni.granted_parse_stream.v3">;
+    operation_protocol: z.ZodLiteral<"omni.direct_operation.v3">;
+    settlement_protocol: z.ZodLiteral<"omni.grant_settlement.v5">;
+    release_protocol: z.ZodLiteral<"omni.release_decision.v3">;
+    settlement_journal_protocol: z.ZodLiteral<"omni.direct_settlement_journal.v3">;
+    usage_protocol: z.ZodLiteral<"omni_parse_usage.v2">;
+    billing_protocol: z.ZodLiteral<"omni_billing.v2">;
+    bridge_protocol: z.ZodLiteral<"omni.local_bridge_tools.v5">;
+    bundle_protocol: z.ZodLiteral<"omni.result_bundle.v1">;
+    grounding_schema: z.ZodLiteral<"omni.grounding.v1">;
+    details: z.ZodTuple<[z.ZodLiteral<"grounded">, z.ZodLiteral<"layout">], null>;
+    max_result_bytes: z.ZodLiteral<67108864>;
+}, "strict", z.ZodTypeAny, {
+    profile: "omni.direct_grounding_billing.v1";
+    grant_protocol: "omni.parse_grant.v4";
+    stream_protocol: "omni.granted_parse_stream.v3";
+    operation_protocol: "omni.direct_operation.v3";
+    settlement_protocol: "omni.grant_settlement.v5";
+    release_protocol: "omni.release_decision.v3";
+    settlement_journal_protocol: "omni.direct_settlement_journal.v3";
+    usage_protocol: "omni_parse_usage.v2";
+    billing_protocol: "omni_billing.v2";
+    bridge_protocol: "omni.local_bridge_tools.v5";
+    bundle_protocol: "omni.result_bundle.v1";
+    grounding_schema: "omni.grounding.v1";
+    details: ["grounded", "layout"];
+    max_result_bytes: 67108864;
+}, {
+    profile: "omni.direct_grounding_billing.v1";
+    grant_protocol: "omni.parse_grant.v4";
+    stream_protocol: "omni.granted_parse_stream.v3";
+    operation_protocol: "omni.direct_operation.v3";
+    settlement_protocol: "omni.grant_settlement.v5";
+    release_protocol: "omni.release_decision.v3";
+    settlement_journal_protocol: "omni.direct_settlement_journal.v3";
+    usage_protocol: "omni_parse_usage.v2";
+    billing_protocol: "omni_billing.v2";
+    bridge_protocol: "omni.local_bridge_tools.v5";
+    bundle_protocol: "omni.result_bundle.v1";
+    grounding_schema: "omni.grounding.v1";
+    details: ["grounded", "layout"];
+    max_result_bytes: 67108864;
+}>]>;
 export type DirectProfileV1 = z.infer<typeof directProfileSchema>;
 export type UrlProfileV1 = z.infer<typeof urlProfileSchema>;
+export type DirectProfileV2 = z.infer<typeof directProfileV2Schema>;
+export type DirectProfile = DirectProfileV1["profile"] | DirectProfileV2["profile"];
 export interface ReaderCapabilitiesV1 {
     readonly protocol_version: typeof READER_CAPABILITIES_PROTOCOL;
     readonly expires_at: Date;
     readonly direct_profiles: readonly DirectProfileV1[];
     readonly url_profiles: readonly UrlProfileV1[];
 }
+export interface ReaderCapabilitiesV2 {
+    readonly protocol_version: typeof READER_CAPABILITIES_V2_PROTOCOL;
+    readonly expires_at: Date;
+    readonly direct_profiles: readonly DirectProfileV2[];
+}
 export declare function parseReaderCapabilities(value: unknown, now: Date): ReaderCapabilitiesV1;
-export declare function selectDirectProfile(value: ReaderCapabilitiesV1, detail: RequestedDetail): DirectProfileV1;
-export declare function selectUrlProfile(value: ReaderCapabilitiesV1, detail: RequestedDetail): UrlProfileV1;
+export declare function selectDirectProfile(value: ReaderCapabilitiesV1, detail: RequestedDetail, sourceKind?: OmniSourceKind): DirectProfileV1;
+export declare function selectUrlProfile(value: ReaderCapabilitiesV1, detail: RequestedDetail, sourceKind?: OmniSourceKind): UrlProfileV1;
+export declare function parseReaderCapabilitiesV2(value: unknown, now: Date): ReaderCapabilitiesV2;
+export declare function selectDirectProfileV2(value: ReaderCapabilitiesV2, detail: RequestedDirectDetailV2, sourceKind?: OmniSourceKind): DirectProfileV2;
 export {};