@gtkx/mcp 0.21.0 → 1.0.0-rc.1

package/src/protocol/errors.ts

@@ -1,61 +1,32 @@
-/**
- * Error codes for MCP protocol errors.
- */
-export enum McpErrorCode {
-    /** Internal server error */
-    INTERNAL_ERROR = 1000,
-    /** No GTKX application is connected */
-    NO_APP_CONNECTED = 1001,
-    /** Requested application ID was not found */
-    APP_NOT_FOUND = 1002,
-    /** Widget with specified ID was not found */
-    WIDGET_NOT_FOUND = 1003,
-    /** Widget cannot be interacted with */
-    WIDGET_NOT_INTERACTABLE = 1004,
-    /** Query timed out waiting for widget */
-    QUERY_TIMEOUT = 1005,
-    /** Widget is not the expected type */
-    INVALID_WIDGET_TYPE = 1006,
-    /** Screenshot capture failed */
-    SCREENSHOT_FAILED = 1007,
-    /** IPC request timed out */
-    IPC_TIMEOUT = 1008,
-    /** Failed to serialize data */
-    SERIALIZATION_ERROR = 1009,
-    /** Request format is invalid */
-    INVALID_REQUEST = 1010,
-    /** Requested method does not exist */
-    METHOD_NOT_FOUND = 1011,
+export const ErrorCode = {
+    INTERNAL_ERROR: 1000,
+    NO_APP_CONNECTED: 1001,
+    APP_NOT_FOUND: 1002,
+    WIDGET_NOT_FOUND: 1003,
+    CONNECTION_WRITE_FAILED: 1004,
+    REQUEST_TIMEOUT: 1005,
+    INVALID_REQUEST: 1006,
+    METHOD_NOT_FOUND: 1007,
+} as const;
+
+export type ErrorCode = (typeof ErrorCode)[keyof typeof ErrorCode];
+
+export function isErrorCode(code: number): code is ErrorCode {
+    return (Object.values(ErrorCode) as number[]).includes(code);
 }
 
-/**
- * Error class for MCP protocol errors.
- *
- * Contains an error code, message, and optional additional data.
- */
-export class McpError extends Error {
-    /** The MCP error code */
-    readonly code: McpErrorCode;
-    /** Additional error context */
-    readonly data?: unknown;
+export class ProtocolError extends Error {
+    code: ErrorCode;
+    data?: unknown;
 
-    constructor(code: McpErrorCode, message: string, data?: unknown) {
+    constructor(code: ErrorCode, message: string, data?: unknown) {
         super(message);
         this.code = code;
         this.data = data;
-        this.name = "McpError";
-
-        if (Error.captureStackTrace) {
-            Error.captureStackTrace(this, McpError);
-        }
+        this.name = "ProtocolError";
     }
 
-    /**
-     * Converts the error to an IPC-compatible format.
-     *
-     * @returns Object suitable for IPC response error field
-     */
-    toIpcError(): { code: number; message: string; data?: unknown } {
+    toErrorObject(): { code: number; message: string; data?: unknown } {
         return {
             code: this.code,
             message: this.message,
@@ -64,65 +35,38 @@ export class McpError extends Error {
     }
 }
 
-/**
- * Creates an error for when no GTKX application is connected.
- *
- * @returns McpError with NO_APP_CONNECTED code
- */
-export function noAppConnectedError(): McpError {
-    return new McpError(
-        McpErrorCode.NO_APP_CONNECTED,
+export function noAppConnectedError(): ProtocolError {
+    return new ProtocolError(
+        ErrorCode.NO_APP_CONNECTED,
         "No GTKX application connected: start an app with 'gtkx dev' to connect",
-        { hint: "Run 'gtkx dev src/app.tsx' in your project directory" },
+        { hint: "Run 'gtkx dev' in your project directory" },
     );
 }
 
-/**
- * Creates an error for when a requested app is not found.
- *
- * @param appId - The application ID that was not found
- * @returns McpError with APP_NOT_FOUND code
- */
-export function appNotFoundError(appId: string): McpError {
-    return new McpError(McpErrorCode.APP_NOT_FOUND, `Application '${appId}' not found`, { appId });
+export function appNotFoundError(applicationId: string): ProtocolError {
+    return new ProtocolError(ErrorCode.APP_NOT_FOUND, `Application '${applicationId}' not found`, { applicationId });
+}
+
+export function connectionWriteFailedError(applicationId: string): ProtocolError {
+    return new ProtocolError(
+        ErrorCode.CONNECTION_WRITE_FAILED,
+        `Connection to application '${applicationId}' is no longer writable`,
+        { applicationId },
+    );
 }
 
-/**
- * Creates an error for when a widget is not found.
- *
- * @param widgetId - The widget ID that was not found
- * @returns McpError with WIDGET_NOT_FOUND code
- */
-export function widgetNotFoundError(widgetId: string): McpError {
-    return new McpError(McpErrorCode.WIDGET_NOT_FOUND, `Widget '${widgetId}' not found`, { widgetId });
+export function widgetNotFoundError(widgetId: string): ProtocolError {
+    return new ProtocolError(ErrorCode.WIDGET_NOT_FOUND, `Widget '${widgetId}' not found`, { widgetId });
 }
 
-/**
- * Creates an error for when an IPC request times out.
- *
- * @param timeout - The timeout duration in milliseconds
- * @returns McpError with IPC_TIMEOUT code
- */
-export function ipcTimeoutError(timeout: number): McpError {
-    return new McpError(McpErrorCode.IPC_TIMEOUT, `IPC request timed out after ${timeout}ms`, { timeout });
+export function requestTimeoutError(timeout: number): ProtocolError {
+    return new ProtocolError(ErrorCode.REQUEST_TIMEOUT, `Request timed out after ${timeout}ms`, { timeout });
 }
 
-/**
- * Creates an error for invalid request format.
- *
- * @param reason - Description of why the request is invalid
- * @returns McpError with INVALID_REQUEST code
- */
-export function invalidRequestError(reason: string): McpError {
-    return new McpError(McpErrorCode.INVALID_REQUEST, `Invalid request: ${reason}`, { reason });
+export function invalidRequestError(reason: string): ProtocolError {
+    return new ProtocolError(ErrorCode.INVALID_REQUEST, `Invalid request: ${reason}`, { reason });
 }
 
-/**
- * Creates an error for when a method is not found.
- *
- * @param method - The method name that was not found
- * @returns McpError with METHOD_NOT_FOUND code
- */
-export function methodNotFoundError(method: string): McpError {
-    return new McpError(McpErrorCode.METHOD_NOT_FOUND, `Method '${method}' not found`, { method });
+export function methodNotFoundError(method: string): ProtocolError {
+    return new ProtocolError(ErrorCode.METHOD_NOT_FOUND, `Method '${method}' not found`, { method });
 }

package/src/protocol/schemas.ts

@@ -0,0 +1,148 @@
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { z } from "zod";
+
+export const RequestSchema: z.ZodObject<
+    {
+        id: z.ZodString;
+        method: z.ZodString;
+        params: z.ZodOptional<z.ZodUnknown>;
+    },
+    z.core.$strip
+> = z.object({
+    id: z.string(),
+    method: z.string(),
+    params: z.unknown().optional(),
+});
+
+export type Request = z.infer<typeof RequestSchema>;
+
+const ErrorSchema: z.ZodObject<
+    { code: z.ZodNumber; message: z.ZodString; data: z.ZodOptional<z.ZodUnknown> },
+    z.core.$strip
+> = z.object({
+    code: z.number(),
+    message: z.string(),
+    data: z.unknown().optional(),
+});
+
+export const ResponseSchema: z.ZodObject<
+    {
+        id: z.ZodString;
+        result: z.ZodOptional<z.ZodUnknown>;
+        error: z.ZodOptional<typeof ErrorSchema>;
+    },
+    z.core.$strip
+> = z.object({
+    id: z.string(),
+    result: z.unknown().optional(),
+    error: ErrorSchema.optional(),
+});
+
+export type Response = z.infer<typeof ResponseSchema>;
+
+export type SerializedWidget = {
+    id: string;
+    type: string;
+    role: string;
+    name: string | null;
+    text: string | null;
+    sensitive: boolean;
+    visible: boolean;
+    cssClasses: string[];
+    children: SerializedWidget[];
+};
+
+export type AppInfo = {
+    applicationId: string;
+    pid: number;
+    projectRoot?: string;
+};
+
+export const RegisterParamsSchema: z.ZodObject<
+    {
+        applicationId: z.ZodString;
+        pid: z.ZodNumber;
+        projectRoot: z.ZodOptional<z.ZodString>;
+    },
+    z.core.$strip
+> = z.object({
+    applicationId: z.string(),
+    pid: z.number(),
+    projectRoot: z.string().optional(),
+});
+
+const emptyParams: z.ZodObject<Record<string, never>, z.core.$strip> = z.object({});
+export const widgetIdParams: z.ZodObject<{ widgetId: z.ZodString }, z.core.$strip> = z.object({
+    widgetId: z.string(),
+});
+export const queryOptionsSchema: z.ZodObject<
+    { name: z.ZodOptional<z.ZodString>; exact: z.ZodOptional<z.ZodBoolean>; timeout: z.ZodOptional<z.ZodNumber> },
+    z.core.$strip
+> = z.object({
+    name: z.string().optional(),
+    exact: z.boolean().optional(),
+    timeout: z.number().optional(),
+});
+
+export const queryParams: z.ZodObject<
+    {
+        by: z.ZodEnum<{ role: "role"; text: "text"; name: "name"; labelText: "labelText" }>;
+        value: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+        options: z.ZodOptional<typeof queryOptionsSchema>;
+    },
+    z.core.$strip
+> = z.object({
+    by: z.enum(["role", "text", "name", "labelText"]),
+    value: z.union([z.string(), z.number()]),
+    options: queryOptionsSchema.optional(),
+});
+export const typeParams: z.ZodObject<
+    { widgetId: z.ZodString; text: z.ZodString; clear: z.ZodOptional<z.ZodBoolean> },
+    z.core.$strip
+> = z.object({ widgetId: z.string(), text: z.string(), clear: z.boolean().optional() });
+export const fireEventParams: z.ZodObject<
+    { widgetId: z.ZodString; signal: z.ZodString; args: z.ZodOptional<z.ZodArray<z.ZodUnknown>> },
+    z.core.$strip
+> = z.object({ widgetId: z.string(), signal: z.string(), args: z.array(z.unknown()).optional() });
+export const screenshotParams: z.ZodObject<
+    { windowId: z.ZodOptional<z.ZodString>; path: z.ZodOptional<z.ZodString> },
+    z.core.$strip
+> = z.object({
+    windowId: z.string().optional(),
+    path: z.string().optional(),
+});
+
+export const ServerRequestParamsSchemas: {
+    "app.getWindows": typeof emptyParams;
+    "widget.getTree": typeof emptyParams;
+    "widget.query": typeof queryParams;
+    "widget.getProps": typeof widgetIdParams;
+    "widget.click": typeof widgetIdParams;
+    "widget.type": typeof typeParams;
+    "widget.fireEvent": typeof fireEventParams;
+    "widget.screenshot": typeof screenshotParams;
+} = {
+    "app.getWindows": emptyParams,
+    "widget.getTree": emptyParams,
+    "widget.query": queryParams,
+    "widget.getProps": widgetIdParams,
+    "widget.click": widgetIdParams,
+    "widget.type": typeParams,
+    "widget.fireEvent": fireEventParams,
+    "widget.screenshot": screenshotParams,
+};
+
+export type ServerRequestParams<Method extends keyof typeof ServerRequestParamsSchemas> = z.infer<
+    (typeof ServerRequestParamsSchemas)[Method]
+>;
+
+export type ParamsSchema<Output> = z.ZodType<Output>;
+
+export type ServerInitiatedMethod = keyof typeof ServerRequestParamsSchemas;
+
+export type Message = Request | Response;
+
+const getRuntimeDir = (): string => process.env.XDG_RUNTIME_DIR ?? tmpdir();
+
+export const DEFAULT_SOCKET_PATH: string = join(getRuntimeDir(), "gtkx-mcp.sock");

package/src/reference.ts

@@ -0,0 +1,340 @@
+import { statSync } from "node:fs";
+import { resolve } from "node:path";
+import { type ApiReference, type ApiSymbol, loadApiReference, resolveGirPath, resolveLibraries } from "@gtkx/codegen";
+import { loadConfig } from "@gtkx/config";
+import { type McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { ErrorCode, McpError, type ReadResourceResult } from "@modelcontextprotocol/sdk/types.js";
+import { z } from "zod";
+import { defineTool, type Tool, textContent, textError } from "./tool.js";
+
+export type ReferenceApi = Pick<
+    ApiReference,
+    "lookup" | "namespaceOverview" | "namespaces" | "overview" | "search" | "symbolNames"
+>;
+
+export type ReferenceProvider = {
+    get(): Promise<ReferenceApi>;
+};
+
+type WatchedFile = {
+    path: string;
+    mtimeMs: number;
+    size: number;
+};
+
+type LoadedReference = {
+    reference: ApiReference;
+    watched: WatchedFile[];
+};
+
+const watchFile = (path: string): WatchedFile => {
+    try {
+        const stats = statSync(path);
+        return { path, mtimeMs: stats.mtimeMs, size: stats.size };
+    } catch {
+        return { path, mtimeMs: -1, size: -1 };
+    }
+};
+
+const isFresh = (loaded: LoadedReference): boolean =>
+    loaded.watched.every((file) => {
+        const current = watchFile(file.path);
+        return current.mtimeMs === file.mtimeMs && current.size === file.size;
+    });
+
+const loadReference = async (root: string): Promise<LoadedReference> => {
+    const { config, configFile } = await loadConfig(root);
+    if (config.codegen === false) {
+        throw new Error(
+            `codegen is disabled for the project at ${root}, so there are no generated bindings to document. Remove \`codegen: false\` from gtkx.config.ts to use the API reference.`,
+        );
+    }
+    const girPath = resolveGirPath(config.girPath);
+    if (girPath.length === 0) {
+        throw new Error(
+            "No GIR search paths available. Install gobject-introspection (Linux: `sudo dnf install gobject-introspection-devel` or `sudo apt install libgirepository1.0-dev`), or set `girPath` in gtkx.config.ts.",
+        );
+    }
+    const libraries = resolveLibraries(config.libraries, girPath);
+    const reference = loadApiReference({ libraries, girPath, elementProps: config.elementProps ?? {} });
+    const watched = [
+        ...(configFile === undefined ? [] : [watchFile(resolve(root, configFile))]),
+        ...reference.girFiles.map(watchFile),
+    ];
+    return { reference, watched };
+};
+
+const FRESHNESS_INTERVAL_MS = 2000;
+const FAILURE_RETRY_MS = 5000;
+
+type CacheEntry = {
+    pending: Promise<LoadedReference>;
+    verifiedAt: number;
+    failedAt: number | undefined;
+};
+
+export const createReferenceProvider = (resolveRoot: () => string): ReferenceProvider => {
+    const cache = new Map<string, CacheEntry>();
+    const startLoad = (root: string): CacheEntry => {
+        const entry: CacheEntry = { pending: loadReference(root), verifiedAt: Date.now(), failedAt: undefined };
+        entry.pending.catch(() => {
+            entry.failedAt = Date.now();
+        });
+        cache.set(root, entry);
+        return entry;
+    };
+    return {
+        async get(): Promise<ReferenceApi> {
+            const root = resolve(resolveRoot());
+            let entry = cache.get(root) ?? startLoad(root);
+            if (entry.failedAt !== undefined && Date.now() - entry.failedAt >= FAILURE_RETRY_MS) {
+                entry = startLoad(root);
+            }
+            const loaded = await entry.pending;
+            if (Date.now() - entry.verifiedAt < FRESHNESS_INTERVAL_MS) return loaded.reference;
+            if (isFresh(loaded)) {
+                entry.verifiedAt = Date.now();
+                return loaded.reference;
+            }
+            const current = cache.get(root);
+            const replacement = current === undefined || current === entry ? startLoad(root) : current;
+            return (await replacement.pending).reference;
+        },
+    };
+};
+
+const SYMBOL_KIND = z.enum([
+    "element",
+    "class",
+    "interface",
+    "record",
+    "enum",
+    "callback",
+    "alias",
+    "function",
+    "constant",
+]);
+
+const SYMBOL_DESCRIPTION =
+    "Qualified symbol name (`Gtk.Button`, `Gtk.Orientation`, `GLib.idleAdd`), JSX element name (`GtkButton`), or bare symbol name when unambiguous (`Button`).";
+
+const listApiShape = {
+    namespace: z
+        .string()
+        .optional()
+        .describe("Namespace to list (e.g. `Gtk`, `Adw`, `Gio`). Omit for an overview of all namespaces."),
+};
+
+const searchApiShape = {
+    query: z.string().describe("Case-insensitive substring of a symbol name, e.g. `headerbar` or `orientation`."),
+    namespace: z.string().optional().describe("Restrict matches to one namespace (e.g. `Gtk`)."),
+    kind: SYMBOL_KIND.optional().describe("Restrict matches to one symbol kind."),
+    limit: z.number().int().min(1).optional().describe("Maximum number of results (default: 20)."),
+};
+
+const getApiDocsShape = {
+    symbol: z.string().describe(SYMBOL_DESCRIPTION),
+    kind: SYMBOL_KIND.optional().describe("Disambiguate when several kinds share the symbol name."),
+};
+
+const formatCandidates = (candidates: ApiSymbol[]): string =>
+    candidates.map((candidate) => `- ${candidate.namespace}.${candidate.name} (${candidate.kind})`).join("\n");
+
+const listApiTool = (provider: ReferenceProvider): Tool =>
+    defineTool({
+        name: "gtkx_list_api",
+        title: "List API reference",
+        kind: "readOnly",
+        description:
+            "List the project's generated GTK4 bindings API (`@gtkx/gi` and `@gtkx/jsx`). Without a namespace, returns every namespace with symbol counts; with a namespace, lists all of its symbols grouped by kind.",
+        inputSchema: listApiShape,
+        handler: async ({ namespace }) => {
+            const reference = await provider.get();
+            if (namespace === undefined) return textContent(reference.overview());
+            const overview = reference.namespaceOverview(namespace);
+            if (overview === undefined) {
+                const names = reference
+                    .namespaces()
+                    .map((summary) => summary.name)
+                    .join(", ");
+                return textError(`Unknown namespace "${namespace}". Available namespaces: ${names}`);
+            }
+            return textContent(overview);
+        },
+    });
+
+const searchApiTool = (provider: ReferenceProvider): Tool =>
+    defineTool({
+        name: "gtkx_search_api",
+        title: "Search API reference",
+        kind: "readOnly",
+        description:
+            "Search the project's generated GTK4 bindings API by symbol name. Returns matching symbols with their namespace, kind, and a one-line summary; fetch full pages with `gtkx_get_api_docs`.",
+        inputSchema: searchApiShape,
+        handler: async ({ query, namespace, kind, limit }) => {
+            const reference = await provider.get();
+            const results = reference.search({
+                query,
+                ...(namespace === undefined ? {} : { namespace }),
+                ...(kind === undefined ? {} : { kinds: [kind] }),
+                ...(limit === undefined ? {} : { limit }),
+            });
+            if (results.length === 0) {
+                return textContent(`No symbols matched "${query}". Try a shorter substring or \`gtkx_list_api\`.`);
+            }
+            return textContent(JSON.stringify(results, null, 2));
+        },
+    });
+
+const getApiDocsTool = (provider: ReferenceProvider): Tool =>
+    defineTool({
+        name: "gtkx_get_api_docs",
+        title: "Get API docs",
+        kind: "readOnly",
+        description:
+            "Get the full reference page for one symbol of the project's generated GTK4 bindings: JSX elements (props, signals, methods) or `@gtkx/gi` classes, interfaces, records, enums, callbacks, aliases, functions, and constants.",
+        inputSchema: getApiDocsShape,
+        handler: async ({ symbol, kind }) => {
+            const reference = await provider.get();
+            const result = reference.lookup(symbol, kind);
+            if (result.outcome === "notFound") {
+                return textError(`No symbol named "${symbol}". Use \`gtkx_search_api\` to find the right name.`);
+            }
+            if (result.outcome === "ambiguous") {
+                return textError(
+                    `"${symbol}" matches several symbols. Pass a qualified name or a kind:\n${formatCandidates(result.candidates)}`,
+                );
+            }
+            return textContent(result.markdown);
+        },
+    });
+
+export const buildReferenceTools = (provider: ReferenceProvider): Tool[] => [
+    listApiTool(provider),
+    searchApiTool(provider),
+    getApiDocsTool(provider),
+];
+
+const markdownResource = (uri: URL, text: string): ReadResourceResult => ({
+    contents: [{ uri: uri.href, mimeType: "text/markdown", text }],
+});
+
+const variableValue = (value: string | string[] | undefined): string =>
+    Array.isArray(value) ? (value[0] ?? "") : (value ?? "");
+
+type ResourceServer = Pick<McpServer, "registerResource">;
+
+const swallowLoadFailure =
+    <T>(fallback: T) =>
+    (): T =>
+        fallback;
+
+const namespaceCompleter =
+    (provider: ReferenceProvider) =>
+    (value: string): Promise<string[]> =>
+        provider
+            .get()
+            .then((reference) =>
+                reference
+                    .namespaces()
+                    .map((summary) => summary.name)
+                    .filter((name) => name.toLowerCase().startsWith(value.toLowerCase())),
+            )
+            .catch(swallowLoadFailure<string[]>([]));
+
+const resourceNotFound = (message: string): McpError => new McpError(ErrorCode.InvalidParams, message);
+
+const registerIndexResource = (server: ResourceServer, provider: ReferenceProvider): void => {
+    server.registerResource(
+        "gtkx-api-reference",
+        "gtkx://reference/index",
+        {
+            title: "GTKX API reference index",
+            description: "Namespaces of the project's generated GTK4 bindings, with symbol and JSX element counts.",
+            mimeType: "text/markdown",
+        },
+        async (uri) => markdownResource(uri, (await provider.get()).overview()),
+    );
+};
+
+const registerNamespaceResource = (server: ResourceServer, provider: ReferenceProvider): void => {
+    server.registerResource(
+        "gtkx-api-namespace",
+        new ResourceTemplate("gtkx://reference/{namespace}", {
+            list: () =>
+                provider
+                    .get()
+                    .then((reference) => ({
+                        resources: reference.namespaces().map((summary) => ({
+                            uri: `gtkx://reference/${summary.name}`,
+                            name: `${summary.name} namespace reference`,
+                            mimeType: "text/markdown",
+                        })),
+                    }))
+                    .catch(swallowLoadFailure({ resources: [] })),
+            complete: {
+                namespace: namespaceCompleter(provider),
+            },
+        }),
+        {
+            title: "GTKX namespace reference",
+            description: "All symbols of one namespace of the project's generated GTK4 bindings, grouped by kind.",
+            mimeType: "text/markdown",
+        },
+        async (uri, variables) => {
+            const namespace = variableValue(variables.namespace);
+            const overview = (await provider.get()).namespaceOverview(namespace);
+            if (overview === undefined) throw resourceNotFound(`Unknown namespace "${namespace}"`);
+            return markdownResource(uri, overview);
+        },
+    );
+};
+
+const registerSymbolResource = (server: ResourceServer, provider: ReferenceProvider): void => {
+    server.registerResource(
+        "gtkx-api-symbol",
+        new ResourceTemplate("gtkx://reference/{namespace}/{symbol}", {
+            list: undefined,
+            complete: {
+                namespace: namespaceCompleter(provider),
+                symbol: (value, context) => {
+                    const namespace = variableValue(context?.arguments?.namespace);
+                    if (namespace.length === 0) return [];
+                    return provider
+                        .get()
+                        .then((reference) =>
+                            reference
+                                .symbolNames(namespace)
+                                .filter((name) => name.toLowerCase().startsWith(value.toLowerCase())),
+                        )
+                        .catch(swallowLoadFailure<string[]>([]));
+                },
+            },
+        }),
+        {
+            title: "GTKX symbol reference",
+            description:
+                "Reference page for one symbol of the project's generated GTK4 bindings: a JSX element or a class, interface, record, enum, callback, alias, function, or constant.",
+            mimeType: "text/markdown",
+        },
+        async (uri, variables) => {
+            const namespace = variableValue(variables.namespace);
+            const symbol = variableValue(variables.symbol);
+            const reference = await provider.get();
+            const result = reference.lookup(`${namespace}.${symbol}`);
+            if (result.outcome === "page") return markdownResource(uri, result.markdown);
+            if (result.outcome === "ambiguous") {
+                throw resourceNotFound(
+                    `"${namespace}.${symbol}" matches several symbols:\n${formatCandidates(result.candidates)}`,
+                );
+            }
+            throw resourceNotFound(`No symbol named "${namespace}.${symbol}"`);
+        },
+    );
+};
+
+export const registerReferenceResources = (server: ResourceServer, provider: ReferenceProvider): void => {
+    registerIndexResource(server, provider);
+    registerNamespaceResource(server, provider);
+    registerSymbolResource(server, provider);
+};