@cueai/omni-reader-mcp 1.6.0 → 1.7.1

package/dist/cube-client.js

@@ -1,8 +1,8 @@
 import { createHash, randomUUID } from "node:crypto";
 import { z } from "zod";
-import { BRIDGE_RELEASE_VERSION, CUBE_CAPABILITIES_PATH, CUBE_GRANT_PROTOCOL_VERSION, DEFAULT_CUBE_BASE_URL, MAX_FILE_BYTES, } from "./constants.js";
-import { parseReaderCapabilities, selectDirectProfile, } from "./capabilities.js";
-import { OmniBridgeError } from "./errors.js";
+import { BRIDGE_RELEASE_VERSION, CAPABILITIES_V2_PATH, CUBE_CAPABILITIES_PATH, CUBE_GRANT_PROTOCOL_VERSION, DEFAULT_CUBE_BASE_URL, MAX_FILE_BYTES, } from "./constants.js";
+import { DIRECT_GROUNDING_BILLING_PROFILE, DIRECT_TEXT_BILLING_PROFILE, parseReaderCapabilities, parseReaderCapabilitiesV2, selectDirectProfile, selectDirectProfileV2, } from "./capabilities.js";
+import { OmniBridgeError, unsupportedDetailError, } from "./errors.js";
 const GRANT_PATH = "/api/omni-reader/direct-upload/v1/parse-grants";
 const BRIDGE_PACKAGE = "@cueai/omni-reader-mcp";
 // Legacy grant response for UNPROFILED (detail-less) requests. cube-mcp serves
@@ -48,6 +48,16 @@ const bridgeUpgradeRequiredSchema = z
     retryable: z.literal(false),
 })
     .strict();
+const unsupportedDetailSchema = z
+    .object({
+    code: z.literal("UNSUPPORTED_DETAIL"),
+    message: z.literal("The declared capability profile is not supported by this control plane."),
+    file_uploaded: z.literal(false),
+    billed: z.literal(false),
+    content_released: z.literal(false),
+    retryable: z.literal(false),
+})
+    .strict();
 // Closed v3 grant response: the exact tuple of the selected direct profile is
 // required before the upload phase may start. The tuple is re-checked against
 // the profile after schema parsing so a drifting server cannot slip through.
@@ -70,6 +80,90 @@ const grantResponseV3Schema = z
     approved_result_max_bytes: z.literal(67108864),
 })
     .strict();
+const grantResponseV4Schema = z
+    .object({
+    grant_id: z.string().min(1),
+    operation_id: z.string().min(1),
+    parse_grant: z.string().min(1),
+    operation_token: z.string().min(1),
+    upload_url: z
+        .string()
+        .url()
+        .refine((value) => new URL(value).protocol === "https:"),
+    expires_at: z.string().datetime({ offset: true }),
+    max_bytes: z.literal(MAX_FILE_BYTES),
+    protocol_version: z.literal("omni.parse_grant.v4"),
+})
+    .strict();
+const textRepresentationV4Schema = z
+    .object({
+    kind: z.literal("text"),
+    media_type: z.literal("text/markdown; charset=utf-8"),
+    usage_schema_version: z.literal("omni_parse_usage.v2"),
+    billing_contract_version: z.literal("omni_billing.v2"),
+})
+    .strict();
+const bundleRepresentationV4Schema = z
+    .object({
+    kind: z.literal("result_bundle"),
+    media_type: z.literal("application/vnd.cue.omni-result-bundle+json; version=1"),
+    bundle_protocol_version: z.literal("omni.result_bundle.v1"),
+    grounding_schema_version: z.literal("omni.grounding.v1"),
+    usage_schema_version: z.literal("omni_parse_usage.v2"),
+    billing_contract_version: z.literal("omni_billing.v2"),
+})
+    .strict();
+const signedGrantV4BaseShape = {
+    protocol_version: z.literal("omni.parse_grant.v4"),
+    iss: z.string().min(1).max(64),
+    aud: z.literal("omni-reader-l1"),
+    sub: z.string().regex(/^sha256:[a-f0-9]{64}$/u),
+    jti: z.string().regex(/^pg_[A-Za-z0-9_-]+$/u),
+    grant_id: z.string().regex(/^pg_[A-Za-z0-9_-]+$/u),
+    operation_id: z.string().regex(/^op_[A-Za-z0-9_-]+$/u),
+    usage_event_id: z.string().regex(/^[a-f0-9]{32}$/u),
+    request_id: z.string().max(128).regex(/^req_[A-Za-z0-9_-]+$/u),
+    stream_protocol: z.literal("omni.granted_parse_stream.v3"),
+    operation_protocol: z.literal("omni.direct_operation.v3"),
+    settlement_protocol: z.literal("omni.grant_settlement.v5"),
+    release_protocol: z.literal("omni.release_decision.v3"),
+    settlement_journal_protocol: z.literal("omni.direct_settlement_journal.v3"),
+    usage_schema_version: z.literal("omni_parse_usage.v2"),
+    billing_contract_version: z.literal("omni_billing.v2"),
+    bridge_protocol: z.literal("omni.local_bridge_tools.v5"),
+    method: z.literal("POST"),
+    path: z.literal("/omni/granted/parse_stream"),
+    content_length: z.number().int().min(1).max(MAX_FILE_BYTES),
+    content_type: z.string().min(1).max(128),
+    file_extension: z.string().regex(/^\.[a-z0-9]{1,10}$/u),
+    no_store: z.boolean(),
+    output: z.enum(["markdown", "hypertext", "chunks"]),
+    max_bytes: z.literal(MAX_FILE_BYTES),
+    nonce: z.string().min(32).max(256),
+    iat: z.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
+    nbf: z.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
+    exp: z.number().int().min(1).max(Number.MAX_SAFE_INTEGER),
+};
+const signedGrantV4Schema = z.discriminatedUnion("profile", [
+    z
+        .object({
+        ...signedGrantV4BaseShape,
+        profile: z.literal(DIRECT_TEXT_BILLING_PROFILE.profile),
+        detail: z.literal("text"),
+        representation: textRepresentationV4Schema,
+        approved_result_max_bytes: z.literal(DIRECT_TEXT_BILLING_PROFILE.max_result_bytes),
+    })
+        .strict(),
+    z
+        .object({
+        ...signedGrantV4BaseShape,
+        profile: z.literal(DIRECT_GROUNDING_BILLING_PROFILE.profile),
+        detail: z.enum(["grounded", "layout"]),
+        representation: bundleRepresentationV4Schema,
+        approved_result_max_bytes: z.literal(DIRECT_GROUNDING_BILLING_PROFILE.max_result_bytes),
+    })
+        .strict(),
+]);
 function bridgeError(code, message, retryable, options = {}) {
     return new OmniBridgeError({
         code,
@@ -81,6 +175,7 @@ function bridgeError(code, message, retryable, options = {}) {
         contentReleased: false,
         retryable,
         ...(options.failureScope === undefined ? {} : { failureScope: options.failureScope }),
+        ...(options.sourceKind === undefined ? {} : { sourceKind: options.sourceKind }),
         ...(options.userAction === undefined ? {} : { userAction: options.userAction }),
         ...(options.retryAfter === undefined ? {} : { retryAfter: options.retryAfter }),
     });
@@ -125,6 +220,19 @@ function grantRequestBody(input, profile) {
         approved_result_max_bytes: profile.max_result_bytes,
     };
 }
+function v4GrantRequestBody(input, profile, detail, clientRequestId) {
+    const base = grantRequestBody(input);
+    const requestId = `req_${createHash("sha256")
+        .update(clientRequestId, "utf8")
+        .digest("base64url")
+        .slice(0, 22)}`;
+    return {
+        ...base,
+        profile,
+        detail,
+        request_id: requestId,
+    };
+}
 function requireV3GrantTuple(parsed, profile, detail) {
     if (parsed.protocol_version !== profile.grant_protocol ||
         parsed.stream_protocol_version !== profile.stream_protocol ||
@@ -134,6 +242,56 @@ function requireV3GrantTuple(parsed, profile, detail) {
         throw bridgeError("CUBE_PROTOCOL_ERROR", "Cube returned a parse grant outside the negotiated representation.", false);
     }
 }
+function parseSignedGrantV4(parseGrant) {
+    const segments = parseGrant.split(".");
+    if (segments.length !== 3 ||
+        segments.some((segment) => segment.length === 0 || !/^[A-Za-z0-9_-]+$/u.test(segment))) {
+        throw new Error("invalid compact JWT");
+    }
+    const payload = segments[1];
+    const decoded = Buffer.from(payload, "base64url");
+    if (decoded.length === 0 || decoded.toString("base64url") !== payload) {
+        throw new Error("noncanonical JWT payload");
+    }
+    const value = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(decoded));
+    return signedGrantV4Schema.parse(value);
+}
+function requireV4GrantBinding(parsed, profile, detail, body) {
+    let claims;
+    try {
+        claims = parseSignedGrantV4(parsed.parse_grant);
+    }
+    catch {
+        throw bridgeError("CUBE_PROTOCOL_ERROR", "Cube returned a parse grant outside the negotiated representation.", false);
+    }
+    const expiresAt = Date.parse(parsed.expires_at);
+    const expiryMatches = expiresAt % 1000 === 0 && claims.exp === expiresAt / 1000;
+    if (claims.jti !== parsed.grant_id ||
+        claims.grant_id !== parsed.grant_id ||
+        claims.operation_id !== parsed.operation_id ||
+        claims.request_id !== body.request_id ||
+        claims.protocol_version !== profile.grant_protocol ||
+        claims.profile !== profile.profile ||
+        claims.detail !== detail ||
+        claims.approved_result_max_bytes !== profile.max_result_bytes ||
+        claims.stream_protocol !== profile.stream_protocol ||
+        claims.operation_protocol !== profile.operation_protocol ||
+        claims.settlement_protocol !== profile.settlement_protocol ||
+        claims.release_protocol !== profile.release_protocol ||
+        claims.settlement_journal_protocol !== profile.settlement_journal_protocol ||
+        claims.usage_schema_version !== profile.usage_protocol ||
+        claims.billing_contract_version !== profile.billing_protocol ||
+        claims.bridge_protocol !== profile.bridge_protocol ||
+        claims.content_length !== body.content_length ||
+        claims.content_type !== body.content_type ||
+        claims.file_extension !== body.file_extension ||
+        claims.no_store !== body.no_store ||
+        claims.output !== body.output ||
+        claims.max_bytes !== MAX_FILE_BYTES ||
+        !expiryMatches) {
+        throw bridgeError("CUBE_PROTOCOL_ERROR", "Cube returned a parse grant outside the negotiated representation.", false);
+    }
+}
 export function grantRequestHash(body) {
     return `sha256:${createHash("sha256")
         .update(JSON.stringify(body), "utf8")
@@ -144,24 +302,38 @@ export function createClientRequestId() {
 }
 function responseError(status) {
     if (status === 401) {
-        return bridgeError("INVALID_CUE_API_KEY", "The Cue API Key is invalid or expired.", false);
+        return bridgeError("INVALID_CUE_API_KEY", "The Cue API Key is invalid or expired.", false, { failureScope: "authentication", sourceKind: "local" });
     }
     if (status === 403) {
-        return bridgeError("OMNI_NOT_ENTITLED", "This Cue account is not entitled to use Omni Reader.", false);
+        return bridgeError("OMNI_NOT_ENTITLED", "This Cue account is not entitled to use Omni Reader.", false, { failureScope: "authentication", sourceKind: "local" });
     }
     if (status === 402) {
-        return bridgeError("INSUFFICIENT_BALANCE", "The Cue account does not have enough balance to start this parse.", false);
+        return bridgeError("INSUFFICIENT_BALANCE", "The Cue account does not have enough balance to start this parse.", false, { failureScope: "billing", sourceKind: "local" });
     }
     if (status === 409) {
-        return bridgeError("IDEMPOTENCY_COLLISION", "This grant request identifier is already bound to different metadata.", false);
+        return bridgeError("IDEMPOTENCY_COLLISION", "This grant request identifier is already bound to different metadata.", false, { failureScope: "operation", sourceKind: "local" });
     }
     if (status === 404) {
-        return bridgeError("DIRECT_UPLOAD_DISABLED", "Direct local-file parsing is not enabled on this Omni service.", false);
+        return bridgeError("DIRECT_UPLOAD_UNAVAILABLE", "The Omni service's direct-upload route is unavailable.", false, {
+            failureScope: "local_capability",
+            sourceKind: "local",
+            userAction: "Do not infer an account restriction; HTTP 403 is the entitlement signal. Retry only after the service route is enabled, or parse an existing HTTP(S) source instead.",
+        });
     }
     if (status === 429) {
-        return bridgeError("CUBE_BUSY", "Cube is temporarily busy. Retry this same grant request later.", true);
+        return bridgeError("CUBE_BUSY", "Cube is temporarily busy. Retry this same grant request later.", true, { failureScope: "service", sourceKind: "local" });
     }
-    return bridgeError("CUBE_UNAVAILABLE", "Cube could not create the parse grant. Retry this same grant request later.", status >= 500);
+    return bridgeError("CUBE_UNAVAILABLE", "Cube could not create the parse grant. Retry this same grant request later.", status >= 500, { failureScope: "service", sourceKind: "local" });
+}
+function capabilitiesResponseError(status) {
+    if (status === 404) {
+        return bridgeError("DETAIL_CAPABILITIES_UNAVAILABLE", "This Omni service does not advertise grounded or layout parsing.", false, {
+            failureScope: "local_capability",
+            sourceKind: "local",
+            userAction: "Use text output only when plain Markdown is acceptable; text may retain headings, lists, and tables but does not include grounding or layout sidecars.",
+        });
+    }
+    return responseError(status);
 }
 function retryAfterSeconds(response) {
     const value = response.headers.get("retry-after");
@@ -171,6 +343,19 @@ function retryAfterSeconds(response) {
     return Number.isSafeInteger(seconds) && seconds > 0 ? seconds : undefined;
 }
 async function grantResponseError(response) {
+    if (response.status === 422 && !response.headers.has("retry-after")) {
+        let body;
+        try {
+            body = await response.json();
+        }
+        catch {
+            return responseError(response.status);
+        }
+        if (unsupportedDetailSchema.safeParse(body).success) {
+            return unsupportedDetailError("local");
+        }
+        return responseError(response.status);
+    }
     // The strict 426 marker is only recognized when there is exactly a 426 status,
     // no Retry-After, and a body matching the six frozen literal fields. Any drift
     // degrades through `responseError` to the generic nonretryable CUBE_UNAVAILABLE.
@@ -185,7 +370,8 @@ async function grantResponseError(response) {
         if (bridgeUpgradeRequiredSchema.safeParse(body).success) {
             return bridgeError("BRIDGE_UPGRADE_REQUIRED", "This Bridge release is not accepted for direct local-file parsing.", false, {
                 failureScope: "service",
-                userAction: `Upgrade to @cueai/omni-reader-mcp@${BRIDGE_RELEASE_VERSION} using the official Omni setup instructions, then retry the same local-file parse.`,
+                sourceKind: "local",
+                userAction: "Install the latest published @cueai/omni-reader-mcp release using the official Omni setup instructions, then retry once. If you are already running the latest published release, do not reinstall or retry; run doctor --json and ask the service operator to verify Bridge admission.",
             });
         }
     }
@@ -201,6 +387,7 @@ async function grantResponseError(response) {
         if (principalConcurrencyErrorSchema.safeParse(body).success) {
             return bridgeError("PRINCIPAL_CONCURRENCY_LIMIT", "The maximum number of concurrent parsing operations is already active.", true, {
                 failureScope: "service",
+                sourceKind: "local",
                 userAction: "Wait for retry_after seconds, then retry the same local-file parse.",
                 retryAfter,
             });
@@ -212,9 +399,11 @@ export class CubeGrantClient {
     #journal;
     #apiKey;
     #grantUrl;
-    #capabilitiesUrl;
+    #capabilitiesV1Url;
+    #capabilitiesV2Url;
     #fetch;
-    #capabilitiesCache;
+    #capabilitiesV1Cache;
+    #capabilitiesV2Cache;
     constructor(options) {
         this.#journal = options.journal;
         this.#apiKey =
@@ -229,7 +418,8 @@ export class CubeGrantClient {
             throw bridgeError("INSECURE_CUBE_BASE_URL", "The Cube control endpoint must use HTTPS without embedded credentials.", false);
         }
         this.#grantUrl = new URL(GRANT_PATH, baseUrl).toString();
-        this.#capabilitiesUrl = new URL(CUBE_CAPABILITIES_PATH, baseUrl).toString();
+        this.#capabilitiesV1Url = new URL(CUBE_CAPABILITIES_PATH, baseUrl).toString();
+        this.#capabilitiesV2Url = new URL(CAPABILITIES_V2_PATH, baseUrl).toString();
         this.#fetch = options.fetchImpl ?? fetch;
     }
     // Preflight for any non-text grant request (D2-D item 4): authenticated
@@ -242,13 +432,13 @@ export class CubeGrantClient {
             throw bridgeError("MISSING_CUE_API_KEY", "Set CUE_API_KEY before using local Omni document parsing.", false);
         }
         const now = Date.now();
-        const cached = this.#capabilitiesCache;
+        const cached = this.#capabilitiesV1Cache;
         if (cached !== undefined && cached.expiresAt > now) {
             return cached.value;
         }
         let response;
         try {
-            response = await this.#fetch(this.#capabilitiesUrl, {
+            response = await this.#fetch(this.#capabilitiesV1Url, {
                 method: "GET",
                 headers: {
                     authorization: `Bearer ${this.#apiKey}`,
@@ -264,7 +454,7 @@ export class CubeGrantClient {
             throw bridgeError("CUBE_UNAVAILABLE", "Cube could not provide reader capabilities. Retry the same request later.", true);
         }
         if (!response.ok) {
-            throw responseError(response.status);
+            throw capabilitiesResponseError(response.status);
         }
         let capabilities;
         try {
@@ -273,7 +463,57 @@ export class CubeGrantClient {
         catch {
             throw bridgeError("CUBE_PROTOCOL_ERROR", "Cube returned invalid reader capability profiles.", false);
         }
-        this.#capabilitiesCache = {
+        this.#capabilitiesV1Cache = {
+            expiresAt: capabilities.expires_at.getTime(),
+            value: capabilities,
+        };
+        return capabilities;
+    }
+    async getCapabilitiesV2(signal) {
+        if (this.#apiKey.length === 0) {
+            throw bridgeError("MISSING_CUE_API_KEY", "Set CUE_API_KEY before using local Omni document parsing.", false);
+        }
+        const now = Date.now();
+        const cached = this.#capabilitiesV2Cache;
+        if (cached !== undefined && cached.expiresAt > now) {
+            return cached.value;
+        }
+        let response;
+        try {
+            response = await this.#fetch(this.#capabilitiesV2Url, {
+                method: "GET",
+                headers: {
+                    authorization: `Bearer ${this.#apiKey}`,
+                    accept: "application/json",
+                },
+                signal,
+            });
+        }
+        catch {
+            if (signal?.aborted) {
+                throw bridgeError("CAPABILITIES_REQUEST_CANCELED", "The capabilities request was canceled.", false);
+            }
+            throw bridgeError("CUBE_UNAVAILABLE", "Cube could not provide reader capabilities. Retry the same request later.", true);
+        }
+        if (response.status === 404) {
+            try {
+                await response.body?.cancel();
+            }
+            catch {
+                throw bridgeError("CUBE_UNAVAILABLE", "Cube could not release the capabilities response. Retry the same request later.", true);
+            }
+            return null;
+        }
+        if (!response.ok)
+            throw responseError(response.status);
+        let capabilities;
+        try {
+            capabilities = parseReaderCapabilitiesV2(await response.json(), new Date(now));
+        }
+        catch {
+            throw bridgeError("CUBE_PROTOCOL_ERROR", "Cube returned invalid reader capability profiles.", false);
+        }
+        this.#capabilitiesV2Cache = {
             expiresAt: capabilities.expires_at.getTime(),
             value: capabilities,
         };
@@ -285,23 +525,27 @@ export class CubeGrantClient {
     // UNSUPPORTED_DETAIL before any grant request is constructed.
     async #directProfileFor(detail, signal) {
         const capabilities = await this.getCapabilities(signal);
-        return selectDirectProfile(capabilities, detail);
+        return selectDirectProfile(capabilities, detail, "local");
     }
     async createGrant(input, clientRequestId, signal, options = {}) {
         if (this.#apiKey.length === 0) {
             throw bridgeError("MISSING_CUE_API_KEY", "Set CUE_API_KEY before using local Omni document parsing.", false);
         }
-        // D2-D Task 14: for any non-text grant the exact direct profile is
-        // obtained and selected BEFORE the request is constructed or journal state
-        // is written; without one exact compatible profile the request fails
-        // closed with UNSUPPORTED_DETAIL and no unknown-field request is sent.
-        const detail = input.detail === "grounded" || input.detail === "layout"
+        const requestedDetail = input.detail ?? "text";
+        const capabilitiesV2 = await this.getCapabilitiesV2(signal);
+        const profileV2 = capabilitiesV2 === null
+            ? undefined
+            : selectDirectProfileV2(capabilitiesV2, requestedDetail, "local");
+        const legacyDetail = input.detail === "grounded" || input.detail === "layout"
             ? input.detail
             : undefined;
-        const profile = detail === undefined
-            ? undefined
-            : await this.#directProfileFor(detail, signal);
-        const body = grantRequestBody(input, profile);
+        const profileV1 = capabilitiesV2 === null && legacyDetail !== undefined
+            ? await this.#directProfileFor(legacyDetail, signal)
+            : undefined;
+        const directProfile = profileV2?.profile ?? profileV1?.profile ?? null;
+        const body = profileV2 === undefined
+            ? grantRequestBody(input, profileV1)
+            : v4GrantRequestBody(input, profileV2, requestedDetail, clientRequestId);
         const serializedBody = JSON.stringify(body);
         const requestHash = grantRequestHash(body);
         if (options.journal !== false) {
@@ -329,18 +573,26 @@ export class CubeGrantClient {
         if (!response.ok) {
             throw await grantResponseError(response);
         }
-        // The v3 response tuple is required before this promise resolves: the
-        // upload phase can only start after the negotiated representation is
-        // confirmed by the server.
+        // Profiled responses are accepted only for the exact negotiated grant
+        // generation. Legacy response meanings remain frozen.
         let parsed;
-        if (profile !== undefined) {
+        if (profileV2 !== undefined) {
+            try {
+                parsed = grantResponseV4Schema.parse(await response.json());
+            }
+            catch {
+                throw bridgeError("CUBE_PROTOCOL_ERROR", "Cube returned a parse grant outside the negotiated representation.", false);
+            }
+            requireV4GrantBinding(parsed, profileV2, requestedDetail, body);
+        }
+        else if (profileV1 !== undefined) {
             try {
                 parsed = grantResponseV3Schema.parse(await response.json());
             }
             catch {
                 throw bridgeError("CUBE_PROTOCOL_ERROR", "Cube returned a parse grant outside the negotiated representation.", false);
             }
-            requireV3GrantTuple(parsed, profile, detail);
+            requireV3GrantTuple(parsed, profileV1, legacyDetail);
         }
         else {
             try {
@@ -369,6 +621,8 @@ export class CubeGrantClient {
             expiresAt: parsed.expires_at,
             maxBytes: parsed.max_bytes,
             protocolVersion: parsed.protocol_version,
+            directProfile,
+            requestedDetail,
         };
     }
 }

package/dist/errors.d.ts

@@ -54,3 +54,4 @@ export declare class OmniBridgeError extends Error {
     constructor(init: OmniBridgeErrorInit);
     toJSON(): OmniBridgeErrorPayload;
 }
+export declare function unsupportedDetailError(sourceKind?: OmniSourceKind): OmniBridgeError;

package/dist/errors.js

@@ -49,3 +49,18 @@ export class OmniBridgeError extends Error {
         };
     }
 }
+export function unsupportedDetailError(sourceKind) {
+    return new OmniBridgeError({
+        code: "UNSUPPORTED_DETAIL",
+        message: "The requested parsing representation is not supported by this control plane.",
+        failureScope: "local_capability",
+        ...(sourceKind === undefined ? {} : { sourceKind }),
+        userAction: "Use text output only when Markdown without grounding/layout sidecars is acceptable; otherwise do not retry unchanged.",
+        operationCreated: false,
+        fileUploaded: false,
+        parserStarted: false,
+        billed: false,
+        contentReleased: false,
+        retryable: false,
+    });
+}

package/dist/iiis-client.d.ts

@@ -1,3 +1,4 @@
+import type { DirectProfile, RequestedDirectDetailV2 } from "./capabilities.js";
 import type { OpenedAllowedFile } from "./path-security.js";
 import { type ProgressSink } from "./progress.js";
 export interface ResultRetentionStart {
@@ -22,14 +23,22 @@ export interface IiisOperationInput {
     readonly operationToken: string;
     readonly uploadUrl?: string;
     readonly expiresAt?: string;
+    readonly directProfile?: DirectProfile | null;
+    readonly expectedDetail?: RequestedDirectDetailV2;
     readonly openedFile?: OpenedAllowedFile;
     readonly retention: ResultRetentionSink;
     readonly progress?: ProgressSink;
     readonly signal?: AbortSignal;
 }
+export interface WireBillingFacts {
+    readonly credits_charged: number;
+    readonly credits_remaining: number;
+}
 export interface ReleasedResult extends ReleasedMetadata {
+    readonly directProfile: DirectProfile | null;
+    readonly billing: WireBillingFacts | null;
 }
-export type IiisOperationStatus = "ISSUED" | "CLAIMED" | "UPLOADING" | "PROCESSING" | "SETTLING" | "RELEASED" | "EXPIRED" | "SETTLEMENT_DENIED" | "FAILED" | "CANCELED" | "DELIVERY_EXPIRED" | "DELIVERED";
+export type IiisOperationStatus = "ISSUED" | "CLAIMED" | "UPLOADING" | "PROCESSING" | "SETTLING" | "RELEASED" | "EXPIRED" | "SETTLEMENT_DENIED" | "FAILED" | "UNSUPPORTED" | "CANCELED" | "DELIVERY_EXPIRED" | "DELIVERED";
 export interface IiisOperationSnapshot {
     readonly status: IiisOperationStatus;
     readonly parserStarted: boolean;
@@ -38,6 +47,8 @@ export interface IiisOperationSnapshot {
     readonly contentReleased: boolean;
     readonly retryable: boolean;
     readonly expiresAt: string | null;
+    readonly directProfile: DirectProfile | null;
+    readonly billing: WireBillingFacts | null;
 }
 export interface IiisClientOptions {
     readonly fetchImpl?: typeof fetch;
@@ -45,6 +56,25 @@ export interface IiisClientOptions {
     readonly maxPolls?: number;
     readonly operationBaseUrl?: string;
 }
+interface ResultIdentity {
+    readonly digest: string;
+    readonly bytes: number;
+    readonly mediaType: string;
+}
+interface OperationStatus {
+    readonly protocol_version: string;
+    readonly operation_id: string;
+    readonly status: IiisOperationStatus;
+    readonly parser_started: boolean;
+    readonly file_uploaded: boolean;
+    readonly billed: boolean;
+    readonly content_released: boolean;
+    readonly retryable: boolean;
+    readonly expires_at: string | null;
+    readonly directProfile: DirectProfile | null;
+    readonly billing: WireBillingFacts | null;
+    readonly result: ResultIdentity | null;
+}
 export declare class IiisClient {
     #private;
     constructor(options?: IiisClientOptions);
@@ -52,6 +82,7 @@ export declare class IiisClient {
     recoverAndWait(input: IiisOperationInput): Promise<ReleasedResult>;
     inspectOperation(input: IiisOperationInput): Promise<IiisOperationSnapshot>;
     cancelOperation(input: IiisOperationInput): Promise<IiisOperationSnapshot>;
-    downloadResult(input: IiisOperationInput, progress?: ProgressSink): Promise<ReleasedResult>;
+    downloadResult(input: IiisOperationInput, progress?: ProgressSink, settledStatus?: OperationStatus): Promise<ReleasedResult>;
     ack(input: IiisOperationInput): Promise<void>;
 }
+export {};