@nyuchi/mzizi-mcp 0.6.0 → 0.7.0

package/dist/server.js

@@ -1,457 +1,32 @@
 /**
- * Mzizi MCP — registry-driven server factory.
+ * The Mzizi MCP server.
  *
- * The tool surface is NOT hardcoded. It is read at startup from the public
- * `mcp_tool_registry` table (the same registry that powers the design system's
- * MCP), and each tool is dispatched dynamically to its backing implementation:
+ * Backed by `mzizi.dev/api/v1` over HTTP. There is no Supabase client here.
  *
- *   • `sql_function`  → `supabase.rpc(fn, args)`   (the common case)
- *   • `edge_function` → `supabase.functions.invoke(fn, { body: args })`
- *   • `source_table`  → `supabase.from(table).select()` (fallback)
+ * WHAT CHANGED AND WHY. This server used to build its tool catalog at startup from the
+ * `mcp_tool_registry` table and dispatch each call to a Supabase RPC, edge function or
+ * table read — 62 enabled tools, defined as data. Two things were wrong with that:
  *
- * This makes mzizi-mcp a drop-in replacement for the legacy design MCP: adding,
- * renaming, or retiring a tool is a registry edit, not a code change. Argument
- * names in the registry's `input_schema` (and in the curated fallback schemas
- * below) match the SQL function parameters exactly, so arguments pass straight
- * through to `rpc()` with no remapping.
+ *   1. Components are not rows. They are real files in `nyuchi/mzizi` that the Next.js
+ *      app compiles and typechecks, so an error in one fails the build. The app serves
+ *      them over `/api/v1/*`, which makes that API the source of truth and this server
+ *      one of its clients. Reading the database put a second, uncompiled representation
+ *      in the path — one that could disagree with the code while still looking correct.
  *
- * The factory takes a pre-built `SupabaseClient` so the same factory works
- * across transports (HTTP per-request anon client; stdio long-lived anon
- * client). RLS grants public read on `mcp_tool_registry`, `component_documents`,
- * and EXECUTE on the document/registry RPCs.
- */
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
-import { FUNDI_A2A_TOOLS, dispatchFundiA2A, isFundiA2AToolName, } from "./fundi-a2a.js";
-import { jsonContent, toolError } from "./tool-result.js";
-export const MZIZI_MCP_VERSION = "0.6.0";
-/**
- * Every tool this server exposes is prefixed with `mzizi_` so the surface is
- * unambiguous when mounted alongside other MCP servers (see the mcp-builder
- * "service prefix" guideline). The prefix is applied at the boundary only:
- * registry rows, core-tool dispatch, and the backing SQL/edge/table names all
- * stay unprefixed, and the CallTool handler strips the prefix before dispatch.
- */
-const TOOL_PREFIX = "mzizi_";
-/** Human-readable title from a (possibly prefixed) tool name: `get_component` → "Get component". */
-function titleFor(name) {
-    const words = name
-        .replace(new RegExp(`^${TOOL_PREFIX}`), "")
-        .replace(/_/g, " ")
-        .trim();
-    return words.charAt(0).toUpperCase() + words.slice(1);
-}
-const READ_ONLY_HINTS = {
-    readOnlyHint: true,
-    destructiveHint: false,
-    idempotentHint: true,
-    openWorldHint: false,
-};
-/**
- * Defaults for a mutating tool: not read-only, but append-only (never deletes
- * or overwrites → `destructiveHint` false) and not idempotent (each call makes
- * a new row). Also the fallback for `action`-kind tools, which run/compute
- * something and are likewise neither read-only nor idempotent.
- */
-const WRITE_HINTS = {
-    readOnlyHint: false,
-    destructiveHint: false,
-    idempotentHint: false,
-    openWorldHint: false,
-};
-/**
- * The only write-kind tools allowed onto the anonymous public surface: the
- * feedback sinks that either run SECURITY DEFINER (bypassing RLS safely) or
- * self-gate to an allow-list. Every other write stays off this surface and is
- * reached through an authenticated path (fundi worker / first-party caller).
- *   • submit_component_feedback — report a failing/misconfigured component (N9)
- *   • record_observability_event — structural error/perf beacon fundi watches
- *   • record_chaos_event — resilience-testing feedback (self-gates in prod)
- */
-const PUBLIC_WRITE_TOOLS = new Set([
-    "submit_component_feedback",
-    "record_observability_event",
-    "record_chaos_event",
-]);
-/**
- * Annotations for a CORE tool defined in this file (list_collections,
- * get_database_status, fundi_status, the registry-unavailable diagnostic).
- * These have no registry row, so their hints live here. Defaults to read-only;
- * pass overrides for the exceptions.
- */
-function annotationsFor(name, overrides = {}) {
-    return { title: titleFor(name), ...READ_ONLY_HINTS, ...overrides };
-}
-/**
- * Annotations for a registry-backed tool, read from the `mcp_tool_registry`
- * annotation columns — the single source of truth. Each column that is null
- * falls back to the per-`tool_kind` default (`read` → READ_ONLY_HINTS, anything
- * else → WRITE_HINTS), and `title` falls back to the derived `titleFor`. This
- * keeps the emitted annotations honest for every kind, including `action` tools
- * (which compute/run and are correctly NOT read-only), without hardcoding any
- * per-tool behaviour in the server.
- */
-function annotationsFromRow(row) {
-    const fallback = row.tool_kind === "read" ? READ_ONLY_HINTS : WRITE_HINTS;
-    const pick = (col, def) => col ?? def;
-    return {
-        title: row.title ?? titleFor(row.tool_name),
-        readOnlyHint: pick(row.read_only_hint, fallback.readOnlyHint),
-        destructiveHint: pick(row.destructive_hint, fallback.destructiveHint),
-        idempotentHint: pick(row.idempotent_hint, fallback.idempotentHint),
-        openWorldHint: pick(row.open_world_hint, fallback.openWorldHint),
-    };
-}
-/**
- * Namespaced `_meta` for a tool. The registry groups tools by `category`
- * (component, architecture, brand, skills, documents, release, a11y,
- * observability, fundi, …); surfacing it here lets clients organise the ~60
- * tools by function. The `mzizi.dev/` prefix keeps the key out of the reserved
- * `modelcontextprotocol.io/` namespace.
- */
-function metaFor(category) {
-    return { "mzizi.dev/category": category ?? "uncategorised" };
-}
-/**
- * The registry stores each tool's return shape as an already-enveloped JSON
- * Schema object: `{ type:"object", properties:{ <key>: … }, required:[<key>] }`
- * where `<key>` is `rows` for the array-returning `RETURNS TABLE` functions and
- * `result` for scalar/jsonb returns. MCP requires `outputSchema` (and the
- * matching `structuredContent`) to be an object, so the RPC's raw array/scalar
- * result is wrapped under that single key at dispatch time. Returns the schema
- * to emit plus the wrap key, or null when no usable shape is stored.
- */
-function emittedOutput(raw) {
-    if (!raw || typeof raw !== "object" || Array.isArray(raw))
-        return null;
-    if (raw["type"] !== "object")
-        return null;
-    const props = raw["properties"];
-    if (!props || typeof props !== "object")
-        return null;
-    const keys = Object.keys(props);
-    if (keys.length === 0)
-        return null;
-    const required = Array.isArray(raw["required"])
-        ? raw["required"]
-        : [];
-    const wrapKey = required[0] ?? keys[0];
-    if (!wrapKey)
-        return null;
-    return { outputSchema: raw, wrapKey };
-}
-const str = (description) => ({
-    type: ["string", "null"],
-    description,
-});
-const reqStr = (description) => ({ type: "string", description });
-const int = (description) => ({
-    type: ["integer", "null"],
-    description,
-});
-const bool = (description) => ({
-    type: ["boolean", "null"],
-    description,
-});
-const num = (description) => ({
-    type: ["number", "null"],
-    description,
-});
-/**
- * Curated input schemas for the parameterized tools whose registry
- * `input_schema` is not (yet) populated. Property names are the exact SQL
- * function parameter names so `rpc()` receives them unchanged. No-arg tools are
- * omitted — they fall back to an empty-object schema.
+ *   2. A tool surface defined in a table changes whenever someone edits a row: no diff,
+ *      no review, no test. The 10 tools live in `tools.ts` as code, so changing them is
+ *      a pull request.
  *
- * NEVER put a `maximum` on a node argument, and never name a range in its
- * description. Nodes are labels, not a sequence, and the set only ever grows
- * (N11 discovery already exists) — a ceiling silently hides every node above it
- * and has to be chased forever. An unknown node returning an empty set is the
- * correct answer; a validation error is not. Use NODE_ARG_DESCRIPTION so this
- * cannot drift back one property at a time.
- */
-const NODE_ARG_DESCRIPTION = "Ecosystem node number. Nodes are labels, not a sequence, and are never " +
-    "capped — read the documentation-architecture-nodes collection for the live set.";
-const INPUT_SCHEMAS = {
-    // component
-    get_component: {
-        type: "object",
-        properties: { p_name: reqStr("Component name, e.g. 'button'") },
-        required: ["p_name"],
-    },
-    get_component_history: {
-        type: "object",
-        properties: {
-            p_component_name: reqStr("Component name"),
-            p_limit: int("Max rows (default 20)"),
-        },
-        required: ["p_component_name"],
-    },
-    get_component_links: {
-        type: "object",
-        properties: { p_name: reqStr("Component name") },
-        required: ["p_name"],
-    },
-    list_components: {
-        type: "object",
-        properties: {
-            p_node: int(NODE_ARG_DESCRIPTION),
-            p_status: str("Status filter"),
-            p_category: str("Category filter"),
-            p_limit: int("Max rows (default 500)"),
-            p_offset: int("Offset"),
-        },
-    },
-    search_components: {
-        type: "object",
-        properties: {
-            p_query: reqStr("Search query"),
-            p_limit: int("Max rows (default 50)"),
-        },
-        required: ["p_query"],
-    },
-    get_node_categories: {
-        type: "object",
-        properties: { p_node: int(`${NODE_ARG_DESCRIPTION} Omit for all nodes.`) },
-    },
-    get_node_detail: {
-        type: "object",
-        properties: {
-            p_node: int(`${NODE_ARG_DESCRIPTION} Omit for a summary of every node.`),
-        },
-    },
-    // documents
-    get_node_documents: {
-        type: "object",
-        properties: {
-            p_node: int(NODE_ARG_DESCRIPTION),
-            p_collection: str("Collection key, e.g. 'agentic-components'"),
-            p_name: str("Exact document name"),
-            p_owner: str("Owner: bundu | mzizi | framework | nyuchi"),
-            p_limit: int("Max rows (default 1000)"),
-        },
-    },
-    // skills
-    get_skill: {
-        type: "object",
-        properties: { p_name: reqStr("Skill name") },
-        required: ["p_name"],
-    },
-    // ai
-    get_ai_instructions: {
-        type: "object",
-        properties: { p_name: reqStr("Target/instruction name, e.g. 'claude'") },
-        required: ["p_name"],
-    },
-    list_ai_instructions: {
-        type: "object",
-        properties: { p_target: str("Filter by target") },
-    },
-    // brand
-    get_brand_tokens: {
-        type: "object",
-        properties: { p_category: reqStr("Token category") },
-        required: ["p_category"],
-    },
-    list_ecosystem_brands: {
-        type: "object",
-        properties: { p_adopter_type: str("Adopter type filter") },
-    },
-    // governance
-    get_bundu_convention: {
-        type: "object",
-        properties: { p_slug: reqStr("Convention slug") },
-        required: ["p_slug"],
-    },
-    // release
-    get_changelog_entry: {
-        type: "object",
-        properties: { p_version: reqStr("Version, e.g. '7.0.0'") },
-        required: ["p_version"],
-    },
-    get_component_status_history: {
-        type: "object",
-        properties: { p_name: reqStr("Component name") },
-        required: ["p_name"],
-    },
-    get_release_with_diff: {
-        type: "object",
-        properties: { p_version: reqStr("Version") },
-        required: ["p_version"],
-    },
-    compute_release_diff: {
-        type: "object",
-        properties: {
-            p_since: reqStr("ISO timestamp (inclusive)"),
-            p_until: str("ISO timestamp (default now)"),
-        },
-        required: ["p_since"],
-    },
-    list_changelog: {
-        type: "object",
-        properties: {
-            p_limit: int("Max rows (default 50)"),
-            p_offset: int("Offset"),
-        },
-    },
-    list_tool_versions: {
-        type: "object",
-        properties: {
-            p_tool_name: reqStr("Tool name"),
-            p_limit: int("Max rows (default 20)"),
-        },
-        required: ["p_tool_name"],
-    },
-    // fundi (reads)
-    get_healing_log: {
-        type: "object",
-        properties: {
-            p_issue_id: int("Filter by issue id"),
-            p_limit: int("Max rows (default 100)"),
-        },
-    },
-    list_recent_fundi_issues: {
-        type: "object",
-        properties: {
-            p_status: str("Status filter"),
-            p_severity: str("Severity filter"),
-            p_limit: int("Max rows (default 50)"),
-        },
-    },
-    // resolver
-    resolve_primitive: {
-        type: "object",
-        properties: {
-            p_primitive_name: reqStr("Primitive name"),
-            p_descriptor_slug: reqStr("Framework descriptor slug, e.g. 'react'"),
-        },
-        required: ["p_primitive_name", "p_descriptor_slug"],
-    },
-    list_primitive_sources: {
-        type: "object",
-        properties: { p_primitive_name: reqStr("Primitive name") },
-        required: ["p_primitive_name"],
-    },
-    list_framework_descriptors: {
-        type: "object",
-        properties: { p_active_only: bool("Only active descriptors") },
-    },
-    // observability
-    is_domain_allowed: {
-        type: "object",
-        properties: {
-            p_domain: reqStr("Domain"),
-            p_feature: str("Feature (default 'portal_links')"),
-        },
-        required: ["p_domain"],
-    },
-    list_observability_domains: {
-        type: "object",
-        properties: { p_feature: str("Feature filter") },
-    },
-    list_observability_events: {
-        type: "object",
-        properties: {
-            p_domain: str("Domain filter"),
-            p_component_name: str("Component filter"),
-            p_event_type: str("Event-type filter"),
-            p_limit: int("Max rows (default 100)"),
-        },
-    },
-    // chaos (read)
-    list_chaos_events: {
-        type: "object",
-        properties: {
-            p_domain: str("Domain filter"),
-            p_environment: str("Environment filter"),
-            p_event_type: str("Event-type filter"),
-            p_limit: int("Max rows (default 100)"),
-        },
-    },
-    // a11y
-    calculate_contrast_ratio: {
-        type: "object",
-        properties: {
-            fg_hex: reqStr("Foreground hex, e.g. '#111111'"),
-            bg_hex: reqStr("Background hex, e.g. '#ffffff'"),
-        },
-        required: ["fg_hex", "bg_hex"],
-    },
-    relative_luminance: {
-        type: "object",
-        properties: { hex: reqStr("Hex colour") },
-        required: ["hex"],
-    },
-    simulate_color_blindness: {
-        type: "object",
-        properties: {
-            hex: reqStr("Hex colour"),
-            cb_type: reqStr("Type: protanopia | deuteranopia | tritanopia"),
-        },
-        required: ["hex", "cb_type"],
-    },
-    run_accessibility_audit: {
-        type: "object",
-        properties: {
-            p_file_fundi_issues: bool("File fundi issues for failures (default true)"),
-            p_contrast_floor: num("Minimum contrast ratio (default 3.0)"),
-        },
-    },
-    // meta
-    mcp_describe: {
-        type: "object",
-        properties: {
-            p_category: str("Filter by category"),
-            p_stability: str("Filter by stability"),
-            p_tool_kind: str("Filter by tool kind"),
-        },
-    },
-};
-const EMPTY_SCHEMA = { type: "object", properties: {} };
-/**
- * Fetch every `(collection, node, owner)` row from the document store, paging
- * past PostgREST's max-rows cap (1000 by default). The store holds >3k rows;
- * a single unpaged select silently truncates the aggregate — counts come back
- * wrong and whole collections (shell, safety, agentic-components, …) vanish
- * from the surface. Ordered by the `(collection, name)` primary key so pages
- * are stable.
+ * The 10 are specified in `docs/mcp-tool-consolidation.md` (mzizi repo). Each carries its
+ * `replaces` list in `TOOL_COVERAGE`, so coverage of the old 62 is checkable rather than
+ * asserted.
  */
-async function fetchCollectionRows(supabase) {
-    const rows = [];
-    const page = 1000;
-    for (let from = 0;; from += page) {
-        const { data, error } = await supabase
-            .from("component_documents")
-            .select("collection, node, owner")
-            .order("collection", { ascending: true })
-            .order("name", { ascending: true })
-            .range(from, from + page - 1);
-        if (error)
-            return { rows, error: error.message };
-        const batch = data ?? [];
-        rows.push(...batch);
-        if (batch.length < page)
-            return { rows, error: null };
-    }
-}
-function hasProperties(schema) {
-    const props = schema && schema.properties;
-    return (!!props &&
-        typeof props === "object" &&
-        Object.keys(props).length > 0);
-}
-function schemaFor(row) {
-    if (hasProperties(row.input_schema))
-        return row.input_schema;
-    return INPUT_SCHEMAS[row.tool_name] ?? EMPTY_SCHEMA;
-}
-/**
- * Build the Mzizi MCP server bound to a Supabase client with public read on
- * `mcp_tool_registry` / `component_documents` and EXECUTE on the backing RPCs.
- * The tool catalog is loaded from the registry; write-kind tools are excluded
- * from this (anonymous, public) surface.
- */
-export async function createMziziMcpServer(supabase, opts = {}) {
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { MziziApiClient } from "./api-client.js";
+import { registerMziziTools, TOOL_COVERAGE, TOOL_PREFIX } from "./tools.js";
+import { jsonContent } from "./tool-result.js";
+export const MZIZI_MCP_VERSION = "0.7.0";
+export async function createMziziMcpServer(opts = {}) {
     const server = new McpServer({
         name: "mzizi-mcp",
         version: MZIZI_MCP_VERSION,
@@ -461,271 +36,39 @@ export async function createMziziMcpServer(supabase, opts = {}) {
             tools: { listChanged: true },
             resources: { listChanged: true },
         },
-        instructions: "Read-only access to the Mzizi design-system registry (a nyuchi-brand project of the Bundu ecosystem): components, design tokens, brand, the ecosystem architecture nodes, Ubuntu doctrine, skills, releases, and the agentic-components surface. The tool surface is registry-driven — call mcp_describe to enumerate tools and categories, list_collections to see document collections, get_component / list_components / search_components for components, and get_node_documents for everything under an ecosystem node or collection.",
+        instructions: "Access to the Mzizi design system (a nyuchi-brand project of the Bundu ecosystem) over its public API: components, design tokens, brand, the DNA-helix architecture, Ubuntu doctrine, agent skills and releases. Ten tools. Start with mzizi_search if you do not know the name of what you want; mzizi_get_component returns a component in full in one read; mzizi_get_architecture returns the helix and takes an uncapped node number.",
     });
-    // ── Registry-driven tool catalog ───────────────────────────────────────────
-    const { data, error } = await supabase
-        .from("mcp_tool_registry")
-        .select("tool_name, description, category, tool_kind, sql_function, source_table, edge_function, input_schema, output_shape, requires_first_party, read_only_hint, destructive_hint, idempotent_hint, open_world_hint, title")
-        .eq("enabled", true);
-    if (error) {
-        // Surface the failure as a diagnostic tool rather than a silent empty server.
-        server.server.setRequestHandler(ListToolsRequestSchema, async () => ({
-            tools: [
-                {
-                    name: `${TOOL_PREFIX}registry_unavailable`,
-                    description: `The mcp_tool_registry could not be read: ${error.message}`,
-                    inputSchema: EMPTY_SCHEMA,
-                    annotations: annotationsFor("registry_unavailable"),
-                },
-            ],
-        }));
-        server.server.setRequestHandler(CallToolRequestSchema, async () => toolError(`mcp_tool_registry unavailable: ${error.message}`));
-        return server;
-    }
-    const rows = (data ?? []).filter((r) => !r.requires_first_party &&
-        (r.tool_kind !== "write" || PUBLIC_WRITE_TOOLS.has(r.tool_name)));
-    const byName = new Map(rows.map((r) => [r.tool_name, r]));
-    // Core document tools that are aggregates without an RPC, so they aren't
-    // registry-backed. Everything else is registry-driven.
-    const collectionsOutput = {
-        type: "object",
-        properties: {
-            rows: {
-                type: "array",
-                items: {
-                    type: "object",
-                    properties: {
-                        collection: { type: "string" },
-                        node: { type: ["integer", "null"] },
-                        total: { type: "integer" },
-                        byOwner: { type: "object" },
-                    },
-                },
+    const api = new MziziApiClient({ baseUrl: opts.apiBaseUrl, fetchImpl: opts.fetchImpl });
+    const registered = registerMziziTools(server, { api, fundi: opts.fundi });
+    const describe = () => ({
+        version: MZIZI_MCP_VERSION,
+        source: "https://mzizi.dev/api/v1",
+        note: "Components are files in nyuchi/mzizi compiled by the Next.js app and served over /api/v1. This server reads that API and holds no database credential.",
+        tools: registered.map((name) => ({
+            name: `${TOOL_PREFIX}${name}`,
+            replaces: TOOL_COVERAGE[name] ?? [],
+        })),
+    });
+    // Computed from what was actually registered, never a hand-maintained list — a
+    // hardcoded catalog is how the old registry drifted from the tools it described.
+    server.registerResource("mzizi-tools", "mzizi://tools", {
+        title: "Mzizi MCP tools",
+        description: "The tools this server exposes, and which legacy tools each replaces.",
+        mimeType: "application/json",
+    }, async (uri) => ({
+        contents: [
+            {
+                uri: uri.href,
+                mimeType: "application/json",
+                text: JSON.stringify(describe(), null, 2),
             },
-        },
-        required: ["rows"],
-    };
-    const databaseStatusOutput = {
-        type: "object",
-        properties: {
-            provider: { type: "string" },
-            status: { type: "string" },
-            error: { type: ["string", "null"] },
-            documents: { type: "integer" },
-            registryTools: { type: "integer" },
-            version: { type: "string" },
-            readOnly: { type: "boolean" },
-        },
-        required: ["provider", "status", "documents", "registryTools", "version"],
-    };
-    const coreTools = [
-        {
-            name: `${TOOL_PREFIX}list_collections`,
-            description: "List every collection in the Mzizi document store with document counts and per-owner breakdown (components, primitives, brand, agentic-components, skills, …).",
-            inputSchema: EMPTY_SCHEMA,
-            outputSchema: collectionsOutput,
-            annotations: annotationsFor("list_collections"),
-            _meta: metaFor("documents"),
-        },
-        {
-            name: `${TOOL_PREFIX}get_database_status`,
-            description: "Provider health, document-store row count, and registered-tool count.",
-            inputSchema: EMPTY_SCHEMA,
-            outputSchema: databaseStatusOutput,
-            annotations: annotationsFor("get_database_status"),
-            _meta: metaFor("system"),
-        },
-    ];
-    // fundi trigger — exposed only when this Worker is wired as a fundi caller
-    // (holds the M2M secret). fundi never runs in isolation: this routes the
-    // signed-in user's request to fundi with an M2M token + the user's token.
-    if (opts.fundi) {
-        coreTools.push({
-            name: `${TOOL_PREFIX}fundi_status`,
-            description: "Check fundi — the self-healing agent — on behalf of the signed-in user. fundi is machine-to-machine and only runs through an authenticated tool; this routes your request through mzizi-mcp, which holds the M2M credential.",
-            inputSchema: EMPTY_SCHEMA,
-            // Reaches the external fundi worker → open-world; still a read-only whoami.
-            annotations: annotationsFor("fundi_status", { openWorldHint: true }),
-            _meta: metaFor("fundi"),
-        });
-        // The A2A bridge (docs/a2a-fundi.md §4): delegate a run to fundi as a task
-        // and poll it. Same condition as fundi_status — a tool that always appears
-        // and always fails is worse than an absent one.
-        for (const def of FUNDI_A2A_TOOLS) {
-            coreTools.push({
-                name: `${TOOL_PREFIX}${def.name}`,
-                description: def.description,
-                inputSchema: def.inputSchema,
-                outputSchema: def.outputSchema,
-                annotations: annotationsFor(def.name, def.annotations),
-                _meta: metaFor(def.category),
-            });
-        }
-    }
-    const tools = [
-        ...rows.map((r) => {
-            const emitted = emittedOutput(r.output_shape);
-            return {
-                name: `${TOOL_PREFIX}${r.tool_name}`,
-                description: r.description ??
-                    `${r.category ?? "mzizi"} ${r.tool_kind ?? "read"} tool (registry-driven).`,
-                inputSchema: schemaFor(r),
-                ...(emitted
-                    ? {
-                        outputSchema: emitted.outputSchema,
-                    }
-                    : {}),
-                annotations: annotationsFromRow(r),
-                _meta: metaFor(r.category),
-            };
-        }),
-        ...coreTools,
-    ];
-    server.server.setRequestHandler(ListToolsRequestSchema, async () => ({
-        tools,
+        ],
     }));
-    server.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-        // Tools are exposed with the `mzizi_` prefix; strip it back to the internal
-        // (registry / core) name before dispatch. Tolerate an unprefixed call too.
-        const requested = request.params.name;
-        const name = requested.startsWith(TOOL_PREFIX)
-            ? requested.slice(TOOL_PREFIX.length)
-            : requested;
-        const args = (request.params.arguments ?? {});
-        // Core document tools (aggregates without an RPC).
-        if (name === "list_collections") {
-            const { rows, error } = await fetchCollectionRows(supabase);
-            if (error)
-                return toolError(`list_collections failed: ${error}`);
-            return jsonContent(summariseCollections(rows), "rows");
-        }
-        if (name === "get_database_status") {
-            const docs = await supabase
-                .from("component_documents")
-                .select("*", { count: "exact", head: true });
-            const toolsCount = await supabase
-                .from("mcp_tool_registry")
-                .select("*", { count: "exact", head: true })
-                .eq("enabled", true);
-            return jsonContent({
-                provider: "supabase",
-                status: docs.error ? "error" : "connected",
-                error: docs.error?.message,
-                documents: docs.count ?? 0,
-                registryTools: toolsCount.count ?? 0,
-                version: MZIZI_MCP_VERSION,
-                readOnly: true,
-            });
-        }
-        if (name === "fundi_status") {
-            if (!opts.fundi)
-                return toolError("fundi is not configured on this server");
-            const res = await opts.fundi.caller.call("/admin/whoami", opts.fundi.userAccessToken);
-            const body = await res.text();
-            if (!res.ok)
-                return toolError(`fundi call failed (${res.status}): ${body}`);
-            try {
-                return jsonContent(JSON.parse(body));
-            }
-            catch {
-                return jsonContent({ ok: true, raw: body });
-            }
-        }
-        if (isFundiA2AToolName(name)) {
-            if (!opts.fundi)
-                return toolError("fundi is not configured on this server");
-            return dispatchFundiA2A(name, args, opts.fundi);
-        }
-        const row = byName.get(name);
-        if (!row)
-            return toolError(`Unknown tool: ${name}`);
-        const wrapKey = emittedOutput(row.output_shape)?.wrapKey ?? null;
-        try {
-            if (row.sql_function) {
-                const fn = row.sql_function.replace(/^public\./, "");
-                const { data, error } = await supabase.rpc(fn, args);
-                if (error)
-                    return toolError(`${row.tool_name} failed: ${error.message}`);
-                return jsonContent(data, wrapKey);
-            }
-            if (row.edge_function) {
-                const { data, error } = await supabase.functions.invoke(row.edge_function, { body: args });
-                if (error)
-                    return toolError(`${row.tool_name} (edge) failed: ${error.message}`);
-                return jsonContent(data, wrapKey);
-            }
-            if (row.source_table) {
-                const { data, error } = await supabase
-                    .from(row.source_table)
-                    .select("*")
-                    .limit(200);
-                if (error)
-                    return toolError(`${row.tool_name} failed: ${error.message}`);
-                return jsonContent(data, wrapKey);
-            }
-            return toolError(`${row.tool_name} has no dispatch target in the registry.`);
-        }
-        catch (err) {
-            return toolError(`${row.tool_name} threw: ${err instanceof Error ? err.message : String(err)}`);
-        }
-    });
-    // ── Resources ──────────────────────────────────────────────────────────────
-    server.resource("collections", "mzizi://collections", {
-        description: "Index of every collection in the Mzizi document store with document counts and ownership breakdown.",
-    }, async () => {
-        const { rows } = await fetchCollectionRows(supabase);
-        return {
-            contents: [
-                {
-                    uri: "mzizi://collections",
-                    mimeType: "application/json",
-                    text: JSON.stringify(summariseCollections(rows), null, 2),
-                },
-            ],
-        };
-    });
-    server.resource("components", "mzizi://components", {
-        description: "Lean index of the `components` collection (name / node / owner / status). Full documents via the get_component tool.",
-    }, async () => {
-        const { data } = await supabase.rpc("read_documents", {
-            p_collection: "components",
-            p_limit: 1000,
-        });
-        const rows = data ?? [];
-        const lean = rows.map((row) => ({
-            name: row.name,
-            owner: row.owner,
-            node: row.document?.["node"] ?? null,
-            status: row.document?.["status"] ?? null,
-            description: row.document?.["description"] ?? null,
-        }));
-        return {
-            contents: [
-                {
-                    uri: "mzizi://components",
-                    mimeType: "application/json",
-                    text: JSON.stringify(lean, null, 2),
-                },
-            ],
-        };
-    });
+    server.registerTool(`${TOOL_PREFIX}mcp_describe`, {
+        title: "Describe this server",
+        description: "What this MCP server exposes: its tools, what each replaces, and where its data comes from.",
+        annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: false },
+    }, async () => jsonContent(describe()));
     return server;
 }
-/** Aggregate `(collection, node, owner)` rows into a per-collection summary. */
-function summariseCollections(rows) {
-    const summary = new Map();
-    for (const row of rows) {
-        const entry = summary.get(row.collection) ?? {
-            collection: row.collection,
-            node: row.node,
-            total: 0,
-            byOwner: {},
-        };
-        entry.total += 1;
-        entry.byOwner[row.owner] = (entry.byOwner[row.owner] ?? 0) + 1;
-        summary.set(row.collection, entry);
-    }
-    return [...summary.values()].sort((a, b) => a.collection.localeCompare(b.collection));
-}
 //# sourceMappingURL=server.js.map