@cueai/omni-reader-mcp 1.0.0

package/dist/path-security.d.ts

@@ -0,0 +1,22 @@
+import { type BigIntStats, type ReadStream } from "node:fs";
+import { type FileHandle } from "node:fs/promises";
+export interface PathSecurityFileSystem {
+    realpath(candidate: string): Promise<string>;
+    open(candidate: string, flags: number): Promise<FileHandle>;
+    stat(candidate: string): Promise<BigIntStats>;
+}
+export interface OpenAllowedFileOptions {
+    workspace: string;
+    extraRoots?: readonly string[];
+    homeDirectory?: string;
+    fileSystem?: PathSecurityFileSystem;
+}
+export interface OpenedAllowedFile {
+    readonly size: number;
+    readonly safeExtension: string;
+    readonly contentType: string;
+    createReadStream(): ReadStream;
+    close(): Promise<void>;
+}
+export declare function splitAllowedRoots(value: string | undefined): string[];
+export declare function openAllowedFile(input: string, options: OpenAllowedFileOptions): Promise<OpenedAllowedFile>;

package/dist/path-security.js

@@ -0,0 +1,240 @@
+import { constants, } from "node:fs";
+import { open as nodeOpen, realpath as nodeRealpath, stat as nodeStat, } from "node:fs/promises";
+import { homedir } from "node:os";
+import path from "node:path";
+import { MAX_FILE_BYTES } from "./constants.js";
+import { OmniBridgeError } from "./errors.js";
+const CONTENT_TYPES = {
+    ".pdf": "application/pdf",
+    ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+    ".doc": "application/msword",
+    ".xls": "application/vnd.ms-excel",
+    ".ppt": "application/vnd.ms-powerpoint",
+    ".zip": "application/zip",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".png": "image/png",
+    ".gif": "image/gif",
+    ".bmp": "image/bmp",
+    ".tif": "image/tiff",
+    ".tiff": "image/tiff",
+    ".webp": "image/webp",
+    ".heic": "image/heic",
+    ".avif": "image/avif",
+    ".wav": "audio/wav",
+    ".mp3": "audio/mpeg",
+    ".flac": "audio/flac",
+    ".ogg": "audio/ogg",
+    ".m4a": "audio/mp4",
+    ".aac": "audio/aac",
+    ".mp4": "video/mp4",
+    ".mov": "video/quicktime",
+    ".mkv": "video/x-matroska",
+    ".webm": "video/webm",
+    ".avi": "video/x-msvideo",
+    ".m4v": "video/x-m4v",
+    ".txt": "text/plain",
+    ".md": "text/markdown",
+    ".csv": "text/csv",
+    ".html": "text/html",
+    ".htm": "text/html",
+};
+const NODE_FILE_SYSTEM = {
+    realpath: (candidate) => nodeRealpath(candidate),
+    open: (candidate, flags) => nodeOpen(candidate, flags),
+    stat: (candidate) => nodeStat(candidate, { bigint: true }),
+};
+class DescriptorBackedFile {
+    size;
+    safeExtension;
+    contentType;
+    #handle;
+    #closed = false;
+    constructor(handle, size, safeExtension, contentType) {
+        this.size = size;
+        this.safeExtension = safeExtension;
+        this.contentType = contentType;
+        this.#handle = handle;
+    }
+    createReadStream() {
+        if (this.#closed) {
+            throw bridgeError("FILE_HANDLE_CLOSED", "The local file is no longer available for upload.", false);
+        }
+        return this.#handle.createReadStream({ autoClose: false, start: 0 });
+    }
+    async close() {
+        if (this.#closed) {
+            return;
+        }
+        this.#closed = true;
+        await this.#handle.close();
+    }
+}
+function bridgeError(code, message, retryable) {
+    return new OmniBridgeError({
+        code,
+        message,
+        fileUploaded: false,
+        billed: false,
+        contentReleased: false,
+        retryable,
+    });
+}
+function validatePathText(value) {
+    if (value.length === 0 || value.includes("\0")) {
+        throw bridgeError("INVALID_LOCAL_PATH", "Provide one valid local file path.", false);
+    }
+}
+function expandHomeOnly(value, homeDirectory) {
+    if (value === "~") {
+        return homeDirectory;
+    }
+    if (/^~[\\/]/u.test(value)) {
+        return path.join(homeDirectory, value.slice(2));
+    }
+    return value;
+}
+function isInsideRoot(candidate, root) {
+    const relative = path.relative(root, candidate);
+    return (relative === "" ||
+        (relative !== ".." &&
+            !relative.startsWith(`..${path.sep}`) &&
+            !path.isAbsolute(relative)));
+}
+function requireInsideAnyRoot(candidate, roots) {
+    if (!roots.some((root) => isInsideRoot(candidate, root))) {
+        throw bridgeError("PATH_NOT_ALLOWED", "Move the file into the current workspace or add its parent directory to OMNI_ALLOWED_ROOTS.", false);
+    }
+}
+function requireRegularFile(fileStat) {
+    if (!fileStat.isFile()) {
+        throw bridgeError("NOT_REGULAR_FILE", "The local path must identify one regular file.", false);
+    }
+}
+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);
+    }
+    return Number(fileStat.size);
+}
+function requireSameFile(before, after) {
+    if (before.dev !== after.dev ||
+        before.ino !== after.ino ||
+        before.size !== after.size ||
+        before.mtimeNs !== after.mtimeNs ||
+        before.ctimeNs !== after.ctimeNs) {
+        throw bridgeError("FILE_CHANGED_DURING_OPEN", "The local file changed while it was being opened. Retry after file changes stop.", true);
+    }
+}
+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);
+    }
+    const contentType = CONTENT_TYPES[safeExtension];
+    if (contentType === undefined) {
+        throw bridgeError("UNSUPPORTED_FILE_TYPE", "The local file type is not supported.", false);
+    }
+    return { safeExtension, contentType };
+}
+function fileAccessError(error) {
+    if (error instanceof OmniBridgeError) {
+        return error;
+    }
+    const code = error?.code;
+    if (code === "ENOENT" || code === "ENOTDIR") {
+        return bridgeError("FILE_NOT_FOUND", "The local file does not exist.", false);
+    }
+    if (code === "ENXIO" || code === "ENODEV" || code === "EISDIR") {
+        return bridgeError("NOT_REGULAR_FILE", "The local path must identify one regular file.", false);
+    }
+    if (code === "ELOOP") {
+        return bridgeError("FILE_CHANGED_DURING_OPEN", "The local file changed while it was being opened. Retry after file changes stop.", true);
+    }
+    return bridgeError("FILE_NOT_READABLE", "Omni cannot read the local file. Check its permissions and try again.", false);
+}
+async function resolveAllowedRoots(options, fileSystem, homeDirectory) {
+    validatePathText(options.workspace);
+    const workspaceInput = path.resolve(expandHomeOnly(options.workspace, homeDirectory));
+    const requestedRoots = [
+        workspaceInput,
+        ...(options.extraRoots ?? [])
+            .filter((root) => root.length > 0)
+            .map((root) => {
+            validatePathText(root);
+            const expanded = expandHomeOnly(root, homeDirectory);
+            return path.isAbsolute(expanded)
+                ? expanded
+                : path.resolve(workspaceInput, expanded);
+        }),
+    ];
+    try {
+        const roots = await Promise.all(requestedRoots.map(async (root) => {
+            const resolved = await fileSystem.realpath(root);
+            const rootStat = await fileSystem.stat(resolved);
+            if (!rootStat.isDirectory()) {
+                throw bridgeError("INVALID_ALLOWED_ROOT", "The workspace and every OMNI_ALLOWED_ROOTS entry must be a directory.", false);
+            }
+            return resolved;
+        }));
+        return [...new Set(roots)];
+    }
+    catch (error) {
+        if (error instanceof OmniBridgeError) {
+            throw error;
+        }
+        throw bridgeError("INVALID_ALLOWED_ROOT", "The workspace or an OMNI_ALLOWED_ROOTS entry is unavailable.", false);
+    }
+}
+export function splitAllowedRoots(value) {
+    if (value === undefined || value.length === 0) {
+        return [];
+    }
+    return value.split(path.delimiter).filter((root) => root.length > 0);
+}
+export async function openAllowedFile(input, options) {
+    validatePathText(input);
+    const fileSystem = options.fileSystem ?? NODE_FILE_SYSTEM;
+    const homeDirectory = options.homeDirectory ?? homedir();
+    const roots = await resolveAllowedRoots(options, fileSystem, homeDirectory);
+    const expanded = expandHomeOnly(input, homeDirectory);
+    const candidate = path.isAbsolute(expanded)
+        ? expanded
+        : path.resolve(options.workspace, expanded);
+    let resolved;
+    try {
+        resolved = await fileSystem.realpath(candidate);
+    }
+    catch (error) {
+        throw fileAccessError(error);
+    }
+    requireInsideAnyRoot(resolved, roots);
+    let handle;
+    try {
+        const pathStat = await fileSystem.stat(resolved);
+        requireRegularFile(pathStat);
+        const openFlags = constants.O_RDONLY |
+            (constants.O_NOFOLLOW ?? 0) |
+            (constants.O_NONBLOCK ?? 0);
+        handle = await fileSystem.open(resolved, openFlags);
+        const before = await handle.stat({ bigint: true });
+        requireRegularFile(before);
+        requireSameFile(pathStat, before);
+        const size = requireAllowedSize(before);
+        const afterPath = await fileSystem.realpath(resolved);
+        requireInsideAnyRoot(afterPath, roots);
+        const after = await fileSystem.stat(afterPath);
+        requireRegularFile(after);
+        requireSameFile(before, after);
+        const { safeExtension, contentType } = safeFileType(afterPath);
+        const opened = new DescriptorBackedFile(handle, size, safeExtension, contentType);
+        handle = undefined;
+        return opened;
+    }
+    catch (error) {
+        await handle?.close().catch(() => undefined);
+        throw fileAccessError(error);
+    }
+}

package/dist/progress.d.ts

@@ -0,0 +1,4 @@
+export interface ProgressSink {
+    report(progress: number, total: number, message: string): Promise<void>;
+}
+export declare const NOOP_PROGRESS: ProgressSink;

package/dist/progress.js

@@ -0,0 +1,3 @@
+export const NOOP_PROGRESS = {
+    async report() { },
+};

package/dist/protocol.d.ts

@@ -0,0 +1,39 @@
+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">>;
+}, "strict", z.ZodTypeAny, {
+    local_path: string;
+    no_store: boolean;
+    output: "markdown";
+}, {
+    local_path: string;
+    no_store?: boolean | undefined;
+    output?: "markdown" | undefined;
+}>;
+export declare const readResultSchema: z.ZodObject<{
+    result_id: z.ZodString;
+    cursor: z.ZodOptional<z.ZodString>;
+    max_bytes: z.ZodOptional<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    result_id: string;
+    max_bytes?: number | undefined;
+    cursor?: string | undefined;
+}, {
+    result_id: string;
+    max_bytes?: number | undefined;
+    cursor?: string | undefined;
+}>;
+export declare const discardResultSchema: z.ZodObject<{
+    result_id: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    result_id: string;
+}, {
+    result_id: string;
+}>;
+export type ParseDocumentArguments = z.infer<typeof parseDocumentSchema>;
+export type ReadResultArguments = z.infer<typeof readResultSchema>;
+export type DiscardResultArguments = z.infer<typeof discardResultSchema>;

package/dist/protocol.js

@@ -0,0 +1,27 @@
+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.";
+const resultIdSchema = z.string().regex(/^result_[A-Za-z0-9_-]{16,64}$/u);
+export const parseDocumentSchema = 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"),
+})
+    .strict();
+export const readResultSchema = z
+    .object({
+    result_id: resultIdSchema,
+    cursor: z.string().min(1).max(2048).optional(),
+    max_bytes: z.number().int().min(1).max(RESULT_CHUNK_MAX_BYTES).optional(),
+})
+    .strict();
+export const discardResultSchema = z
+    .object({
+    result_id: resultIdSchema,
+})
+    .strict();

package/dist/server.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { type OmniToolDependencies } from "./tools.js";
+export declare function createOmniMcpServer(dependencies: OmniToolDependencies): McpServer;

package/dist/server.js

@@ -0,0 +1,10 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { SAFETY_INSTRUCTIONS } from "./protocol.js";
+import { registerOmniTools } from "./tools.js";
+const SERVER_NAME = "omni-reader-mcp";
+const SERVER_VERSION = "1.0.0";
+export function createOmniMcpServer(dependencies) {
+    const server = new McpServer({ name: SERVER_NAME, version: SERVER_VERSION }, { instructions: SAFETY_INSTRUCTIONS });
+    registerOmniTools(server, dependencies);
+    return server;
+}

package/dist/tools.d.ts

@@ -0,0 +1,24 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { ArtifactReadResult, LocalResult } from "./artifact-store.js";
+import { type CubeGrantClient } from "./cube-client.js";
+import type { IiisClient, ResultRetentionSink } from "./iiis-client.js";
+import { type OpenAllowedFileOptions, type OpenedAllowedFile } from "./path-security.js";
+interface ToolRetention extends ResultRetentionSink {
+    result(): LocalResult;
+}
+interface ToolArtifactStore {
+    createRetention(): ToolRetention;
+    read(resultId: string, cursor?: string, maxBytes?: number): Promise<ArtifactReadResult>;
+    discard(resultId: string): Promise<boolean>;
+}
+export interface OmniToolDependencies {
+    readonly workspace: string;
+    readonly extraRoots?: readonly string[];
+    readonly cubeClient: Pick<CubeGrantClient, "createGrant">;
+    readonly iiisClient: Pick<IiisClient, "uploadAndWait" | "ack">;
+    readonly artifactStore: ToolArtifactStore;
+    readonly createClientRequestId?: () => string;
+    readonly openFile?: (localPath: string, options: OpenAllowedFileOptions) => Promise<OpenedAllowedFile>;
+}
+export declare function registerOmniTools(server: McpServer, dependencies: OmniToolDependencies): void;
+export {};

package/dist/tools.js

@@ -0,0 +1,224 @@
+import { CallToolRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { createClientRequestId as newClientRequestId, } from "./cube-client.js";
+import { OmniBridgeError } from "./errors.js";
+import { openAllowedFile, } from "./path-security.js";
+import { NOOP_PROGRESS } from "./progress.js";
+import { SAFETY_INSTRUCTIONS, discardResultSchema, parseDocumentSchema, readResultSchema, } from "./protocol.js";
+function bridgeError(code, message) {
+    return new OmniBridgeError({
+        code,
+        message,
+        fileUploaded: false,
+        billed: false,
+        contentReleased: false,
+        retryable: false,
+    });
+}
+function errorResult(error) {
+    const stable = error instanceof OmniBridgeError
+        ? error
+        : bridgeError("BRIDGE_INTERNAL_ERROR", "The local Omni Bridge could not complete the request.");
+    return {
+        isError: true,
+        content: [{ type: "text", text: JSON.stringify(stable.toJSON()) }],
+    };
+}
+function successResult(value) {
+    return {
+        content: [{ type: "text", text: JSON.stringify(value) }],
+    };
+}
+function progressSink(extra) {
+    const progressToken = extra._meta?.progressToken;
+    if (progressToken === undefined)
+        return NOOP_PROGRESS;
+    return {
+        async report(progress, total, message) {
+            await extra.sendNotification({
+                method: "notifications/progress",
+                params: { progressToken, progress, total, message },
+            });
+        },
+    };
+}
+function parseSuccess(local) {
+    if (local.kind === "inline") {
+        return successResult({
+            operation_id: local.operationId,
+            text: local.text,
+        });
+    }
+    if (local.nextCursor === undefined) {
+        throw bridgeError("LOCAL_RESULT_INTEGRITY_FAILED", "The local result artifact cursor is missing.");
+    }
+    return successResult({
+        result_id: local.resultId,
+        result_bytes: local.resultBytes,
+        artifact_path: local.artifactPath,
+        expires_at: local.expiresAt,
+        preview: local.preview,
+        next_cursor: local.nextCursor,
+    });
+}
+async function parseDocument(args, extra, dependencies) {
+    const openFile = dependencies.openFile ?? openAllowedFile;
+    const opened = await openFile(args.local_path, {
+        workspace: dependencies.workspace,
+        extraRoots: dependencies.extraRoots,
+    });
+    let primaryError;
+    try {
+        const clientRequestId = (dependencies.createClientRequestId ?? newClientRequestId)();
+        const granted = await dependencies.cubeClient.createGrant({
+            contentLength: opened.size,
+            contentType: opened.contentType,
+            fileExtension: opened.safeExtension,
+            noStore: args.no_store,
+            output: args.output,
+        }, clientRequestId, extra.signal);
+        const retention = dependencies.artifactStore.createRetention();
+        const operation = {
+            parseGrant: granted.parseGrant,
+            operationId: granted.operationId,
+            operationToken: granted.operationToken,
+            uploadUrl: granted.uploadUrl,
+            expiresAt: granted.expiresAt,
+            openedFile: opened,
+            retention,
+            progress: progressSink(extra),
+            signal: extra.signal,
+        };
+        await dependencies.iiisClient.uploadAndWait(operation);
+        const local = retention.result();
+        const result = parseSuccess(local);
+        await dependencies.iiisClient.ack(operation);
+        return result;
+    }
+    catch (error) {
+        primaryError = error;
+        throw error;
+    }
+    finally {
+        try {
+            await opened.close();
+        }
+        catch {
+            if (primaryError === undefined) {
+                throw bridgeError("FILE_CLOSE_FAILED", "The local source file could not be closed safely.");
+            }
+        }
+    }
+}
+function readSuccess(result) {
+    return successResult({
+        result_id: result.resultId,
+        result_bytes: result.resultBytes,
+        expires_at: result.expiresAt,
+        text: result.text,
+        ...(result.nextCursor === undefined ? {} : { next_cursor: result.nextCursor }),
+    });
+}
+function invalidArgumentsResult() {
+    return errorResult(bridgeError("INVALID_TOOL_ARGUMENTS", "The Omni tool arguments are invalid."));
+}
+async function dispatchTool(name, rawArguments, extra, dependencies) {
+    if (name === "parse_document") {
+        const parsed = parseDocumentSchema.safeParse(rawArguments ?? {});
+        if (!parsed.success)
+            return invalidArgumentsResult();
+        try {
+            return await parseDocument(parsed.data, extra, dependencies);
+        }
+        catch (error) {
+            return errorResult(error);
+        }
+    }
+    if (name === "read_result") {
+        const parsed = readResultSchema.safeParse(rawArguments ?? {});
+        if (!parsed.success)
+            return invalidArgumentsResult();
+        try {
+            return readSuccess(await dependencies.artifactStore.read(parsed.data.result_id, parsed.data.cursor, parsed.data.max_bytes));
+        }
+        catch (error) {
+            return errorResult(error);
+        }
+    }
+    if (name === "discard_result") {
+        const parsed = discardResultSchema.safeParse(rawArguments ?? {});
+        if (!parsed.success)
+            return invalidArgumentsResult();
+        try {
+            return successResult({
+                result_id: parsed.data.result_id,
+                discarded: await dependencies.artifactStore.discard(parsed.data.result_id),
+            });
+        }
+        catch (error) {
+            return errorResult(error);
+        }
+    }
+    return errorResult(bridgeError("TOOL_NOT_FOUND", "The requested Omni tool is not available."));
+}
+export function registerOmniTools(server, dependencies) {
+    server.registerTool("parse_document", {
+        description: `${SAFETY_INSTRUCTIONS}\n\nParse one local file through Omni without sending source bytes through the model or Cube-MCP.`,
+        inputSchema: parseDocumentSchema,
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: true,
+        },
+    }, async (args, extra) => {
+        try {
+            return await parseDocument(args, extra, dependencies);
+        }
+        catch (error) {
+            return errorResult(error);
+        }
+    });
+    server.registerTool("read_result", {
+        description: "Read one UTF-8 chunk from a Bridge-created local result artifact.",
+        inputSchema: readResultSchema,
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+    }, async (args) => {
+        try {
+            return readSuccess(await dependencies.artifactStore.read(args.result_id, args.cursor, args.max_bytes));
+        }
+        catch (error) {
+            return errorResult(error);
+        }
+    });
+    server.registerTool("discard_result", {
+        description: "Immediately delete one Bridge-created local result artifact.",
+        inputSchema: discardResultSchema,
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+    }, async (args) => {
+        try {
+            return successResult({
+                result_id: args.result_id,
+                discarded: await dependencies.artifactStore.discard(args.result_id),
+            });
+        }
+        catch (error) {
+            return errorResult(error);
+        }
+    });
+    server.server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
+        if (request.params.task !== undefined) {
+            return errorResult(bridgeError("TOOL_TASK_UNSUPPORTED", "Task-augmented tool calls are not supported by this Omni Bridge."));
+        }
+        return dispatchTool(request.params.name, request.params.arguments, extra, dependencies);
+    });
+}

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@cueai/omni-reader-mcp",
+  "version": "1.0.0",
+  "description": "Local stdio MCP bridge for direct Omni document parsing",
+  "type": "module",
+  "license": "UNLICENSED",
+  "engines": {
+    "node": ">=20.12"
+  },
+  "bin": {
+    "omni-reader-mcp": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "vitest run",
+    "typecheck": "tsc -p tsconfig.json --noEmit && tsc -p tsconfig.test.json --noEmit",
+    "prepack": "npm run test && npm run build"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.24.0",
+    "zod": "^3.25.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.17.0",
+    "typescript": "^5.8.0",
+    "vitest": "^4.0.0"
+  }
+}