@cueai/omni-reader-mcp 1.0.1 → 1.1.0

package/dist/cube-client.d.ts

@@ -1,6 +1,6 @@
+import { BRIDGE_RELEASE_VERSION } from "./constants.js";
 import { OperationJournal } from "./operation-journal.js";
 declare const BRIDGE_PACKAGE = "@cueai/omni-reader-mcp";
-declare const BRIDGE_VERSION = "1.0.1";
 export interface GrantRequestInput {
     readonly contentLength: number;
     readonly contentType: string;
@@ -35,7 +35,7 @@ interface GrantRequestBody {
     readonly output: "markdown";
     readonly bridge: {
         readonly package: typeof BRIDGE_PACKAGE;
-        readonly version: typeof BRIDGE_VERSION;
+        readonly version: typeof BRIDGE_RELEASE_VERSION;
     };
 }
 export declare function grantRequestHash(body: GrantRequestBody): string;
@@ -43,6 +43,8 @@ export declare function createClientRequestId(): string;
 export declare class CubeGrantClient {
     #private;
     constructor(options: CubeGrantClientOptions);
-    createGrant(input: GrantRequestInput, clientRequestId: string, signal?: AbortSignal): Promise<GrantedOperation>;
+    createGrant(input: GrantRequestInput, clientRequestId: string, signal?: AbortSignal, options?: {
+        journal?: boolean;
+    }): Promise<GrantedOperation>;
 }
 export {};

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, 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.1";
 const grantResponseSchema = z
     .object({
     grant_id: z.string().min(1),
@@ -17,14 +16,16 @@ const grantResponseSchema = z
         .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(PROTOCOL_VERSION),
+    protocol_version: z.literal(CUBE_GRANT_PROTOCOL_VERSION),
 })
     .strict();
 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>;
-    downloadResult(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>;
 }