@roam-research/roam-tools-core 0.4.0

package/dist/operations/query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../../src/operations/query.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC/C,OAAO,KAAK,EAAiB,cAAc,EAAE,MAAM,aAAa,CAAC;AAKjE,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;EAStB,CAAC;AAEH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEtD,wBAAsB,KAAK,CAAC,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,cAAc,CAAC,CA2B5F"}

package/dist/operations/query.js

@@ -0,0 +1,46 @@
+import { z } from "zod";
+import { textResult } from "../types.js";
+// Schema for executing Roam queries ({{query: }} or {{[[query]]: }} blocks, NOT Datalog)
+// Supports two modes: UID mode (execute existing query block) or Query mode (raw query string)
+export const QuerySchema = z.object({
+    uid: z.string().optional().describe("UID of a block containing {{query: ...}} or {{[[query]]: ...}} - uses the block's saved display settings and filters"),
+    query: z.string().optional().describe("Raw Roam query string (e.g., \"{and: [[TODO]] {not: [[DONE]]}}\") - NOT Datalog - results are flat list, no user filters applied"),
+    sort: z.enum(["created-date", "edited-date", "daily-note-date"]).optional().describe("Sort order (only for query mode, default: created-date)"),
+    sortOrder: z.enum(["asc", "desc"]).optional().describe("Sort direction (only for query mode, default: desc)"),
+    includePath: z.boolean().optional().describe("Include breadcrumb path in results (only for query mode, default: true)"),
+    offset: z.coerce.number().optional().describe("Skip first N results (default: 0)"),
+    limit: z.coerce.number().optional().describe("Max results to return (default: 20)"),
+    maxDepth: z.coerce.number().optional().describe("Max depth of children to include in markdown (default: 1)"),
+});
+export async function query(client, params) {
+    // Validate: exactly one of uid or query must be provided
+    const hasUid = params.uid !== undefined;
+    const hasQuery = params.query !== undefined;
+    if (hasUid === hasQuery) {
+        throw new Error("Provide exactly one of 'uid' or 'query', not both or neither");
+    }
+    const apiParams = {};
+    if (params.uid !== undefined) {
+        // UID mode - execute existing query block
+        apiParams.uid = params.uid;
+    }
+    else {
+        // Query mode - raw query string
+        apiParams.query = params.query;
+        if (params.sort !== undefined)
+            apiParams.sort = params.sort;
+        if (params.sortOrder !== undefined)
+            apiParams.sortOrder = params.sortOrder;
+        if (params.includePath !== undefined)
+            apiParams.includePath = params.includePath;
+    }
+    // Common parameters for both modes
+    if (params.offset !== undefined)
+        apiParams.offset = params.offset;
+    if (params.limit !== undefined)
+        apiParams.limit = params.limit;
+    if (params.maxDepth !== undefined)
+        apiParams.maxDepth = params.maxDepth;
+    const response = await client.call("data.ai.roamQuery", [apiParams]);
+    return textResult(response.result ?? { total: 0, results: [] });
+}

package/dist/operations/search.d.ts

@@ -0,0 +1,37 @@
+import { z } from "zod";
+import type { RoamClient } from "../client.js";
+import type { CallToolResult } from "../types.js";
+export declare const SearchSchema: z.ZodObject<{
+    query: z.ZodString;
+    scope: z.ZodOptional<z.ZodEnum<["pages", "blocks", "all"]>>;
+    offset: z.ZodOptional<z.ZodNumber>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    includePath: z.ZodOptional<z.ZodBoolean>;
+    maxDepth: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    query: string;
+    maxDepth?: number | undefined;
+    offset?: number | undefined;
+    limit?: number | undefined;
+    includePath?: boolean | undefined;
+    scope?: "pages" | "blocks" | "all" | undefined;
+}, {
+    query: string;
+    maxDepth?: number | undefined;
+    offset?: number | undefined;
+    limit?: number | undefined;
+    includePath?: boolean | undefined;
+    scope?: "pages" | "blocks" | "all" | undefined;
+}>;
+export declare const SearchTemplatesSchema: z.ZodObject<{
+    query: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    query?: string | undefined;
+}, {
+    query?: string | undefined;
+}>;
+export type SearchParams = z.infer<typeof SearchSchema>;
+export type SearchTemplatesParams = z.infer<typeof SearchTemplatesSchema>;
+export declare function search(client: RoamClient, params: SearchParams): Promise<CallToolResult>;
+export declare function searchTemplates(client: RoamClient, params: SearchTemplatesParams): Promise<CallToolResult>;
+//# sourceMappingURL=search.d.ts.map

package/dist/operations/search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../src/operations/search.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC/C,OAAO,KAAK,EAA4B,cAAc,EAAE,MAAM,aAAa,CAAC;AAI5E,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;EAOvB,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;;;EAEhC,CAAC;AAGH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AACxD,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAE1E,wBAAsB,MAAM,CAAC,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,cAAc,CAAC,CAY9F;AAED,wBAAsB,eAAe,CACnC,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,qBAAqB,GAC5B,OAAO,CAAC,cAAc,CAAC,CAKzB"}

package/dist/operations/search.js

@@ -0,0 +1,33 @@
+import { z } from "zod";
+import { textResult } from "../types.js";
+// Schemas
+export const SearchSchema = z.object({
+    query: z.string().describe("Search query"),
+    scope: z.enum(["pages", "blocks", "all"]).optional().describe("Search scope: 'pages' for page titles only, 'blocks' for block content only, 'all' for both (default: 'all')"),
+    offset: z.coerce.number().optional().describe("Skip first N results (default: 0)"),
+    limit: z.coerce.number().optional().describe("Max results (default: 20)"),
+    includePath: z.boolean().optional().describe("Include breadcrumb path to each result (default: true)"),
+    maxDepth: z.coerce.number().optional().describe("Max depth of children to include in markdown (default: 0)"),
+});
+export const SearchTemplatesSchema = z.object({
+    query: z.string().optional().describe("Keywords to filter templates by name (case-insensitive). Try relevant keywords first before listing all."),
+});
+export async function search(client, params) {
+    const apiParams = {
+        query: params.query,
+        scope: params.scope ?? "all",
+        offset: params.offset ?? 0,
+        limit: params.limit ?? 20,
+        includePath: params.includePath ?? true,
+    };
+    if (params.maxDepth !== undefined)
+        apiParams.maxDepth = params.maxDepth;
+    const response = await client.call("data.ai.search", [apiParams]);
+    return textResult(response.result ?? { total: 0, results: [] });
+}
+export async function searchTemplates(client, params) {
+    const response = await client.call("data.ai.searchTemplates", [
+        { query: params.query },
+    ]);
+    return textResult(response.result ?? []);
+}

package/dist/roam-api.d.ts

@@ -0,0 +1,32 @@
+import type { GraphType } from "./types.js";
+export interface AvailableGraph {
+    name: string;
+    type: GraphType;
+}
+export interface GraphsResponse {
+    success: boolean;
+    result?: AvailableGraph[];
+    error?: string;
+}
+export interface TokenExchangeResponse {
+    success: boolean;
+    token?: string;
+    graphName?: string;
+    graphType?: GraphType;
+    grantedAccessLevel?: string;
+    grantedScopes?: {
+        read?: boolean;
+        append?: boolean;
+        edit?: boolean;
+    };
+    error?: {
+        code?: string;
+        message?: string;
+    } | string;
+}
+export declare function fetchAvailableGraphs(port: number): Promise<AvailableGraph[]>;
+export declare function requestToken(port: number, graph: string, graphType: GraphType, accessLevel: string): Promise<TokenExchangeResponse>;
+export declare function sleep(ms: number): Promise<void>;
+export declare function openRoamApp(): Promise<void>;
+export declare function slugify(input: string): string;
+//# sourceMappingURL=roam-api.d.ts.map

package/dist/roam-api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"roam-api.d.ts","sourceRoot":"","sources":["../src/roam-api.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAM5C,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,SAAS,CAAC;CACjB;AAED,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,CAAC,EAAE,cAAc,EAAE,CAAC;IAC1B,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,aAAa,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,OAAO,CAAC;QAAC,MAAM,CAAC,EAAE,OAAO,CAAC;QAAC,IAAI,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC;IACrE,KAAK,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,MAAM,CAAC;CACtD;AAMD,wBAAsB,oBAAoB,CACxC,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,cAAc,EAAE,CAAC,CAc3B;AAED,wBAAsB,YAAY,CAChC,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,SAAS,EACpB,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,qBAAqB,CAAC,CAehC;AAMD,wBAAgB,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAE/C;AAED,wBAAsB,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC,CAEjD;AAED,wBAAgB,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAM7C"}

package/dist/roam-api.js

@@ -0,0 +1,50 @@
+// src/core/roam-api.ts
+// Shared API functions for interacting with Roam's local API.
+// Used by both the CLI (connect command) and the MCP tool (setup_new_graph).
+import open from "open";
+// ============================================================================
+// API Functions
+// ============================================================================
+export async function fetchAvailableGraphs(port) {
+    const url = `http://127.0.0.1:${port}/api/graphs/available`;
+    const response = await fetch(url, {
+        method: "GET",
+        headers: { "Content-Type": "application/json" },
+    });
+    const data = (await response.json());
+    if (!data.success) {
+        throw new Error(data.error || "Failed to get available graphs");
+    }
+    return data.result || [];
+}
+export async function requestToken(port, graph, graphType, accessLevel) {
+    const url = `http://127.0.0.1:${port}/api/graphs/tokens/request`;
+    const response = await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+            graph,
+            graphType,
+            description: "roam-mcp CLI",
+            accessLevel,
+            ai: true,
+        }),
+    });
+    return (await response.json());
+}
+// ============================================================================
+// Helpers
+// ============================================================================
+export function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export async function openRoamApp() {
+    await open("roam://open");
+}
+export function slugify(input) {
+    return input
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-|-$/g, "")
+        .replace(/-{2,}/g, "-");
+}

package/dist/tools.d.ts

@@ -0,0 +1,22 @@
+import { z } from "zod";
+import type { CallToolResult } from "./types.js";
+import { RoamClient } from "./client.js";
+export interface ClientToolDefinition {
+    name: string;
+    description: string;
+    schema: z.ZodObject<z.ZodRawShape>;
+    action: (client: RoamClient, args: unknown) => Promise<CallToolResult>;
+    type: "client";
+}
+export interface StandaloneToolDefinition {
+    name: string;
+    description: string;
+    schema: z.ZodObject<z.ZodRawShape>;
+    action: (args: unknown) => Promise<CallToolResult>;
+    type: "standalone";
+}
+export type ToolDefinition = ClientToolDefinition | StandaloneToolDefinition;
+export declare const tools: ToolDefinition[];
+export declare function findTool(name: string): ToolDefinition | undefined;
+export declare function routeToolCall(toolName: string, args: Record<string, unknown>): Promise<CallToolResult>;
+//# sourceMappingURL=tools.d.ts.map

package/dist/tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../src/tools.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,cAAc,EAAkC,MAAM,YAAY,CAAC;AAEjF,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AA8BzC,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC;IACnC,MAAM,EAAE,CAAC,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,OAAO,KAAK,OAAO,CAAC,cAAc,CAAC,CAAC;IACvE,IAAI,EAAE,QAAQ,CAAC;CAChB;AAGD,MAAM,WAAW,wBAAwB;IACvC,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC;IACnC,MAAM,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,OAAO,CAAC,cAAc,CAAC,CAAC;IACnD,IAAI,EAAE,YAAY,CAAC;CACpB;AAED,MAAM,MAAM,cAAc,GAAG,oBAAoB,GAAG,wBAAwB,CAAC;AAmL7E,eAAO,MAAM,KAAK,EAAE,cAAc,EAGjC,CAAC;AAEF,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS,CAEjE;AA0FD,wBAAsB,aAAa,CACjC,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC5B,OAAO,CAAC,cAAc,CAAC,CA+HzB"}

package/dist/tools.js

@@ -0,0 +1,276 @@
+import { z } from "zod";
+import { RoamError } from "./types.js";
+import { RoamClient } from "./client.js";
+import { resolveGraph, getPort, updateGraphTokenStatus } from "./graph-resolver.js";
+import { CreatePageSchema, GetPageSchema, DeletePageSchema, UpdatePageSchema, GetGuidelinesSchema, createPage, getPage, deletePage, updatePage, getGuidelines, } from "./operations/pages.js";
+import { CreateBlockSchema, GetBlockSchema, UpdateBlockSchema, DeleteBlockSchema, MoveBlockSchema, GetBacklinksSchema, createBlock, getBlock, updateBlock, deleteBlock, moveBlock, getBacklinks, } from "./operations/blocks.js";
+import { SearchSchema, SearchTemplatesSchema, search, searchTemplates } from "./operations/search.js";
+import { QuerySchema, query } from "./operations/query.js";
+import { GetOpenWindowsSchema, GetSelectionSchema, OpenMainWindowSchema, OpenSidebarSchema, getOpenWindows, getSelection, openMainWindow, openSidebar, } from "./operations/navigation.js";
+import { FileGetSchema, FileUploadSchema, FileDeleteSchema, getFile, uploadFile, deleteFile } from "./operations/files.js";
+import { ListGraphsSchema, SetupNewGraphSchema, listGraphs, setupNewGraph } from "./operations/graphs.js";
+// Common schema for graph parameter (used by most tools)
+const GraphSchema = z.object({
+    graph: z.string().optional().describe("Graph nickname or name (optional - auto-selects if only one graph is configured)"),
+});
+// Helper to extend any schema with graph parameter
+function withGraph(schema) {
+    return schema.extend(GraphSchema.shape);
+}
+// Helper to create tool with graph parameter
+function defineTool(name, description, schema, action) {
+    return {
+        name,
+        description,
+        schema: withGraph(schema),
+        action: (client, args) => action(client, args),
+        type: "client",
+    };
+}
+// Helper to create standalone tool (no graph parameter, handles its own resolution)
+function defineStandaloneTool(name, description, schema, action) {
+    return {
+        name,
+        description,
+        schema: schema,
+        action: (args) => action(args),
+        type: "standalone",
+    };
+}
+// Graph Management Tools (standalone - handle their own resolution)
+const graphManagementTools = [
+    defineStandaloneTool("list_graphs", "List all configured graphs with their nicknames. Also provides setup instructions for connecting additional graphs.", ListGraphsSchema, listGraphs),
+    defineStandaloneTool("setup_new_graph", "Set up a new Roam graph for access, or list available graphs. Call without arguments to see which graphs are available in Roam Desktop. Call with graph and nickname to connect a specific graph — ask the user what they'd like to call the graph before choosing a nickname. The user will see an approval dialog in Roam desktop app and must approve the token request. If the graph is already configured, returns the existing configuration without making changes.", SetupNewGraphSchema, setupNewGraph),
+];
+// Note appended to all client tool descriptions
+const GUIDELINES_NOTE = "\n\nNote: Call get_graph_guidelines first when starting to work with a graph.";
+// Content Tools (require graph/client)
+const contentTools = [
+    defineTool("get_graph_guidelines", "IMPORTANT: Call this tool first when starting to work with a graph, before performing any other operations. Returns user-defined instructions and preferences for AI agents. The user may have specified naming conventions, preferred structures, or constraints that should guide your behavior.", GetGuidelinesSchema, getGuidelines),
+    defineTool("create_page", "Create a new page in Roam, optionally with markdown content." + GUIDELINES_NOTE, CreatePageSchema, createPage),
+    defineTool("create_block", "Create a new block under a parent, using markdown content. Supports nested bulleted lists - pass a markdown string with `- ` list items and indentation to create an entire block hierarchy in a single call." + GUIDELINES_NOTE, CreateBlockSchema, createBlock),
+    defineTool("update_block", "Update an existing block's content or properties." + GUIDELINES_NOTE, UpdateBlockSchema, updateBlock),
+    defineTool("delete_block", "Delete a block and all its children." + GUIDELINES_NOTE, DeleteBlockSchema, deleteBlock),
+    defineTool("move_block", "Move a block to a new location." + GUIDELINES_NOTE, MoveBlockSchema, moveBlock),
+    defineTool("delete_page", "Delete a page and all its contents." + GUIDELINES_NOTE, DeletePageSchema, deletePage),
+    defineTool("update_page", "Update a page's title or children view type. Set mergePages to true if renaming to a title that already exists." + GUIDELINES_NOTE, UpdatePageSchema, updatePage),
+    defineTool("search", "Search for pages and blocks by text. Returns paginated results with markdown content and optional breadcrumb paths." + GUIDELINES_NOTE, SearchSchema, search),
+    defineTool("search_templates", "Search Roam templates by name. When the user mentions 'my X template' or 'the X template', use this tool to find it. Templates are user-created reusable content blocks tagged with [[roam/templates]]. Returns template name, uid, and content as markdown." + GUIDELINES_NOTE, SearchTemplatesSchema, searchTemplates),
+    defineTool("roam_query", 'Execute a Roam query ({{query: }} or {{[[query]]: }} blocks, NOT Datalog). Two modes: (1) UID mode - pass a block UID containing a query component to run it with saved settings/filters; (2) Query mode - pass a raw query string like "{and: [[TODO]] {not: [[DONE]]}}". Returns paginated results with markdown content.' + GUIDELINES_NOTE, QuerySchema, query),
+    defineTool("get_page", "Get a page's content as markdown. Returns content with <roam> metadata tags containing UIDs - use these for follow-up operations but strip them when showing content to the user. Show remaining content verbatim, never paraphrase. Use maxDepth for large pages." + GUIDELINES_NOTE, GetPageSchema, getPage),
+    defineTool("get_block", "Get a block's content as markdown. Returns content with <roam> metadata tags containing UIDs - use these for follow-up operations but strip them when showing content to the user. Show remaining content verbatim, never paraphrase. Use maxDepth for large blocks." + GUIDELINES_NOTE, GetBlockSchema, getBlock),
+    defineTool("get_backlinks", "Get paginated backlinks (linked references) for a page or block, formatted as markdown. Returns total count and results with optional breadcrumb paths." + GUIDELINES_NOTE, GetBacklinksSchema, getBacklinks),
+    defineTool("get_open_windows", "Get the current view in the main window and all open sidebar windows." + GUIDELINES_NOTE, GetOpenWindowsSchema, getOpenWindows),
+    defineTool("get_selection", "Get the currently focused block and any multi-selected blocks." + GUIDELINES_NOTE, GetSelectionSchema, getSelection),
+    defineTool("open_main_window", "Navigate to a page or block in the main window." + GUIDELINES_NOTE, OpenMainWindowSchema, openMainWindow),
+    defineTool("open_sidebar", "Open a page or block in the right sidebar." + GUIDELINES_NOTE, OpenSidebarSchema, openSidebar),
+    defineTool("file_get", "Fetch a file hosted on Roam (handles decryption for encrypted graphs)." + GUIDELINES_NOTE, FileGetSchema, getFile),
+    defineTool("file_upload", "Upload an image to Roam. Returns the Firebase storage URL. Usually you'll want to create a new block with the image as markdown: `![](url)`. Provide ONE of: filePath (preferred - local file, server reads directly), url (remote URL, server fetches), or base64 (raw data, fallback for sandboxed clients)." + GUIDELINES_NOTE, FileUploadSchema, uploadFile),
+    defineTool("file_delete", "Delete a file hosted on Roam." + GUIDELINES_NOTE, FileDeleteSchema, deleteFile),
+];
+export const tools = [
+    ...graphManagementTools,
+    ...contentTools,
+];
+export function findTool(name) {
+    return tools.find((t) => t.name === name);
+}
+/**
+ * Prepend graph nickname to a tool result.
+ */
+function prependGraphInfo(result, nickname) {
+    const prefix = `Roam graph: ${nickname}`;
+    const content = result.content;
+    if (!content || content.length === 0)
+        return result;
+    const first = content[0];
+    if (first.type === "text") {
+        return {
+            ...result,
+            content: [
+                { ...first, text: `${prefix}\n\n${first.text}` },
+                ...content.slice(1),
+            ],
+        };
+    }
+    // For image or other content types, prepend a text block
+    return {
+        ...result,
+        content: [
+            { type: "text", text: prefix },
+            ...content,
+        ],
+    };
+}
+/**
+ * Enrich a JSON text result with token info (accessLevel + scopes).
+ */
+function enrichResultWithTokenInfo(result, info) {
+    const first = result.content?.[0];
+    if (!first || first.type !== "text")
+        return result;
+    try {
+        const parsed = JSON.parse(first.text);
+        parsed.accessLevel = info.grantedAccessLevel;
+        parsed.scopes = info.grantedScopes;
+        return {
+            ...result,
+            content: [{ ...first, text: JSON.stringify(parsed, null, 2) }, ...result.content.slice(1)],
+        };
+    }
+    catch {
+        return result;
+    }
+}
+/**
+ * Prepend a token revocation warning to the result.
+ */
+function enrichResultWithTokenStatus(result, nickname) {
+    const warning = `Roam graph: ${nickname}\n\n` +
+        `WARNING: The token for this graph has been revoked.\n` +
+        `Call setup_new_graph with this graph's name to request a new token.\n`;
+    const first = result.content?.[0];
+    if (first?.type === "text") {
+        return {
+            ...result,
+            content: [{ ...first, text: warning + "\n" + first.text }, ...result.content.slice(1)],
+        };
+    }
+    return {
+        ...result,
+        content: [{ type: "text", text: warning }, ...(result.content || [])],
+    };
+}
+/**
+ * Convert a RoamError into a structured error result with isError: true.
+ */
+function roamErrorResult(error) {
+    const errorPayload = {
+        error: {
+            code: error.code,
+            message: error.message,
+            ...(error.context || {}),
+        },
+    };
+    return {
+        content: [{ type: "text", text: JSON.stringify(errorPayload, null, 2) }],
+        isError: true,
+    };
+}
+export async function routeToolCall(toolName, args) {
+    const tool = findTool(toolName);
+    if (!tool) {
+        throw new Error(`Unknown tool: ${toolName}`);
+    }
+    // Validate and parse args with Zod
+    const parsed = tool.schema.safeParse(args);
+    if (!parsed.success) {
+        throw new Error(`Invalid arguments: ${parsed.error.message}`);
+    }
+    // Handle standalone tools (graph management)
+    if (tool.type === "standalone") {
+        try {
+            return await tool.action(parsed.data);
+        }
+        catch (error) {
+            if (error instanceof RoamError) {
+                return roamErrorResult(error);
+            }
+            throw error;
+        }
+    }
+    // Handle client tools (require graph resolution)
+    try {
+        // Extract graph from validated args and resolve it
+        const { graph, ...restArgs } = parsed.data;
+        const resolvedGraph = await resolveGraph(graph);
+        const port = await getPort();
+        // Create client with full config
+        const client = new RoamClient({
+            graphName: resolvedGraph.name,
+            graphType: resolvedGraph.type,
+            token: resolvedGraph.token,
+            port,
+        });
+        // Special handling for get_graph_guidelines: sync token info in parallel
+        if (tool.name === "get_graph_guidelines") {
+            const [actionSettled, tokenInfoSettled] = await Promise.allSettled([
+                tool.action(client, restArgs),
+                client.getTokenInfo(),
+            ]);
+            // getTokenInfo() never throws, so always fulfilled
+            const tokenInfoResult = tokenInfoSettled.status === "fulfilled"
+                ? tokenInfoSettled.value
+                : { status: "unknown" };
+            // Handle revoked token FIRST (before examining action result)
+            if (tokenInfoResult.status === "revoked") {
+                if (resolvedGraph.lastKnownTokenStatus !== "revoked") {
+                    try {
+                        await updateGraphTokenStatus(resolvedGraph.nickname, { lastKnownTokenStatus: "revoked" });
+                    }
+                    catch { }
+                }
+                const baseResult = actionSettled.status === "fulfilled"
+                    ? actionSettled.value
+                    : actionSettled.reason instanceof RoamError
+                        ? roamErrorResult(actionSettled.reason)
+                        : { content: [{ type: "text", text: String(actionSettled.reason) }], isError: true };
+                return enrichResultWithTokenStatus(baseResult, resolvedGraph.nickname);
+            }
+            // Not revoked — if action failed, propagate the original error
+            if (actionSettled.status === "rejected") {
+                throw actionSettled.reason;
+            }
+            const result = actionSettled.value;
+            if (tokenInfoResult.status === "active") {
+                const info = tokenInfoResult.info;
+                // Validate access level before writing to prevent config corruption
+                const validLevels = ["read-only", "read-append", "full"];
+                const level = validLevels.includes(info.grantedAccessLevel)
+                    ? info.grantedAccessLevel
+                    : undefined;
+                // Only write to config if something actually changed
+                const accessLevelChanged = level && resolvedGraph.accessLevel !== level;
+                const tokenStatusChanged = resolvedGraph.lastKnownTokenStatus !== "active";
+                if (accessLevelChanged || tokenStatusChanged) {
+                    try {
+                        await updateGraphTokenStatus(resolvedGraph.nickname, {
+                            ...(accessLevelChanged ? { accessLevel: level } : {}),
+                            lastKnownTokenStatus: "active",
+                        });
+                    }
+                    catch { }
+                }
+                if (!result.isError) {
+                    const enriched = enrichResultWithTokenInfo(result, info);
+                    return prependGraphInfo(enriched, resolvedGraph.nickname);
+                }
+                return result;
+            }
+            // status === "unknown" — action succeeded, so token isn't revoked; clear stale status
+            if (resolvedGraph.lastKnownTokenStatus !== "active") {
+                try {
+                    await updateGraphTokenStatus(resolvedGraph.nickname, { lastKnownTokenStatus: "active" });
+                }
+                catch { }
+            }
+            if (!result.isError) {
+                return prependGraphInfo(result, resolvedGraph.nickname);
+            }
+            return result;
+        }
+        // Normal flow for all other tools
+        const result = await tool.action(client, restArgs);
+        // Prepend graph info to successful responses
+        if (!result.isError) {
+            return prependGraphInfo(result, resolvedGraph.nickname);
+        }
+        return result;
+    }
+    catch (error) {
+        if (error instanceof RoamError) {
+            return roamErrorResult(error);
+        }
+        throw error;
+    }
+}