@cueai/omni-reader-mcp 1.6.0 → 1.7.0

package/dist/iiis-client.js

@@ -1,12 +1,12 @@
 import { createHash } from "node:crypto";
-import { DEFAULT_IIIS_GRANTED_BASE_URL, GRANTED_STREAM_PROTOCOL_VERSION, RESULT_CHUNK_MAX_BYTES, } from "./constants.js";
+import { DEFAULT_IIIS_GRANTED_BASE_URL, GRANTED_STREAM_PROTOCOL_VERSION, MAX_FILE_BYTES, RESULT_CHUNK_MAX_BYTES, } from "./constants.js";
 import { OmniBridgeError } from "./errors.js";
 import { createMultipartBody } from "./multipart-body.js";
 import { NOOP_PROGRESS, } from "./progress.js";
 class TransportFailure extends Error {
 }
 const ACTIVE_STATUSES = new Set(["CLAIMED", "UPLOADING", "PROCESSING", "SETTLING"]);
-const TERMINAL_STATUSES = new Set([
+const LEGACY_TERMINAL_STATUSES = new Set([
     "EXPIRED",
     "SETTLEMENT_DENIED",
     "FAILED",
@@ -14,14 +14,27 @@ const TERMINAL_STATUSES = new Set([
     "DELIVERY_EXPIRED",
     "DELIVERED",
 ]);
-const OPERATION_STATUSES = new Set([
+const PHASE2_TERMINAL_STATUSES = new Set([
+    ...LEGACY_TERMINAL_STATUSES,
+    "UNSUPPORTED",
+]);
+const SETTLED_PHASE2_STATUSES = new Set([
+    "RELEASED",
+    "DELIVERED",
+    "DELIVERY_EXPIRED",
+]);
+const LEGACY_OPERATION_STATUSES = new Set([
     "ISSUED",
     "CLAIMED",
     "UPLOADING",
     "PROCESSING",
     "SETTLING",
     "RELEASED",
-    ...TERMINAL_STATUSES,
+    ...LEGACY_TERMINAL_STATUSES,
+]);
+const PHASE2_OPERATION_STATUSES = new Set([
+    ...LEGACY_OPERATION_STATUSES,
+    "UNSUPPORTED",
 ]);
 const RECOVERABLE_SETTLEMENT_ERRORS = new Set([
     "SETTLEMENT_IN_PROGRESS",
@@ -33,6 +46,15 @@ const RECOVERABLE_SETTLEMENT_ERRORS = new Set([
 ]);
 const BASE64URL_PATTERN = /^[A-Za-z0-9_-]+$/;
 const SHA256_PATTERN = /^sha256:[0-9a-f]{64}$/;
+const STREAM_V2_PROTOCOL = "omni.granted_parse_stream.v2";
+const STREAM_V3_PROTOCOL = "omni.granted_parse_stream.v3";
+const OPERATION_V2_PROTOCOL = "omni.direct_operation.v2";
+const OPERATION_V3_PROTOCOL = "omni.direct_operation.v3";
+const TEXT_BILLING_PROFILE = "omni.direct_text_billing.v1";
+const GROUNDING_BILLING_PROFILE = "omni.direct_grounding_billing.v1";
+const LEGACY_GROUNDING_PROFILE = "omni.direct_grounding.v1";
+const TEXT_MEDIA_TYPE = "text/markdown; charset=utf-8";
+const BUNDLE_MEDIA_TYPE = "application/vnd.cue.omni-result-bundle+json; version=1";
 const ERROR_CODE_PATTERN = /^[A-Z][A-Z0-9_]{0,127}$/;
 const RFC3339_PATTERN = /^(\d{4})-(\d{2})-(\d{2})[Tt](?:[01]\d|2[0-3]):[0-5]\d:[0-5]\d(?:\.\d+)?(?:[Zz]|[+-](?:[01]\d|2[0-3]):[0-5]\d)$/u;
 const PROGRESS_UNITS = new Set([
@@ -59,6 +81,7 @@ function bridgeError(code, message, facts = {}) {
 function recoveryFacts(value) {
     return {
         fileUploaded: value?.fileUploaded ?? false,
+        parserStarted: value?.parserStarted ?? false,
         billed: value?.billed ?? false,
         contentReleased: value?.contentReleased ?? false,
     };
@@ -66,6 +89,7 @@ function recoveryFacts(value) {
 function mergeRecoveryFacts(left, right) {
     return {
         fileUploaded: left.fileUploaded || right.fileUploaded === true,
+        parserStarted: left.parserStarted || right.parserStarted === true,
         billed: left.billed || right.billed === true,
         contentReleased: left.contentReleased || right.contentReleased === true,
     };
@@ -73,6 +97,7 @@ function mergeRecoveryFacts(left, right) {
 function errorWithRecoveryFacts(error, facts) {
     return bridgeError(error.code, error.message, {
         fileUploaded: error.fileUploaded || facts.fileUploaded,
+        parserStarted: error.parserStarted || facts.parserStarted,
         billed: error.billed || facts.billed,
         contentReleased: error.contentReleased || facts.contentReleased,
         retryable: error.retryable,
@@ -125,6 +150,154 @@ function safeInteger(value, minimum = 0) {
         && Number.isSafeInteger(value)
         && value >= minimum;
 }
+function inputDirectProfile(input) {
+    return input.directProfile ?? null;
+}
+function isBillingProfile(profile) {
+    return profile === TEXT_BILLING_PROFILE || profile === GROUNDING_BILLING_PROFILE;
+}
+function operationStatusesFor(profile) {
+    return isBillingProfile(profile)
+        ? PHASE2_OPERATION_STATUSES
+        : LEGACY_OPERATION_STATUSES;
+}
+function terminalStatusesFor(profile) {
+    return isBillingProfile(profile)
+        ? PHASE2_TERMINAL_STATUSES
+        : LEGACY_TERMINAL_STATUSES;
+}
+function streamProtocolFor(profile) {
+    if (isBillingProfile(profile))
+        return STREAM_V3_PROTOCOL;
+    if (profile === LEGACY_GROUNDING_PROFILE)
+        return STREAM_V2_PROTOCOL;
+    return GRANTED_STREAM_PROTOCOL_VERSION;
+}
+function operationProtocolFor(profile) {
+    if (isBillingProfile(profile))
+        return OPERATION_V3_PROTOCOL;
+    if (profile === LEGACY_GROUNDING_PROFILE)
+        return OPERATION_V2_PROTOCOL;
+    return GRANTED_STREAM_PROTOCOL_VERSION;
+}
+function invalidPhase2Response() {
+    return bridgeError("IIIS_INVALID_RESPONSE", "IIIS returned invalid billing-aware operation data.");
+}
+const PHASE2_STATUS_REQUIRED_KEYS = [
+    "protocol_version",
+    "operation_id",
+    "status",
+    "parser_started",
+    "file_uploaded",
+    "billed",
+    "content_released",
+    "retryable",
+    "expires_at",
+    "profile",
+    "detail",
+    "approved_result_max_bytes",
+];
+const PHASE2_RELEASE_KEYS = [
+    "type",
+    "protocol_version",
+    "operation_id",
+    "stream_protocol_version",
+    "profile",
+    "detail",
+    "approved_result_max_bytes",
+    "result",
+    "billing",
+    "billed",
+    "content_released",
+];
+const PHASE2_PROGRESS_KEYS = [
+    "type",
+    "protocol_version",
+    "source",
+    "stage",
+    "done",
+    "total",
+    "message",
+];
+const PHASE2_RESULT_CHUNK_KEYS = [
+    "type",
+    "protocol_version",
+    "operation_id",
+    "offset",
+    "decoded_bytes",
+    "data",
+];
+const PHASE2_RESULT_COMPLETE_KEYS = [
+    "type",
+    "protocol_version",
+    "operation_id",
+    "result_bytes",
+    "result_digest",
+];
+const PHASE2_ERROR_KEYS = [
+    "type",
+    "protocol_version",
+    "code",
+    "message",
+    "file_uploaded",
+    "billed",
+    "content_released",
+    "retryable",
+];
+function hasExactKeys(value, required, optional = []) {
+    const allowed = new Set([...required, ...optional]);
+    return required.every((key) => Object.prototype.hasOwnProperty.call(value, key))
+        && Object.keys(value).every((key) => allowed.has(key));
+}
+function billingValue(value) {
+    if (!isRecord(value)
+        || typeof value.credits_charged !== "number"
+        || !Number.isFinite(value.credits_charged)
+        || value.credits_charged < 0
+        || typeof value.credits_remaining !== "number"
+        || !Number.isFinite(value.credits_remaining)
+        || value.credits_remaining < 0
+        || Object.keys(value).some((key) => key !== "credits_charged" && key !== "credits_remaining")) {
+        throw invalidPhase2Response();
+    }
+    return {
+        credits_charged: value.credits_charged,
+        credits_remaining: value.credits_remaining,
+    };
+}
+function profileDetail(profile, detail) {
+    return profile === TEXT_BILLING_PROFILE
+        ? detail === "text"
+        : detail === "grounded" || detail === "layout";
+}
+function expectedDetailFor(input, profile) {
+    const detail = input.expectedDetail;
+    if (!profileDetail(profile, detail))
+        throw invalidPhase2Response();
+    return detail;
+}
+function profileMaxBytes(profile) {
+    return profile === TEXT_BILLING_PROFILE ? MAX_FILE_BYTES : 67108864;
+}
+function profileMediaType(profile) {
+    return profile === TEXT_BILLING_PROFILE ? TEXT_MEDIA_TYPE : BUNDLE_MEDIA_TYPE;
+}
+function resultIdentityValue(value, profile) {
+    if (!isRecord(value)
+        || typeof value.digest !== "string"
+        || !SHA256_PATTERN.test(value.digest)
+        || !safeInteger(value.bytes)
+        || value.bytes > profileMaxBytes(profile)
+        || value.media_type !== profileMediaType(profile)
+        || Object.keys(value).some((key) => key !== "digest" && key !== "bytes" && key !== "media_type")) {
+        throw invalidPhase2Response();
+    }
+    return {
+        digest: value.digest,
+        bytes: value.bytes,
+        mediaType: value.media_type,
+    };
+}
 function isRfc3339(value) {
     if (typeof value !== "string")
         return false;
@@ -141,8 +314,8 @@ function isRfc3339(value) {
     const days = month === 2 && leapYear ? 29 : monthDays[month - 1];
     return day <= days;
 }
-function validateProtocol(event) {
-    if (event.protocol_version !== GRANTED_STREAM_PROTOCOL_VERSION) {
+function validateProtocol(event, expectedProtocol = GRANTED_STREAM_PROTOCOL_VERSION) {
+    if (event.protocol_version !== expectedProtocol) {
         throw bridgeError("PROTOCOL_MISMATCH", "IIIS returned an unsupported protocol version.");
     }
 }
@@ -169,11 +342,31 @@ function stableProgressMessage(stage) {
         return "Finalizing result";
     return "Processing document";
 }
-function progressValue(event) {
-    validateProtocol(event);
+function progressValue(event, expectedProtocol = GRANTED_STREAM_PROTOCOL_VERSION, retained = false) {
+    if (expectedProtocol === STREAM_V3_PROTOCOL) {
+        const requiredKeys = retained
+            ? [...PHASE2_PROGRESS_KEYS, "sequence"]
+            : PHASE2_PROGRESS_KEYS;
+        if (!hasExactKeys(event, requiredKeys)
+            || event.type !== "progress"
+            || event.protocol_version !== STREAM_V3_PROTOCOL
+            || (event.source !== "bridge" && event.source !== "l1")
+            || typeof event.stage !== "string"
+            || event.stage.length < 1
+            || event.stage.length > 64
+            || typeof event.message !== "string"
+            || event.message.length < 1
+            || event.message.length > 256
+            || (retained && !safeInteger(event.sequence, 1))) {
+            throw invalidPhase2Response();
+        }
+    }
+    validateProtocol(event, expectedProtocol);
     if (!safeInteger(event.done) ||
         !safeInteger(event.total) ||
         event.done > event.total) {
+        if (expectedProtocol === STREAM_V3_PROTOCOL)
+            throw invalidPhase2Response();
         throw bridgeError("INVALID_PROGRESS_EVENT", "IIIS returned an invalid progress event.");
     }
     const unit = typeof event.unit === "string" &&
@@ -316,21 +509,65 @@ async function protocolJson(response, input, description) {
         throw bridgeError("PROTOCOL_MISMATCH", `IIIS returned invalid ${description} JSON.`);
     }
 }
-function operationStatusValue(value, operationId) {
+function operationStatusValue(value, operationId, directProfile, expectedDetail) {
     if (!isRecord(value)
-        || value.protocol_version !== GRANTED_STREAM_PROTOCOL_VERSION
+        || value.protocol_version !== operationProtocolFor(directProfile)
         || value.operation_id !== operationId
         || typeof value.status !== "string"
-        || !OPERATION_STATUSES.has(value.status)
+        || !operationStatusesFor(directProfile).has(value.status)
         || typeof value.parser_started !== "boolean"
         || typeof value.file_uploaded !== "boolean"
         || typeof value.billed !== "boolean"
         || typeof value.content_released !== "boolean"
         || typeof value.retryable !== "boolean"
         || !(value.expires_at === null || isRfc3339(value.expires_at))) {
+        if (isBillingProfile(directProfile))
+            throw invalidPhase2Response();
         throw bridgeError("PROTOCOL_MISMATCH", "IIIS returned an invalid operation status.");
     }
-    return value;
+    let billing = null;
+    let result = null;
+    if (isBillingProfile(directProfile)) {
+        if (!hasExactKeys(value, PHASE2_STATUS_REQUIRED_KEYS, ["result", "billing"])
+            || value.profile !== directProfile
+            || value.protocol_version !== OPERATION_V3_PROTOCOL
+            || !profileDetail(directProfile, expectedDetail)
+            || value.detail !== expectedDetail
+            || value.approved_result_max_bytes !== profileMaxBytes(directProfile)) {
+            throw invalidPhase2Response();
+        }
+        const settled = SETTLED_PHASE2_STATUSES.has(value.status);
+        if (settled) {
+            if (!value.billed
+                || !value.content_released
+                || !Object.prototype.hasOwnProperty.call(value, "result")
+                || !Object.prototype.hasOwnProperty.call(value, "billing")) {
+                throw invalidPhase2Response();
+            }
+            result = resultIdentityValue(value.result, directProfile);
+            billing = billingValue(value.billing);
+        }
+        else if (value.billed
+            || value.content_released
+            || Object.prototype.hasOwnProperty.call(value, "result")
+            || Object.prototype.hasOwnProperty.call(value, "billing")) {
+            throw invalidPhase2Response();
+        }
+    }
+    return {
+        protocol_version: value.protocol_version,
+        operation_id: value.operation_id,
+        status: value.status,
+        parser_started: value.parser_started,
+        file_uploaded: value.file_uploaded,
+        billed: value.billed,
+        content_released: value.content_released,
+        retryable: value.retryable,
+        expires_at: value.expires_at,
+        directProfile,
+        billing,
+        result,
+    };
 }
 function operationSnapshot(status) {
     return {
@@ -341,6 +578,8 @@ function operationSnapshot(status) {
         contentReleased: status.content_released,
         retryable: status.retryable,
         expiresAt: status.expires_at,
+        directProfile: status.directProfile,
+        billing: status.billing,
     };
 }
 async function* sseEvents(response) {
@@ -454,10 +693,16 @@ export class IiisClient {
             return this.inspectOperation(input);
         }
         const value = await protocolJson(response, input, "operation cancellation");
-        return operationSnapshot(operationStatusValue(value, input.operationId));
+        return operationSnapshot(operationStatusValue(value, input.operationId, inputDirectProfile(input), input.expectedDetail));
     }
-    async downloadResult(input, progress = NOOP_PROGRESS) {
+    async downloadResult(input, progress = NOOP_PROGRESS, settledStatus) {
         throwIfCanceled(input);
+        const directProfile = settledStatus?.directProfile ?? inputDirectProfile(input);
+        const billing = settledStatus?.billing ?? null;
+        const expectedResult = settledStatus?.result ?? null;
+        if (isBillingProfile(directProfile) && (billing === null || expectedResult === null)) {
+            throw invalidPhase2Response();
+        }
         const confirmedFacts = recoveryFacts({
             fileUploaded: true,
             billed: true,
@@ -501,15 +746,22 @@ export class IiisClient {
             throw errorWithRecoveryFacts(await errorFromResponse(response, input), confirmedFacts);
         }
         const declared = Number(response.headers.get("content-length"));
+        const mediaType = response.headers.get("content-type")
+            ?? "application/octet-stream";
         if (!safeInteger(declared)) {
             throw bridgeError("RESULT_INTEGRITY_FAILED", "The recovered result length is invalid.", {
                 ...confirmedFacts,
             });
         }
+        if (expectedResult !== null
+            && (declared !== expectedResult.bytes
+                || mediaType !== expectedResult.mediaType)) {
+            throw invalidPhase2Response();
+        }
         const start = {
             operationId: input.operationId,
             resultBytes: declared,
-            mediaType: response.headers.get("content-type") ?? "application/octet-stream",
+            mediaType,
             source: "recovery",
         };
         const hash = createHash("sha256");
@@ -549,9 +801,16 @@ export class IiisClient {
                     ...confirmedFacts,
                 });
             }
+            const resultDigest = `sha256:${hash.digest("hex")}`;
+            if (expectedResult !== null
+                && resultDigest !== expectedResult.digest) {
+                throw invalidPhase2Response();
+            }
             const metadata = {
                 ...start,
-                resultDigest: `sha256:${hash.digest("hex")}`,
+                resultDigest,
+                directProfile,
+                billing,
             };
             await input.retention.complete(metadata);
             throwIfCanceled(input);
@@ -644,6 +903,11 @@ export class IiisClient {
     async #consumeReleasedSse(input, response, progress) {
         let released;
         let completedMetadata;
+        const directProfile = inputDirectProfile(input);
+        const expectedProtocol = streamProtocolFor(directProfile);
+        const expectedDetail = isBillingProfile(directProfile)
+            ? expectedDetailFor(input, directProfile)
+            : undefined;
         let offset = 0;
         let complete = false;
         let streamFacts = recoveryFacts();
@@ -660,37 +924,84 @@ export class IiisClient {
                     });
                 }
                 if (event.type === "progress") {
-                    const parsed = progressValue(event);
+                    const parsed = progressValue(event, expectedProtocol);
                     await progress.report(parserProgress(parsed.done, parsed.total), 100, parsed.message, parsed.detail);
                     continue;
                 }
                 if (event.type === "error") {
+                    if (isBillingProfile(directProfile)) {
+                        if (!hasExactKeys(event, PHASE2_ERROR_KEYS)
+                            || event.protocol_version !== STREAM_V3_PROTOCOL
+                            || typeof event.code !== "string"
+                            || !ERROR_CODE_PATTERN.test(event.code)
+                            || typeof event.message !== "string"
+                            || event.message.length < 1
+                            || event.message.length > 512
+                            || typeof event.file_uploaded !== "boolean"
+                            || event.billed !== false
+                            || event.content_released !== false
+                            || typeof event.retryable !== "boolean") {
+                            throw invalidPhase2Response();
+                        }
+                    }
                     const code = stableErrorCode(event.code, "IIIS_PARSE_FAILED");
                     throw bridgeError(code, stableErrorMessage(code), {
                         fileUploaded: event.file_uploaded === true,
-                        billed: event.billed === true,
-                        contentReleased: event.content_released === true,
+                        billed: isBillingProfile(directProfile)
+                            ? false
+                            : event.billed === true,
+                        contentReleased: isBillingProfile(directProfile)
+                            ? false
+                            : event.content_released === true,
                         retryable: event.retryable === true,
                     });
                 }
                 if (event.type === "released") {
-                    validateProtocol(event);
+                    if (isBillingProfile(directProfile)
+                        && !hasExactKeys(event, PHASE2_RELEASE_KEYS)) {
+                        throw invalidPhase2Response();
+                    }
+                    validateProtocol(event, expectedProtocol);
                     if (released !== undefined
                         || event.operation_id !== input.operationId
                         || event.billed !== true
-                        || event.content_released !== true
-                        || !safeInteger(event.result_bytes)
-                        || typeof event.media_type !== "string"
-                        || event.media_type.length === 0
-                        || typeof event.result_digest !== "string"
-                        || !SHA256_PATTERN.test(event.result_digest)) {
+                        || event.content_released !== true) {
+                        if (isBillingProfile(directProfile))
+                            throw invalidPhase2Response();
                         throw bridgeError("INVALID_RELEASE_EVENT", "IIIS returned an invalid release event.");
                     }
-                    released = {
-                        resultBytes: event.result_bytes,
-                        mediaType: event.media_type,
-                        resultDigest: event.result_digest,
-                    };
+                    if (isBillingProfile(directProfile)) {
+                        if (event.stream_protocol_version !== STREAM_V3_PROTOCOL
+                            || event.profile !== directProfile
+                            || event.detail !== expectedDetail
+                            || event.approved_result_max_bytes !== profileMaxBytes(directProfile)) {
+                            throw invalidPhase2Response();
+                        }
+                        const result = resultIdentityValue(event.result, directProfile);
+                        released = {
+                            resultBytes: result.bytes,
+                            mediaType: result.mediaType,
+                            resultDigest: result.digest,
+                            directProfile,
+                            billing: billingValue(event.billing),
+                        };
+                    }
+                    else {
+                        if (!safeInteger(event.result_bytes)
+                            || typeof event.media_type !== "string"
+                            || event.media_type.length === 0
+                            || typeof event.result_digest !== "string"
+                            || !SHA256_PATTERN.test(event.result_digest)) {
+                            throw bridgeError("INVALID_RELEASE_EVENT", "IIIS returned an invalid release event.");
+                        }
+                        released = {
+                            resultBytes: event.result_bytes,
+                            mediaType: event.media_type,
+                            resultDigest: event.result_digest,
+                            directProfile,
+                            billing: null,
+                        };
+                    }
                     streamFacts = recoveryFacts({
                         fileUploaded: true,
                         billed: true,
@@ -705,7 +1016,11 @@ export class IiisClient {
                     continue;
                 }
                 if (event.type === "result_chunk") {
-                    validateProtocol(event);
+                    if (isBillingProfile(directProfile)
+                        && !hasExactKeys(event, PHASE2_RESULT_CHUNK_KEYS)) {
+                        throw invalidPhase2Response();
+                    }
+                    validateProtocol(event, expectedProtocol);
                     if (released === undefined) {
                         throw bridgeError("RESULT_BEFORE_RELEASE", "IIIS sent result bytes before billing release.");
                     }
@@ -734,7 +1049,11 @@ export class IiisClient {
                     continue;
                 }
                 if (event.type === "result_complete") {
-                    validateProtocol(event);
+                    if (isBillingProfile(directProfile)
+                        && !hasExactKeys(event, PHASE2_RESULT_COMPLETE_KEYS)) {
+                        throw invalidPhase2Response();
+                    }
+                    validateProtocol(event, expectedProtocol);
                     if (released === undefined
                         || event.operation_id !== input.operationId
                         || !safeInteger(event.result_bytes)
@@ -754,6 +1073,8 @@ export class IiisClient {
                         mediaType: released.mediaType,
                         resultDigest: released.resultDigest,
                         source: "sse",
+                        directProfile: released.directProfile,
+                        billing: released.billing,
                     };
                     await input.retention.complete(metadata);
                     throwIfCanceled(input);
@@ -761,6 +1082,8 @@ export class IiisClient {
                     complete = true;
                     continue;
                 }
+                if (isBillingProfile(directProfile))
+                    throw invalidPhase2Response();
                 throw bridgeError("INVALID_SSE_EVENT", "IIIS returned an unsupported progress event.");
             }
             if (completedMetadata !== undefined) {
@@ -772,7 +1095,9 @@ export class IiisClient {
         }
         catch (error) {
             const facts = error instanceof OmniBridgeError
-                ? mergeRecoveryFacts(streamFacts, recoveryFacts(error))
+                ? error.code === "IIIS_INVALID_RESPONSE"
+                    ? recoveryFacts(error)
+                    : mergeRecoveryFacts(streamFacts, recoveryFacts(error))
                 : streamFacts;
             try {
                 await input.retention.abort();
@@ -808,7 +1133,7 @@ export class IiisClient {
         if (!response.ok)
             throw await errorFromResponse(response, input);
         const value = await protocolJson(response, input, "operation status");
-        return operationStatusValue(value, input.operationId);
+        return operationStatusValue(value, input.operationId, inputDirectProfile(input), input.expectedDetail);
     }
     async #events(input, afterSequence) {
         throwIfCanceled(input);
@@ -823,8 +1148,9 @@ export class IiisClient {
         if (!response.ok)
             throw await errorFromResponse(response, input);
         const value = await protocolJson(response, input, "operation events");
+        const expectedProtocol = streamProtocolFor(inputDirectProfile(input));
         if (!isRecord(value)
-            || value.protocol_version !== GRANTED_STREAM_PROTOCOL_VERSION
+            || value.protocol_version !== expectedProtocol
             || value.operation_id !== input.operationId
             || typeof value.status !== "string"
             || value.after_sequence !== afterSequence
@@ -839,7 +1165,7 @@ export class IiisClient {
             if (!isRecord(raw) || raw.sequence !== expected || raw.type !== "progress") {
                 throw bridgeError("EVENT_CURSOR_EXPIRED", "IIIS returned a non-contiguous operation event page.");
             }
-            progressValue(raw);
+            progressValue(raw, expectedProtocol, true);
             events.push(raw);
             expected += 1;
         }
@@ -859,6 +1185,7 @@ export class IiisClient {
                 const status = await this.#status(input);
                 facts = mergeRecoveryFacts(facts, {
                     fileUploaded: status.file_uploaded,
+                    parserStarted: status.parser_started,
                     billed: status.billed,
                     contentReleased: status.content_released,
                 });
@@ -881,19 +1208,20 @@ export class IiisClient {
                     }
                 }
                 else if (status.status === "RELEASED") {
-                    return await this.downloadResult(input, progress);
+                    return await this.downloadResult(input, progress, status);
                 }
                 else if (ACTIVE_STATUSES.has(status.status)) {
                     const page = await this.#events(input, eventCursor);
                     for (const event of page.events) {
-                        const parsed = progressValue(event);
+                        const parsed = progressValue(event, streamProtocolFor(inputDirectProfile(input)), true);
                         await progress.report(parserProgress(parsed.done, parsed.total), 100, parsed.message, parsed.detail);
                     }
                     eventCursor = page.nextSequence;
                 }
-                else if (TERMINAL_STATUSES.has(status.status)) {
+                else if (terminalStatusesFor(inputDirectProfile(input)).has(status.status)) {
                     throw bridgeError(status.status, stableErrorMessage(status.status), {
                         fileUploaded: status.file_uploaded,
+                        parserStarted: status.parser_started,
                         billed: status.billed,
                         contentReleased: status.content_released,
                         retryable: status.retryable,

package/dist/operation-journal.d.ts

@@ -1,3 +1,4 @@
+import type { DirectProfile } from "./capabilities.js";
 import { type RepresentationIntent } from "./protocol.js";
 export type JournalState = "CREATED" | "GRANT_PENDING" | "GRANT_ISSUED" | "UPLOADING" | "PROCESSING" | "RESULT_READY" | "ACK_PENDING" | "CLEANUP_PENDING" | "COMPLETED" | "FAILED" | "CANCELED" | "EXPIRED";
 export type JournalProgressUnit = "page" | "sheet" | "slide" | "frame" | "segment";
@@ -9,6 +10,14 @@ export interface JournalProgress {
     readonly completed: number;
     readonly total: number;
 }
+export interface JournalBillingFacts {
+    readonly creditsCharged: number;
+    readonly creditsRemaining: number;
+}
+export interface JournalSettlementFacts {
+    readonly directProfile: DirectProfile | null;
+    readonly billing: JournalBillingFacts;
+}
 export type JournalSourceKind = "local" | "url";
 export type JournalDetail = "text" | "grounded" | "layout";
 export type JournalGroundingSchemaVersion = "none" | "omni.grounding.v1";
@@ -24,6 +33,8 @@ export interface JournalRecord {
     readonly groundingSchemaVersion: JournalGroundingSchemaVersion;
     readonly bundleProtocolVersion: JournalBundleProtocolVersion;
     readonly resultDeliveryEffective: JournalResultDelivery;
+    readonly directProfile: DirectProfile | null;
+    readonly billing: JournalBillingFacts | null;
     readonly operationId: string | null;
     readonly operationToken: string | null;
     readonly uploadUrl: string | null;
@@ -91,6 +102,8 @@ export declare class OperationJournal {
     migrateLegacyRecord(clientRequestId: string, canonicalIdentityJson: string, sourceLocator?: string | null): Promise<JournalRecord | null>;
     transition(clientRequestId: string, expectedState: JournalState, nextState: JournalState, patch: JournalPatch): Promise<JournalRecord>;
     strengthenResultDelivery(clientRequestId: string, requested: JournalResultDelivery): Promise<JournalRecord>;
+    bindDirectProfile(clientRequestId: string, directProfile: DirectProfile): Promise<JournalRecord>;
+    bindSettlementFacts(clientRequestId: string, facts: JournalSettlementFacts): Promise<JournalRecord>;
     loadByRequestId(clientRequestId: string): Promise<JournalRecord | null>;
     loadByOperationId(operationId: string): Promise<JournalRecord | null>;
     loadLatestByRequestIdentityHmac(requestIdentityHmac: string): Promise<JournalRecord | null>;