@powerhousedao/reactor-mcp 4.1.0-dev.4 → 4.1.0-dev.7

package/dist/src/server.js

@@ -1,271 +1,29 @@
-import { McpServer, ResourceTemplate, } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { generateFromDocument, validateDocumentModelState, } from "@powerhousedao/codegen";
-import { getConfig } from "@powerhousedao/config/utils";
-import * as documentModelZ from "document-model/document-model/gen/schema/zod";
-import { z } from "zod";
-// Discriminated union schema that ties each action type to its specific input schema
-const DocumentModelActionSchema = z.discriminatedUnion("type", [
-    // Versioning and Change Log Operations
-    z.object({
-        type: z
-            .literal("ADD_CHANGE_LOG_ITEM")
-            .describe("Add a new item to the version change log"),
-        input: documentModelZ.AddChangeLogItemInputSchema(),
-    }),
-    z.object({
-        type: z
-            .literal("DELETE_CHANGE_LOG_ITEM")
-            .describe("Remove an item from the version change log"),
-        input: documentModelZ.DeleteChangeLogItemInputSchema(),
-    }),
-    z.object({
-        type: z
-            .literal("UPDATE_CHANGE_LOG_ITEM")
-            .describe("Update an existing change log item"),
-        input: documentModelZ.UpdateChangeLogItemInputSchema(),
-    }),
-    z.object({
-        type: z
-            .literal("REORDER_CHANGE_LOG_ITEMS")
-            .describe("Reorder items in the change log"),
-        input: documentModelZ.ReorderChangeLogItemsInputSchema(),
-    }),
-    z.object({
-        type: z
-            .literal("RELEASE_NEW_VERSION")
-            .describe("Release a new version of the document model"),
-        input: z.object({}), // No input required for version release
-    }),
-    // Model Header Operations
-    z.object({
-        type: z
-            .literal("SET_MODEL_NAME")
-            .describe("Set the name of the document model"),
-        input: documentModelZ.SetModelNameInputSchema(),
-    }),
-    z.object({
-        type: z
-            .literal("SET_MODEL_ID")
-            .describe("Set the unique identifier for the document model"),
-        input: documentModelZ.SetModelIdInputSchema(),
-    }),
-    z.object({
-        type: z
-            .literal("SET_MODEL_DESCRIPTION")
-            .describe("Set the description of the document model"),
-        input: documentModelZ.SetModelDescriptionInputSchema(),
-    }),
-    z.object({
-        type: z
-            .literal("SET_MODEL_EXTENSION")
-            .describe("Set the file extension for document model files"),
-        input: documentModelZ.SetModelExtensionInputSchema(),
-    }),
-    z.object({
-        type: z
-            .literal("SET_AUTHOR_NAME")
-            .describe("Set the author name for the document model"),
-        input: documentModelZ.SetAuthorNameInputSchema(),
-    }),
-    z.object({
-        type: z
-            .literal("SET_AUTHOR_WEBSITE")
-            .describe("Set the author website for the document model"),
-        input: documentModelZ.SetAuthorWebsiteInputSchema(),
-    }),
-    // Module Operations
-    z.object({
-        type: z
-            .literal("ADD_MODULE")
-            .describe("Add a new module to the document model"),
-        input: documentModelZ.AddModuleInputSchema(),
-    }),
-    z.object({
-        type: z
-            .literal("DELETE_MODULE")
-            .describe("Remove a module from the document model"),
-        input: documentModelZ.DeleteModuleInputSchema(),
-    }),
-    z.object({
-        type: z
-            .literal("REORDER_MODULES")
-            .describe("Reorder modules in the document model"),
-        input: documentModelZ.ReorderModulesInputSchema(),
-    }),
-    z.object({
-        type: z
-            .literal("SET_MODULE_NAME")
-            .describe("Set the name of a specific module"),
-        input: documentModelZ.SetModuleNameInputSchema(),
-    }),
-    z.object({
-        type: z
-            .literal("SET_MODULE_DESCRIPTION")
-            .describe("Set the description of a specific module"),
-        input: documentModelZ.SetModuleDescriptionInputSchema(),
-    }),
-    // Operation Operations
-    z.object({
-        type: z
-            .literal("ADD_OPERATION")
-            .describe("Add a new operation to a module"),
-        input: documentModelZ.AddOperationInputSchema(),
-    }),
-    z.object({
-        type: z
-            .literal("DELETE_OPERATION")
-            .describe("Remove an operation from a module"),
-        input: documentModelZ.DeleteOperationInputSchema(),
-    }),
-    z.object({
-        type: z
-            .literal("MOVE_OPERATION")
-            .describe("Move an operation between modules"),
-        input: documentModelZ.MoveOperationInputSchema(),
-    }),
-    z.object({
-        type: z
-            .literal("REORDER_MODULE_OPERATIONS")
-            .describe("Reorder operations within a module"),
-        input: documentModelZ.ReorderModuleOperationsInputSchema(),
-    }),
-    z.object({
-        type: z
-            .literal("SET_OPERATION_NAME")
-            .describe("Set the name of an operation"),
-        input: documentModelZ.SetOperationNameInputSchema(),
-    }),
-    z.object({
-        type: z
-            .literal("SET_OPERATION_DESCRIPTION")
-            .describe("Set the description of an operation"),
-        input: documentModelZ.SetOperationDescriptionInputSchema(),
-    }),
-    z.object({
-        type: z
-            .literal("SET_OPERATION_SCHEMA")
-            .describe("Set the input schema for an operation"),
-        input: documentModelZ.SetOperationSchemaInputSchema(),
-    }),
-    z.object({
-        type: z
-            .literal("SET_OPERATION_SCOPE")
-            .describe("Set the scope (global/local) of an operation"),
-        input: documentModelZ.SetOperationScopeInputSchema(),
-    }),
-    z.object({
-        type: z
-            .literal("SET_OPERATION_TEMPLATE")
-            .describe("Set the template for an operation"),
-        input: documentModelZ.SetOperationTemplateInputSchema(),
-    }),
-    z.object({
-        type: z
-            .literal("SET_OPERATION_REDUCER")
-            .describe("Set the reducer function for an operation"),
-        input: documentModelZ.SetOperationReducerInputSchema(),
-    }),
-    // Operation Error Operations
-    z.object({
-        type: z
-            .literal("ADD_OPERATION_ERROR")
-            .describe("Add an error definition to an operation"),
-        input: documentModelZ.AddOperationErrorInputSchema(),
-    }),
-    z.object({
-        type: z
-            .literal("DELETE_OPERATION_ERROR")
-            .describe("Remove an error definition from an operation"),
-        input: documentModelZ.DeleteOperationErrorInputSchema(),
-    }),
-    z.object({
-        type: z
-            .literal("REORDER_OPERATION_ERRORS")
-            .describe("Reorder error definitions for an operation"),
-        input: documentModelZ.ReorderOperationErrorsInputSchema(),
-    }),
-    z.object({
-        type: z
-            .literal("SET_OPERATION_ERROR_CODE")
-            .describe("Set the error code for an operation error"),
-        input: documentModelZ.SetOperationErrorCodeInputSchema(),
-    }),
-    z.object({
-        type: z
-            .literal("SET_OPERATION_ERROR_NAME")
-            .describe("Set the name for an operation error"),
-        input: documentModelZ.SetOperationErrorNameInputSchema(),
-    }),
-    // Operation Example Operations
-    z.object({
-        type: z
-            .literal("ADD_OPERATION_EXAMPLE")
-            .describe("Add an example to an operation"),
-        input: documentModelZ.AddOperationExampleInputSchema(),
-    }),
-    z.object({
-        type: z
-            .literal("DELETE_OPERATION_EXAMPLE")
-            .describe("Remove an example from an operation"),
-        input: documentModelZ.DeleteOperationExampleInputSchema(),
-    }),
-    z.object({
-        type: z
-            .literal("UPDATE_OPERATION_EXAMPLE")
-            .describe("Update an existing operation example"),
-        input: documentModelZ.UpdateOperationExampleInputSchema(),
-    }),
-    z.object({
-        type: z
-            .literal("REORDER_OPERATION_EXAMPLES")
-            .describe("Reorder examples for an operation"),
-        input: documentModelZ.ReorderOperationExamplesInputSchema(),
-    }),
-    // State Operations
-    z.object({
-        type: z
-            .literal("SET_STATE_SCHEMA")
-            .describe("Set the state schema for global or local state"),
-        input: documentModelZ.SetStateSchemaInputSchema(),
-    }),
-    z.object({
-        type: z
-            .literal("SET_INITIAL_STATE")
-            .describe("Set the initial state value for global or local state"),
-        input: documentModelZ.SetInitialStateInputSchema(),
-    }),
-    z.object({
-        type: z
-            .literal("ADD_STATE_EXAMPLE")
-            .describe("Add an example to state schema"),
-        input: documentModelZ.AddStateExampleInputSchema(),
-    }),
-    z.object({
-        type: z
-            .literal("DELETE_STATE_EXAMPLE")
-            .describe("Remove an example from state schema"),
-        input: documentModelZ.DeleteStateExampleInputSchema(),
-    }),
-    z.object({
-        type: z
-            .literal("UPDATE_STATE_EXAMPLE")
-            .describe("Update an existing state example"),
-        input: documentModelZ.UpdateStateExampleInputSchema(),
-    }),
-    z.object({
-        type: z
-            .literal("REORDER_STATE_EXAMPLES")
-            .describe("Reorder examples for state schema"),
-        input: documentModelZ.ReorderStateExamplesInputSchema(),
-    }),
-]);
-export function createServer(reactor) {
+import { createReactorMcpProvider } from "#mcp/reactor.js";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export const ReactorMcpInstructions = `MUST BE USED when creating, updating or deleting documents or document-models for the Powerhouse/Vetra ecosystem.
+There are 5 main concepts to know of: 
+- Document Model: A template for creating documents. It defines the schema and allowed operations for a type of document.
+- Document: An instance of a document model. It contains actual data following the structure defined by the document model and can be changed using operations.
+- Drive: A document of type "powerhouse/document-drive" which represents a collection of documents and folders. To add documents to a drive, use the "addActions" tool with an "ADD_FILE" action.
+- Action: A proposed change to a document. It is a JSON object with the action name and input that defines the action to be taken on the document. Should be dispatched by calling the "addActions" tool.
+- Operation: A change done to a document. It contains the action object plus additional metadata such as the index of the operation in the document history, the timestamp it was added, the hash of the resulting document data, the number of operations skipped, and the error message if the operation failed. Actions dispatched with "addActions" get converted into an operation.
+
+When planning to add multiple actions to a document, try to reduce the number of "addActions" calls to a minimum by adding multiple actions at once.
+Unless the user specifies otherwise, and a drive with slug "vetra" is available, add newly created documents to it.
+
+Examples:
+<example>Context: User needs to create a new document model for their application. user: 'I need to create a user profile document model with fields for name, email, and preferences' assistant: 'I'll use the reactor-mcp-server to help you create this document model.' <commentary>Since the user is requesting document model creation, use the reactor-mcp-document-expert agent to ensure proper reactor-mcp tool usage.</commentary></example> <example>Context: User is building a content management system and needs create documents for certain types of document models. user: 'Can you help me create example documents for blog posts and categories document models?' assistant: 'Let me use the reactor-mcp-server to create these documents using the appropriate reactor-mcp tool calls.' <commentary>Document model creation requires the reactor-mcp-server tool calls to ensure compliance.</commentary></example>
+<example>Context: User needs to create a new document instance of a given document model. user: 'I need to create a demo user profile document' assistant: 'I'll use the reactor-mcp-server to help you create this document with example values.' <commentary>Since the user is requesting document model creation, use the reactor-mcp-document-expert agent to ensure proper reactor-mcp tool usage.</commentary></example> <example>Context: User is building a content management system and needs create documents for certain types of document models. user: 'Can you help me create example documents for blog posts and categories document models?' assistant: 'Let me use the reactor-mcp-server to create these documents using the appropriate reactor-mcp tool calls.' <commentary>Document creation requires the reactor-mcp-server tool calls to ensure compliance.</commentary></example>
+`;
+export async function createServer(reactor) {
     // Create an MCP server for document model operations.
     // For document model creation tasks, consider using the document-model-creator agent
     // which provides a more guided experience.
     const server = new McpServer({
         name: "reactor-mcp-server",
         version: "1.0.0",
+        description: ReactorMcpInstructions,
+        instructions: ReactorMcpInstructions,
     }, {
         capabilities: {
             tools: {},
@@ -278,503 +36,24 @@ export function createServer(reactor) {
             },
         },
     });
-    server.registerTool("createDocumentModel", {
-        title: "Create Document Model",
-        description: "Create a new document model. For document model creation tasks, consider using the document-model-creator agent which provides a more guided experience.",
-        inputSchema: {
-            name: z.string(),
-        },
-    }, async ({ name }) => {
-        try {
-            await reactor.createDocumentModel(name);
-            return {
-                content: [],
-            };
-        }
-        catch (error) {
-            const errorString = error instanceof Error ? error.message : String(error);
-            return {
-                isError: true,
-                content: [{ type: "text", text: `Error: ${errorString}` }],
-            };
-        }
-    });
-    server.registerTool("addDocumentModelAction", {
-        title: "Add Document Model Action",
-        description: "Add an action to a document model. For document model design and modification tasks, consider using the document-model-creator agent which provides a more guided experience.",
-        inputSchema: {
-            documentModelName: z
-                .string()
-                .describe("Name of the document model to modify"),
-            action: DocumentModelActionSchema.describe("Action with its specific input data to perform on the document model"),
-        },
-    }, async ({ documentModelName, action }) => {
-        try {
-            const result = await reactor.addDocumentModelAction(documentModelName, {
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-                type: action.type,
-                scope: "global",
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-                input: action.input,
-            });
-            const errors = result.operations.reduce((errors, op) => {
-                if (op.error) {
-                    errors.push(op.error);
-                }
-                return errors;
-            }, []);
-            const causeString = result.error?.cause instanceof Error
-                ? ` (${result.error.cause.message})`
-                : result.error?.cause
-                    ? // eslint-disable-next-line @typescript-eslint/no-base-to-string
-                        String(result.error.cause)
-                    : errors.length > 0
-                        ? errors.join("\n- ")
-                        : undefined;
-            const errorString = result.error
-                ? `Error: ${result.error.message}${causeString ? ` (${causeString})` : ""}`
-                : undefined;
-            return {
-                isError: result.status !== "SUCCESS",
-                content: [
-                    {
-                        type: "text",
-                        text: `Status: ${result.status}${errorString ? "\n" + errorString : ""}`,
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            const errorString = error instanceof Error ? error.message : String(error);
-            return {
-                isError: true,
-                content: [{ type: "text", text: `Error: ${errorString}` }],
-            };
-        }
-    });
-    // server.registerTool(
-    //   "getDocument",
-    //   {
-    //     title: "Get Document",
-    //     description: "Get a document by id",
-    //     inputSchema: { id: z.string() },
-    //     outputSchema: documentModelZ.DocumentModelStateSchema().shape,
-    //   },
-    //   async ({ id }) => {
-    //     try {
-    //       const documentModel = await reactor.getDocumentModel(name);
-    //       return {
-    //         content: [],
-    //         structuredContent: documentModel,
-    //       };
-    //     } catch (error) {
-    //       const errorString =
-    //         error instanceof Error ? error.message : String(error);
-    //       return {
-    //         isError: true,
-    //         content: [{ type: "text", text: `Error: ${errorString}` }],
-    //       };
-    //     }
-    //   },
-    // );
-    // server.registerTool(
-    //   "getDocumentModels",
-    //   {
-    //     title: "Get Document Models",
-    //     description: "Get all document models",
-    //     inputSchema: {},
-    //     outputSchema: {
-    //       documentModels: z.record(
-    //         z.string(),
-    //         documentModelZ.DocumentModelStateSchema(),
-    //       ),
-    //     },
-    //   },
-    //   async () => {
-    //     try {
-    //       const documentModels = await reactor.getDocumentModels();
-    //       return {
-    //         content: [],
-    //         structuredContent: {
-    //           documentModels,
-    //         },
-    //       };
-    //     } catch (error) {
-    //       const errorString =
-    //         error instanceof Error ? error.message : String(error);
-    //       return {
-    //         isError: true,
-    //         content: [{ type: "text", text: `Error: ${errorString}` }],
-    //       };
-    //     }
-    //   },
-    // );
-    server.registerTool("generateDocumentModel", {
-        title: "Generate Document Model",
-        description: "Generate a document model. For document model creation and generation tasks, consider using the document-model-creator agent which provides a more guided experience.",
-        inputSchema: {
-            name: z.string(),
-        },
-    }, async ({ name }) => {
-        try {
-            const config = getConfig();
-            const documentModel = await reactor.getDocumentModel(name);
-            const validationResult = validateDocumentModelState(documentModel);
-            if (!validationResult.isValid) {
-                return {
-                    isError: true,
-                    content: validationResult.errors.map((error) => ({
-                        type: "text",
-                        text: `Error: ${error}`,
-                    })),
-                };
-            }
-            try {
-                await generateFromDocument(documentModel, config);
-            }
-            catch (error) {
-                const errorString = error instanceof Error ? error.message : String(error);
-                return {
-                    isError: true,
-                    content: [{ type: "text", text: `Error: ${errorString}` }],
-                };
-            }
-            return {
-                content: [],
-            };
-        }
-        catch (error) {
-            const errorString = error instanceof Error ? error.message : String(error);
-            return {
-                isError: true,
-                content: [{ type: "text", text: `Error: ${errorString}` }],
-            };
-        }
-    });
-    // Register resources for document model schemas and metadata
-    server.registerResource("document-model-schema", new ResourceTemplate("document-model://schema/{name}", {
-        list: async () => {
-            try {
-                const documentModels = await reactor.getDocumentModels();
-                return {
-                    resources: Object.keys(documentModels).map((name) => ({
-                        uri: `document-model://schema/${name}`,
-                        name: `${name} Schema`,
-                        description: documentModels[name].description ||
-                            `Schema for the ${name} document model`,
-                        mimeType: "application/json",
-                    })),
-                };
-            }
-            catch (error) {
-                // Return empty list on error to avoid breaking the listing
-                return { resources: [] };
-            }
-        },
-    }), {
-        title: "Document Model Schema",
-        description: "Get the schema of a specific document model",
-        mimeType: "application/json",
-    }, async (uri, { name }) => {
-        try {
-            const modelName = Array.isArray(name) ? name[0] : name;
-            const documentModel = await reactor.getDocumentModel(modelName);
-            return {
-                contents: [
-                    {
-                        uri: uri.href,
-                        text: JSON.stringify(documentModel, null, 2),
-                        mimeType: "application/json",
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            const errorString = error instanceof Error ? error.message : String(error);
-            return {
-                contents: [
-                    {
-                        uri: uri.href,
-                        text: `Error retrieving document model schema: ${errorString}`,
-                        mimeType: "text/plain",
-                    },
-                ],
-            };
-        }
-    });
-    server.registerResource("document-models-list", "document-model://list", {
-        title: "Document Models List",
-        description: "Get a list of all available document models",
-        mimeType: "application/json",
-    }, async (uri) => {
-        try {
-            const documentModels = await reactor.getDocumentModels();
-            const modelList = Object.keys(documentModels).map((name) => ({
-                name,
-                id: documentModels[name].id,
-                description: documentModels[name].description || "No description",
-            }));
-            return {
-                contents: [
-                    {
-                        uri: uri.href,
-                        text: JSON.stringify(modelList, null, 2),
-                        mimeType: "application/json",
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            const errorString = error instanceof Error ? error.message : String(error);
-            return {
-                contents: [
-                    {
-                        uri: uri.href,
-                        text: `Error retrieving document models list: ${errorString}`,
-                        mimeType: "text/plain",
-                    },
-                ],
-            };
-        }
-    });
-    server.registerTool("createDocument", {
-        title: "Create Document",
-        description: "Create a new document of a specific document model type with a given name.",
-        inputSchema: {
-            documentType: z.string().describe("The document model type to create"),
-            name: z.string().describe("The name for the new document"),
-        },
-    }, async ({ documentType, name }) => {
-        try {
-            const result = await reactor.createDocument(documentType, name);
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Document created successfully with ID: ${result.id}`,
-                    },
-                ],
-                structuredContent: {
-                    id: result.id,
-                    name: result.document.header.name,
-                    documentType: result.document.header.documentType,
-                },
-            };
-        }
-        catch (error) {
-            const errorString = error instanceof Error ? error.message : String(error);
-            return {
-                isError: true,
-                content: [{ type: "text", text: `Error: ${errorString}` }],
-            };
-        }
-    });
-    server.registerTool("addAction", {
-        title: "Add Action",
-        description: "Add an action to any document by ID. Actions are operations that modify document state.",
-        inputSchema: {
-            documentId: z.string().describe("ID of the document to modify"),
-            action: z
-                .object({
-                type: z.string().describe("The action type"),
-                input: z
-                    .unknown()
-                    .transform((input) => input || {})
-                    .describe("The action input"),
-                scope: z
-                    .enum(["global", "local"])
-                    .describe("The scope of the action"),
-            })
-                .describe("The action to perform on the document"),
-        },
-    }, async ({ documentId, action }) => {
-        try {
-            const result = await reactor.addAction(documentId, action);
-            const errors = result.operations.reduce((errors, op) => {
-                if (op.error) {
-                    errors.push(op.error);
-                }
-                return errors;
-            }, []);
-            const causeString = result.error?.cause instanceof Error
-                ? ` (${result.error.cause.message})`
-                : result.error?.cause
-                    ? // eslint-disable-next-line @typescript-eslint/no-base-to-string
-                        String(result.error.cause)
-                    : errors.length > 0
-                        ? errors.join("\n- ")
-                        : undefined;
-            const errorString = result.error
-                ? `Error: ${result.error.message}${causeString ? ` (${causeString})` : ""}`
-                : undefined;
-            return {
-                isError: result.status !== "SUCCESS",
-                content: [
-                    {
-                        type: "text",
-                        text: `Status: ${result.status}${errorString ? "\n" + errorString : ""}`,
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            const errorString = error instanceof Error ? error.message : String(error);
-            return {
-                isError: true,
-                content: [{ type: "text", text: `Error: ${errorString}` }],
-            };
-        }
-    });
-    // Register resource for individual documents
-    server.registerResource("document", new ResourceTemplate("document://{id}", {
-        list: async () => {
-            try {
-                const documentIds = await reactor.getDocuments();
-                return {
-                    resources: documentIds.map((id) => ({
-                        uri: `document://${id}`,
-                        name: `Document ${id}`,
-                        description: `Document with ID ${id}`,
-                        mimeType: "application/json",
-                    })),
-                };
-            }
-            catch (error) {
-                // Return empty list on error to avoid breaking the listing
-                return { resources: [] };
-            }
-        },
-    }), {
-        title: "Document",
-        description: "Get a specific document by ID",
-        mimeType: "application/json",
-    }, async (uri, { id }) => {
-        try {
-            const documentId = Array.isArray(id) ? id[0] : id;
-            const document = await reactor.getDocument(documentId);
-            return {
-                contents: [
-                    {
-                        uri: uri.href,
-                        text: JSON.stringify(document, null, 2),
-                        mimeType: "application/json",
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            const errorString = error instanceof Error ? error.message : String(error);
-            return {
-                contents: [
-                    {
-                        uri: uri.href,
-                        text: `Error retrieving document: ${errorString}`,
-                        mimeType: "text/plain",
-                    },
-                ],
-            };
-        }
-    });
-    server.registerResource("documents-list", "documents://list", {
-        title: "Documents List",
-        description: "Get a list of all available document IDs",
-        mimeType: "application/json",
-    }, async (uri) => {
-        try {
-            const documentIds = await reactor.getDocuments();
-            return {
-                contents: [
-                    {
-                        uri: uri.href,
-                        text: JSON.stringify(documentIds, null, 2),
-                        mimeType: "application/json",
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            const errorString = error instanceof Error ? error.message : String(error);
-            return {
-                contents: [
-                    {
-                        uri: uri.href,
-                        text: `Error retrieving documents list: ${errorString}`,
-                        mimeType: "text/plain",
-                    },
-                ],
-            };
-        }
-    });
-    // Register prompts for document model operations
-    server.registerPrompt("analyze-document-model", {
-        title: "Analyze Document Model",
-        description: "Analyze a document model structure and suggest improvements",
-        argsSchema: {
-            modelName: z.string().describe("Name of the document model to analyze"),
-        },
-    }, async ({ modelName }) => {
-        try {
-            const documentModel = await reactor.getDocumentModel(modelName);
-            return {
-                messages: [
-                    {
-                        role: "user",
-                        content: {
-                            type: "text",
-                            text: `Please analyze this document model structure and suggest improvements for maintainability, performance, and best practices:\n\nModel Name: ${modelName}\n\nStructure:\n${JSON.stringify(documentModel, null, 2)}`,
-                        },
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            const errorString = error instanceof Error ? error.message : String(error);
-            return {
-                messages: [
-                    {
-                        role: "user",
-                        content: {
-                            type: "text",
-                            text: `Error analyzing document model "${modelName}": ${errorString}`,
-                        },
-                    },
-                ],
-            };
-        }
-    });
-    server.registerPrompt("create-document-model-template", {
-        title: "Create Document Model Template",
-        description: "Generate a template for creating a new document model",
-        argsSchema: {
-            purpose: z
-                .string()
-                .describe("The purpose or use case for the document model"),
-            domain: z
-                .string()
-                .optional()
-                .describe("The business domain (e.g., finance, content, project management)"),
-        },
-    }, async ({ purpose, domain }) => {
-        const domainContext = domain ? ` in the ${domain} domain` : "";
-        return {
-            messages: [
-                {
-                    role: "user",
-                    content: {
-                        type: "text",
-                        text: `Please help me create a document model template for: ${purpose}${domainContext}
-
-Please provide:
-1. A suggested document model structure with state schema
-2. Key operations that should be supported
-3. Business logic considerations
-4. Best practices for this type of document model
-
-Focus on creating a well-structured, maintainable design that follows Powerhouse document model conventions.`,
-                    },
-                },
-            ],
-        };
+    server.registerResource("instructions", "reactor://instructions", {
+        title: "Instructions",
+        description: "General instructions on how to use the tools of this MCP",
+        mimeType: "text/plain",
+    }, (uri) => ({
+        contents: [
+            {
+                uri: uri.href,
+                text: ReactorMcpInstructions,
+            },
+        ],
+    }));
+    const reactorProvider = await createReactorMcpProvider(reactor);
+    const { callback, ...toolSchema } = reactorProvider.tools.getDocumentModels;
+    // server.registerTool("getDocumentModels", toolSchema, callback);
+    Object.entries(reactorProvider.tools).forEach(([toolName, { callback, ...schema }]) => {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+        server.registerTool(toolName, schema, callback);
     });
     return server;
 }