@powerhousedao/reactor-mcp 4.1.0-dev.3 → 4.1.0-dev.30

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@powerhousedao/reactor-mcp",
-  "version": "4.1.0-dev.3",
+  "version": "4.1.0-dev.30",
   "description": "MCP server for document model operations in the Powerhouse ecosystem. For document model creation tasks, consider using the document-model-creator agent which provides a more guided experience.",
   "type": "module",
   "types": "./dist/index.d.ts",
@@ -9,7 +9,7 @@
     "url": "https://github.com/powerhouse-inc/powerhouse"
   },
   "exports": {
-    ".": "./dist/index.js"
+    "./*": "./dist/src/*.js"
   },
   "imports": {
     "#*": "./dist/src/*"
@@ -27,26 +27,32 @@
   "keywords": [],
   "author": "",
   "license": "AGPL-3.0-only",
-  "devDependencies": {
-    "@types/node": "^22.15.17",
-    "vitest": "^3.1.2"
-  },
   "dependencies": {
+    "@ai-sdk/openai": "^2.0.0",
     "@modelcontextprotocol/sdk": "^1.17.0",
+    "ai": "^5.0.0",
     "change-case": "^5.4.4",
+    "express": "^4.21.1",
+    "vite": "^6.3.5",
     "zod": "^3.24.3",
-    "@powerhousedao/codegen": "4.1.0-dev.3",
-    "@powerhousedao/config": "4.1.0-dev.3",
-    "document-drive": "4.1.0-dev.3",
-    "document-model": "4.1.0-dev.3"
+    "@powerhousedao/config": "4.1.0-dev.30",
+    "@powerhousedao/codegen": "4.1.0-dev.30",
+    "document-drive": "4.1.0-dev.30",
+    "document-model": "4.1.0-dev.30"
+  },
+  "devDependencies": {
+    "@types/express": "^5.0.0",
+    "@types/node": "^22.15.17",
+    "vitest": "^3.1.2"
   },
   "scripts": {
     "build": "tsc --build",
     "build:tsc": "tsc --build",
     "prebuild": "npm run clean",
     "lint": "eslint",
-    "test": "vitest",
+    "test": "vitest run",
     "test:run": "vitest run",
+    "test:watch": "vitest",
     "bench": "vitest bench",
     "clean": "rimraf dist",
     "clean:node_modules": "rimraf node_modules"

package/dist/src/mcp/reactor.d.ts

@@ -1,630 +0,0 @@
-import type { IDocumentDriveServer } from "document-drive";
-import { z } from "zod";
-import type { ToolSchema, ToolWithCallback } from "./types.js";
-export declare const getDocumentTool: {
-    readonly name: "getDocument";
-    readonly description: "Retrieve a document by its ID";
-    readonly inputSchema: {
-        readonly id: z.ZodString;
-    };
-    readonly outputSchema: {
-        readonly document: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
-    };
-};
-export declare const createDocumentTool: {
-    readonly name: "createDocument";
-    readonly description: "Create a new document";
-    readonly inputSchema: {
-        readonly documentType: z.ZodString;
-        readonly documentId: z.ZodOptional<z.ZodString>;
-    };
-    readonly outputSchema: {
-        readonly result: z.ZodObject<{
-            status: z.ZodEnum<["SUCCESS", "CONFLICT", "MISSING", "ERROR"]>;
-            error: z.ZodOptional<z.ZodString>;
-            operations: z.ZodArray<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>, "many">;
-            document: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>>;
-            signals: z.ZodArray<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>, "many">;
-        }, "strip", z.ZodTypeAny, {
-            status: "SUCCESS" | "CONFLICT" | "MISSING" | "ERROR";
-            operations: {}[];
-            signals: {}[];
-            document?: {} | undefined;
-            error?: string | undefined;
-        }, {
-            status: "SUCCESS" | "CONFLICT" | "MISSING" | "ERROR";
-            operations: {}[];
-            signals: {}[];
-            document?: {} | undefined;
-            error?: string | undefined;
-        }>;
-    };
-};
-export declare const getDocumentsTool: {
-    readonly name: "getDocuments";
-    readonly description: "List documents in a drive";
-    readonly inputSchema: {
-        readonly parentId: z.ZodString;
-    };
-    readonly outputSchema: {
-        readonly documentIds: z.ZodArray<z.ZodString, "many">;
-    };
-};
-export declare const deleteDocumentTool: {
-    readonly name: "deleteDocument";
-    readonly description: "Delete a document";
-    readonly inputSchema: {
-        readonly documentId: z.ZodString;
-    };
-    readonly outputSchema: {
-        readonly success: z.ZodBoolean;
-    };
-};
-export declare const addActionTool: {
-    readonly name: "addAction";
-    readonly description: "Add an action to a document";
-    readonly inputSchema: {
-        readonly documentId: z.ZodString;
-        readonly action: z.ZodObject<{
-            type: z.ZodString;
-            input: z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>, z.ZodArray<z.ZodAny, "many">, z.ZodNull]>;
-            scope: z.ZodString;
-            context: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>>;
-        }, "strict", z.ZodTypeAny, {
-            scope: string;
-            input: string | number | boolean | any[] | {} | null;
-            type: string;
-            context?: {} | undefined;
-        }, {
-            scope: string;
-            input: string | number | boolean | any[] | {} | null;
-            type: string;
-            context?: {} | undefined;
-        }>;
-    };
-    readonly outputSchema: {
-        readonly result: z.ZodObject<{
-            status: z.ZodEnum<["SUCCESS", "CONFLICT", "MISSING", "ERROR"]>;
-            error: z.ZodOptional<z.ZodString>;
-            operations: z.ZodArray<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>, "many">;
-            document: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>>;
-            signals: z.ZodArray<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>, "many">;
-        }, "strip", z.ZodTypeAny, {
-            status: "SUCCESS" | "CONFLICT" | "MISSING" | "ERROR";
-            operations: {}[];
-            signals: {}[];
-            document?: {} | undefined;
-            error?: string | undefined;
-        }, {
-            status: "SUCCESS" | "CONFLICT" | "MISSING" | "ERROR";
-            operations: {}[];
-            signals: {}[];
-            document?: {} | undefined;
-            error?: string | undefined;
-        }>;
-    };
-};
-export declare const addOperationTool: {
-    readonly name: "addOperation";
-    readonly description: "Add an operation to a document";
-    readonly inputSchema: {
-        readonly documentId: z.ZodString;
-        readonly operation: z.ZodObject<{
-            type: z.ZodString;
-            input: z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>, z.ZodArray<z.ZodAny, "many">, z.ZodNull]>;
-            scope: z.ZodString;
-            index: z.ZodNumber;
-            timestamp: z.ZodString;
-            hash: z.ZodString;
-            skip: z.ZodNumber;
-            error: z.ZodOptional<z.ZodString>;
-            id: z.ZodOptional<z.ZodString>;
-            context: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>>;
-        }, "strict", z.ZodTypeAny, {
-            scope: string;
-            input: string | number | boolean | any[] | {} | null;
-            type: string;
-            index: number;
-            timestamp: string;
-            hash: string;
-            skip: number;
-            id?: string | undefined;
-            error?: string | undefined;
-            context?: {} | undefined;
-        }, {
-            scope: string;
-            input: string | number | boolean | any[] | {} | null;
-            type: string;
-            index: number;
-            timestamp: string;
-            hash: string;
-            skip: number;
-            id?: string | undefined;
-            error?: string | undefined;
-            context?: {} | undefined;
-        }>;
-    };
-    readonly outputSchema: {
-        readonly result: z.ZodObject<{
-            status: z.ZodEnum<["SUCCESS", "CONFLICT", "MISSING", "ERROR"]>;
-            error: z.ZodOptional<z.ZodString>;
-            operations: z.ZodArray<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>, "many">;
-            document: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>>;
-            signals: z.ZodArray<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>, "many">;
-        }, "strip", z.ZodTypeAny, {
-            status: "SUCCESS" | "CONFLICT" | "MISSING" | "ERROR";
-            operations: {}[];
-            signals: {}[];
-            document?: {} | undefined;
-            error?: string | undefined;
-        }, {
-            status: "SUCCESS" | "CONFLICT" | "MISSING" | "ERROR";
-            operations: {}[];
-            signals: {}[];
-            document?: {} | undefined;
-            error?: string | undefined;
-        }>;
-    };
-};
-export declare const getDrivesTool: {
-    readonly name: "getDrives";
-    readonly description: "List all drives";
-    readonly inputSchema: {};
-    readonly outputSchema: {
-        readonly driveIds: z.ZodArray<z.ZodString, "many">;
-    };
-};
-export declare const addDriveTool: {
-    readonly name: "addDrive";
-    readonly description: "Create a new drive";
-    readonly inputSchema: {
-        readonly driveInput: z.ZodObject<{
-            global: z.ZodObject<{
-                name: z.ZodString;
-                icon: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            }, "strip", z.ZodTypeAny, {
-                name: string;
-                icon?: string | null | undefined;
-            }, {
-                name: string;
-                icon?: string | null | undefined;
-            }>;
-            id: z.ZodOptional<z.ZodString>;
-            slug: z.ZodOptional<z.ZodString>;
-            preferredEditor: z.ZodOptional<z.ZodString>;
-            local: z.ZodOptional<z.ZodObject<{
-                availableOffline: z.ZodOptional<z.ZodBoolean>;
-                sharingType: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            }, "strip", z.ZodTypeAny, {
-                availableOffline?: boolean | undefined;
-                sharingType?: string | null | undefined;
-            }, {
-                availableOffline?: boolean | undefined;
-                sharingType?: string | null | undefined;
-            }>>;
-        }, "strip", z.ZodTypeAny, {
-            global: {
-                name: string;
-                icon?: string | null | undefined;
-            };
-            local?: {
-                availableOffline?: boolean | undefined;
-                sharingType?: string | null | undefined;
-            } | undefined;
-            id?: string | undefined;
-            slug?: string | undefined;
-            preferredEditor?: string | undefined;
-        }, {
-            global: {
-                name: string;
-                icon?: string | null | undefined;
-            };
-            local?: {
-                availableOffline?: boolean | undefined;
-                sharingType?: string | null | undefined;
-            } | undefined;
-            id?: string | undefined;
-            slug?: string | undefined;
-            preferredEditor?: string | undefined;
-        }>;
-    };
-    readonly outputSchema: {
-        readonly drive: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
-    };
-};
-export declare const getDriveTool: {
-    readonly name: "getDrive";
-    readonly description: "Get a specific drive";
-    readonly inputSchema: {
-        readonly driveId: z.ZodString;
-        readonly options: z.ZodOptional<z.ZodObject<{
-            revisions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
-            checkHashes: z.ZodOptional<z.ZodBoolean>;
-        }, "strip", z.ZodTypeAny, {
-            revisions?: Record<string, number> | undefined;
-            checkHashes?: boolean | undefined;
-        }, {
-            revisions?: Record<string, number> | undefined;
-            checkHashes?: boolean | undefined;
-        }>>;
-    };
-    readonly outputSchema: {
-        readonly drive: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
-    };
-};
-export declare const deleteDriveTool: {
-    readonly name: "deleteDrive";
-    readonly description: "Delete a drive";
-    readonly inputSchema: {
-        readonly driveId: z.ZodString;
-    };
-    readonly outputSchema: {
-        readonly success: z.ZodBoolean;
-    };
-};
-export declare const addRemoteDriveTool: {
-    readonly name: "addRemoteDrive";
-    readonly description: "Connect to a remote drive";
-    readonly inputSchema: {
-        readonly url: z.ZodString;
-        readonly options: z.ZodObject<{
-            availableOffline: z.ZodBoolean;
-            sharingType: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            pullFilter: z.ZodOptional<z.ZodObject<{
-                branch: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString, "many">>>;
-                documentId: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString, "many">>>;
-                documentType: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString, "many">>>;
-                scope: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString, "many">>>;
-            }, "strip", z.ZodTypeAny, {
-                scope?: string[] | null | undefined;
-                documentType?: string[] | null | undefined;
-                documentId?: string[] | null | undefined;
-                branch?: string[] | null | undefined;
-            }, {
-                scope?: string[] | null | undefined;
-                documentType?: string[] | null | undefined;
-                documentId?: string[] | null | undefined;
-                branch?: string[] | null | undefined;
-            }>>;
-            pullInterval: z.ZodOptional<z.ZodNumber>;
-        }, "strip", z.ZodTypeAny, {
-            availableOffline: boolean;
-            sharingType?: string | null | undefined;
-            pullFilter?: {
-                scope?: string[] | null | undefined;
-                documentType?: string[] | null | undefined;
-                documentId?: string[] | null | undefined;
-                branch?: string[] | null | undefined;
-            } | undefined;
-            pullInterval?: number | undefined;
-        }, {
-            availableOffline: boolean;
-            sharingType?: string | null | undefined;
-            pullFilter?: {
-                scope?: string[] | null | undefined;
-                documentType?: string[] | null | undefined;
-                documentId?: string[] | null | undefined;
-                branch?: string[] | null | undefined;
-            } | undefined;
-            pullInterval?: number | undefined;
-        }>;
-    };
-    readonly outputSchema: {
-        readonly drive: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
-    };
-};
-type ToolRecord<T extends readonly ToolSchema[]> = {
-    [K in T[number]["name"]]: ToolWithCallback<Extract<T[number], {
-        name: K;
-    }>>;
-};
-declare const allTools: readonly [{
-    readonly name: "getDocument";
-    readonly description: "Retrieve a document by its ID";
-    readonly inputSchema: {
-        readonly id: z.ZodString;
-    };
-    readonly outputSchema: {
-        readonly document: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
-    };
-}, {
-    readonly name: "createDocument";
-    readonly description: "Create a new document";
-    readonly inputSchema: {
-        readonly documentType: z.ZodString;
-        readonly documentId: z.ZodOptional<z.ZodString>;
-    };
-    readonly outputSchema: {
-        readonly result: z.ZodObject<{
-            status: z.ZodEnum<["SUCCESS", "CONFLICT", "MISSING", "ERROR"]>;
-            error: z.ZodOptional<z.ZodString>;
-            operations: z.ZodArray<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>, "many">;
-            document: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>>;
-            signals: z.ZodArray<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>, "many">;
-        }, "strip", z.ZodTypeAny, {
-            status: "SUCCESS" | "CONFLICT" | "MISSING" | "ERROR";
-            operations: {}[];
-            signals: {}[];
-            document?: {} | undefined;
-            error?: string | undefined;
-        }, {
-            status: "SUCCESS" | "CONFLICT" | "MISSING" | "ERROR";
-            operations: {}[];
-            signals: {}[];
-            document?: {} | undefined;
-            error?: string | undefined;
-        }>;
-    };
-}, {
-    readonly name: "getDocuments";
-    readonly description: "List documents in a drive";
-    readonly inputSchema: {
-        readonly parentId: z.ZodString;
-    };
-    readonly outputSchema: {
-        readonly documentIds: z.ZodArray<z.ZodString, "many">;
-    };
-}, {
-    readonly name: "deleteDocument";
-    readonly description: "Delete a document";
-    readonly inputSchema: {
-        readonly documentId: z.ZodString;
-    };
-    readonly outputSchema: {
-        readonly success: z.ZodBoolean;
-    };
-}, {
-    readonly name: "addAction";
-    readonly description: "Add an action to a document";
-    readonly inputSchema: {
-        readonly documentId: z.ZodString;
-        readonly action: z.ZodObject<{
-            type: z.ZodString;
-            input: z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>, z.ZodArray<z.ZodAny, "many">, z.ZodNull]>;
-            scope: z.ZodString;
-            context: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>>;
-        }, "strict", z.ZodTypeAny, {
-            scope: string;
-            input: string | number | boolean | any[] | {} | null;
-            type: string;
-            context?: {} | undefined;
-        }, {
-            scope: string;
-            input: string | number | boolean | any[] | {} | null;
-            type: string;
-            context?: {} | undefined;
-        }>;
-    };
-    readonly outputSchema: {
-        readonly result: z.ZodObject<{
-            status: z.ZodEnum<["SUCCESS", "CONFLICT", "MISSING", "ERROR"]>;
-            error: z.ZodOptional<z.ZodString>;
-            operations: z.ZodArray<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>, "many">;
-            document: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>>;
-            signals: z.ZodArray<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>, "many">;
-        }, "strip", z.ZodTypeAny, {
-            status: "SUCCESS" | "CONFLICT" | "MISSING" | "ERROR";
-            operations: {}[];
-            signals: {}[];
-            document?: {} | undefined;
-            error?: string | undefined;
-        }, {
-            status: "SUCCESS" | "CONFLICT" | "MISSING" | "ERROR";
-            operations: {}[];
-            signals: {}[];
-            document?: {} | undefined;
-            error?: string | undefined;
-        }>;
-    };
-}, {
-    readonly name: "addOperation";
-    readonly description: "Add an operation to a document";
-    readonly inputSchema: {
-        readonly documentId: z.ZodString;
-        readonly operation: z.ZodObject<{
-            type: z.ZodString;
-            input: z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>, z.ZodArray<z.ZodAny, "many">, z.ZodNull]>;
-            scope: z.ZodString;
-            index: z.ZodNumber;
-            timestamp: z.ZodString;
-            hash: z.ZodString;
-            skip: z.ZodNumber;
-            error: z.ZodOptional<z.ZodString>;
-            id: z.ZodOptional<z.ZodString>;
-            context: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>>;
-        }, "strict", z.ZodTypeAny, {
-            scope: string;
-            input: string | number | boolean | any[] | {} | null;
-            type: string;
-            index: number;
-            timestamp: string;
-            hash: string;
-            skip: number;
-            id?: string | undefined;
-            error?: string | undefined;
-            context?: {} | undefined;
-        }, {
-            scope: string;
-            input: string | number | boolean | any[] | {} | null;
-            type: string;
-            index: number;
-            timestamp: string;
-            hash: string;
-            skip: number;
-            id?: string | undefined;
-            error?: string | undefined;
-            context?: {} | undefined;
-        }>;
-    };
-    readonly outputSchema: {
-        readonly result: z.ZodObject<{
-            status: z.ZodEnum<["SUCCESS", "CONFLICT", "MISSING", "ERROR"]>;
-            error: z.ZodOptional<z.ZodString>;
-            operations: z.ZodArray<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>, "many">;
-            document: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>>;
-            signals: z.ZodArray<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>, "many">;
-        }, "strip", z.ZodTypeAny, {
-            status: "SUCCESS" | "CONFLICT" | "MISSING" | "ERROR";
-            operations: {}[];
-            signals: {}[];
-            document?: {} | undefined;
-            error?: string | undefined;
-        }, {
-            status: "SUCCESS" | "CONFLICT" | "MISSING" | "ERROR";
-            operations: {}[];
-            signals: {}[];
-            document?: {} | undefined;
-            error?: string | undefined;
-        }>;
-    };
-}, {
-    readonly name: "getDrives";
-    readonly description: "List all drives";
-    readonly inputSchema: {};
-    readonly outputSchema: {
-        readonly driveIds: z.ZodArray<z.ZodString, "many">;
-    };
-}, {
-    readonly name: "addDrive";
-    readonly description: "Create a new drive";
-    readonly inputSchema: {
-        readonly driveInput: z.ZodObject<{
-            global: z.ZodObject<{
-                name: z.ZodString;
-                icon: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            }, "strip", z.ZodTypeAny, {
-                name: string;
-                icon?: string | null | undefined;
-            }, {
-                name: string;
-                icon?: string | null | undefined;
-            }>;
-            id: z.ZodOptional<z.ZodString>;
-            slug: z.ZodOptional<z.ZodString>;
-            preferredEditor: z.ZodOptional<z.ZodString>;
-            local: z.ZodOptional<z.ZodObject<{
-                availableOffline: z.ZodOptional<z.ZodBoolean>;
-                sharingType: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            }, "strip", z.ZodTypeAny, {
-                availableOffline?: boolean | undefined;
-                sharingType?: string | null | undefined;
-            }, {
-                availableOffline?: boolean | undefined;
-                sharingType?: string | null | undefined;
-            }>>;
-        }, "strip", z.ZodTypeAny, {
-            global: {
-                name: string;
-                icon?: string | null | undefined;
-            };
-            local?: {
-                availableOffline?: boolean | undefined;
-                sharingType?: string | null | undefined;
-            } | undefined;
-            id?: string | undefined;
-            slug?: string | undefined;
-            preferredEditor?: string | undefined;
-        }, {
-            global: {
-                name: string;
-                icon?: string | null | undefined;
-            };
-            local?: {
-                availableOffline?: boolean | undefined;
-                sharingType?: string | null | undefined;
-            } | undefined;
-            id?: string | undefined;
-            slug?: string | undefined;
-            preferredEditor?: string | undefined;
-        }>;
-    };
-    readonly outputSchema: {
-        readonly drive: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
-    };
-}, {
-    readonly name: "getDrive";
-    readonly description: "Get a specific drive";
-    readonly inputSchema: {
-        readonly driveId: z.ZodString;
-        readonly options: z.ZodOptional<z.ZodObject<{
-            revisions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
-            checkHashes: z.ZodOptional<z.ZodBoolean>;
-        }, "strip", z.ZodTypeAny, {
-            revisions?: Record<string, number> | undefined;
-            checkHashes?: boolean | undefined;
-        }, {
-            revisions?: Record<string, number> | undefined;
-            checkHashes?: boolean | undefined;
-        }>>;
-    };
-    readonly outputSchema: {
-        readonly drive: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
-    };
-}, {
-    readonly name: "deleteDrive";
-    readonly description: "Delete a drive";
-    readonly inputSchema: {
-        readonly driveId: z.ZodString;
-    };
-    readonly outputSchema: {
-        readonly success: z.ZodBoolean;
-    };
-}, {
-    readonly name: "addRemoteDrive";
-    readonly description: "Connect to a remote drive";
-    readonly inputSchema: {
-        readonly url: z.ZodString;
-        readonly options: z.ZodObject<{
-            availableOffline: z.ZodBoolean;
-            sharingType: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            pullFilter: z.ZodOptional<z.ZodObject<{
-                branch: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString, "many">>>;
-                documentId: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString, "many">>>;
-                documentType: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString, "many">>>;
-                scope: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString, "many">>>;
-            }, "strip", z.ZodTypeAny, {
-                scope?: string[] | null | undefined;
-                documentType?: string[] | null | undefined;
-                documentId?: string[] | null | undefined;
-                branch?: string[] | null | undefined;
-            }, {
-                scope?: string[] | null | undefined;
-                documentType?: string[] | null | undefined;
-                documentId?: string[] | null | undefined;
-                branch?: string[] | null | undefined;
-            }>>;
-            pullInterval: z.ZodOptional<z.ZodNumber>;
-        }, "strip", z.ZodTypeAny, {
-            availableOffline: boolean;
-            sharingType?: string | null | undefined;
-            pullFilter?: {
-                scope?: string[] | null | undefined;
-                documentType?: string[] | null | undefined;
-                documentId?: string[] | null | undefined;
-                branch?: string[] | null | undefined;
-            } | undefined;
-            pullInterval?: number | undefined;
-        }, {
-            availableOffline: boolean;
-            sharingType?: string | null | undefined;
-            pullFilter?: {
-                scope?: string[] | null | undefined;
-                documentType?: string[] | null | undefined;
-                documentId?: string[] | null | undefined;
-                branch?: string[] | null | undefined;
-            } | undefined;
-            pullInterval?: number | undefined;
-        }>;
-    };
-    readonly outputSchema: {
-        readonly drive: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
-    };
-}];
-export type ReactorMcpTools = ToolRecord<typeof allTools>;
-export declare function createReactorMcpProvider(reactor: IDocumentDriveServer): Promise<{
-    tools: ReactorMcpTools;
-    resources: {};
-    prompts: {};
-}>;
-export {};
-//# sourceMappingURL=reactor.d.ts.map

package/dist/src/mcp/reactor.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"reactor.d.ts","sourceRoot":"","sources":["../../../src/mcp/reactor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAC3D,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAG/D,eAAO,MAAM,eAAe;;;;;;;;;CASG,CAAC;AAEhC,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyBA,CAAC;AAEhC,eAAO,MAAM,gBAAgB;;;;;;;;;CASE,CAAC;AAEhC,eAAO,MAAM,kBAAkB;;;;;;;;;CASA,CAAC;AAEhC,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0CK,CAAC;AAEhC,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqDE,CAAC;AAIhC,eAAO,MAAM,aAAa;;;;;;;CAOK,CAAC;AAEhC,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0CM,CAAC;AAEhC,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;CAoBM,CAAC;AAEhC,eAAO,MAAM,eAAe;;;;;;;;;CASG,CAAC;AAEhC,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8CA,CAAC;AAEhC,KAAK,UAAU,CAAC,CAAC,SAAS,SAAS,UAAU,EAAE,IAAI;KAChD,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,GAAG,gBAAgB,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,EAAE;QAAE,IAAI,EAAE,CAAC,CAAA;KAAE,CAAC,CAAC;CAC5E,CAAC;AAIF,QAAA,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAYJ,CAAC;AAGX,MAAM,MAAM,eAAe,GAAG,UAAU,CAAC,OAAO,QAAQ,CAAC,CAAC;AAE1D,wBAAsB,wBAAwB,CAAC,OAAO,EAAE,oBAAoB;;;;GA6H3E"}