@cueai/omni-reader-mcp 1.1.2 → 1.2.0

package/dist/operation-manager.d.ts

@@ -1,8 +1,9 @@
-import type { ArtifactReadResult, LocalResult } from "./artifact-store.js";
+import type { ArtifactReadResult, BundleLocalResult, LocalResult } from "./artifact-store.js";
 import type { CubeGrantClient } from "./cube-client.js";
 import type { IiisClient, ResultRetentionSink } from "./iiis-client.js";
 import type { JournalPatch, JournalRecord, JournalState, OperationJournal } from "./operation-journal.js";
 import { type OpenAllowedFileOptions, type OpenedAllowedFile } from "./path-security.js";
+import { type RepresentationIntent } from "./protocol.js";
 import type { RemoteOmniClient } from "./remote-client.js";
 import type { ParseResult } from "./result-contract.js";
 export interface SubmitOperationInput {
@@ -11,6 +12,7 @@ export interface SubmitOperationInput {
     readonly clientRequestId: string;
     readonly signal?: AbortSignal;
     readonly context?: unknown;
+    readonly representation?: RepresentationIntent;
 }
 export interface OperationDriverUpdate {
     readonly state: JournalState;
@@ -36,11 +38,12 @@ export interface OperationManagerDriver {
     result?(record: JournalRecord, signal: AbortSignal): Promise<ParseResult | void>;
 }
 export interface OperationManagerOptions {
-    readonly journal: Pick<OperationJournal, "beginIntent" | "transition" | "loadByRequestId" | "loadByOperationId" | "loadLatestByRequestHash" | "loadLatestBySourceLocatorHash" | "listRecoverable">;
+    readonly journal: Pick<OperationJournal, "beginIntent" | "migrateLegacyRecord" | "requestIdentityHmac" | "sourceLocatorHmac" | "transition" | "loadByRequestId" | "loadByOperationId" | "loadLatestByRequestIdentityHmac" | "loadLatestBySourceLocatorHmac" | "listRecoverable">;
     readonly driver: OperationManagerDriver;
     readonly now?: () => number;
     readonly sleep?: (milliseconds: number) => Promise<void>;
 }
+export declare function canonicalRequestIdentity(input: Pick<SubmitOperationInput, "sourceKind" | "sourceFacts">): string;
 export declare function operationRequestHash(input: Pick<SubmitOperationInput, "sourceKind" | "sourceFacts">): string;
 export declare class OperationManager {
     #private;
@@ -54,10 +57,12 @@ export declare class OperationManager {
 }
 interface LocalRetention extends ResultRetentionSink {
     result(): LocalResult;
+    bundleResult?(): BundleLocalResult;
 }
 interface LocalArtifactStore {
     createRetention(): LocalRetention;
     read(resultId: string, cursor?: string, maxBytes?: number): Promise<ArtifactReadResult>;
+    readBundleDescriptor?(resultId: string): Promise<BundleLocalResult | null>;
 }
 export interface LocalParseOperationManagerOptions {
     readonly journal: OperationJournal;

package/dist/operation-manager.js

@@ -1,8 +1,10 @@
 import { createHash } from "node:crypto";
 import { DELIVERY_TTL_SECONDS, FOREGROUND_BUDGET_MS, INLINE_RESULT_MAX_BYTES, STATUS_LONG_POLL_MAX_MS, STATUS_POLL_AFTER_SECONDS, } from "./constants.js";
 import { OmniBridgeError } from "./errors.js";
+import { LEGACY_RECOVERY_FAILURE_CODE } from "./operation-journal.js";
 import { openAllowedFile, } from "./path-security.js";
 import { NOOP_PROGRESS } from "./progress.js";
+import { normalizeRepresentation } from "./protocol.js";
 const TERMINAL_STATES = new Set([
     "COMPLETED",
     "FAILED",
@@ -51,12 +53,54 @@ function canonicalValue(value) {
     }
     throw managerError("INVALID_SOURCE_FACTS", "The operation source facts contain an unsupported value.");
 }
-export function operationRequestHash(input) {
-    const serialized = JSON.stringify({
+// Exact canonical serialization of the request identity. The normalized
+// representation tuple lives inside sourceFacts, so omitted/text and each
+// non-text detail serialize to distinct canonical strings; the journal derives
+// its keyed request identity HMAC from exactly this string.
+export function canonicalRequestIdentity(input) {
+    return JSON.stringify({
         source_kind: input.sourceKind,
         source_facts: canonicalValue(input.sourceFacts),
     });
-    return `sha256:${createHash("sha256").update(serialized, "utf8").digest("hex")}`;
+}
+export function operationRequestHash(input) {
+    return `sha256:${createHash("sha256").update(canonicalRequestIdentity(input), "utf8").digest("hex")}`;
+}
+function representationFromSourceFacts(sourceFacts) {
+    const detail = sourceFacts.detail;
+    if (detail !== undefined &&
+        detail !== "text" &&
+        detail !== "grounded" &&
+        detail !== "layout") {
+        throw managerError("INVALID_REPRESENTATION", "The operation request representation is invalid.");
+    }
+    const normalized = normalizeRepresentation(detail === undefined ? undefined : detail);
+    if (sourceFacts.groundingSchemaVersion !== undefined &&
+        sourceFacts.groundingSchemaVersion !== normalized.groundingSchemaVersion) {
+        throw managerError("INVALID_REPRESENTATION", "The operation request representation is invalid.");
+    }
+    if (sourceFacts.bundleProtocolVersion !== undefined &&
+        sourceFacts.bundleProtocolVersion !== normalized.bundleProtocolVersion) {
+        throw managerError("INVALID_REPRESENTATION", "The operation request representation is invalid.");
+    }
+    return normalized;
+}
+function recordRepresentation(record) {
+    return {
+        detail: record.detail,
+        groundingSchemaVersion: record.groundingSchemaVersion,
+        bundleProtocolVersion: record.bundleProtocolVersion,
+    };
+}
+function sameRepresentationTuple(left, right) {
+    return (left.detail === right.detail &&
+        left.groundingSchemaVersion === right.groundingSchemaVersion &&
+        left.bundleProtocolVersion === right.bundleProtocolVersion);
+}
+function assertSameRepresentation(input, record) {
+    if (!sameRepresentationTuple(representationFromSourceFacts(input.sourceFacts), recordRepresentation(record))) {
+        throw managerError("REPRESENTATION_MISMATCH", "The operation request representation differs from the stored record.", { operationCreated: true });
+    }
 }
 function defaultSleep(milliseconds) {
     return new Promise((resolve) => {
@@ -188,7 +232,7 @@ export class OperationManager {
         const active = this.#submissions.get(requestHash);
         if (active !== undefined)
             return active;
-        const pending = this.#submit(input, requestHash);
+        const pending = this.#submit(input);
         this.#submissions.set(requestHash, pending);
         try {
             return await pending;
@@ -199,30 +243,60 @@ export class OperationManager {
             }
         }
     }
-    async #submit(input, requestHash) {
+    async #submit(input) {
         let effectiveInput = input;
-        const sourceLocatorHash = typeof input.sourceFacts.sourceHash === "string"
+        // The exact canonical identity (which includes the normalized
+        // representation tuple) drives the keyed journal identity and every
+        // recovery selection; a different representation is a different identity.
+        const identityJson = canonicalRequestIdentity(input);
+        const representation = representationFromSourceFacts(input.sourceFacts);
+        if (input.representation !== undefined &&
+            !sameRepresentationTuple(input.representation, representation)) {
+            throw managerError("REPRESENTATION_MISMATCH", "The operation request representation is inconsistent.");
+        }
+        const requestIdentityHmac = await this.#journal.requestIdentityHmac(identityJson);
+        const sourceLocator = typeof input.sourceFacts.sourceHash === "string"
             ? input.sourceFacts.sourceHash
             : null;
+        const sourceLocatorHmac = sourceLocator === null
+            ? null
+            : await this.#journal.sourceLocatorHmac(sourceLocator);
         let record = await this.#journal.loadByRequestId(input.clientRequestId);
         if (record === null) {
-            let matching = await this.#journal.loadLatestByRequestHash(requestHash);
+            let matching = await this.#journal.loadLatestByRequestIdentityHmac(requestIdentityHmac);
             if (matching === null &&
                 input.sourceKind === "local" &&
                 input.sourceFacts.sourceFingerprint === undefined &&
-                sourceLocatorHash !== null) {
-                matching = await this.#journal.loadLatestBySourceLocatorHash(sourceLocatorHash);
+                sourceLocatorHmac !== null) {
+                matching = await this.#journal.loadLatestBySourceLocatorHmac(sourceLocatorHmac);
+                // The locator does not bind the representation, so an exact match is
+                // required before a record may be reused across submissions.
+                if (matching !== null &&
+                    !sameRepresentationTuple(recordRepresentation(matching), representation)) {
+                    matching = null;
+                }
             }
             if (matching !== null && this.#shouldReuseByRequestHash(matching)) {
                 record = matching;
                 effectiveInput = { ...input, clientRequestId: matching.clientRequestId };
             }
             else {
-                record = await this.#journal.beginIntent(input.clientRequestId, requestHash, input.sourceKind, sourceLocatorHash);
+                record = await this.#journal.beginIntent(input.clientRequestId, identityJson, input.sourceKind, sourceLocator, representation);
             }
         }
+        else if (record.requestIdentityHmac === null) {
+            // Legacy v1/v2 record: reconstruct the keyed identity from the safe
+            // canonical source facts, or fail safe as a terminal source-free
+            // recovery failure. It can never be resumed as grounded/layout.
+            const migrated = await this.#journal.migrateLegacyRecord(input.clientRequestId, identityJson, sourceLocator);
+            record = migrated === null
+                ? await this.#journal.beginIntent(input.clientRequestId, identityJson, input.sourceKind, sourceLocator, representation)
+                : migrated;
+            if (TERMINAL_STATES.has(record.state))
+                return record;
+        }
         else {
-            record = await this.#journal.beginIntent(input.clientRequestId, requestHash, input.sourceKind, sourceLocatorHash);
+            record = await this.#journal.beginIntent(input.clientRequestId, identityJson, input.sourceKind, sourceLocator, representation);
         }
         const signal = effectiveInput.signal ?? new AbortController().signal;
         if (TERMINAL_STATES.has(record.state))
@@ -248,7 +322,7 @@ export class OperationManager {
                 : this.#resume(raced, effectiveInput, signal);
         }
         try {
-            const start = await this.#driver.create(effectiveInput, requestHash, signal);
+            const start = await this.#driver.create(effectiveInput, requestIdentityHmac, signal);
             return this.#acceptStart(record, start);
         }
         catch (error) {
@@ -489,6 +563,24 @@ export class OperationManager {
         if (record === null) {
             throw managerError("OPERATION_NOT_FOUND", "The requested parse operation is not available.");
         }
+        // A legacy v1/v2 record without a reconstructed keyed identity cannot be
+        // recovered safely (no proof of the request identity). It becomes a
+        // terminal source-free recovery failure instead of resuming, reparsing,
+        // or rebilling anything.
+        if (record.requestIdentityHmac === null) {
+            try {
+                return await this.#journal.transition(record.clientRequestId, record.state, "FAILED", { errorCode: LEGACY_RECOVERY_FAILURE_CODE, stage: "failed" });
+            }
+            catch (error) {
+                if (!(error instanceof OmniBridgeError) || error.code !== "JOURNAL_STATE_CONFLICT") {
+                    throw error;
+                }
+                const latest = await this.#journal.loadByOperationId(operationId);
+                if (latest === null)
+                    throw error;
+                return latest;
+            }
+        }
         return record;
     }
     async #applyUpdate(record, update) {
@@ -684,9 +776,49 @@ function remoteResultUpdate(result, expectedOperationId) {
         result,
     };
 }
+// The v3 bundle descriptor carries the normalized representation tuple
+// (detail/grounding schema/bundle protocol) plus the exact per-part metadata.
+// The schema-level ParseResult union accepts the descriptor; the type-level
+// union is narrower, so the boundary needs a cast (the tools layer validates
+// through parseResultSchema).
+function bundleDescriptorValue(bundle) {
+    const contentStorage = bundle.parts.content.storage.kind === "inline"
+        ? { kind: "inline", text: bundle.parts.content.storage.text }
+        : { kind: "artifact", next_cursor: bundle.parts.content.storage.nextCursor };
+    const groundingStorage = bundle.parts.grounding.storage.kind === "inline"
+        ? { kind: "inline", value: bundle.parts.grounding.storage.value }
+        : { kind: "artifact", next_cursor: bundle.parts.grounding.storage.nextCursor };
+    return {
+        kind: "bundle",
+        result_id: bundle.resultId,
+        detail: bundle.detail,
+        bundle_protocol_version: bundle.bundleProtocolVersion,
+        bundle_digest: bundle.bundleDigest,
+        bundle_bytes: bundle.bundleBytes,
+        expires_at: bundle.expiresAt,
+        parts: {
+            content: {
+                part: "content",
+                media_type: bundle.parts.content.mediaType,
+                result_bytes: bundle.parts.content.resultBytes,
+                digest: bundle.parts.content.digest,
+                storage: contentStorage,
+            },
+            grounding: {
+                part: "grounding",
+                media_type: bundle.parts.grounding.mediaType,
+                result_bytes: bundle.parts.grounding.resultBytes,
+                digest: bundle.parts.grounding.digest,
+                storage: groundingStorage,
+            },
+        },
+    };
+}
 function localResultValue(local) {
     if (local.kind === "inline")
         return { kind: "inline", text: local.text };
+    if (local.kind === "bundle")
+        return bundleDescriptorValue(local);
     if (local.nextCursor === undefined) {
         throw managerError("LOCAL_RESULT_INTEGRITY_FAILED", "The local result artifact cursor is missing.", {
             operationCreated: true,
@@ -717,7 +849,7 @@ function completedLocalParse(local) {
             original_source: "unchanged",
             remote_content_retained: false,
         },
-        ...(local.kind === "artifact" ? {
+        ...(local.kind === "artifact" || local.kind === "bundle" ? {
             local_result_cache: {
                 expires_at: local.expiresAt,
                 discard_action: "discard_result",
@@ -813,6 +945,18 @@ function localFailure(error) {
         ? error
         : managerError("BRIDGE_INTERNAL_ERROR", "The local Omni operation could not complete.", { operationCreated: true });
 }
+function requireBundleResult(retention) {
+    if (retention.bundleResult === undefined) {
+        throw managerError("LOCAL_RESULT_INTEGRITY_FAILED", "The retained local result bundle is incomplete.", {
+            operationCreated: true,
+            fileUploaded: true,
+            parserStarted: true,
+            billed: true,
+            contentReleased: false,
+        });
+    }
+    return retention.bundleResult();
+}
 export function createLocalParseOperationManager(options) {
     const now = options.now ?? (() => new Date());
     const openFile = options.openFile ?? openAllowedFile;
@@ -835,6 +979,9 @@ export function createLocalParseOperationManager(options) {
         }
         throw managerError("JOURNAL_STATE_CONFLICT", "The operation changed repeatedly while saving a delivery checkpoint.", { operationCreated: true, retryable: true });
     }
+    // A retained logical bundle is reconstructed through its closed descriptor
+    // and keeps the stored representation tuple; without the descriptor the
+    // recovery fails safe instead of degrading the bundle to text.
     async function recoverLocalArtifact(record) {
         if (record.operationId === null || record.resultId === null) {
             throw managerError("RESULT_NOT_AVAILABLE", "The retained local result artifact is unavailable.", {
@@ -845,6 +992,28 @@ export function createLocalParseOperationManager(options) {
                 contentReleased: record.contentReleased,
             });
         }
+        if (record.detail !== "text") {
+            if (options.artifactStore.readBundleDescriptor === undefined) {
+                throw managerError("RESULT_NOT_AVAILABLE", "The retained local result bundle is unavailable.", {
+                    operationCreated: true,
+                    fileUploaded: record.fileUploaded,
+                    parserStarted: record.parserStarted,
+                    billed: record.billed,
+                    contentReleased: record.contentReleased,
+                });
+            }
+            const descriptor = await options.artifactStore.readBundleDescriptor(record.resultId);
+            if (descriptor === null || descriptor.kind !== "bundle") {
+                throw managerError("RESULT_NOT_AVAILABLE", "The retained local result bundle is unavailable.", {
+                    operationCreated: true,
+                    fileUploaded: record.fileUploaded,
+                    parserStarted: record.parserStarted,
+                    billed: record.billed,
+                    contentReleased: record.contentReleased,
+                });
+            }
+            return descriptor;
+        }
         const preview = await options.artifactStore.read(record.resultId, undefined, 2_048);
         if (preview.resultBytes <= INLINE_RESULT_MAX_BYTES) {
             const recovered = preview.nextCursor === undefined
@@ -879,6 +1048,16 @@ export function createLocalParseOperationManager(options) {
         };
     }
     async function startExecution(input, recovery) {
+        // Recovery keeps the stored representation tuple exactly: status, download
+        // (recoverLocalArtifact), and ACK all operate on the representation the
+        // record was created with, never on the caller's (possibly absent) one.
+        if (recovery !== undefined) {
+            assertSameRepresentation(input, recovery);
+        }
+        const representation = recovery === undefined
+            ? representationFromSourceFacts(input.sourceFacts)
+            : recordRepresentation(recovery);
+        const expectedBundle = representation.detail !== "text";
         const recoveryOrder = recovery === undefined ? undefined : STATE_ORDER.get(recovery.state);
         const needsUploadContext = recovery === undefined ||
             recoveryOrder === undefined ||
@@ -903,12 +1082,16 @@ export function createLocalParseOperationManager(options) {
                 throw managerError("SOURCE_CHANGED_DURING_SUBMISSION", "The local source changed before the upload operation was created.", { retryable: true });
             }
             try {
+                // D2-D Task 14: the normalized detail reaches the grant boundary so
+                // CubeGrantClient selects the exact direct profile BEFORE constructing
+                // the v3 request and requires the v3 response tuple before any upload.
                 granted = await options.cubeClient.createGrant({
                     contentLength: opened.size,
                     contentType: opened.contentType,
                     fileExtension: opened.safeExtension,
                     noStore: true,
                     output: "markdown",
+                    ...(representation.detail === "text" ? {} : { detail: representation.detail }),
                 }, input.clientRequestId, input.signal, { journal: false });
             }
             catch (error) {
@@ -1031,7 +1214,12 @@ export function createLocalParseOperationManager(options) {
                     else {
                         await options.iiisClient.uploadAndWait(operation);
                     }
-                    local = retention.result();
+                    // Non-text results require the durable BundleLocalResult (both named
+                    // parts verified and fsynced); ACK_PENDING is persisted only after
+                    // it exists, so a partial bundle can never be acknowledged.
+                    local = expectedBundle
+                        ? requireBundleResult(retention)
+                        : retention.result();
                 }
                 const cleanupDeadline = recovery?.resultExpiresAt ?? new Date(now().getTime() + DELIVERY_TTL_SECONDS * 1000).toISOString();
                 const resultPatch = {
@@ -1220,8 +1408,17 @@ export function createLocalParseOperationManager(options) {
         if (options.remoteClient === undefined) {
             throw managerError("REMOTE_PARSE_UNAVAILABLE", "Remote URL parsing is not available in this Bridge build.", { retryable: true });
         }
+        // Remote recovery must also equal the stored representation tuple; the
+        // exact tuple is passed to the remote boundary so the URL profile is
+        // selected before any non-text tools/call is sent.
+        const representation = recovery === undefined
+            ? representationFromSourceFacts(input.sourceFacts)
+            : recordRepresentation(recovery);
+        if (recovery !== undefined) {
+            assertSameRepresentation(input, recovery);
+        }
         const context = remoteContext(input.context);
-        const result = await options.remoteClient.parse(context.source, input.clientRequestId, input.signal ?? new AbortController().signal);
+        const result = await options.remoteClient.parse(context.source, input.clientRequestId, input.signal ?? new AbortController().signal, representation.detail);
         return remoteResultUpdate(result, recovery?.operationId ?? undefined);
     }
     const driver = {
@@ -1242,9 +1439,11 @@ export function createLocalParseOperationManager(options) {
             const order = STATE_ORDER.get(record.state);
             if (order === undefined || order < STATE_ORDER.get("UPLOADING"))
                 return undefined;
+            // The recovery input carries the record's own stored representation
+            // tuple so status always recovers exactly what was requested.
             return startExecution({
                 sourceKind: "local",
-                sourceFacts: {},
+                sourceFacts: { ...recordRepresentation(record) },
                 clientRequestId: record.clientRequestId,
                 signal,
             }, record);

package/dist/protocol.d.ts

@@ -1,12 +1,25 @@
 import { z } from "zod";
-export declare const LOCAL_BRIDGE_PROTOCOL_VERSION = "omni.local_bridge_tools.v2";
+export declare const LOCAL_BRIDGE_PROTOCOL_VERSION = "omni.local_bridge_tools.v3";
+export declare const OPERATION_JOURNAL_VERSION = 3;
+export declare const BUNDLE_CURSOR_VERSION = 2;
+export declare const RESULT_BUNDLE_PROTOCOL_VERSION = "omni.result_bundle.v1";
+export declare const GROUNDING_SCHEMA_VERSION = "omni.grounding.v1";
+export interface RepresentationIntent {
+    readonly detail: "text" | "grounded" | "layout";
+    readonly groundingSchemaVersion: "none" | "omni.grounding.v1";
+    readonly bundleProtocolVersion: "none" | "omni.result_bundle.v1";
+}
+export declare function normalizeRepresentation(detail?: "text" | "grounded" | "layout"): RepresentationIntent;
 export declare const MACHINE_INSTRUCTIONS: string;
 export declare const parseSchema: z.ZodObject<{
     source: z.ZodEffects<z.ZodString, string, string>;
+    detail: z.ZodOptional<z.ZodEnum<["text", "grounded", "layout"]>>;
 }, "strict", z.ZodTypeAny, {
     source: string;
+    detail?: "grounded" | "layout" | "text" | undefined;
 }, {
     source: string;
+    detail?: "grounded" | "layout" | "text" | undefined;
 }>;
 export declare const getParseStatusSchema: z.ZodObject<{
     operation_id: z.ZodString;
@@ -31,12 +44,12 @@ export declare const readResultSchema: z.ZodObject<{
     max_bytes: z.ZodOptional<z.ZodNumber>;
 }, "strict", z.ZodTypeAny, {
     result_id: string;
-    max_bytes?: number | undefined;
     cursor?: string | undefined;
+    max_bytes?: number | undefined;
 }, {
     result_id: string;
-    max_bytes?: number | undefined;
     cursor?: string | undefined;
+    max_bytes?: number | undefined;
 }>;
 export declare const discardResultSchema: z.ZodObject<{
     result_id: z.ZodString;

package/dist/protocol.js

@@ -1,6 +1,29 @@
 import { z } from "zod";
 import { RESULT_CHUNK_MAX_BYTES, STATUS_LONG_POLL_MAX_MS } from "./constants.js";
-export const LOCAL_BRIDGE_PROTOCOL_VERSION = "omni.local_bridge_tools.v2";
+export const LOCAL_BRIDGE_PROTOCOL_VERSION = "omni.local_bridge_tools.v3";
+// D2-D item 1: versioned persistence literals frozen with the v3 contract.
+// The journal record version and the bundle cursor version are bumped
+// together with the tool contract; legacy v2 journal records still recover
+// text operations unchanged and are never auto-upgraded.
+export const OPERATION_JOURNAL_VERSION = 3;
+export const BUNDLE_CURSOR_VERSION = 2;
+// Canonical bundle/grounding literals carried by non-text representations.
+export const RESULT_BUNDLE_PROTOCOL_VERSION = "omni.result_bundle.v1";
+export const GROUNDING_SCHEMA_VERSION = "omni.grounding.v1";
+export function normalizeRepresentation(detail) {
+    if (detail === "grounded" || detail === "layout") {
+        return {
+            detail,
+            groundingSchemaVersion: GROUNDING_SCHEMA_VERSION,
+            bundleProtocolVersion: RESULT_BUNDLE_PROTOCOL_VERSION,
+        };
+    }
+    return {
+        detail: "text",
+        groundingSchemaVersion: "none",
+        bundleProtocolVersion: "none",
+    };
+}
 export const MACHINE_INSTRUCTIONS = [
     "Pass the user-provided source string directly to parse.",
     "Treat only HTTP(S) as URL; ordinary paths require the local Bridge.",
@@ -24,6 +47,7 @@ export const parseSchema = z
         .min(1)
         .max(8192)
         .refine((value) => !value.includes("\0")),
+    detail: z.enum(["text", "grounded", "layout"]).optional(),
 })
     .strict();
 export const getParseStatusSchema = z

package/dist/remote-client.d.ts

@@ -1,6 +1,7 @@
+import { type ReaderCapabilitiesV1 } from "./capabilities.js";
 import { type ParseResult } from "./result-contract.js";
 export interface RemoteOmniClient {
-    parse(source: string, clientRequestId: string, signal: AbortSignal): Promise<ParseResult>;
+    parse(source: string, clientRequestId: string, signal: AbortSignal, detail?: "text" | "grounded" | "layout"): Promise<ParseResult>;
     status(operationId: string, waitMs: number | undefined, signal: AbortSignal): Promise<ParseResult>;
     cancel(operationId: string, signal: AbortSignal): Promise<ParseResult>;
 }
@@ -11,7 +12,8 @@ export interface HttpRemoteOmniClientOptions {
 export declare class HttpRemoteOmniClient implements RemoteOmniClient {
     #private;
     constructor(options: HttpRemoteOmniClientOptions);
-    parse(source: string, clientRequestId: string, signal: AbortSignal): Promise<ParseResult>;
+    initializeCapabilities(signal: AbortSignal): Promise<ReaderCapabilitiesV1>;
+    parse(source: string, clientRequestId: string, signal: AbortSignal, detail?: "text" | "grounded" | "layout"): Promise<ParseResult>;
     status(operationId: string, waitMs: number | undefined, signal: AbortSignal): Promise<ParseResult>;
     cancel(operationId: string, signal: AbortSignal): Promise<ParseResult>;
 }