@prih/mcp-graph-memory 1.0.3

package/dist/api/rest/skills.js

@@ -0,0 +1,284 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSkillsRouter = createSkillsRouter;
+const fs_1 = __importDefault(require("fs"));
+const mime_1 = __importDefault(require("mime"));
+const express_1 = require("express");
+const multer_1 = __importDefault(require("multer"));
+const validation_1 = require("../../api/rest/validation");
+const manager_types_1 = require("../../graphs/manager-types");
+const upload = (0, multer_1.default)({ storage: multer_1.default.memoryStorage(), limits: { fileSize: 50 * 1024 * 1024 } });
+function createSkillsRouter() {
+    const router = (0, express_1.Router)({ mergeParams: true });
+    function getProject(req) {
+        return req.project;
+    }
+    // List skills
+    router.get('/', (0, validation_1.validateQuery)(validation_1.skillListSchema), (req, res, next) => {
+        try {
+            const p = getProject(req);
+            const q = req.validatedQuery;
+            const skills = p.skillManager.listSkills(q);
+            res.json({ results: skills });
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    // Search skills
+    router.get('/search', (0, validation_1.validateQuery)(validation_1.skillSearchSchema), async (req, res, next) => {
+        try {
+            const p = getProject(req);
+            const q = req.validatedQuery;
+            const results = await p.skillManager.searchSkills(q.q, {
+                topK: q.topK,
+                minScore: q.minScore,
+                searchMode: q.searchMode,
+            });
+            res.json({ results });
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    // Recall skills (higher recall search for task contexts)
+    router.get('/recall', (0, validation_1.validateQuery)(validation_1.skillSearchSchema), async (req, res, next) => {
+        try {
+            const p = getProject(req);
+            const q = req.validatedQuery;
+            const results = await p.skillManager.searchSkills(q.q, {
+                topK: q.topK,
+                minScore: q.minScore ?? 0.3,
+                searchMode: q.searchMode,
+            });
+            res.json({ results });
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    // Find skills linked to an external entity
+    router.get('/linked', (0, validation_1.validateQuery)(validation_1.linkedQuerySchema), (req, res, next) => {
+        try {
+            const p = getProject(req);
+            const { targetGraph, targetNodeId, kind, projectId } = req.validatedQuery;
+            const skills = p.skillManager.findLinkedSkills(targetGraph, targetNodeId, kind, projectId ?? req.params.projectId);
+            res.json({ results: skills });
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    // Get skill
+    router.get('/:skillId', (req, res, next) => {
+        try {
+            const p = getProject(req);
+            const skill = p.skillManager.getSkill(req.params.skillId);
+            if (!skill)
+                return res.status(404).json({ error: 'Skill not found' });
+            const relations = p.skillManager.listRelations(req.params.skillId);
+            res.json({ ...skill, relations });
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    // Create skill
+    router.post('/', (0, validation_1.validateBody)(validation_1.createSkillSchema), async (req, res, next) => {
+        try {
+            const p = getProject(req);
+            const { title, description, steps, triggers, inputHints, filePatterns, tags, source, confidence } = req.body;
+            const created = await p.mutationQueue.enqueue(async () => {
+                const skillId = await p.skillManager.createSkill(title, description, steps, triggers, inputHints, filePatterns, tags, source, confidence);
+                return p.skillManager.getSkill(skillId);
+            });
+            res.status(201).json(created);
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    // Update skill
+    router.put('/:skillId', (0, validation_1.validateBody)(validation_1.updateSkillSchema), async (req, res, next) => {
+        try {
+            const p = getProject(req);
+            const skillId = req.params.skillId;
+            const { version, ...patch } = req.body;
+            const result = await p.mutationQueue.enqueue(async () => {
+                const ok = await p.skillManager.updateSkill(skillId, patch, version);
+                if (!ok)
+                    return null;
+                return p.skillManager.getSkill(skillId);
+            });
+            if (!result)
+                return res.status(404).json({ error: 'Skill not found' });
+            res.json(result);
+        }
+        catch (err) {
+            if (err instanceof manager_types_1.VersionConflictError) {
+                return res.status(409).json({ error: 'version_conflict', current: err.current, expected: err.expected });
+            }
+            next(err);
+        }
+    });
+    // Bump usage
+    router.post('/:skillId/bump', async (req, res, next) => {
+        try {
+            const p = getProject(req);
+            const skillId = req.params.skillId;
+            const result = await p.mutationQueue.enqueue(async () => {
+                const ok = p.skillManager.bumpUsage(skillId);
+                if (!ok)
+                    return null;
+                return p.skillManager.getSkill(skillId);
+            });
+            if (!result)
+                return res.status(404).json({ error: 'Skill not found' });
+            res.json(result);
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    // Delete skill
+    router.delete('/:skillId', async (req, res, next) => {
+        try {
+            const p = getProject(req);
+            const skillId = req.params.skillId;
+            const ok = await p.mutationQueue.enqueue(async () => {
+                return p.skillManager.deleteSkill(skillId);
+            });
+            if (!ok)
+                return res.status(404).json({ error: 'Skill not found' });
+            res.status(204).end();
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    // Create skill link (skill-to-skill or cross-graph)
+    router.post('/links', (0, validation_1.validateBody)(validation_1.createSkillLinkSchema), async (req, res, next) => {
+        try {
+            const p = getProject(req);
+            const { fromId, toId, kind, targetGraph, projectId } = req.body;
+            const ok = await p.mutationQueue.enqueue(async () => {
+                if (targetGraph) {
+                    return p.skillManager.createCrossLink(fromId, toId, targetGraph, kind, projectId);
+                }
+                else {
+                    return p.skillManager.linkSkills(fromId, toId, kind);
+                }
+            });
+            if (!ok)
+                return res.status(400).json({ error: 'Failed to create link' });
+            res.status(201).json({ fromId, toId, kind, targetGraph: targetGraph || undefined });
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    // Delete skill link
+    router.delete('/links', (0, validation_1.validateBody)(validation_1.createSkillLinkSchema.pick({ fromId: true, toId: true, targetGraph: true, projectId: true })), async (req, res, next) => {
+        try {
+            const p = getProject(req);
+            const { fromId, toId, targetGraph, projectId } = req.body;
+            const ok = await p.mutationQueue.enqueue(async () => {
+                if (targetGraph) {
+                    return p.skillManager.deleteCrossLink(fromId, toId, targetGraph, projectId);
+                }
+                else {
+                    return p.skillManager.deleteSkillLink(fromId, toId);
+                }
+            });
+            if (!ok)
+                return res.status(404).json({ error: 'Link not found' });
+            res.status(204).end();
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    // List relations for a skill
+    router.get('/:skillId/relations', (req, res, next) => {
+        try {
+            const p = getProject(req);
+            const relations = p.skillManager.listRelations(req.params.skillId);
+            res.json({ results: relations });
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    // -- Attachments --
+    // Upload attachment
+    router.post('/:skillId/attachments', upload.single('file'), async (req, res, next) => {
+        try {
+            const p = getProject(req);
+            const skillId = req.params.skillId;
+            const file = req.file;
+            if (!file)
+                return res.status(400).json({ error: 'No file uploaded' });
+            const meta = await p.mutationQueue.enqueue(async () => {
+                return p.skillManager.addAttachment(skillId, file.originalname, file.buffer);
+            });
+            if (!meta)
+                return res.status(404).json({ error: 'Skill not found' });
+            res.status(201).json(meta);
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    // List attachments
+    router.get('/:skillId/attachments', (req, res, next) => {
+        try {
+            const p = getProject(req);
+            const attachments = p.skillManager.listAttachments(req.params.skillId);
+            res.json({ results: attachments });
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    // Download attachment
+    router.get('/:skillId/attachments/:filename', (req, res, next) => {
+        try {
+            const p = getProject(req);
+            const filename = validation_1.attachmentFilenameSchema.parse(req.params.filename);
+            const filePath = p.skillManager.getAttachmentPath(req.params.skillId, filename);
+            if (!filePath)
+                return res.status(404).json({ error: 'Attachment not found' });
+            const mimeType = mime_1.default.getType(filePath) ?? 'application/octet-stream';
+            res.setHeader('Content-Type', mimeType);
+            res.setHeader('Content-Disposition', `attachment; filename="${filename}"`);
+            res.setHeader('X-Content-Type-Options', 'nosniff');
+            const stream = fs_1.default.createReadStream(filePath);
+            stream.on('error', (err) => next(err));
+            stream.pipe(res);
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    // Delete attachment
+    router.delete('/:skillId/attachments/:filename', async (req, res, next) => {
+        try {
+            const p = getProject(req);
+            const skillId = req.params.skillId;
+            const filename = validation_1.attachmentFilenameSchema.parse(req.params.filename);
+            const ok = await p.mutationQueue.enqueue(async () => {
+                return p.skillManager.removeAttachment(skillId, filename);
+            });
+            if (!ok)
+                return res.status(404).json({ error: 'Attachment not found' });
+            res.status(204).end();
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    return router;
+}

package/dist/api/rest/tasks.js

@@ -0,0 +1,272 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTasksRouter = createTasksRouter;
+const fs_1 = __importDefault(require("fs"));
+const mime_1 = __importDefault(require("mime"));
+const express_1 = require("express");
+const multer_1 = __importDefault(require("multer"));
+const validation_1 = require("../../api/rest/validation");
+const manager_types_1 = require("../../graphs/manager-types");
+const upload = (0, multer_1.default)({ storage: multer_1.default.memoryStorage(), limits: { fileSize: 50 * 1024 * 1024 } });
+function createTasksRouter() {
+    const router = (0, express_1.Router)({ mergeParams: true });
+    function getProject(req) {
+        return req.project;
+    }
+    // List tasks
+    router.get('/', (0, validation_1.validateQuery)(validation_1.taskListSchema), (req, res, next) => {
+        try {
+            const p = getProject(req);
+            const q = req.validatedQuery;
+            const tasks = p.taskManager.listTasks(q);
+            res.json({ results: tasks });
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    // Search tasks
+    router.get('/search', (0, validation_1.validateQuery)(validation_1.taskSearchSchema), async (req, res, next) => {
+        try {
+            const p = getProject(req);
+            const q = req.validatedQuery;
+            const results = await p.taskManager.searchTasks(q.q, {
+                topK: q.topK,
+                minScore: q.minScore,
+                searchMode: q.searchMode,
+            });
+            res.json({ results });
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    // Find tasks linked to an external entity
+    router.get('/linked', (0, validation_1.validateQuery)(validation_1.linkedQuerySchema), (req, res, next) => {
+        try {
+            const p = getProject(req);
+            const { targetGraph, targetNodeId, kind, projectId } = req.validatedQuery;
+            const tasks = p.taskManager.findLinkedTasks(targetGraph, targetNodeId, kind, projectId ?? req.params.projectId);
+            res.json({ results: tasks });
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    // Get task
+    router.get('/:taskId', (req, res, next) => {
+        try {
+            const p = getProject(req);
+            const task = p.taskManager.getTask(req.params.taskId);
+            if (!task)
+                return res.status(404).json({ error: 'Task not found' });
+            const relations = p.taskManager.listRelations(req.params.taskId);
+            res.json({ ...task, relations });
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    // Create task
+    router.post('/', (0, validation_1.validateBody)(validation_1.createTaskSchema), async (req, res, next) => {
+        try {
+            const p = getProject(req);
+            const { title, description, status, priority, tags, dueDate, estimate } = req.body;
+            const created = await p.mutationQueue.enqueue(async () => {
+                const taskId = await p.taskManager.createTask(title, description, status, priority, tags, dueDate, estimate);
+                return p.taskManager.getTask(taskId);
+            });
+            res.status(201).json(created);
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    // Update task
+    router.put('/:taskId', (0, validation_1.validateBody)(validation_1.updateTaskSchema), async (req, res, next) => {
+        try {
+            const p = getProject(req);
+            const taskId = req.params.taskId;
+            const { version, ...patch } = req.body;
+            const result = await p.mutationQueue.enqueue(async () => {
+                const ok = await p.taskManager.updateTask(taskId, patch, version);
+                if (!ok)
+                    return null;
+                return p.taskManager.getTask(taskId);
+            });
+            if (!result)
+                return res.status(404).json({ error: 'Task not found' });
+            res.json(result);
+        }
+        catch (err) {
+            if (err instanceof manager_types_1.VersionConflictError) {
+                return res.status(409).json({ error: 'version_conflict', current: err.current, expected: err.expected });
+            }
+            next(err);
+        }
+    });
+    // Move task (change status) — action, so POST
+    router.post('/:taskId/move', (0, validation_1.validateBody)(validation_1.moveTaskSchema), async (req, res, next) => {
+        try {
+            const p = getProject(req);
+            const taskId = req.params.taskId;
+            const { status, version } = req.body;
+            const result = await p.mutationQueue.enqueue(async () => {
+                const ok = p.taskManager.moveTask(taskId, status, version);
+                if (!ok)
+                    return null;
+                return p.taskManager.getTask(taskId);
+            });
+            if (!result)
+                return res.status(404).json({ error: 'Task not found' });
+            res.json(result);
+        }
+        catch (err) {
+            if (err instanceof manager_types_1.VersionConflictError) {
+                return res.status(409).json({ error: 'version_conflict', current: err.current, expected: err.expected });
+            }
+            next(err);
+        }
+    });
+    // Delete task
+    router.delete('/:taskId', async (req, res, next) => {
+        try {
+            const p = getProject(req);
+            const taskId = req.params.taskId;
+            const ok = await p.mutationQueue.enqueue(async () => {
+                return p.taskManager.deleteTask(taskId);
+            });
+            if (!ok)
+                return res.status(404).json({ error: 'Task not found' });
+            res.status(204).end();
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    // Create task link (task-to-task or cross-graph)
+    router.post('/links', (0, validation_1.validateBody)(validation_1.createTaskLinkSchema), async (req, res, next) => {
+        try {
+            const p = getProject(req);
+            const { fromId, toId, kind, targetGraph, projectId } = req.body;
+            const ok = await p.mutationQueue.enqueue(async () => {
+                if (targetGraph) {
+                    return p.taskManager.createCrossLink(fromId, toId, targetGraph, kind, projectId);
+                }
+                else {
+                    return p.taskManager.linkTasks(fromId, toId, kind);
+                }
+            });
+            if (!ok)
+                return res.status(400).json({ error: 'Failed to create link' });
+            res.status(201).json({ fromId, toId, kind, targetGraph: targetGraph || undefined });
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    // Delete task link
+    router.delete('/links', (0, validation_1.validateBody)(validation_1.createTaskLinkSchema.pick({ fromId: true, toId: true, targetGraph: true, projectId: true })), async (req, res, next) => {
+        try {
+            const p = getProject(req);
+            const { fromId, toId, targetGraph, projectId } = req.body;
+            const ok = await p.mutationQueue.enqueue(async () => {
+                if (targetGraph) {
+                    return p.taskManager.deleteCrossLink(fromId, toId, targetGraph, projectId);
+                }
+                else {
+                    return p.taskManager.deleteTaskLink(fromId, toId);
+                }
+            });
+            if (!ok)
+                return res.status(404).json({ error: 'Link not found' });
+            res.status(204).end();
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    // List relations for a task
+    router.get('/:taskId/relations', (req, res, next) => {
+        try {
+            const p = getProject(req);
+            const relations = p.taskManager.listRelations(req.params.taskId);
+            res.json({ results: relations });
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    // -- Attachments --
+    // Upload attachment
+    router.post('/:taskId/attachments', upload.single('file'), async (req, res, next) => {
+        try {
+            const p = getProject(req);
+            const taskId = req.params.taskId;
+            const file = req.file;
+            if (!file)
+                return res.status(400).json({ error: 'No file uploaded' });
+            const meta = await p.mutationQueue.enqueue(async () => {
+                return p.taskManager.addAttachment(taskId, file.originalname, file.buffer);
+            });
+            if (!meta)
+                return res.status(404).json({ error: 'Task not found' });
+            res.status(201).json(meta);
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    // List attachments
+    router.get('/:taskId/attachments', (req, res, next) => {
+        try {
+            const p = getProject(req);
+            const attachments = p.taskManager.listAttachments(req.params.taskId);
+            res.json({ results: attachments });
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    // Download attachment
+    router.get('/:taskId/attachments/:filename', (req, res, next) => {
+        try {
+            const p = getProject(req);
+            const filename = validation_1.attachmentFilenameSchema.parse(req.params.filename);
+            const filePath = p.taskManager.getAttachmentPath(req.params.taskId, filename);
+            if (!filePath)
+                return res.status(404).json({ error: 'Attachment not found' });
+            const mimeType = mime_1.default.getType(filePath) ?? 'application/octet-stream';
+            res.setHeader('Content-Type', mimeType);
+            res.setHeader('Content-Disposition', `attachment; filename="${filename}"`);
+            res.setHeader('X-Content-Type-Options', 'nosniff');
+            const stream = fs_1.default.createReadStream(filePath);
+            stream.on('error', (err) => next(err));
+            stream.pipe(res);
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    // Delete attachment
+    router.delete('/:taskId/attachments/:filename', async (req, res, next) => {
+        try {
+            const p = getProject(req);
+            const taskId = req.params.taskId;
+            const filename = validation_1.attachmentFilenameSchema.parse(req.params.filename);
+            const ok = await p.mutationQueue.enqueue(async () => {
+                return p.taskManager.removeAttachment(taskId, filename);
+            });
+            if (!ok)
+                return res.status(404).json({ error: 'Attachment not found' });
+            res.status(204).end();
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    return router;
+}

package/dist/api/rest/tools.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createToolsRouter = createToolsRouter;
+const express_1 = require("express");
+const index_js_1 = require("@modelcontextprotocol/sdk/client/index.js");
+const inMemory_js_1 = require("@modelcontextprotocol/sdk/inMemory.js");
+const index_1 = require("../../api/index");
+// Tool category detection based on tool name
+const TOOL_CATEGORIES = {
+    get_context: 'context',
+    list_topics: 'docs', get_toc: 'docs', search: 'docs', get_node: 'docs',
+    search_topic_files: 'docs', find_examples: 'docs', search_snippets: 'docs',
+    list_snippets: 'docs', explain_symbol: 'docs', cross_references: 'cross-graph',
+    list_files: 'code', get_file_symbols: 'code', search_code: 'code',
+    get_symbol: 'code', search_files: 'code',
+    list_all_files: 'files', search_all_files: 'files', get_file_info: 'files',
+    create_note: 'knowledge', update_note: 'knowledge', delete_note: 'knowledge',
+    get_note: 'knowledge', list_notes: 'knowledge', search_notes: 'knowledge',
+    create_relation: 'knowledge', delete_relation: 'knowledge',
+    list_relations: 'knowledge', find_linked_notes: 'knowledge',
+    add_note_attachment: 'knowledge', remove_note_attachment: 'knowledge',
+    create_task: 'tasks', update_task: 'tasks', delete_task: 'tasks',
+    get_task: 'tasks', list_tasks: 'tasks', search_tasks: 'tasks',
+    move_task: 'tasks', link_task: 'tasks', create_task_link: 'tasks',
+    delete_task_link: 'tasks', find_linked_tasks: 'tasks',
+    add_task_attachment: 'tasks', remove_task_attachment: 'tasks',
+    create_skill: 'skills', update_skill: 'skills', delete_skill: 'skills',
+    get_skill: 'skills', list_skills: 'skills', search_skills: 'skills',
+    recall_skills: 'skills', bump_skill_usage: 'skills',
+    link_skill: 'skills', create_skill_link: 'skills', delete_skill_link: 'skills',
+    find_linked_skills: 'skills',
+    add_skill_attachment: 'skills', remove_skill_attachment: 'skills',
+};
+/**
+ * Get or create a lazy MCP client for a project instance.
+ * The client is cached on the instance for reuse.
+ */
+async function getClient(p, pm) {
+    if (p.mcpClient)
+        return p.mcpClient;
+    // Build session context for get_context tool
+    const ws = p.workspaceId ? pm.getWorkspace(p.workspaceId) : undefined;
+    const sessionCtx = {
+        projectId: p.id,
+        workspaceId: ws?.id,
+        workspaceProjects: ws?.config.projects,
+    };
+    const [serverTransport, clientTransport] = inMemory_js_1.InMemoryTransport.createLinkedPair();
+    const server = (0, index_1.createMcpServer)(p.docGraph, p.codeGraph, p.knowledgeGraph, p.fileIndexGraph, p.taskGraph, p.embedFns, p.mutationQueue, p.config.projectDir, p.skillGraph, sessionCtx);
+    await server.connect(serverTransport);
+    const client = new index_js_1.Client({ name: 'tools-explorer', version: '1.0.0' });
+    await client.connect(clientTransport);
+    p.mcpClient = client;
+    p.mcpClientCleanup = async () => {
+        await client.close();
+        p.mcpClient = undefined;
+        p.mcpClientCleanup = undefined;
+    };
+    return client;
+}
+function createToolsRouter(projectManager) {
+    const router = (0, express_1.Router)({ mergeParams: true });
+    function getProject(req) {
+        return req.project;
+    }
+    // List all available tools
+    router.get('/', async (req, res, next) => {
+        try {
+            const p = getProject(req);
+            const client = await getClient(p, projectManager);
+            const { tools } = await client.listTools();
+            const results = tools.map(t => ({
+                name: t.name,
+                description: t.description || '',
+                category: TOOL_CATEGORIES[t.name] || 'other',
+                inputSchema: t.inputSchema,
+            }));
+            res.json({ results });
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    // Get single tool info
+    router.get('/:toolName', async (req, res, next) => {
+        try {
+            const p = getProject(req);
+            const client = await getClient(p, projectManager);
+            const { tools } = await client.listTools();
+            const tool = tools.find(t => t.name === req.params.toolName);
+            if (!tool)
+                return res.status(404).json({ error: `Tool "${req.params.toolName}" not found` });
+            res.json({
+                name: tool.name,
+                description: tool.description || '',
+                category: TOOL_CATEGORIES[tool.name] || 'other',
+                inputSchema: tool.inputSchema,
+            });
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    // Call a tool
+    router.post('/:toolName/call', async (req, res, next) => {
+        try {
+            const p = getProject(req);
+            const client = await getClient(p, projectManager);
+            const start = Date.now();
+            const result = await client.callTool({
+                name: req.params.toolName,
+                arguments: req.body.arguments || {},
+            });
+            const duration = Date.now() - start;
+            res.json({
+                result: result.content,
+                isError: result.isError || false,
+                duration,
+            });
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    return router;
+}