roam-research-mcp 0.25.0 → 0.25.5

package/build/markdown-utils.js

@@ -176,39 +176,23 @@ function parseMarkdown(markdown) {
         // Calculate indentation level (2 spaces = 1 level)
         const indentation = line.match(/^\s*/)?.[0].length ?? 0;
         let level = Math.floor(indentation / 2);
-        // First check for headings
-        const { heading_level, content: headingContent } = parseMarkdownHeadingLevel(trimmedLine);
-        // Then handle bullet points if not a heading
-        let content;
-        if (heading_level > 0) {
-            content = headingContent; // Use clean heading content without # marks
-            level = 0; // Headings start at root level
-            stack.length = 1; // Reset stack but keep heading as parent
-            // Create heading node
-            const node = {
-                content,
-                level,
-                heading_level, // Store heading level in node
-                children: []
-            };
-            rootNodes.push(node);
-            stack[0] = node;
-            continue; // Skip to next line
-        }
-        // Handle non-heading content
+        let contentToParse;
         const bulletMatch = trimmedLine.match(/^(\s*)[-*+]\s+/);
         if (bulletMatch) {
-            // For bullet points, use the bullet's indentation for level
-            content = trimmedLine.substring(bulletMatch[0].length);
+            // If it's a bullet point, adjust level based on bullet indentation
             level = Math.floor(bulletMatch[1].length / 2);
+            contentToParse = trimmedLine.substring(bulletMatch[0].length); // Content after bullet
         }
         else {
-            content = trimmedLine;
+            contentToParse = trimmedLine; // No bullet, use trimmed line
         }
-        // Create regular node
+        // Now, from the content after bullet/initial indentation, check for heading
+        const { heading_level, content: finalContent } = parseMarkdownHeadingLevel(contentToParse);
+        // Create node
         const node = {
-            content,
-            level,
+            content: finalContent, // Use content after heading parsing
+            level, // Use level derived from bullet/indentation
+            ...(heading_level > 0 && { heading_level }),
             children: []
         };
         // Pop stack until we find the parent level

package/build/search/block-ref-search.js

@@ -3,7 +3,6 @@ import { BaseSearchHandler } from './types.js';
 import { SearchUtils } from './utils.js';
 import { resolveRefs } from '../tools/helpers/refs.js';
 export class BlockRefSearchHandler extends BaseSearchHandler {
-    params;
     constructor(graph, params) {
         super(graph);
         this.params = params;

package/build/search/datomic-search.js

@@ -1,7 +1,6 @@
 import { q } from '@roam-research/roam-api-sdk';
 import { BaseSearchHandler } from './types.js';
 export class DatomicSearchHandler extends BaseSearchHandler {
-    params;
     constructor(graph, params) {
         super(graph);
         this.params = params;

package/build/search/hierarchy-search.js

@@ -3,7 +3,6 @@ import { BaseSearchHandler } from './types.js';
 import { SearchUtils } from './utils.js';
 import { resolveRefs } from '../tools/helpers/refs.js';
 export class HierarchySearchHandler extends BaseSearchHandler {
-    params;
     constructor(graph, params) {
         super(graph);
         this.params = params;

package/build/search/status-search.js

@@ -3,7 +3,6 @@ import { BaseSearchHandler } from './types.js';
 import { SearchUtils } from './utils.js';
 import { resolveRefs } from '../tools/helpers/refs.js';
 export class StatusSearchHandler extends BaseSearchHandler {
-    params;
     constructor(graph, params) {
         super(graph);
         this.params = params;

package/build/search/tag-search.js

@@ -3,7 +3,6 @@ import { BaseSearchHandler } from './types.js';
 import { SearchUtils } from './utils.js';
 import { resolveRefs } from '../tools/helpers/refs.js';
 export class TagSearchHandler extends BaseSearchHandler {
-    params;
     constructor(graph, params) {
         super(graph);
         this.params = params;

package/build/search/text-search.js

@@ -3,7 +3,6 @@ import { BaseSearchHandler } from './types.js';
 import { SearchUtils } from './utils.js';
 import { resolveRefs } from '../tools/helpers/refs.js';
 export class TextSearchHandler extends BaseSearchHandler {
-    params;
     constructor(graph, params) {
         super(graph);
         this.params = params;

package/build/search/types.js

@@ -1,6 +1,5 @@
 // Base class for all search handlers
 export class BaseSearchHandler {
-    graph;
     constructor(graph) {
         this.graph = graph;
     }

package/build/server/roam-server.js

@@ -6,9 +6,6 @@ import { API_TOKEN, GRAPH_NAME } from '../config/environment.js';
 import { toolSchemas } from '../tools/schemas.js';
 import { ToolHandlers } from '../tools/tool-handlers.js';
 export class RoamServer {
-    server;
-    toolHandlers;
-    graph;
     constructor() {
         this.graph = initializeGraph({
             token: API_TOKEN,
@@ -17,7 +14,7 @@ export class RoamServer {
         this.toolHandlers = new ToolHandlers(this.graph);
         this.server = new Server({
             name: 'roam-research',
-            version: '0.25.0',
+            version: '0.25.5',
         }, {
             capabilities: {
                 tools: {
@@ -67,8 +64,8 @@ export class RoamServer {
                         };
                     }
                     case 'roam_fetch_page_by_title': {
-                        const { title } = request.params.arguments;
-                        const content = await this.toolHandlers.fetchPageByTitle(title);
+                        const { title, format } = request.params.arguments;
+                        const content = await this.toolHandlers.fetchPageByTitle(title, format);
                         return {
                             content: [{ type: 'text', text: content }],
                         };
@@ -81,8 +78,8 @@ export class RoamServer {
                         };
                     }
                     case 'roam_create_block': {
-                        const { content, page_uid, title } = request.params.arguments;
-                        const result = await this.toolHandlers.createBlock(content, page_uid, title);
+                        const { content, page_uid, title, heading } = request.params.arguments;
+                        const result = await this.toolHandlers.createBlock(content, page_uid, title, heading);
                         return {
                             content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
                         };

package/build/tools/operations/blocks.js

@@ -1,13 +1,12 @@
-import { q, createBlock as createRoamBlock, updateBlock as updateRoamBlock, batchActions, createPage } from '@roam-research/roam-api-sdk';
+import { q, updateBlock as updateRoamBlock, batchActions, createPage } from '@roam-research/roam-api-sdk';
 import { McpError, ErrorCode } from '@modelcontextprotocol/sdk/types.js';
 import { formatRoamDate } from '../../utils/helpers.js';
 import { parseMarkdown, convertToRoamActions, convertToRoamMarkdown } from '../../markdown-utils.js';
 export class BlockOperations {
-    graph;
     constructor(graph) {
         this.graph = graph;
     }
-    async createBlock(content, page_uid, title) {
+    async createBlock(content, page_uid, title, heading) {
         // If page_uid provided, use it directly
         let targetPageUid = page_uid;
         // If no page_uid but title provided, search for page by title
@@ -68,9 +67,44 @@ export class BlockOperations {
         try {
             // If the content has multiple lines or is a table, use nested import
             if (content.includes('\n')) {
-                // Parse and import the nested content
-                const convertedContent = convertToRoamMarkdown(content);
-                const nodes = parseMarkdown(convertedContent);
+                let nodes;
+                // If heading parameter is provided, manually construct nodes to preserve heading
+                if (heading) {
+                    const lines = content.split('\n');
+                    const firstLine = lines[0].trim();
+                    const remainingLines = lines.slice(1);
+                    // Create the first node with heading formatting
+                    const firstNode = {
+                        content: firstLine,
+                        level: 0,
+                        heading_level: heading,
+                        children: []
+                    };
+                    // If there are remaining lines, parse them as children or siblings
+                    if (remainingLines.length > 0 && remainingLines.some(line => line.trim())) {
+                        const remainingContent = remainingLines.join('\n');
+                        const convertedRemainingContent = convertToRoamMarkdown(remainingContent);
+                        const remainingNodes = parseMarkdown(convertedRemainingContent);
+                        // Add remaining nodes as siblings to the first node
+                        nodes = [firstNode, ...remainingNodes];
+                    }
+                    else {
+                        nodes = [firstNode];
+                    }
+                }
+                else {
+                    // No heading parameter, use original parsing logic
+                    const convertedContent = convertToRoamMarkdown(content);
+                    nodes = parseMarkdown(convertedContent);
+                    // If we have simple newline-separated content (no markdown formatting),
+                    // and parseMarkdown created nodes at level 0, reverse them to maintain original order
+                    if (nodes.every(node => node.level === 0 && !node.heading_level)) {
+                        const lines = content.split('\n').filter(line => line.trim());
+                        if (lines.length === nodes.length) {
+                            nodes.reverse();
+                        }
+                    }
+                }
                 const actions = convertToRoamActions(nodes, targetPageUid, 'last');
                 // Execute batch actions to create the nested structure
                 const result = await batchActions(this.graph, {
@@ -88,27 +122,26 @@ export class BlockOperations {
                 };
             }
             else {
-                // For non-table content, create a simple block
-                await createRoamBlock(this.graph, {
-                    action: 'create-block',
-                    location: {
-                        "parent-uid": targetPageUid,
-                        "order": "last"
-                    },
-                    block: { string: content }
+                // For single block content, use the same convertToRoamActions approach that works in roam_create_page
+                const nodes = [{
+                        content: content,
+                        level: 0,
+                        ...(heading && typeof heading === 'number' && heading > 0 && { heading_level: heading }),
+                        children: []
+                    }];
+                if (!targetPageUid) {
+                    throw new McpError(ErrorCode.InternalError, 'targetPageUid is undefined');
+                }
+                const actions = convertToRoamActions(nodes, targetPageUid, 'last');
+                // Execute batch actions to create the block
+                const result = await batchActions(this.graph, {
+                    action: 'batch-actions',
+                    actions
                 });
-                // Get the block's UID
-                const findBlockQuery = `[:find ?uid
-                               :in $ ?parent ?string
-                               :where [?b :block/uid ?uid]
-                                     [?b :block/string ?string]
-                                     [?b :block/parents ?p]
-                                     [?p :block/uid ?parent]]`;
-                const blockResults = await q(this.graph, findBlockQuery, [targetPageUid, content]);
-                if (!blockResults || blockResults.length === 0) {
-                    throw new Error('Could not find created block');
+                if (!result) {
+                    throw new Error('Failed to create block');
                 }
-                const blockUid = blockResults[0][0];
+                const blockUid = result.created_uids?.[0];
                 return {
                     success: true,
                     block_uid: blockUid,

package/build/tools/operations/memory.js

@@ -4,8 +4,6 @@ import { formatRoamDate } from '../../utils/helpers.js';
 import { resolveRefs } from '../helpers/refs.js';
 import { SearchOperations } from './search/index.js';
 export class MemoryOperations {
-    graph;
-    searchOps;
     constructor(graph) {
         this.graph = graph;
         this.searchOps = new SearchOperations(graph);

package/build/tools/operations/outline.js

@@ -4,10 +4,24 @@ import { formatRoamDate } from '../../utils/helpers.js';
 import { capitalizeWords } from '../helpers/text.js';
 import { parseMarkdown, convertToRoamActions, convertToRoamMarkdown } from '../../markdown-utils.js';
 export class OutlineOperations {
-    graph;
     constructor(graph) {
         this.graph = graph;
     }
+    /**
+     * Creates an outline structure on a Roam Research page, optionally under a specific block.
+     *
+     * @param outline - An array of OutlineItem objects, each containing text and a level.
+     *                  Markdown heading syntax (#, ##, ###) in the text will be recognized
+     *                  and converted to Roam headings while preserving the outline's hierarchical
+     *                  structure based on indentation.
+     * @param page_title_uid - The title or UID of the page where the outline should be created.
+     *                         If not provided, today's daily page will be used.
+     * @param block_text_uid - Optional. The text content or UID of an existing block under which
+     *                         the outline should be inserted. If a text string is provided and
+     *                         no matching block is found, a new block with that text will be created
+     *                         on the page to serve as the parent. If a UID is provided and the block
+     *                         is not found, an error will be thrown.
+     */
     async createOutline(outline, page_title_uid, block_text_uid) {
         // Validate input
         if (!Array.isArray(outline) || outline.length === 0) {
@@ -210,6 +224,8 @@ export class OutlineOperations {
             const markdownContent = validOutline
                 .map(item => {
                 const indent = '  '.repeat(item.level - 1);
+                // If the item text starts with a markdown heading (e.g., #, ##, ###),
+                // treat it as a direct heading without adding a bullet or outline indentation.
                 return `${indent}- ${item.text?.trim()}`;
             })
                 .join('\n');

package/build/tools/operations/pages.js

@@ -4,7 +4,6 @@ import { capitalizeWords } from '../helpers/text.js';
 import { resolveRefs } from '../helpers/refs.js';
 import { convertToRoamActions } from '../../markdown-utils.js';
 export class PageOperations {
-    graph;
     constructor(graph) {
         this.graph = graph;
     }
@@ -38,7 +37,7 @@ export class PageOperations {
                 };
             }
             // Extract unique page titles
-            const uniquePages = [...new Set(results.map(([title]) => title))];
+            const uniquePages = Array.from(new Set(results.map(([title]) => title)));
             return {
                 success: true,
                 pages: uniquePages,
@@ -87,6 +86,7 @@ export class PageOperations {
                 const nodes = content.map(block => ({
                     content: block.text,
                     level: block.level,
+                    ...(block.heading && { heading_level: block.heading }),
                     children: []
                 }));
                 // Create hierarchical structure based on levels
@@ -126,7 +126,7 @@ export class PageOperations {
         }
         return { success: true, uid: pageUid };
     }
-    async fetchPageByTitle(title) {
+    async fetchPageByTitle(title, format = 'raw') {
         if (!title) {
             throw new McpError(ErrorCode.InvalidRequest, 'title is required');
         }
@@ -169,8 +169,26 @@ export class PageOperations {
                                [?parent :block/uid ?parent-uid]]`;
         const blocks = await q(this.graph, blocksQuery, [ancestorRule, title]);
         if (!blocks || blocks.length === 0) {
+            if (format === 'raw') {
+                return [];
+            }
             return `${title} (no content found)`;
         }
+        // Get heading information for blocks that have it
+        const headingsQuery = `[:find ?block-uid ?heading
+                          :in $ % ?page-title
+                          :where [?page :node/title ?page-title]
+                                 [?block :block/uid ?block-uid]
+                                 [?block :block/heading ?heading]
+                                 (ancestor ?block ?page)]`;
+        const headings = await q(this.graph, headingsQuery, [ancestorRule, title]);
+        // Create a map of block UIDs to heading levels
+        const headingMap = new Map();
+        if (headings) {
+            for (const [blockUid, heading] of headings) {
+                headingMap.set(blockUid, heading);
+            }
+        }
         // Create a map of all blocks
         const blockMap = new Map();
         const rootBlocks = [];
@@ -181,6 +199,7 @@ export class PageOperations {
                 uid: blockUid,
                 string: resolvedString,
                 order: order,
+                heading: headingMap.get(blockUid) || null,
                 children: []
             };
             blockMap.set(blockUid, block);
@@ -209,16 +228,31 @@ export class PageOperations {
             });
         };
         sortBlocks(rootBlocks);
+        if (format === 'raw') {
+            return JSON.stringify(rootBlocks);
+        }
         // Convert to markdown with proper nesting
         const toMarkdown = (blocks, level = 0) => {
-            return blocks.map(block => {
+            return blocks
+                .map(block => {
                 const indent = '  '.repeat(level);
-                let md = `${indent}- ${block.string}`;
+                let md;
+                // Check block heading level and format accordingly
+                if (block.heading && block.heading > 0) {
+                    // Format as heading with appropriate number of hashtags
+                    const hashtags = '#'.repeat(block.heading);
+                    md = `${indent}${hashtags} ${block.string}`;
+                }
+                else {
+                    // No heading, use bullet point (current behavior)
+                    md = `${indent}- ${block.string}`;
+                }
                 if (block.children.length > 0) {
                     md += '\n' + toMarkdown(block.children, level + 1);
                 }
                 return md;
-            }).join('\n');
+            })
+                .join('\n');
         };
         return `# ${title}\n\n${toMarkdown(rootBlocks)}`;
     }

package/build/tools/operations/search/handlers.js

@@ -1,14 +1,12 @@
 import { TagSearchHandler, BlockRefSearchHandler, HierarchySearchHandler, TextSearchHandler, DatomicSearchHandler, StatusSearchHandler } from '../../../search/index.js';
 // Base class for all search handlers
 export class BaseSearchHandler {
-    graph;
     constructor(graph) {
         this.graph = graph;
     }
 }
 // Tag search handler
 export class TagSearchHandlerImpl extends BaseSearchHandler {
-    params;
     constructor(graph, params) {
         super(graph);
         this.params = params;
@@ -20,7 +18,6 @@ export class TagSearchHandlerImpl extends BaseSearchHandler {
 }
 // Block reference search handler
 export class BlockRefSearchHandlerImpl extends BaseSearchHandler {
-    params;
     constructor(graph, params) {
         super(graph);
         this.params = params;
@@ -32,7 +29,6 @@ export class BlockRefSearchHandlerImpl extends BaseSearchHandler {
 }
 // Hierarchy search handler
 export class HierarchySearchHandlerImpl extends BaseSearchHandler {
-    params;
     constructor(graph, params) {
         super(graph);
         this.params = params;
@@ -44,7 +40,6 @@ export class HierarchySearchHandlerImpl extends BaseSearchHandler {
 }
 // Text search handler
 export class TextSearchHandlerImpl extends BaseSearchHandler {
-    params;
     constructor(graph, params) {
         super(graph);
         this.params = params;
@@ -56,7 +51,6 @@ export class TextSearchHandlerImpl extends BaseSearchHandler {
 }
 // Status search handler
 export class StatusSearchHandlerImpl extends BaseSearchHandler {
-    params;
     constructor(graph, params) {
         super(graph);
         this.params = params;
@@ -68,7 +62,6 @@ export class StatusSearchHandlerImpl extends BaseSearchHandler {
 }
 // Datomic query handler
 export class DatomicSearchHandlerImpl extends BaseSearchHandler {
-    params;
     constructor(graph, params) {
         super(graph);
         this.params = params;

package/build/tools/operations/search/index.js

@@ -1,6 +1,5 @@
 import { TagSearchHandlerImpl, BlockRefSearchHandlerImpl, HierarchySearchHandlerImpl, TextSearchHandlerImpl, StatusSearchHandlerImpl } from './handlers.js';
 export class SearchOperations {
-    graph;
     constructor(graph) {
         this.graph = graph;
     }

package/build/tools/operations/todos.js

@@ -2,7 +2,6 @@ import { q, createBlock, createPage, batchActions } from '@roam-research/roam-ap
 import { McpError, ErrorCode } from '@modelcontextprotocol/sdk/types.js';
 import { formatRoamDate } from '../../utils/helpers.js';
 export class TodoOperations {
-    graph;
     constructor(graph) {
         this.graph = graph;
     }

package/build/tools/schemas.js

@@ -19,22 +19,25 @@ export const toolSchemas = {
         },
     },
     roam_fetch_page_by_title: {
-        name: 'roam_fetch_page_by_title',
-        description: 'Retrieve complete page contents by exact title, including all nested blocks and resolved block references. Use for accessing daily pages, reading and analyzing existing Roam pages.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                title: {
-                    type: 'string',
-                    description: 'Title of the page. For date pages, use ordinal date formats such as January 2nd, 2025',
-                },
+        description: 'Fetch page by title, defaults to raw JSON string.',
+        type: 'object',
+        properties: {
+            title: {
+                type: 'string',
+                description: 'Title of the page. For date pages, use ordinal date formats such as January 2nd, 2025'
             },
-            required: ['title'],
+            format: {
+                type: 'string',
+                enum: ['markdown', 'raw'],
+                default: 'raw',
+                description: "Format output as markdown or JSON. 'markdown' returns as string; 'raw' returns JSON string of the page's blocks"
+            }
         },
+        required: ['title']
     },
     roam_create_page: {
         name: 'roam_create_page',
-        description: 'Create a new standalone page in Roam with optional content using explicit nesting levels. Best for:\n- Creating foundational concept pages that other pages will link to/from\n- Establishing new topic areas that need their own namespace\n- Setting up reference materials or documentation\n- Making permanent collections of information.',
+        description: 'Create new standalone page in Roam with optional content using explicit nesting levels and headings (H1-H3). Best for:\n- Creating foundational concept pages that other pages will link to/from\n- Establishing new topic areas that need their own namespace\n- Setting up reference materials or documentation\n- Making permanent collections of information.',
         inputSchema: {
             type: 'object',
             properties: {
@@ -57,6 +60,12 @@ export const toolSchemas = {
                                 description: 'Indentation level (1-10, where 1 is top level)',
                                 minimum: 1,
                                 maximum: 10
+                            },
+                            heading: {
+                                type: 'integer',
+                                description: 'Optional: Heading formatting for this block (1-3)',
+                                minimum: 1,
+                                maximum: 3
                             }
                         },
                         required: ['text', 'level']
@@ -68,7 +77,7 @@ export const toolSchemas = {
     },
     roam_create_block: {
         name: 'roam_create_block',
-        description: 'Add a new block to an existing Roam page. If no page specified, adds to today\'s daily note. Best for capturing immediate thoughts, additions to discussions, or content that doesn\'t warrant its own page. Can specify page by title or UID.\nNOTE on Roam-flavored markdown: For direct linking: use [[link]] syntax. For aliased linking, use [alias]([[link]]) syntax. Do not concatenate words in links/hashtags - correct: #[[multiple words]] #self-esteem (for typically hyphenated words).',
+        description: 'Add new block to an existing Roam page. If no page specified, adds to today\'s daily note. Best for capturing immediate thoughts, additions to discussions, or content that doesn\'t warrant its own page. Can specify page by title or UID.\nNOTE on Roam-flavored markdown: For direct linking: use [[link]] syntax. For aliased linking, use [alias]([[link]]) syntax. Do not concatenate words in links/hashtags - correct: #[[multiple words]] #self-esteem (for typically hyphenated words).',
         inputSchema: {
             type: 'object',
             properties: {
@@ -84,6 +93,12 @@ export const toolSchemas = {
                     type: 'string',
                     description: 'Optional: Title of the page to add block to (defaults to today\'s date if neither page_uid nor title provided)',
                 },
+                heading: {
+                    type: 'integer',
+                    description: 'Optional: Heading formatting for this block (1-3)',
+                    minimum: 1,
+                    maximum: 3
+                }
             },
             required: ['content'],
         },
@@ -100,7 +115,7 @@ export const toolSchemas = {
                 },
                 block_text_uid: {
                     type: 'string',
-                    description: 'A relevant title heading for the outline (or UID, if known) of the block under which outline content will be nested. If blank, content will be nested under the page title.'
+                    description: 'A relevant title heading for the outline (or UID, if known) of the block under which outline content will be nested. If blank, content will be nested directly under the page. This can be either the text content of the block or its UID.'
                 },
                 outline: {
                     type: 'array',
@@ -117,6 +132,12 @@ export const toolSchemas = {
                                 description: 'Indentation level (1-10, where 1 is top level)',
                                 minimum: 1,
                                 maximum: 10
+                            },
+                            heading: {
+                                type: 'integer',
+                                description: 'Optional: Heading formatting for this block (1-3)',
+                                minimum: 1,
+                                maximum: 3
                             }
                         },
                         required: ['text', 'level']
@@ -398,7 +419,7 @@ export const toolSchemas = {
                 scope: {
                     type: 'string',
                     enum: ['blocks', 'pages', 'both'],
-                    description: 'Whether to search blocks, pages, or both',
+                    description: 'Whether to search blocks, pages',
                 },
                 include_content: {
                     type: 'boolean',

package/build/tools/tool-handlers.js

@@ -6,13 +6,6 @@ import { TodoOperations } from './operations/todos.js';
 import { OutlineOperations } from './operations/outline.js';
 import { DatomicSearchHandlerImpl } from './operations/search/handlers.js';
 export class ToolHandlers {
-    graph;
-    pageOps;
-    blockOps;
-    searchOps;
-    memoryOps;
-    todoOps;
-    outlineOps;
     constructor(graph) {
         this.graph = graph;
         this.pageOps = new PageOperations(graph);
@@ -29,12 +22,12 @@ export class ToolHandlers {
     async createPage(title, content) {
         return this.pageOps.createPage(title, content);
     }
-    async fetchPageByTitle(title) {
-        return this.pageOps.fetchPageByTitle(title);
+    async fetchPageByTitle(title, format) {
+        return this.pageOps.fetchPageByTitle(title, format);
     }
     // Block Operations
-    async createBlock(content, page_uid, title) {
-        return this.blockOps.createBlock(content, page_uid, title);
+    async createBlock(content, page_uid, title, heading) {
+        return this.blockOps.createBlock(content, page_uid, title, heading);
     }
     async updateBlock(block_uid, content, transform) {
         return this.blockOps.updateBlock(block_uid, content, transform);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "roam-research-mcp",
-  "version": "0.25.0",
+  "version": "0.25.5",
   "description": "A Model Context Protocol (MCP) server for Roam Research API integration",
   "private": false,
   "repository": {