@powerhousedao/reactor-mcp 6.0.0-dev.25 → 6.0.0-dev.250

package/dist/index.d.mts

@@ -0,0 +1,637 @@
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { McpServer, ToolCallback } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { IReactorClient, ISyncManager } from "@powerhousedao/reactor";
+import { Action, DocumentModelModule } from "@powerhousedao/shared/document-model";
+import { ZodRawShape, z } from "zod";
+import { IncomingMessage, ServerResponse } from "node:http";
+import * as _modelcontextprotocol_sdk_types0 from "@modelcontextprotocol/sdk/types";
+import { CallToolResult, Prompt, Resource, ToolAnnotations } from "@modelcontextprotocol/sdk/types.js";
+
+//#region src/mcp-routes.d.ts
+/** Minimal interface for an HTTP adapter that supports Node.js-style route handlers. */
+interface NodeRouteAdapter {
+  mountNodeRoute(method: "DELETE" | "GET" | "POST", path: string, handler: (req: IncomingMessage, res: ServerResponse, body?: unknown) => void | Promise<void>): void;
+}
+interface SetupMcpServerOptions {
+  client: IReactorClient;
+  syncManager?: ISyncManager;
+}
+/** @internal Injected in tests to avoid relying on constructor mock semantics. */
+type TransportFactory = (opts: {
+  sessionIdGenerator: undefined;
+}) => InstanceType<typeof StreamableHTTPServerTransport>;
+declare function setupMcpServer(options: SetupMcpServerOptions, httpAdapter: NodeRouteAdapter, createTransport?: TransportFactory): Promise<void>;
+//#endregion
+//#region src/server.d.ts
+interface CreateServerOptions {
+  client: IReactorClient;
+  syncManager?: ISyncManager;
+}
+declare function createServer(options: CreateServerOptions): Promise<McpServer>;
+//#endregion
+//#region src/tools/types.d.ts
+type ExtractCallbackFromTool<T extends ToolSchema> = T extends {
+  inputSchema: infer S;
+} ? ToolCallback<S extends ZodRawShape ? S : undefined> : ToolCallback;
+type ToolWithCallback<T extends ToolSchema = ToolSchema> = T & {
+  callback: ExtractCallbackFromTool<T>;
+};
+type ToolSchema<InputArgs extends ZodRawShape = ZodRawShape, OutputArgs extends ZodRawShape = ZodRawShape> = {
+  name: string;
+  title?: string;
+  description?: string;
+  inputSchema?: InputArgs;
+  outputSchema?: OutputArgs;
+  annotations?: ToolAnnotations;
+};
+type ResolveZodSchema<T> = T extends z.ZodRawShape ? z.infer<z.ZodObject<T>> : T;
+interface IMcpProvider<T extends ToolWithCallback = ToolWithCallback, R extends Resource = Resource, P extends Prompt = Prompt> {
+  tools: Record<T["name"], ToolWithCallback<T>>;
+  resources: Record<R["name"], R>;
+  prompts: Record<P["name"], P>;
+}
+//#endregion
+//#region src/tools/reactor.d.ts
+type ReactorMcpProviderOptions = {
+  client: IReactorClient;
+  syncManager?: ISyncManager;
+};
+declare const createDocumentTool: {
+  readonly name: "createDocument";
+  readonly description: "Create a new document.\n     Unless the user specifies otherwise, and a drive named \"vetra\" is available, add the document to that drive by providing the drive's ID in the \"driveId\" parameter.\n     When \"driveId\" is provided, the document is created and added to the drive atomically — no separate \"addActions\" call with \"ADD_FILE\" is needed.";
+  readonly inputSchema: {
+    readonly documentType: z.ZodString;
+    readonly name: z.ZodOptional<z.ZodString>;
+    readonly driveId: z.ZodOptional<z.ZodString>;
+    readonly parentFolder: z.ZodOptional<z.ZodString>;
+  };
+  readonly outputSchema: {
+    readonly documentId: z.ZodString;
+  };
+};
+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.ZodUnknown;
+  };
+};
+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>;
+  };
+};
+declare const deleteDocumentTool: {
+  readonly name: "deleteDocument";
+  readonly description: "Delete a document";
+  readonly inputSchema: {
+    readonly documentId: z.ZodString;
+  };
+  readonly outputSchema: {
+    readonly success: z.ZodBoolean;
+  };
+};
+declare const addActionsTool: {
+  readonly name: "addActions";
+  readonly description: "Adds actions to a document. Prefer adding multiples actions at once to reduce the number of steps.";
+  readonly inputSchema: {
+    readonly documentId: z.ZodString;
+    readonly actions: z.ZodArray<z.ZodObject<{
+      type: z.ZodString;
+      input: z.ZodUnknown;
+      scope: z.ZodString;
+      context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>>;
+  };
+  readonly outputSchema: {
+    readonly success: z.ZodBoolean;
+  };
+};
+declare const getDrivesTool: {
+  readonly name: "getDrives";
+  readonly description: "List all drives";
+  readonly inputSchema: {};
+  readonly outputSchema: {
+    readonly driveIds: z.ZodArray<z.ZodString>;
+  };
+};
+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>>;
+      }, z.core.$strip>;
+      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>>;
+      }, z.core.$strip>>;
+    }, z.core.$strip>;
+  };
+  readonly outputSchema: {
+    readonly driveId: z.ZodString;
+  };
+};
+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>;
+    }, z.core.$strip>>;
+  };
+  readonly outputSchema: {
+    readonly drive: z.ZodUnknown;
+  };
+};
+declare const deleteDriveTool: {
+  readonly name: "deleteDrive";
+  readonly description: "Delete a drive";
+  readonly inputSchema: {
+    readonly driveId: z.ZodString;
+  };
+  readonly outputSchema: {
+    readonly success: z.ZodBoolean;
+  };
+};
+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>>>;
+        documentId: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+        documentType: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+        scope: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+      }, z.core.$strip>>;
+      pullInterval: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+  };
+  readonly outputSchema: {
+    readonly driveId: z.ZodString;
+  };
+};
+declare const getDocumentModelSchemaTool: {
+  readonly name: "getDocumentModelSchema";
+  readonly description: "Get the schema of a document model";
+  readonly inputSchema: {
+    readonly type: z.ZodString;
+  };
+  readonly outputSchema: {
+    readonly schema: z.ZodUnknown;
+  };
+};
+declare const getDocumentModelsTool: {
+  readonly name: "getDocumentModels";
+  readonly description: "Get the list of document models";
+  readonly inputSchema: {};
+  readonly outputSchema: {
+    readonly documentModels: z.ZodArray<z.ZodObject<{
+      name: z.ZodString;
+      type: z.ZodString;
+      description: z.ZodString;
+      extension: z.ZodString;
+      authorName: z.ZodString;
+      authorWebsite: z.ZodString;
+    }, z.core.$strip>>;
+  };
+};
+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.ZodUnknown;
+  };
+}, {
+  readonly name: "createDocument";
+  readonly description: "Create a new document.\n     Unless the user specifies otherwise, and a drive named \"vetra\" is available, add the document to that drive by providing the drive's ID in the \"driveId\" parameter.\n     When \"driveId\" is provided, the document is created and added to the drive atomically — no separate \"addActions\" call with \"ADD_FILE\" is needed.";
+  readonly inputSchema: {
+    readonly documentType: z.ZodString;
+    readonly name: z.ZodOptional<z.ZodString>;
+    readonly driveId: z.ZodOptional<z.ZodString>;
+    readonly parentFolder: z.ZodOptional<z.ZodString>;
+  };
+  readonly outputSchema: {
+    readonly documentId: z.ZodString;
+  };
+}, {
+  readonly name: "getDocuments";
+  readonly description: "List documents in a drive";
+  readonly inputSchema: {
+    readonly parentId: z.ZodString;
+  };
+  readonly outputSchema: {
+    readonly documentIds: z.ZodArray<z.ZodString>;
+  };
+}, {
+  readonly name: "deleteDocument";
+  readonly description: "Delete a document";
+  readonly inputSchema: {
+    readonly documentId: z.ZodString;
+  };
+  readonly outputSchema: {
+    readonly success: z.ZodBoolean;
+  };
+}, {
+  readonly name: "addActions";
+  readonly description: "Adds actions to a document. Prefer adding multiples actions at once to reduce the number of steps.";
+  readonly inputSchema: {
+    readonly documentId: z.ZodString;
+    readonly actions: z.ZodArray<z.ZodObject<{
+      type: z.ZodString;
+      input: z.ZodUnknown;
+      scope: z.ZodString;
+      context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>>;
+  };
+  readonly outputSchema: {
+    readonly success: z.ZodBoolean;
+  };
+}, {
+  readonly name: "getDrives";
+  readonly description: "List all drives";
+  readonly inputSchema: {};
+  readonly outputSchema: {
+    readonly driveIds: z.ZodArray<z.ZodString>;
+  };
+}, {
+  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>>;
+      }, z.core.$strip>;
+      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>>;
+      }, z.core.$strip>>;
+    }, z.core.$strip>;
+  };
+  readonly outputSchema: {
+    readonly driveId: z.ZodString;
+  };
+}, {
+  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>;
+    }, z.core.$strip>>;
+  };
+  readonly outputSchema: {
+    readonly drive: z.ZodUnknown;
+  };
+}, {
+  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>>>;
+        documentId: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+        documentType: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+        scope: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+      }, z.core.$strip>>;
+      pullInterval: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+  };
+  readonly outputSchema: {
+    readonly driveId: z.ZodString;
+  };
+}, {
+  readonly name: "getDocumentModelSchema";
+  readonly description: "Get the schema of a document model";
+  readonly inputSchema: {
+    readonly type: z.ZodString;
+  };
+  readonly outputSchema: {
+    readonly schema: z.ZodUnknown;
+  };
+}, {
+  readonly name: "getDocumentModels";
+  readonly description: "Get the list of document models";
+  readonly inputSchema: {};
+  readonly outputSchema: {
+    readonly documentModels: z.ZodArray<z.ZodObject<{
+      name: z.ZodString;
+      type: z.ZodString;
+      description: z.ZodString;
+      extension: z.ZodString;
+      authorName: z.ZodString;
+      authorWebsite: z.ZodString;
+    }, z.core.$strip>>;
+  };
+}];
+type ReactorMcpTools = ToolRecord<typeof allTools>;
+declare function createReactorMcpProvider(options: ReactorMcpProviderOptions): Promise<{
+  readonly tools: {
+    readonly getDocument: {
+      readonly name: "getDocument";
+      readonly description: "Retrieve a document by its ID";
+      readonly inputSchema: {
+        readonly id: z.ZodString;
+      };
+      readonly outputSchema: {
+        readonly document: z.ZodUnknown;
+      };
+    } & {
+      callback: (args: {
+        id: string;
+      }) => Promise<_modelcontextprotocol_sdk_types0.CallToolResult>;
+    };
+    readonly createDocument: {
+      readonly name: "createDocument";
+      readonly description: "Create a new document.\n     Unless the user specifies otherwise, and a drive named \"vetra\" is available, add the document to that drive by providing the drive's ID in the \"driveId\" parameter.\n     When \"driveId\" is provided, the document is created and added to the drive atomically — no separate \"addActions\" call with \"ADD_FILE\" is needed.";
+      readonly inputSchema: {
+        readonly documentType: z.ZodString;
+        readonly name: z.ZodOptional<z.ZodString>;
+        readonly driveId: z.ZodOptional<z.ZodString>;
+        readonly parentFolder: z.ZodOptional<z.ZodString>;
+      };
+      readonly outputSchema: {
+        readonly documentId: z.ZodString;
+      };
+    } & {
+      callback: (args: {
+        documentType: string;
+        name?: string | undefined;
+        driveId?: string | undefined;
+        parentFolder?: string | undefined;
+      }) => Promise<_modelcontextprotocol_sdk_types0.CallToolResult>;
+    };
+    readonly getDocuments: {
+      readonly name: "getDocuments";
+      readonly description: "List documents in a drive";
+      readonly inputSchema: {
+        readonly parentId: z.ZodString;
+      };
+      readonly outputSchema: {
+        readonly documentIds: z.ZodArray<z.ZodString>;
+      };
+    } & {
+      callback: (args: {
+        parentId: string;
+      }) => Promise<_modelcontextprotocol_sdk_types0.CallToolResult>;
+    };
+    readonly deleteDocument: {
+      readonly name: "deleteDocument";
+      readonly description: "Delete a document";
+      readonly inputSchema: {
+        readonly documentId: z.ZodString;
+      };
+      readonly outputSchema: {
+        readonly success: z.ZodBoolean;
+      };
+    } & {
+      callback: (args: {
+        documentId: string;
+      }) => Promise<_modelcontextprotocol_sdk_types0.CallToolResult>;
+    };
+    readonly addActions: {
+      readonly name: "addActions";
+      readonly description: "Adds actions to a document. Prefer adding multiples actions at once to reduce the number of steps.";
+      readonly inputSchema: {
+        readonly documentId: z.ZodString;
+        readonly actions: z.ZodArray<z.ZodObject<{
+          type: z.ZodString;
+          input: z.ZodUnknown;
+          scope: z.ZodString;
+          context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strict>>;
+      };
+      readonly outputSchema: {
+        readonly success: z.ZodBoolean;
+      };
+    } & {
+      callback: (args: {
+        documentId: string;
+        actions: {
+          type: string;
+          input: unknown;
+          scope: string;
+          context?: Record<string, unknown> | undefined;
+        }[];
+      }) => Promise<_modelcontextprotocol_sdk_types0.CallToolResult>;
+    };
+    readonly getDrives: {
+      readonly name: "getDrives";
+      readonly description: "List all drives";
+      readonly inputSchema: {};
+      readonly outputSchema: {
+        readonly driveIds: z.ZodArray<z.ZodString>;
+      };
+    } & {
+      callback: (args: Record<string, never>) => Promise<_modelcontextprotocol_sdk_types0.CallToolResult>;
+    };
+    readonly addDrive: {
+      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>>;
+          }, z.core.$strip>;
+          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>>;
+          }, z.core.$strip>>;
+        }, z.core.$strip>;
+      };
+      readonly outputSchema: {
+        readonly driveId: z.ZodString;
+      };
+    } & {
+      callback: (args: {
+        driveInput: {
+          global: {
+            name: string;
+            icon?: string | null | undefined;
+          };
+          id?: string | undefined;
+          slug?: string | undefined;
+          preferredEditor?: string | undefined;
+          local?: {
+            availableOffline?: boolean | undefined;
+            sharingType?: string | null | undefined;
+          } | undefined;
+        };
+      }) => Promise<_modelcontextprotocol_sdk_types0.CallToolResult>;
+    };
+    readonly getDrive: {
+      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>;
+        }, z.core.$strip>>;
+      };
+      readonly outputSchema: {
+        readonly drive: z.ZodUnknown;
+      };
+    } & {
+      callback: (args: {
+        driveId: string;
+        options?: {
+          revisions?: Record<string, number> | undefined;
+          checkHashes?: boolean | undefined;
+        } | undefined;
+      }) => Promise<_modelcontextprotocol_sdk_types0.CallToolResult>;
+    };
+    readonly deleteDrive: {
+      readonly name: "deleteDrive";
+      readonly description: "Delete a drive";
+      readonly inputSchema: {
+        readonly driveId: z.ZodString;
+      };
+      readonly outputSchema: {
+        readonly success: z.ZodBoolean;
+      };
+    } & {
+      callback: (args: {
+        driveId: string;
+      }) => Promise<_modelcontextprotocol_sdk_types0.CallToolResult>;
+    };
+    readonly addRemoteDrive: {
+      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>>>;
+            documentId: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+            documentType: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+            scope: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+          }, z.core.$strip>>;
+          pullInterval: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>;
+      };
+      readonly outputSchema: {
+        readonly driveId: z.ZodString;
+      };
+    } & {
+      callback: (args: {
+        url: string;
+        options: {
+          availableOffline: boolean;
+          sharingType?: string | null | undefined;
+          pullFilter?: {
+            branch?: string[] | null | undefined;
+            documentId?: string[] | null | undefined;
+            documentType?: string[] | null | undefined;
+            scope?: string[] | null | undefined;
+          } | undefined;
+          pullInterval?: number | undefined;
+        };
+      }) => Promise<_modelcontextprotocol_sdk_types0.CallToolResult>;
+    };
+    readonly getDocumentModels: {
+      readonly name: "getDocumentModels";
+      readonly description: "Get the list of document models";
+      readonly inputSchema: {};
+      readonly outputSchema: {
+        readonly documentModels: z.ZodArray<z.ZodObject<{
+          name: z.ZodString;
+          type: z.ZodString;
+          description: z.ZodString;
+          extension: z.ZodString;
+          authorName: z.ZodString;
+          authorWebsite: z.ZodString;
+        }, z.core.$strip>>;
+      };
+    } & {
+      callback: (args: Record<string, never>) => Promise<_modelcontextprotocol_sdk_types0.CallToolResult>;
+    };
+    readonly getDocumentModelSchema: {
+      readonly name: "getDocumentModelSchema";
+      readonly description: "Get the schema of a document model";
+      readonly inputSchema: {
+        readonly type: z.ZodString;
+      };
+      readonly outputSchema: {
+        readonly schema: z.ZodUnknown;
+      };
+    } & {
+      callback: (args: {
+        type: string;
+      }) => Promise<_modelcontextprotocol_sdk_types0.CallToolResult>;
+    };
+  };
+  readonly resources: {};
+  readonly prompts: {};
+}>;
+//#endregion
+//#region src/tools/utils.d.ts
+declare class InvalidToolOutputError extends Error {
+  constructor(zodError: z.ZodError);
+}
+/**
+ * Creates a tool with a callback function that handles the tool execution,
+ * ensuring the output is valid and errors are handled and returned correctly.
+ * @param tool The tool schema to wrap.
+ * @param toolCallback The callback function to execute when the tool is called.
+ * @returns A CallToolResult with structuredContent if OutputSchema is defined or content if undefined. If the
+ * callback throws an error, the result will have isError set to true and the error message in the content.
+ */
+declare function toolWithCallback<T extends ToolSchema>(tool: T, toolCallback: (args: ResolveZodSchema<T["inputSchema"]>) => ResolveZodSchema<T["outputSchema"]> | Promise<ResolveZodSchema<T["outputSchema"]>>): T & {
+  callback: (args: ResolveZodSchema<T["inputSchema"]>) => Promise<CallToolResult>;
+};
+declare function validateDocumentModelAction(documentModelModule: DocumentModelModule, action: Action): {
+  isValid: boolean;
+  errors: string[];
+};
+//#endregion
+export { type CreateServerOptions, ExtractCallbackFromTool, IMcpProvider, InvalidToolOutputError, ReactorMcpProviderOptions, ReactorMcpTools, ResolveZodSchema, type SetupMcpServerOptions, ToolSchema, ToolWithCallback, addActionsTool, addDriveTool, addRemoteDriveTool, createDocumentTool, createReactorMcpProvider, createServer, deleteDocumentTool, deleteDriveTool, getDocumentModelSchemaTool, getDocumentModelsTool, getDocumentTool, getDocumentsTool, getDriveTool, getDrivesTool, setupMcpServer, toolWithCallback, validateDocumentModelAction };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/mcp-routes.ts","../src/server.ts","../src/tools/types.ts","../src/tools/reactor.ts","../src/tools/utils.ts"],"mappings":";;;;;;;;;;;UAKU,gBAAA;EACR,cAAA,CACE,MAAA,6BACA,IAAA,UACA,OAAA,GACE,GAAA,EAAK,eAAA,EACL,GAAA,EAAK,cAAA,EACL,IAAA,sBACU,OAAA;AAAA;AAAA,UAMC,qBAAA;EACf,MAAA,EAAQ,cAAA;EACR,WAAA,GAAc,YAAA;AAAA;;KAgBX,gBAAA,IAAoB,IAAA;EACvB,kBAAA;AAAA,MACI,YAAA,QAAoB,6BAAA;AAAA,iBAEJ,cAAA,CACpB,OAAA,EAAS,qBAAA,EACT,WAAA,EAAa,gBAAA,EAGb,eAAA,GAAiB,gBAAA,GAEhB,OAAA;;;UC5Cc,mBAAA;EACf,MAAA,EAAQ,cAAA;EACR,WAAA,GAAc,YAAA;AAAA;AAAA,iBAmBM,YAAA,CACpB,OAAA,EAAS,mBAAA,GACR,OAAA,CAAQ,SAAA;;;KCnBC,uBAAA,WAAkC,UAAA,IAAc,CAAA;EAC1D,WAAA;AAAA,IAEE,YAAA,CAAa,CAAA,SAAU,WAAA,GAAc,CAAA,gBACrC,YAAA;AAAA,KAEQ,gBAAA,WAA2B,UAAA,GAAa,UAAA,IAAc,CAAA;EAChE,QAAA,EAAU,uBAAA,CAAwB,CAAA;AAAA;AAAA,KAGxB,UAAA,mBACQ,WAAA,GAAc,WAAA,qBACb,WAAA,GAAc,WAAA;EAEjC,IAAA;EACA,KAAA;EACA,WAAA;EACA,WAAA,GAAc,SAAA;EACd,YAAA,GAAe,UAAA;EACf,WAAA,GAAc,eAAA;AAAA;AAAA,KAGJ,gBAAA,MAAsB,CAAA,SAAU,CAAA,CAAE,WAAA,GAC1C,CAAA,CAAE,KAAA,CAAM,CAAA,CAAE,SAAA,CAAU,CAAA,KACpB,CAAA;AAAA,UAEa,YAAA,WACL,gBAAA,GAAmB,gBAAA,YACnB,QAAA,GAAW,QAAA,YACX,MAAA,GAAS,MAAA;EAEnB,KAAA,EAAO,MAAA,CAAO,CAAA,UAAW,gBAAA,CAAiB,CAAA;EAC1C,SAAA,EAAW,MAAA,CAAO,CAAA,UAAW,CAAA;EAC7B,OAAA,EAAS,MAAA,CAAO,CAAA,UAAW,CAAA;AAAA;;;KC1BjB,yBAAA;EACV,MAAA,EAAQ,cAAA;EACR,WAAA,GAAc,YAAA;AAAA;AAAA,cAGH,kBAAA;EAAA;;;;;;;;;;;;cA+BA,eAAA;EAAA;;;iBASkB,CAAA,CAAA,SAAA;EAAA;EAAA;uBAAA,CAAA,CAAA,UAAA;EAAA;AAAA;AAAA,cAElB,gBAAA;EAAA;;;;;;;;;cAWA,kBAAA;EAAA;;;yBASkB,CAAA,CAAA,SAAA;EAAA;EAAA;sBAAA,CAAA,CAAA,UAAA;EAAA;AAAA;AAAA,cAElB,cAAA;EAAA;;;;;;;;;;;;;;;cA2EA,aAAA;EAAA;;;;uBAOkB,CAAA,CAAA,QAAA,CAAA,CAAA,CAAA,SAAA;EAAA;AAAA;AAAA,cAElB,YAAA;EAAA;;;;;;;;;;;;;;;;;;;;;cA4CA,YAAA;EAAA;;;;;;;;;;;;;cAsBA,eAAA;EAAA;;;sBASkB,CAAA,CAAA,SAAA;EAAA;EAAA;sBAAA,CAAA,CAAA,UAAA;EAAA;AAAA;AAAA,cAElB,kBAAA;EAAA;;;;;;;;;;;;;;;;;;;;cAgDA,0BAAA;EAAA;;;mBASkB,CAAA,CAAA,SAAA;EAAA;EAAA;qBAAA,CAAA,CAAA,UAAA;EAAA;AAAA;AAAA,cAElB,qBAAA;EAAA;;;;;;;;;;;;;;KAsBR,UAAA,oBAA8B,UAAA,cAC3B,CAAA,mBAAoB,gBAAA,CAAiB,OAAA,CAAQ,CAAA;EAAa,IAAA,EAAM,CAAA;AAAA;AAAA,cAIlE,QAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAiBM,eAAA,GAAkB,UAAA,QAAkB,QAAA;AAAA,iBAE1B,wBAAA,CACpB,OAAA,EAAS,yBAAA,GAAyB,OAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cCrVvB,sBAAA,SAA+B,KAAA;cAC9B,QAAA,EAAU,CAAA,CAAE,QAAA;AAAA;;;;AJTuC;;;;;iBIwBjD,gBAAA,WAA2B,UAAA,CAAA,CACzC,IAAA,EAAM,CAAA,EACN,YAAA,GACE,IAAA,EAAM,gBAAA,CAAiB,CAAA,qBAErB,gBAAA,CAAiB,CAAA,oBACjB,OAAA,CAAQ,gBAAA,CAAiB,CAAA,qBAAmB,CAAA;mBAGxC,gBAAA,CAAiB,CAAA,qBACtB,OAAA,CAAQ,cAAA;AAAA;AAAA,iBAgCG,2BAAA,CACd,mBAAA,EAAqB,mBAAA,EACrB,MAAA,EAAQ,MAAA;EACL,OAAA;EAAkB,MAAA;AAAA"}

package/dist/index.mjs

@@ -0,0 +1,46 @@
+import { _ as validateDocumentModelAction, a as createDocumentTool, c as deleteDriveTool, d as getDocumentTool, f as getDocumentsTool, g as toolWithCallback, h as InvalidToolOutputError, i as addRemoteDriveTool, l as getDocumentModelSchemaTool, m as getDrivesTool, n as addActionsTool, o as createReactorMcpProvider, p as getDriveTool, r as addDriveTool, s as deleteDocumentTool, t as createServer, u as getDocumentModelsTool, v as logger } from "./server-B68G2N1-.mjs";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+//#region src/mcp-routes.ts
+const METHOD_NOT_ALLOWED = JSON.stringify({
+	jsonrpc: "2.0",
+	error: {
+		code: -32e3,
+		message: "Method not allowed."
+	},
+	id: null
+});
+const INTERNAL_SERVER_ERROR = JSON.stringify({
+	jsonrpc: "2.0",
+	error: {
+		code: -32603,
+		message: "Internal server error"
+	},
+	id: null
+});
+async function setupMcpServer(options, httpAdapter, createTransport = (opts) => new StreamableHTTPServerTransport(opts)) {
+	httpAdapter.mountNodeRoute("POST", "/mcp", async (req, res, body) => {
+		try {
+			const server = await createServer(options);
+			const transport = createTransport({ sessionIdGenerator: void 0 });
+			res.on("close", () => {
+				transport.close();
+				server.close();
+			});
+			await server.connect(transport);
+			await transport.handleRequest(req, res, body);
+		} catch (error) {
+			logger.error("Error handling MCP request:", error);
+			if (!res.headersSent) res.writeHead(500, { "Content-Type": "application/json" }).end(INTERNAL_SERVER_ERROR);
+		}
+	});
+	httpAdapter.mountNodeRoute("GET", "/mcp", (_req, res) => {
+		res.writeHead(405).end(METHOD_NOT_ALLOWED);
+	});
+	httpAdapter.mountNodeRoute("DELETE", "/mcp", (_req, res) => {
+		res.writeHead(405).end(METHOD_NOT_ALLOWED);
+	});
+}
+//#endregion
+export { InvalidToolOutputError, addActionsTool, addDriveTool, addRemoteDriveTool, createDocumentTool, createReactorMcpProvider, createServer, deleteDocumentTool, deleteDriveTool, getDocumentModelSchemaTool, getDocumentModelsTool, getDocumentTool, getDocumentsTool, getDriveTool, getDrivesTool, setupMcpServer, toolWithCallback, validateDocumentModelAction };
+
+//# sourceMappingURL=index.mjs.map