@cueai/omni-reader-mcp 1.0.2 → 1.1.1

package/dist/cube-client.js

@@ -1,10 +1,9 @@
 import { createHash, randomUUID } from "node:crypto";
 import { z } from "zod";
-import { DEFAULT_CUBE_BASE_URL, MAX_FILE_BYTES, CUBE_GRANT_PROTOCOL_VERSION, } from "./constants.js";
+import { BRIDGE_RELEASE_VERSION, CUBE_GRANT_PROTOCOL_VERSION, DEFAULT_CUBE_BASE_URL, MAX_FILE_BYTES, } from "./constants.js";
 import { OmniBridgeError } from "./errors.js";
 const GRANT_PATH = "/api/omni-reader/direct-upload/v1/parse-grants";
 const BRIDGE_PACKAGE = "@cueai/omni-reader-mcp";
-const BRIDGE_VERSION = "1.0.2";
 const grantResponseSchema = z
     .object({
     grant_id: z.string().min(1),
@@ -24,7 +23,9 @@ function bridgeError(code, message, retryable) {
     return new OmniBridgeError({
         code,
         message,
+        operationCreated: false,
         fileUploaded: false,
+        parserStarted: false,
         billed: false,
         contentReleased: false,
         retryable,
@@ -48,7 +49,7 @@ function grantRequestBody(input) {
         output: input.output,
         bridge: {
             package: BRIDGE_PACKAGE,
-            version: BRIDGE_VERSION,
+            version: BRIDGE_RELEASE_VERSION,
         },
     };
 }
@@ -102,14 +103,16 @@ export class CubeGrantClient {
         this.#grantUrl = new URL(GRANT_PATH, baseUrl).toString();
         this.#fetch = options.fetchImpl ?? fetch;
     }
-    async createGrant(input, clientRequestId, signal) {
+    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);
         }
         const body = grantRequestBody(input);
         const serializedBody = JSON.stringify(body);
         const requestHash = grantRequestHash(body);
-        await this.#journal.begin(clientRequestId, requestHash);
+        if (options.journal !== false) {
+            await this.#journal.begin(clientRequestId, requestHash);
+        }
         let response;
         try {
             response = await this.#fetch(this.#grantUrl, {
@@ -139,12 +142,14 @@ export class CubeGrantClient {
         catch {
             throw bridgeError("CUBE_PROTOCOL_ERROR", "Cube returned an invalid parse grant response.", false);
         }
-        await this.#journal.markGrantIssued(clientRequestId, {
-            operationId: parsed.operation_id,
-            operationToken: parsed.operation_token,
-            uploadUrl: parsed.upload_url,
-            expiresAt: parsed.expires_at,
-        });
+        if (options.journal !== false) {
+            await this.#journal.markGrantIssued(clientRequestId, {
+                operationId: parsed.operation_id,
+                operationToken: parsed.operation_token,
+                uploadUrl: parsed.upload_url,
+                expiresAt: parsed.expires_at,
+            });
+        }
         return {
             clientRequestId,
             requestHash,

package/dist/cursor.js

@@ -7,7 +7,9 @@ function cursorError(code, message) {
     return new OmniBridgeError({
         code,
         message,
+        operationCreated: true,
         fileUploaded: true,
+        parserStarted: true,
         billed: true,
         contentReleased: true,
         retryable: false,

package/dist/errors.d.ts

@@ -1,25 +1,56 @@
+export type OmniFailureScope = "source" | "local_capability" | "authentication" | "billing" | "service" | "parser" | "operation" | "cleanup" | "bridge";
+export type OmniSourceKind = "local" | "url";
+export interface OmniErrorConstraints {
+    readonly max_bytes?: number;
+    readonly supported_extensions?: string[];
+}
 export interface OmniBridgeErrorInit {
     code: string;
     message: string;
+    failureScope?: OmniFailureScope;
+    sourceKind?: OmniSourceKind;
+    userAction?: string;
+    requestId?: string;
+    operationCreated: boolean;
     fileUploaded: boolean;
+    parserStarted: boolean;
     billed: boolean;
     contentReleased: boolean;
     retryable: boolean;
+    retryAfter?: number;
+    constraints?: OmniErrorConstraints;
 }
 export interface OmniBridgeErrorPayload {
+    ok: false;
     code: string;
+    failure_scope?: OmniFailureScope;
+    source_kind?: OmniSourceKind;
+    retryable: boolean;
     message: string;
+    user_action?: string;
+    request_id?: string;
+    operation_created: boolean;
     file_uploaded: boolean;
+    parser_started: boolean;
     billed: boolean;
     content_released: boolean;
-    retryable: boolean;
+    retry_after?: number;
+    constraints?: OmniErrorConstraints;
 }
 export declare class OmniBridgeError extends Error {
     readonly code: string;
+    readonly failureScope?: OmniFailureScope;
+    readonly sourceKind?: OmniSourceKind;
+    readonly userAction?: string;
+    readonly requestId?: string;
+    readonly operationCreated: boolean;
     readonly fileUploaded: boolean;
+    readonly parserStarted: boolean;
     readonly billed: boolean;
     readonly contentReleased: boolean;
     readonly retryable: boolean;
+    readonly retryAfter?: number;
+    readonly constraints?: OmniErrorConstraints;
     constructor(init: OmniBridgeErrorInit);
     toJSON(): OmniBridgeErrorPayload;
 }

package/dist/errors.js

@@ -1,26 +1,51 @@
 export class OmniBridgeError extends Error {
     code;
+    failureScope;
+    sourceKind;
+    userAction;
+    requestId;
+    operationCreated;
     fileUploaded;
+    parserStarted;
     billed;
     contentReleased;
     retryable;
+    retryAfter;
+    constraints;
     constructor(init) {
         super(init.message);
         this.name = "OmniBridgeError";
         this.code = init.code;
+        this.failureScope = init.failureScope;
+        this.sourceKind = init.sourceKind;
+        this.userAction = init.userAction;
+        this.requestId = init.requestId;
+        this.operationCreated = init.operationCreated;
         this.fileUploaded = init.fileUploaded;
+        this.parserStarted = init.parserStarted;
         this.billed = init.billed;
         this.contentReleased = init.contentReleased;
         this.retryable = init.retryable;
+        this.retryAfter = init.retryAfter;
+        this.constraints = init.constraints;
     }
     toJSON() {
         return {
+            ok: false,
             code: this.code,
+            ...(this.failureScope === undefined ? {} : { failure_scope: this.failureScope }),
+            ...(this.sourceKind === undefined ? {} : { source_kind: this.sourceKind }),
+            retryable: this.retryable,
             message: this.message,
+            ...(this.userAction === undefined ? {} : { user_action: this.userAction }),
+            ...(this.requestId === undefined ? {} : { request_id: this.requestId }),
+            operation_created: this.operationCreated,
             file_uploaded: this.fileUploaded,
+            parser_started: this.parserStarted,
             billed: this.billed,
             content_released: this.contentReleased,
-            retryable: this.retryable,
+            ...(this.retryAfter === undefined ? {} : { retry_after: this.retryAfter }),
+            ...(this.constraints === undefined ? {} : { constraints: this.constraints }),
         };
     }
 }

package/dist/iiis-client.d.ts

@@ -17,27 +17,41 @@ export interface ResultRetentionSink {
     abort(): Promise<void>;
 }
 export interface IiisOperationInput {
-    readonly parseGrant: string;
+    readonly parseGrant?: string;
     readonly operationId: string;
     readonly operationToken: string;
-    readonly uploadUrl: string;
-    readonly expiresAt: string;
-    readonly openedFile: OpenedAllowedFile;
+    readonly uploadUrl?: string;
+    readonly expiresAt?: string;
+    readonly openedFile?: OpenedAllowedFile;
     readonly retention: ResultRetentionSink;
     readonly progress?: ProgressSink;
     readonly signal?: AbortSignal;
 }
 export interface ReleasedResult extends ReleasedMetadata {
 }
+export type IiisOperationStatus = "ISSUED" | "CLAIMED" | "UPLOADING" | "PROCESSING" | "SETTLING" | "RELEASED" | "EXPIRED" | "SETTLEMENT_DENIED" | "FAILED" | "CANCELED" | "DELIVERY_EXPIRED" | "DELIVERED";
+export interface IiisOperationSnapshot {
+    readonly status: IiisOperationStatus;
+    readonly parserStarted: boolean;
+    readonly fileUploaded: boolean;
+    readonly billed: boolean;
+    readonly contentReleased: boolean;
+    readonly retryable: boolean;
+    readonly expiresAt: string | null;
+}
 export interface IiisClientOptions {
     readonly fetchImpl?: typeof fetch;
     readonly pollIntervalMs?: number;
     readonly maxPolls?: number;
+    readonly operationBaseUrl?: string;
 }
 export declare class IiisClient {
     #private;
     constructor(options?: IiisClientOptions);
     uploadAndWait(input: IiisOperationInput): Promise<ReleasedResult>;
+    recoverAndWait(input: IiisOperationInput): Promise<ReleasedResult>;
+    inspectOperation(input: IiisOperationInput): Promise<IiisOperationSnapshot>;
+    cancelOperation(input: IiisOperationInput): Promise<IiisOperationSnapshot>;
     downloadResult(input: IiisOperationInput, progress?: ProgressSink): Promise<ReleasedResult>;
     ack(input: IiisOperationInput): Promise<void>;
 }

package/dist/iiis-client.js

@@ -1,8 +1,8 @@
 import { createHash } from "node:crypto";
-import { GRANTED_STREAM_PROTOCOL_VERSION, RESULT_CHUNK_MAX_BYTES, } from "./constants.js";
+import { DEFAULT_IIIS_GRANTED_BASE_URL, GRANTED_STREAM_PROTOCOL_VERSION, RESULT_CHUNK_MAX_BYTES, } from "./constants.js";
 import { OmniBridgeError } from "./errors.js";
 import { createMultipartBody } from "./multipart-body.js";
-import { NOOP_PROGRESS } from "./progress.js";
+import { NOOP_PROGRESS, } from "./progress.js";
 class TransportFailure extends Error {
 }
 const ACTIVE_STATUSES = new Set(["CLAIMED", "UPLOADING", "PROCESSING", "SETTLING"]);
@@ -14,6 +14,15 @@ const TERMINAL_STATUSES = new Set([
     "DELIVERY_EXPIRED",
     "DELIVERED",
 ]);
+const OPERATION_STATUSES = new Set([
+    "ISSUED",
+    "CLAIMED",
+    "UPLOADING",
+    "PROCESSING",
+    "SETTLING",
+    "RELEASED",
+    ...TERMINAL_STATUSES,
+]);
 const RECOVERABLE_SETTLEMENT_ERRORS = new Set([
     "SETTLEMENT_IN_PROGRESS",
     "SETTLEMENT_RETRYABLE",
@@ -24,11 +33,24 @@ const RECOVERABLE_SETTLEMENT_ERRORS = new Set([
 ]);
 const BASE64URL_PATTERN = /^[A-Za-z0-9_-]+$/;
 const SHA256_PATTERN = /^sha256:[0-9a-f]{64}$/;
+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([
+    "page",
+    "sheet",
+    "slide",
+    "frame",
+    "segment",
+]);
 function bridgeError(code, message, facts = {}) {
     return new OmniBridgeError({
         code,
         message,
+        operationCreated: facts.operationCreated ?? true,
         fileUploaded: facts.fileUploaded ?? false,
+        parserStarted: (facts.parserStarted ?? false) ||
+            facts.billed === true ||
+            facts.contentReleased === true,
         billed: facts.billed ?? false,
         contentReleased: facts.contentReleased ?? false,
         retryable: facts.retryable ?? false,
@@ -66,11 +88,17 @@ function throwIfCanceled(input) {
     if (input.signal?.aborted)
         throw canceledAfterUpload();
 }
-function operationUrl(input, suffix = "") {
-    const base = new URL(input.uploadUrl);
-    if (base.protocol !== "https:" || base.username !== "" || base.password !== "") {
-        throw bridgeError("INSECURE_IIIS_URL", "The IIIS upload endpoint must use credential-free HTTPS.");
+function secureIiisUrl(value) {
+    const url = new URL(value);
+    if (url.protocol !== "https:" || url.username !== "" || url.password !== "") {
+        throw bridgeError("INSECURE_IIIS_URL", "The IIIS endpoint must use credential-free HTTPS.");
     }
+    return url;
+}
+function operationUrl(input, operationBaseUrl, suffix = "") {
+    const base = input.uploadUrl === undefined
+        ? secureIiisUrl(operationBaseUrl)
+        : secureIiisUrl(input.uploadUrl);
     return new URL(`operations/${encodeURIComponent(input.operationId)}${suffix}`, base).toString();
 }
 function operationHeaders(input) {
@@ -84,29 +112,94 @@ function safeInteger(value, minimum = 0) {
         && Number.isSafeInteger(value)
         && value >= minimum;
 }
+function isRfc3339(value) {
+    if (typeof value !== "string")
+        return false;
+    const match = RFC3339_PATTERN.exec(value);
+    if (match === null)
+        return false;
+    const year = Number(match[1]);
+    const month = Number(match[2]);
+    const day = Number(match[3]);
+    if (month < 1 || month > 12 || day < 1)
+        return false;
+    const monthDays = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+    const leapYear = year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+    const days = month === 2 && leapYear ? 29 : monthDays[month - 1];
+    return day <= days;
+}
 function validateProtocol(event) {
     if (event.protocol_version !== GRANTED_STREAM_PROTOCOL_VERSION) {
         throw bridgeError("PROTOCOL_MISMATCH", "IIIS returned an unsupported protocol version.");
     }
 }
+function stableErrorCode(value, fallback) {
+    return typeof value === "string" && ERROR_CODE_PATTERN.test(value)
+        ? value
+        : fallback;
+}
+function stableErrorMessage(code) {
+    if (code === "SETTLEMENT_DENIED")
+        return "Billing did not authorize content release.";
+    if (code === "DELIVERY_EXPIRED")
+        return "The temporary delivery result has expired.";
+    if (code === "CLEANUP_PENDING")
+        return "Omni cleanup is still pending.";
+    if (code === "CANCELED")
+        return "The Omni operation was canceled.";
+    return "The Omni parsing service could not complete the operation.";
+}
+function stableProgressMessage(stage) {
+    if (stage === "parse" || stage === "parsing")
+        return "Parsing document";
+    if (stage === "settling" || stage === "settlement")
+        return "Finalizing result";
+    return "Processing document";
+}
 function progressValue(event) {
     validateProtocol(event);
-    if (!safeInteger(event.done) || !safeInteger(event.total)) {
+    if (!safeInteger(event.done) ||
+        !safeInteger(event.total) ||
+        event.done > event.total) {
         throw bridgeError("INVALID_PROGRESS_EVENT", "IIIS returned an invalid progress event.");
     }
+    const unit = typeof event.unit === "string" &&
+        PROGRESS_UNITS.has(event.unit)
+        ? event.unit
+        : undefined;
     return {
         done: event.done,
         total: event.total,
-        message: String(event.message ?? event.stage ?? "Parsing"),
+        message: stableProgressMessage(event.stage),
+        ...(unit === undefined || event.total <= 0
+            ? {}
+            : {
+                detail: {
+                    unit,
+                    completed: Math.min(event.done, event.total),
+                    total: event.total,
+                },
+            }),
     };
 }
 function monotonicProgress(sink) {
     let last = 0;
+    let lastDetail;
     return {
-        async report(progress, total, message) {
+        async report(progress, total, message, detail) {
             const next = Math.min(total, Math.max(last, progress));
             last = next;
-            await sink.report(next, total, message);
+            const nextDetail = detail === undefined
+                ? undefined
+                : lastDetail?.unit === detail.unit
+                    ? {
+                        ...detail,
+                        completed: Math.min(detail.total, Math.max(lastDetail.completed, detail.completed)),
+                    }
+                    : detail;
+            if (nextDetail !== undefined)
+                lastDetail = nextDetail;
+            await sink.report(next, total, message, nextDetail);
         },
     };
 }
@@ -118,8 +211,9 @@ function parserProgress(done, total) {
 async function errorFromResponse(response, input) {
     try {
         const body = await response.json();
-        if (isRecord(body) && typeof body.code === "string" && typeof body.message === "string") {
-            return bridgeError(body.code, body.message, {
+        if (isRecord(body) && typeof body.code === "string") {
+            const code = stableErrorCode(body.code, "IIIS_UNAVAILABLE");
+            return bridgeError(code, stableErrorMessage(code), {
                 fileUploaded: body.file_uploaded === true,
                 billed: body.billed === true,
                 contentReleased: body.content_released === true,
@@ -144,6 +238,33 @@ async function protocolJson(response, input, description) {
         throw bridgeError("PROTOCOL_MISMATCH", `IIIS returned invalid ${description} JSON.`);
     }
 }
+function operationStatusValue(value, operationId) {
+    if (!isRecord(value)
+        || value.protocol_version !== GRANTED_STREAM_PROTOCOL_VERSION
+        || value.operation_id !== operationId
+        || typeof value.status !== "string"
+        || !OPERATION_STATUSES.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))) {
+        throw bridgeError("PROTOCOL_MISMATCH", "IIIS returned an invalid operation status.");
+    }
+    return value;
+}
+function operationSnapshot(status) {
+    return {
+        status: status.status,
+        parserStarted: status.parser_started,
+        fileUploaded: status.file_uploaded,
+        billed: status.billed,
+        contentReleased: status.content_released,
+        retryable: status.retryable,
+        expiresAt: status.expires_at,
+    };
+}
 async function* sseEvents(response) {
     if (response.body === null)
         throw new TransportFailure("missing SSE body");
@@ -198,10 +319,17 @@ export class IiisClient {
     #fetch;
     #pollIntervalMs;
     #maxPolls;
+    #operationBaseUrl;
     constructor(options = {}) {
         this.#fetch = options.fetchImpl ?? fetch;
         this.#pollIntervalMs = Math.max(0, options.pollIntervalMs ?? 250);
         this.#maxPolls = Math.max(1, options.maxPolls ?? 240);
+        const operationBase = secureIiisUrl(options.operationBaseUrl ?? DEFAULT_IIIS_GRANTED_BASE_URL);
+        operationBase.search = "";
+        operationBase.hash = "";
+        if (!operationBase.pathname.endsWith("/"))
+            operationBase.pathname += "/";
+        this.#operationBaseUrl = operationBase.toString();
     }
     async uploadAndWait(input) {
         const progress = monotonicProgress(input.progress ?? NOOP_PROGRESS);
@@ -222,6 +350,34 @@ export class IiisClient {
             return this.#recover(input, true, progress);
         }
     }
+    async recoverAndWait(input) {
+        return this.#recover(input, false, monotonicProgress(input.progress ?? NOOP_PROGRESS));
+    }
+    async inspectOperation(input) {
+        return operationSnapshot(await this.#status({ ...input, signal: undefined }));
+    }
+    async cancelOperation(input) {
+        throwIfCanceled(input);
+        let response;
+        try {
+            response = await this.#fetch(operationUrl(input, this.#operationBaseUrl, "/cancel"), {
+                method: "POST",
+                headers: operationHeaders(input),
+                signal: input.signal,
+            });
+        }
+        catch {
+            throwIfCanceled(input);
+            throw bridgeError("IIIS_UNAVAILABLE", "IIIS operation cancellation is unavailable.", { retryable: true });
+        }
+        if (!response.ok)
+            throw await errorFromResponse(response, input);
+        if (response.status === 202 || response.status === 204) {
+            return this.inspectOperation(input);
+        }
+        const value = await protocolJson(response, input, "operation cancellation");
+        return operationSnapshot(operationStatusValue(value, input.operationId));
+    }
     async downloadResult(input, progress = NOOP_PROGRESS) {
         throwIfCanceled(input);
         const confirmedFacts = recoveryFacts({
@@ -249,7 +405,7 @@ export class IiisClient {
         }
         let response;
         try {
-            response = await this.#fetch(operationUrl(input, "/result"), {
+            response = await this.#fetch(operationUrl(input, this.#operationBaseUrl, "/result"), {
                 headers: operationHeaders(input),
                 signal: input.signal,
             });
@@ -347,7 +503,7 @@ export class IiisClient {
         throwIfCanceled(input);
         let response;
         try {
-            response = await this.#fetch(operationUrl(input, "/ack"), {
+            response = await this.#fetch(operationUrl(input, this.#operationBaseUrl, "/ack"), {
                 method: "POST",
                 headers: operationHeaders(input),
                 signal: input.signal,
@@ -366,21 +522,27 @@ export class IiisClient {
             throw await errorFromResponse(response, input);
     }
     async #uploadOnce(input, progress) {
-        const body = createMultipartBody(input.openedFile, {
+        const openedFile = input.openedFile;
+        const parseGrant = input.parseGrant;
+        const uploadUrl = input.uploadUrl;
+        if (openedFile === undefined || parseGrant === undefined || uploadUrl === undefined) {
+            throw bridgeError("UPLOAD_CONTEXT_UNAVAILABLE", "The local upload context is unavailable for this recovery operation.", { retryable: true });
+        }
+        const body = createMultipartBody(openedFile, {
             signal: input.signal,
             onProgress: async (bytes) => {
-                const scaled = input.openedFile.size === 0
+                const scaled = openedFile.size === 0
                     ? 40
-                    : Math.floor(bytes * 40 / input.openedFile.size);
-                await progress.report(scaled, 100, `Uploading ${bytes}/${input.openedFile.size} bytes`);
+                    : Math.floor(bytes * 40 / openedFile.size);
+                await progress.report(scaled, 100, `Uploading ${bytes}/${openedFile.size} bytes`);
             },
         });
         let response;
         try {
-            response = await this.#fetch(input.uploadUrl, {
+            response = await this.#fetch(uploadUrl, {
                 method: "POST",
                 headers: {
-                    authorization: `Bearer ${input.parseGrant}`,
+                    authorization: `Bearer ${parseGrant}`,
                     "content-type": body.contentType,
                     "content-length": String(body.contentLength),
                 },
@@ -421,11 +583,12 @@ export class IiisClient {
                 }
                 if (event.type === "progress") {
                     const parsed = progressValue(event);
-                    await progress.report(parserProgress(parsed.done, parsed.total), 100, parsed.message);
+                    await progress.report(parserProgress(parsed.done, parsed.total), 100, parsed.message, parsed.detail);
                     continue;
                 }
                 if (event.type === "error") {
-                    throw bridgeError(String(event.code ?? "IIIS_PARSE_FAILED"), String(event.message ?? "IIIS parsing failed."), {
+                    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,
@@ -555,7 +718,7 @@ export class IiisClient {
         throwIfCanceled(input);
         let response;
         try {
-            response = await this.#fetch(operationUrl(input), {
+            response = await this.#fetch(operationUrl(input, this.#operationBaseUrl), {
                 headers: operationHeaders(input),
                 signal: input.signal,
             });
@@ -567,25 +730,13 @@ export class IiisClient {
         if (!response.ok)
             throw await errorFromResponse(response, input);
         const value = await protocolJson(response, input, "operation status");
-        if (!isRecord(value)
-            || value.protocol_version !== GRANTED_STREAM_PROTOCOL_VERSION
-            || value.operation_id !== input.operationId
-            || typeof value.status !== "string"
-            || 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 || typeof value.expires_at === "string")) {
-            throw bridgeError("PROTOCOL_MISMATCH", "IIIS returned an invalid operation status.");
-        }
-        return value;
+        return operationStatusValue(value, input.operationId);
     }
     async #events(input, afterSequence) {
         throwIfCanceled(input);
         let response;
         try {
-            response = await this.#fetch(operationUrl(input, `/events?after_sequence=${afterSequence}`), { headers: operationHeaders(input), signal: input.signal });
+            response = await this.#fetch(operationUrl(input, this.#operationBaseUrl, `/events?after_sequence=${afterSequence}`), { headers: operationHeaders(input), signal: input.signal });
         }
         catch {
             throwIfCanceled(input);
@@ -637,7 +788,10 @@ export class IiisClient {
                     await progress.report(45, 100, "Parser started");
                     parserStartedReported = true;
                 }
-                if (status.status === "ISSUED" && mayRetryUpload && Date.parse(input.expiresAt) > Date.now()) {
+                if (status.status === "ISSUED" &&
+                    mayRetryUpload &&
+                    input.expiresAt !== undefined &&
+                    Date.parse(input.expiresAt) > Date.now()) {
                     try {
                         return await this.#uploadOnce(input, progress);
                     }
@@ -655,12 +809,12 @@ export class IiisClient {
                     const page = await this.#events(input, eventCursor);
                     for (const event of page.events) {
                         const parsed = progressValue(event);
-                        await progress.report(parserProgress(parsed.done, parsed.total), 100, parsed.message);
+                        await progress.report(parserProgress(parsed.done, parsed.total), 100, parsed.message, parsed.detail);
                     }
                     eventCursor = page.nextSequence;
                 }
                 else if (TERMINAL_STATUSES.has(status.status)) {
-                    throw bridgeError(status.status, `The IIIS operation ended with status ${status.status}.`, {
+                    throw bridgeError(status.status, stableErrorMessage(status.status), {
                         fileUploaded: status.file_uploaded,
                         billed: status.billed,
                         contentReleased: status.content_released,

package/dist/index.d.ts

@@ -8,10 +8,13 @@ export interface RunCliOptions {
     readonly cwd?: string;
     readonly artifactRoot?: string;
     readonly platform?: NodeJS.Platform;
+    readonly temporaryDirectory?: string;
+    readonly stdinIsTTY?: boolean;
     readonly now?: () => Date;
     readonly npmVersion?: string;
     readonly packageVersion?: string;
     readonly fetchImpl?: typeof fetch;
+    readonly iiisOperationBaseUrl?: string;
     readonly stdout?: WritableLike;
     readonly stderr?: WritableLike;
     readonly ask?: (question: string) => Promise<string>;