@cueai/omni-reader-mcp 1.0.2 → 1.1.0

package/dist/path-security.d.ts

@@ -15,6 +15,7 @@ export interface OpenedAllowedFile {
     readonly size: number;
     readonly safeExtension: string;
     readonly contentType: string;
+    readonly sourceFingerprint?: string;
     createReadStream(): ReadStream;
     close(): Promise<void>;
 }

package/dist/path-security.js

@@ -1,3 +1,4 @@
+import { createHash } from "node:crypto";
 import { constants, } from "node:fs";
 import { open as nodeOpen, realpath as nodeRealpath, stat as nodeStat, } from "node:fs/promises";
 import { homedir } from "node:os";
@@ -41,6 +42,7 @@ const CONTENT_TYPES = {
     ".html": "text/html",
     ".htm": "text/html",
 };
+const SUPPORTED_EXTENSIONS = [...new Set(Object.keys(CONTENT_TYPES).map((extension) => extension.slice(1)))].sort();
 const NODE_FILE_SYSTEM = {
     realpath: (candidate) => nodeRealpath(candidate),
     open: (candidate, flags) => nodeOpen(candidate, flags),
@@ -50,12 +52,14 @@ class DescriptorBackedFile {
     size;
     safeExtension;
     contentType;
+    sourceFingerprint;
     #handle;
     #closed = false;
-    constructor(handle, size, safeExtension, contentType) {
+    constructor(handle, size, safeExtension, contentType, sourceFingerprint) {
         this.size = size;
         this.safeExtension = safeExtension;
         this.contentType = contentType;
+        this.sourceFingerprint = sourceFingerprint;
         this.#handle = handle;
     }
     createReadStream() {
@@ -72,14 +76,20 @@ class DescriptorBackedFile {
         await this.#handle.close();
     }
 }
-function bridgeError(code, message, retryable) {
+function bridgeError(code, message, retryable, constraints) {
     return new OmniBridgeError({
         code,
+        failureScope: "source",
+        sourceKind: "local",
         message,
+        userAction: "Provide an accessible supported file inside an allowed directory.",
+        operationCreated: false,
         fileUploaded: false,
+        parserStarted: false,
         billed: false,
         contentReleased: false,
         retryable,
+        ...(constraints === undefined ? {} : { constraints }),
     });
 }
 function validatePathText(value) {
@@ -115,7 +125,7 @@ function requireRegularFile(fileStat) {
 }
 function requireAllowedSize(fileStat) {
     if (fileStat.size > BigInt(MAX_FILE_BYTES)) {
-        throw bridgeError("FILE_TOO_LARGE", "The local file exceeds the 256 MiB upload limit.", false);
+        throw bridgeError("SOURCE_TOO_LARGE", "The source exceeds the 256 MiB limit.", false, { max_bytes: MAX_FILE_BYTES });
     }
     return Number(fileStat.size);
 }
@@ -128,14 +138,24 @@ function requireSameFile(before, after) {
         throw bridgeError("FILE_CHANGED_DURING_OPEN", "The local file changed while it was being opened. Retry after file changes stop.", true);
     }
 }
+function redactedSourceFingerprint(fileStat) {
+    const identity = [
+        fileStat.dev,
+        fileStat.ino,
+        fileStat.size,
+        fileStat.mtimeNs,
+        fileStat.ctimeNs,
+    ].map((value) => value.toString()).join(":");
+    return `sha256:${createHash("sha256").update(identity, "utf8").digest("hex")}`;
+}
 function safeFileType(resolvedPath) {
     const safeExtension = path.extname(resolvedPath).toLowerCase();
     if (!/^\.[a-z0-9]{1,10}$/u.test(safeExtension)) {
-        throw bridgeError("UNSUPPORTED_FILE_TYPE", "The local file type is not supported.", false);
+        throw bridgeError("UNSUPPORTED_MEDIA_TYPE", "The source media type is not supported.", false, { supported_extensions: SUPPORTED_EXTENSIONS });
     }
     const contentType = CONTENT_TYPES[safeExtension];
     if (contentType === undefined) {
-        throw bridgeError("UNSUPPORTED_FILE_TYPE", "The local file type is not supported.", false);
+        throw bridgeError("UNSUPPORTED_MEDIA_TYPE", "The source media type is not supported.", false, { supported_extensions: SUPPORTED_EXTENSIONS });
     }
     return { safeExtension, contentType };
 }
@@ -229,7 +249,7 @@ export async function openAllowedFile(input, options) {
         requireRegularFile(after);
         requireSameFile(before, after);
         const { safeExtension, contentType } = safeFileType(afterPath);
-        const opened = new DescriptorBackedFile(handle, size, safeExtension, contentType);
+        const opened = new DescriptorBackedFile(handle, size, safeExtension, contentType, redactedSourceFingerprint(before));
         handle = undefined;
         return opened;
     }

package/dist/progress.d.ts

@@ -1,4 +1,9 @@
+export interface ProgressDetail {
+    readonly unit: "page" | "sheet" | "slide" | "frame" | "segment";
+    readonly completed: number;
+    readonly total: number;
+}
 export interface ProgressSink {
-    report(progress: number, total: number, message: string): Promise<void>;
+    report(progress: number, total: number, message: string, detail?: ProgressDetail): Promise<void>;
 }
 export declare const NOOP_PROGRESS: ProgressSink;

package/dist/protocol.d.ts

@@ -1,18 +1,29 @@
 import { z } from "zod";
-export declare const LOCAL_BRIDGE_PROTOCOL_VERSION = "omni.local_bridge_tools.v1";
-export declare const SAFETY_INSTRUCTIONS: string;
-export declare const parseDocumentSchema: z.ZodObject<{
-    local_path: z.ZodEffects<z.ZodString, string, string>;
-    no_store: z.ZodDefault<z.ZodBoolean>;
-    output: z.ZodDefault<z.ZodLiteral<"markdown">>;
+export declare const LOCAL_BRIDGE_PROTOCOL_VERSION = "omni.local_bridge_tools.v2";
+export declare const MACHINE_INSTRUCTIONS: string;
+export declare const parseSchema: z.ZodObject<{
+    source: z.ZodEffects<z.ZodString, string, string>;
 }, "strict", z.ZodTypeAny, {
-    local_path: string;
-    no_store: boolean;
-    output: "markdown";
+    source: string;
 }, {
-    local_path: string;
-    no_store?: boolean | undefined;
-    output?: "markdown" | undefined;
+    source: string;
+}>;
+export declare const getParseStatusSchema: z.ZodObject<{
+    operation_id: z.ZodString;
+    wait_ms: z.ZodOptional<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    operation_id: string;
+    wait_ms?: number | undefined;
+}, {
+    operation_id: string;
+    wait_ms?: number | undefined;
+}>;
+export declare const cancelParseSchema: z.ZodObject<{
+    operation_id: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    operation_id: string;
+}, {
+    operation_id: string;
 }>;
 export declare const readResultSchema: z.ZodObject<{
     result_id: z.ZodString;
@@ -34,6 +45,8 @@ export declare const discardResultSchema: z.ZodObject<{
 }, {
     result_id: string;
 }>;
-export type ParseDocumentArguments = z.infer<typeof parseDocumentSchema>;
+export type ParseArguments = z.infer<typeof parseSchema>;
+export type GetParseStatusArguments = z.infer<typeof getParseStatusSchema>;
+export type CancelParseArguments = z.infer<typeof cancelParseSchema>;
 export type ReadResultArguments = z.infer<typeof readResultSchema>;
 export type DiscardResultArguments = z.infer<typeof discardResultSchema>;

package/dist/protocol.js

@@ -1,16 +1,40 @@
 import { z } from "zod";
-import { RESULT_CHUNK_MAX_BYTES } from "./constants.js";
-export const LOCAL_BRIDGE_PROTOCOL_VERSION = "omni.local_bridge_tools.v1";
-export const SAFETY_INSTRUCTIONS = "For local documents, pass the exact user-provided path to parse_document.\n" +
-    "Do not read, attach, base64-encode, or insert the file content into the\n" +
-    "conversation before calling this tool. Do not use @file as a prerequisite.\n" +
-    "Use parse_url for HTTP(S) URLs.";
+import { RESULT_CHUNK_MAX_BYTES, STATUS_LONG_POLL_MAX_MS } from "./constants.js";
+export const LOCAL_BRIDGE_PROTOCOL_VERSION = "omni.local_bridge_tools.v2";
+export const MACHINE_INSTRUCTIONS = [
+    "Pass the user-provided source string directly to parse.",
+    "Treat only HTTP(S) as URL; ordinary paths require the local Bridge.",
+    "Never read, attach, base64-encode, or insert local source content before calling Omni.",
+    "Never use file://, localhost, or public temporary upload services as fallback.",
+    "Ask before installing Bridge or expanding allowed roots.",
+    "Never ask the user to paste an API Key into chat.",
+    "Retry only when structured state permits; recover an existing operation before resubmitting.",
+    "A tool-level error is not an MCP disconnection.",
+    "Do not promise background notification when the client lacks task support.",
+    "Do not claim deletion before cleanup is confirmed.",
+    "Report authoritative unit progress when present; never treat partial output as final.",
+    "After parsing, continue the user's original task.",
+].join("\n");
+const operationIdSchema = z.string().regex(/^op_[A-Za-z0-9_-]{16,64}$/u);
 const resultIdSchema = z.string().regex(/^result_[A-Za-z0-9_-]{16,64}$/u);
-export const parseDocumentSchema = z
+export const parseSchema = z
     .object({
-    local_path: z.string().min(1).refine((value) => !value.includes("\0")),
-    no_store: z.boolean().default(true),
-    output: z.literal("markdown").default("markdown"),
+    source: z
+        .string()
+        .min(1)
+        .max(8192)
+        .refine((value) => !value.includes("\0")),
+})
+    .strict();
+export const getParseStatusSchema = z
+    .object({
+    operation_id: operationIdSchema,
+    wait_ms: z.number().int().min(0).max(STATUS_LONG_POLL_MAX_MS).optional(),
+})
+    .strict();
+export const cancelParseSchema = z
+    .object({
+    operation_id: operationIdSchema,
 })
     .strict();
 export const readResultSchema = z

package/dist/remote-client.d.ts

@@ -0,0 +1,17 @@
+import { type ParseResult } from "./result-contract.js";
+export interface RemoteOmniClient {
+    parse(source: string, clientRequestId: string, signal: AbortSignal): Promise<ParseResult>;
+    status(operationId: string, waitMs: number | undefined, signal: AbortSignal): Promise<ParseResult>;
+    cancel(operationId: string, signal: AbortSignal): Promise<ParseResult>;
+}
+export interface HttpRemoteOmniClientOptions {
+    readonly apiKey?: string;
+    readonly fetchImpl?: typeof fetch;
+}
+export declare class HttpRemoteOmniClient implements RemoteOmniClient {
+    #private;
+    constructor(options: HttpRemoteOmniClientOptions);
+    parse(source: string, clientRequestId: string, signal: AbortSignal): Promise<ParseResult>;
+    status(operationId: string, waitMs: number | undefined, signal: AbortSignal): Promise<ParseResult>;
+    cancel(operationId: string, signal: AbortSignal): Promise<ParseResult>;
+}

package/dist/remote-client.js

@@ -0,0 +1,233 @@
+import { REMOTE_OMNI_MCP_URL } from "./constants.js";
+import { OmniBridgeError } from "./errors.js";
+import { parseResultSchema } from "./result-contract.js";
+import { classifySource } from "./source.js";
+function remoteError(options) {
+    return new OmniBridgeError({
+        code: options.code,
+        failureScope: options.failureScope,
+        sourceKind: "url",
+        message: options.message,
+        userAction: options.userAction,
+        operationCreated: options.operationCreated,
+        fileUploaded: false,
+        parserStarted: false,
+        billed: false,
+        contentReleased: false,
+        retryable: options.retryable,
+        ...(options.retryAfter === undefined ? {} : { retryAfter: options.retryAfter }),
+    });
+}
+function retryAfterSeconds(response) {
+    const value = response.headers.get("retry-after");
+    if (value === null || !/^\d+$/u.test(value))
+        return undefined;
+    const seconds = Number(value);
+    return Number.isSafeInteger(seconds) ? seconds : undefined;
+}
+function responseError(response) {
+    const retryAfter = retryAfterSeconds(response);
+    if (response.status === 401) {
+        return remoteError({
+            code: "API_KEY_INVALID",
+            message: "The Cue API Key is invalid or expired.",
+            failureScope: "authentication",
+            userAction: "Configure a valid Cue API Key without pasting it into chat.",
+            operationCreated: false,
+            retryable: false,
+        });
+    }
+    if (response.status === 402) {
+        return remoteError({
+            code: "INSUFFICIENT_CREDITS",
+            message: "The Cue account does not have enough credits for this parse.",
+            failureScope: "billing",
+            userAction: "Review the account balance or free daily allowance before retrying.",
+            operationCreated: false,
+            retryable: false,
+        });
+    }
+    if (response.status === 403) {
+        return remoteError({
+            code: "OMNI_NOT_ENTITLED",
+            message: "This Cue account cannot use Omni Reader.",
+            failureScope: "authentication",
+            userAction: "Use an account that is entitled to Omni Reader.",
+            operationCreated: false,
+            retryable: false,
+        });
+    }
+    if (response.status === 429) {
+        return remoteError({
+            code: "RATE_LIMITED",
+            message: "Omni is temporarily rate limited.",
+            failureScope: "service",
+            userAction: "Retry after the server-provided delay.",
+            operationCreated: false,
+            retryable: true,
+            ...(retryAfter === undefined ? {} : { retryAfter }),
+        });
+    }
+    if (response.status >= 500) {
+        return remoteError({
+            code: "SERVICE_TEMPORARILY_UNAVAILABLE",
+            message: "Omni is temporarily unavailable.",
+            failureScope: "service",
+            userAction: "Retry with bounded backoff while preserving the same request identity.",
+            operationCreated: true,
+            retryable: true,
+            ...(retryAfter === undefined ? {} : { retryAfter }),
+        });
+    }
+    return remoteError({
+        code: "REMOTE_REQUEST_REJECTED",
+        message: "The remote Omni request was rejected.",
+        failureScope: "service",
+        userAction: "Check the structured request and retry only when permitted.",
+        operationCreated: false,
+        retryable: false,
+    });
+}
+function protocolError() {
+    return remoteError({
+        code: "REMOTE_PROTOCOL_ERROR",
+        message: "The remote Omni response did not match the expected contract.",
+        failureScope: "service",
+        userAction: "Retry later without changing the source or request identity.",
+        operationCreated: true,
+        retryable: false,
+    });
+}
+function jsonFromSse(body, requestId) {
+    for (const event of body.split(/\r?\n\r?\n/u)) {
+        const data = event
+            .split(/\r?\n/u)
+            .filter((line) => line.startsWith("data:"))
+            .map((line) => line.slice(5).trimStart())
+            .join("\n");
+        if (data.length === 0 || data === "[DONE]")
+            continue;
+        try {
+            const value = JSON.parse(data);
+            if (value !== null &&
+                typeof value === "object" &&
+                !Array.isArray(value) &&
+                value.id === requestId) {
+                return value;
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    throw protocolError();
+}
+function decodeEnvelope(value, requestId) {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        throw protocolError();
+    }
+    const envelope = value;
+    if (envelope.jsonrpc !== "2.0" || envelope.id !== requestId || envelope.error !== undefined) {
+        throw protocolError();
+    }
+    if (envelope.result === null || typeof envelope.result !== "object" || Array.isArray(envelope.result)) {
+        throw protocolError();
+    }
+    const result = envelope.result;
+    try {
+        return parseResultSchema.parse(result.structuredContent);
+    }
+    catch {
+        throw protocolError();
+    }
+}
+export class HttpRemoteOmniClient {
+    #apiKey;
+    #fetch;
+    constructor(options) {
+        this.#apiKey = options.apiKey;
+        this.#fetch = options.fetchImpl ?? fetch;
+    }
+    async parse(source, clientRequestId, signal) {
+        const classified = classifySource(source);
+        if (classified.kind !== "url") {
+            throw remoteError({
+                code: "UNSUPPORTED_SOURCE",
+                message: "The remote Omni service accepts only HTTP(S) sources.",
+                failureScope: "source",
+                userAction: "Use the local Bridge path for local files.",
+                operationCreated: false,
+                retryable: false,
+            });
+        }
+        return this.#call("parse", { source: classified.source }, clientRequestId, signal);
+    }
+    status(operationId, waitMs, signal) {
+        return this.#call("get_parse_status", {
+            operation_id: operationId,
+            ...(waitMs === undefined ? {} : { wait_ms: waitMs }),
+        }, `${operationId}:status`, signal);
+    }
+    cancel(operationId, signal) {
+        return this.#call("cancel_parse", { operation_id: operationId }, `${operationId}:cancel`, signal);
+    }
+    async #call(name, args, requestId, signal) {
+        if (this.#apiKey === undefined || this.#apiKey.length === 0) {
+            throw remoteError({
+                code: "API_KEY_REQUIRED",
+                message: "A Cue API Key is required for Omni parsing.",
+                failureScope: "authentication",
+                userAction: "Create or configure an API Key at https://cuecue.cn/api-key without pasting it into chat.",
+                operationCreated: false,
+                retryable: false,
+            });
+        }
+        let response;
+        try {
+            response = await this.#fetch(REMOTE_OMNI_MCP_URL, {
+                method: "POST",
+                headers: {
+                    authorization: `Bearer ${this.#apiKey}`,
+                    accept: "application/json, text/event-stream",
+                    "cache-control": "no-store",
+                    "content-type": "application/json",
+                    "idempotency-key": requestId,
+                },
+                body: JSON.stringify({
+                    jsonrpc: "2.0",
+                    id: requestId,
+                    method: "tools/call",
+                    params: { name, arguments: args },
+                }),
+                signal,
+            });
+        }
+        catch (error) {
+            if (signal.aborted)
+                throw error;
+            throw remoteError({
+                code: "SERVICE_TEMPORARILY_UNAVAILABLE",
+                message: "Omni could not reach the remote parsing service.",
+                failureScope: "service",
+                userAction: "Retry with bounded backoff while preserving the same request identity.",
+                operationCreated: true,
+                retryable: true,
+            });
+        }
+        if (!response.ok)
+            throw responseError(response);
+        const body = await response.text();
+        let envelope;
+        try {
+            envelope = response.headers.get("content-type")?.includes("text/event-stream") === true
+                ? jsonFromSse(body, requestId)
+                : JSON.parse(body);
+        }
+        catch (error) {
+            if (error instanceof OmniBridgeError)
+                throw error;
+            throw protocolError();
+        }
+        return decodeEnvelope(envelope, requestId);
+    }
+}

package/dist/result-contract.d.ts

@@ -0,0 +1,199 @@
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { z } from "zod";
+import type { OmniBridgeErrorPayload } from "./errors.js";
+export interface DataHandling {
+    processing_copy: "in_use" | "pending" | "deleted";
+    temporary_data: "in_use" | "pending" | "deleted";
+    delivery_result: "not_created" | "pending" | "deleted_after_ack" | {
+        expires_at: string;
+    };
+    original_source: "unchanged";
+    remote_content_retained?: false;
+}
+export type ParseResult = {
+    status: "processing";
+    operation_id: string;
+    stage: string;
+    progress: number;
+    progress_detail?: {
+        unit: "page" | "sheet" | "slide" | "frame" | "segment";
+        completed: number;
+        total: number;
+    };
+    next_action: "check_status";
+    poll_after_seconds: number;
+    can_cancel: boolean;
+    data_handling: DataHandling;
+} | {
+    status: "completed";
+    operation_id: string;
+    result: {
+        kind: "inline";
+        text: string;
+    } | {
+        kind: "artifact";
+        result_id: string;
+        result_bytes: number;
+        expires_at: string;
+        preview: string;
+        next_cursor: string;
+    };
+    billing?: {
+        credits_charged: number;
+        credits_remaining: number;
+    };
+    data_handling: DataHandling;
+    local_result_cache?: {
+        expires_at: string;
+        discard_action: "discard_result";
+    };
+} | {
+    status: "cleanup_pending";
+    operation_id: string;
+    result?: {
+        kind: "inline";
+        text: string;
+    } | {
+        kind: "artifact";
+        result_id: string;
+        result_bytes: number;
+        expires_at: string;
+        preview: string;
+        next_cursor: string;
+    };
+    cleanup_deadline: string;
+    data_handling: DataHandling;
+} | {
+    status: "failed";
+    error: OmniBridgeErrorPayload;
+} | {
+    status: "canceled";
+    operation_id: string;
+    cleanup_deadline?: string;
+    data_handling: DataHandling;
+} | {
+    status: "expired";
+    operation_id: string;
+    requires_user_confirmation: true;
+};
+export declare const stableErrorSchema: z.ZodObject<{
+    ok: z.ZodLiteral<false>;
+    code: z.ZodString;
+    failure_scope: z.ZodOptional<z.ZodEnum<["source", "local_capability", "authentication", "billing", "service", "parser", "operation", "cleanup", "bridge"]>>;
+    source_kind: z.ZodOptional<z.ZodEnum<["local", "url"]>>;
+    retryable: z.ZodBoolean;
+    message: z.ZodString;
+    user_action: z.ZodOptional<z.ZodString>;
+    request_id: z.ZodOptional<z.ZodString>;
+    operation_created: z.ZodBoolean;
+    file_uploaded: z.ZodBoolean;
+    parser_started: z.ZodBoolean;
+    billed: z.ZodBoolean;
+    content_released: z.ZodBoolean;
+    retry_after: z.ZodOptional<z.ZodNumber>;
+    constraints: z.ZodOptional<z.ZodObject<{
+        max_bytes: z.ZodOptional<z.ZodNumber>;
+        supported_extensions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strict", z.ZodTypeAny, {
+        max_bytes?: number | undefined;
+        supported_extensions?: string[] | undefined;
+    }, {
+        max_bytes?: number | undefined;
+        supported_extensions?: string[] | undefined;
+    }>>;
+}, "strict", z.ZodTypeAny, {
+    billed: boolean;
+    retryable: boolean;
+    code: string;
+    file_uploaded: boolean;
+    content_released: boolean;
+    parser_started: boolean;
+    message: string;
+    ok: false;
+    operation_created: boolean;
+    failure_scope?: "source" | "local_capability" | "authentication" | "billing" | "service" | "parser" | "operation" | "cleanup" | "bridge" | undefined;
+    source_kind?: "local" | "url" | undefined;
+    user_action?: string | undefined;
+    request_id?: string | undefined;
+    retry_after?: number | undefined;
+    constraints?: {
+        max_bytes?: number | undefined;
+        supported_extensions?: string[] | undefined;
+    } | undefined;
+}, {
+    billed: boolean;
+    retryable: boolean;
+    code: string;
+    file_uploaded: boolean;
+    content_released: boolean;
+    parser_started: boolean;
+    message: string;
+    ok: false;
+    operation_created: boolean;
+    failure_scope?: "source" | "local_capability" | "authentication" | "billing" | "service" | "parser" | "operation" | "cleanup" | "bridge" | undefined;
+    source_kind?: "local" | "url" | undefined;
+    user_action?: string | undefined;
+    request_id?: string | undefined;
+    retry_after?: number | undefined;
+    constraints?: {
+        max_bytes?: number | undefined;
+        supported_extensions?: string[] | undefined;
+    } | undefined;
+}>;
+export declare const dataHandlingSchema: z.ZodObject<{
+    processing_copy: z.ZodEnum<["in_use", "pending", "deleted"]>;
+    temporary_data: z.ZodEnum<["in_use", "pending", "deleted"]>;
+    delivery_result: z.ZodUnion<[z.ZodLiteral<"not_created">, z.ZodLiteral<"pending">, z.ZodLiteral<"deleted_after_ack">, z.ZodObject<{
+        expires_at: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        expires_at: string;
+    }, {
+        expires_at: string;
+    }>]>;
+    original_source: z.ZodLiteral<"unchanged">;
+    remote_content_retained: z.ZodOptional<z.ZodLiteral<false>>;
+}, "strict", z.ZodTypeAny, {
+    processing_copy: "in_use" | "pending" | "deleted";
+    temporary_data: "in_use" | "pending" | "deleted";
+    delivery_result: "not_created" | "pending" | "deleted_after_ack" | {
+        expires_at: string;
+    };
+    original_source: "unchanged";
+    remote_content_retained?: false | undefined;
+}, {
+    processing_copy: "in_use" | "pending" | "deleted";
+    temporary_data: "in_use" | "pending" | "deleted";
+    delivery_result: "not_created" | "pending" | "deleted_after_ack" | {
+        expires_at: string;
+    };
+    original_source: "unchanged";
+    remote_content_retained?: false | undefined;
+}>;
+export declare const progressDetailSchema: z.ZodEffects<z.ZodObject<{
+    unit: z.ZodEnum<["page", "sheet", "slide", "frame", "segment"]>;
+    completed: z.ZodNumber;
+    total: z.ZodNumber;
+}, "strict", z.ZodTypeAny, {
+    unit: "page" | "sheet" | "slide" | "frame" | "segment";
+    total: number;
+    completed: number;
+}, {
+    unit: "page" | "sheet" | "slide" | "frame" | "segment";
+    total: number;
+    completed: number;
+}>, {
+    unit: "page" | "sheet" | "slide" | "frame" | "segment";
+    total: number;
+    completed: number;
+}, {
+    unit: "page" | "sheet" | "slide" | "frame" | "segment";
+    total: number;
+    completed: number;
+}>;
+export declare const parseResultSchema: z.ZodTypeAny;
+export declare const readResultOutputSchema: z.ZodTypeAny;
+export declare const discardResultOutputSchema: z.ZodTypeAny;
+export declare const parseToolOutputSchema: z.ZodTypeAny;
+export declare const readResultToolOutputSchema: z.ZodTypeAny;
+export declare const discardResultToolOutputSchema: z.ZodTypeAny;
+export declare function structuredResult(schema: z.ZodTypeAny, value: unknown): CallToolResult;