@exposify/supabase 0.1.0

package/dist/index.js

@@ -0,0 +1,687 @@
+// src/index.ts
+import { createWebMcpHandler } from "@exposify/core";
+
+// src/kb.ts
+import { KnowledgeBase } from "@exposify/core";
+async function loadDocsFromDeno(globs, root) {
+  const deno = globalThis.Deno;
+  if (!deno) throw new Error("loadDocsFromDeno can only run under the Deno runtime.");
+  const docs = [];
+  for (const pattern of globs) {
+    const recursive = pattern.match(/^(.*)\/\*\*\/\*\.md$/);
+    if (recursive) {
+      await walkMarkdown(deno, root, recursive[1], docs);
+    } else {
+      try {
+        const content = await deno.readTextFile(new URL(pattern, root));
+        docs.push({ path: pattern, content });
+      } catch {
+      }
+    }
+  }
+  return docs.sort((a, b) => a.path.localeCompare(b.path));
+}
+async function walkMarkdown(deno, root, dir, out) {
+  let entries;
+  try {
+    entries = deno.readDir(new URL(`${dir}/`, root));
+  } catch {
+    return;
+  }
+  for await (const entry of entries) {
+    const relPath = `${dir}/${entry.name}`;
+    if (entry.isDirectory) {
+      await walkMarkdown(deno, root, relPath, out);
+    } else if (entry.isFile && relPath.endsWith(".md")) {
+      try {
+        out.push({ path: relPath, content: await deno.readTextFile(new URL(relPath, root)) });
+      } catch {
+      }
+    }
+  }
+}
+
+// src/config.ts
+var WRITE_OPS = ["insert", "update", "delete"];
+function parseWrites(writes = []) {
+  const grants = /* @__PURE__ */ new Map();
+  for (const entry of writes) {
+    const [table, op] = entry.split(".");
+    if (!table || !op) {
+      warnOnce(`ignoring malformed writes entry "${entry}" (expected "<table>.insert|update|delete|*")`);
+      continue;
+    }
+    const ops = op === "*" ? WRITE_OPS : isWriteOp(op) ? [op] : null;
+    if (!ops) {
+      warnOnce(`ignoring writes entry "${entry}": "${op}" is not insert, update, delete, or *`);
+      continue;
+    }
+    const set = grants.get(table) ?? /* @__PURE__ */ new Set();
+    for (const o of ops) set.add(o);
+    grants.set(table, set);
+  }
+  return grants;
+}
+function isWriteOp(op) {
+  return WRITE_OPS.includes(op);
+}
+var warned = /* @__PURE__ */ new Set();
+function warnOnce(message) {
+  if (warned.has(message)) return;
+  warned.add(message);
+  try {
+    console.warn(`[agentify-supabase] ${message}`);
+  } catch {
+  }
+}
+function resolveSupabaseConfig(options = {}) {
+  return {
+    writes: parseWrites(options.writes),
+    rpc: options.rpc ?? [],
+    functions: options.functions ?? {},
+    docs: options.docs ?? ["docs/**/*.md"],
+    docsAuth: options.docsAuth ?? "public",
+    maxRows: options.maxRows ?? 100,
+    rateLimit: options.rateLimit,
+    rateWindowMs: options.rateWindowMs
+  };
+}
+
+// src/postgrest-client.ts
+var FORWARDED_HEADERS = ["authorization", "apikey"];
+function buildPostgrestHeaders(incoming, anonKey) {
+  const headers = new Headers();
+  for (const name of FORWARDED_HEADERS) {
+    const value = incoming.get(name);
+    if (value) headers.set(name, value);
+  }
+  if (!headers.has("apikey")) headers.set("apikey", anonKey);
+  return headers;
+}
+function createPostgrestClient(postgrestUrl, headers, fetchImpl) {
+  const base = postgrestUrl.replace(/\/+$/, "");
+  const call = async (path, init) => {
+    const res = await fetchImpl(`${base}${path}`, init);
+    return { status: res.status, bodyText: await res.text() };
+  };
+  const jsonHeaders = (extra) => {
+    const h = new Headers(headers);
+    h.set("content-type", "application/json");
+    for (const [k, v] of Object.entries(extra ?? {})) h.set(k, v);
+    return h;
+  };
+  return {
+    select: (table, qs) => call(`/${table}${qs ? `?${qs}` : ""}`, { method: "GET", headers }),
+    insert: (table, body) => call(`/${table}`, {
+      method: "POST",
+      headers: jsonHeaders({ prefer: "return=representation" }),
+      body: JSON.stringify(body)
+    }),
+    update: (table, qs, body) => call(`/${table}?${qs}`, {
+      method: "PATCH",
+      headers: jsonHeaders({ prefer: "return=representation" }),
+      body: JSON.stringify(body)
+    }),
+    delete: (table, qs) => call(`/${table}?${qs}`, { method: "DELETE", headers: jsonHeaders({ prefer: "return=representation" }) }),
+    rpc: (fn, args) => call(`/rpc/${fn}`, { method: "POST", headers: jsonHeaders(), body: JSON.stringify(args ?? {}) })
+  };
+}
+
+// src/fetch-openapi.ts
+async function fetchOpenApi(postgrestUrl, headers, fetchImpl) {
+  const res = await fetchImpl(postgrestUrl, {
+    headers: { ...Object.fromEntries(headers), accept: "application/openapi+json" }
+  });
+  if (!res.ok) {
+    throw new Error(`PostgREST OpenAPI fetch failed: HTTP ${res.status}`);
+  }
+  return await res.json();
+}
+
+// src/meta.ts
+var MissingAgentifyMetaError = class extends Error {
+  constructor(cause) {
+    super(cause);
+    this.name = "MissingAgentifyMetaError";
+  }
+};
+async function fetchAgentifyMeta(postgrestUrl, headers, fetchImpl) {
+  const res = await fetchImpl(`${postgrestUrl}/rpc/agentify_meta`, {
+    method: "POST",
+    headers: { ...Object.fromEntries(headers), "content-type": "application/json" },
+    body: "{}"
+  });
+  if (res.status === 404) {
+    throw new MissingAgentifyMetaError(
+      "agentify_meta() is not reachable at /rpc/agentify_meta (404). Run `npx agentify-supabase init` (or apply sql/agentify_meta.sql directly) and `supabase db push`, then redeploy the function."
+    );
+  }
+  if (!res.ok) {
+    const body = await res.text().catch(() => "");
+    if (/PGRST202|function .* does not exist/i.test(body)) {
+      throw new MissingAgentifyMetaError(
+        "agentify_meta() is missing from the database (PostgREST error PGRST202). Apply the migration in sql/agentify_meta.sql via `supabase db push`, then redeploy the function."
+      );
+    }
+    throw new Error(`agentify_meta() call failed: HTTP ${res.status} ${body}`.trim());
+  }
+  return await res.json();
+}
+
+// src/openapi.ts
+var TYPE_MAP = {
+  integer: "integer",
+  number: "number",
+  boolean: "boolean",
+  object: "object",
+  array: "array",
+  string: "string"
+};
+function isPrimaryKey(prop) {
+  return /<pk\/>/i.test(prop.description ?? "");
+}
+function columnsFromOpenApi(doc, table) {
+  const def = doc.definitions?.[table];
+  if (!def?.properties) return [];
+  const required = new Set(def.required ?? []);
+  return Object.entries(def.properties).map(([name, prop]) => ({
+    name,
+    type: TYPE_MAP[prop.type ?? "string"] ?? "string",
+    format: prop.format,
+    required: required.has(name),
+    isPrimaryKey: isPrimaryKey(prop),
+    // Falls back to the OpenAPI-embedded comment (PostgREST mirrors `COMMENT
+    // ON COLUMN` into `description`, then appends its own "Note:\nThis is a
+    // Primary/Foreign Key...<pk/|fk/>" boilerplate) -- strip that boilerplate
+    // so a column with no real comment ends up `undefined`, not the
+    // boilerplate text. agentify_meta()'s copy wins when both exist anyway
+    // -- see introspect.ts's merge.
+    description: prop.description?.replace(/\n*Note:[\s\S]*$/, "").trim() || void 0
+  }));
+}
+function tablesInOpenApi(doc) {
+  return new Set(Object.keys(doc.definitions ?? {}));
+}
+function rpcArgSchema(doc, fn) {
+  const params = doc.paths?.[`/rpc/${fn}`]?.post?.parameters;
+  const body = params?.find((p) => p.in === "body" && p.schema?.type === "object");
+  if (!body?.schema?.properties) return null;
+  const properties = {};
+  for (const [name, prop] of Object.entries(body.schema.properties)) {
+    properties[name] = { type: TYPE_MAP[prop.type ?? "string"] ?? "string", description: prop.description };
+  }
+  return { type: "object", properties, required: body.schema.required };
+}
+
+// src/introspect.ts
+function introspectTables(openapi, metaRows) {
+  const exposedInOpenApi = tablesInOpenApi(openapi);
+  const byTable = groupByTable(metaRows);
+  const tables = [];
+  for (const [name, rows] of byTable) {
+    const rlsEnabled = rows[0].rls_enabled;
+    if (!rlsEnabled) continue;
+    if (!exposedInOpenApi.has(name)) continue;
+    const openApiColumns = new Map(columnsFromOpenApi(openapi, name).map((c) => [c.name, c]));
+    const columns = [];
+    for (const row of rows) {
+      const fromOpenApi = openApiColumns.get(row.column_name);
+      if (!fromOpenApi) continue;
+      columns.push({
+        ...fromOpenApi,
+        // agentify_meta()'s comment wins over OpenAPI's mirrored copy (spec:
+        // "Column comments → param descriptions" sourced from the migration).
+        description: row.column_comment ?? fromOpenApi.description
+      });
+    }
+    if (columns.length === 0) continue;
+    tables.push({
+      name,
+      rlsEnabled: true,
+      description: rows[0].table_comment ?? void 0,
+      columns
+    });
+  }
+  return tables.sort((a, b) => a.name.localeCompare(b.name));
+}
+function groupByTable(rows) {
+  const map = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const list = map.get(row.table_name) ?? [];
+    list.push(row);
+    map.set(row.table_name, list);
+  }
+  return map;
+}
+
+// src/manifest.ts
+var MANIFEST_VERSION = 1;
+function buildManifest(openapi, metaRows, generatedAt) {
+  return { version: MANIFEST_VERSION, generatedAt, tables: introspectTables(openapi, metaRows) };
+}
+function loadManifest(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const m = raw;
+  if (m.version !== MANIFEST_VERSION || !Array.isArray(m.tables)) return null;
+  return { version: MANIFEST_VERSION, generatedAt: m.generatedAt ?? "unknown", tables: m.tables };
+}
+
+// src/degradation.ts
+async function resolveTableSchemas(deps) {
+  const warnings = [];
+  try {
+    const [openapi, metaRows] = await Promise.all([
+      fetchOpenApi(deps.postgrestUrl, deps.headers, deps.fetchImpl),
+      fetchAgentifyMeta(deps.postgrestUrl, deps.headers, deps.fetchImpl)
+    ]);
+    return { tables: introspectTables(openapi, metaRows), mode: "runtime", warnings, openapi };
+  } catch (err) {
+    warnings.push({ rung: "runtime", reason: messageOf(err) });
+  }
+  const manifest = loadManifest(deps.manifest);
+  if (manifest) {
+    warnings.push({
+      rung: "manifest",
+      reason: "runtime introspection failed; serving tools from the bundled agentify.manifest.json instead"
+    });
+    return { tables: manifest.tables, mode: "manifest", warnings };
+  }
+  warnings.push({
+    rung: "functions-only",
+    reason: "runtime introspection failed and no bundled manifest was found; exposing only registered functions and the knowledge base"
+  });
+  return { tables: [], mode: "functions-only", warnings };
+}
+function messageOf(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+
+// src/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z as z2 } from "zod";
+import {
+  toToolResult,
+  DISPATCH_TIMEOUT_MS
+} from "@exposify/core";
+
+// src/postgrest-query.ts
+function buildQueryString(args, maxRows) {
+  const params = new URLSearchParams();
+  for (const f of args.filter ?? []) {
+    params.append(f.column, `${f.op}.${f.value}`);
+  }
+  if (args.select?.length) params.set("select", args.select.join(","));
+  if (args.order) params.set("order", args.order);
+  const limit = args.limit ? Math.min(args.limit, maxRows) : maxRows;
+  params.set("limit", String(limit));
+  return params.toString();
+}
+function requireFilter(filter) {
+  if (!filter || filter.length === 0) {
+    throw new Error("At least one filter is required -- refusing a table-wide update/delete.");
+  }
+  return filter;
+}
+function filterQueryString(filter) {
+  const params = new URLSearchParams();
+  for (const f of filter) params.append(f.column, `${f.op}.${f.value}`);
+  return params.toString();
+}
+
+// src/naming.ts
+function sanitizeIdentifier(name) {
+  return name.toLowerCase().replace(/[^a-z0-9_]/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "");
+}
+function toolName(prefix, name, taken) {
+  const base = `${prefix}_${sanitizeIdentifier(name)}`;
+  let candidate = base;
+  let i = 2;
+  while (taken.has(candidate)) candidate = `${base}_${i++}`;
+  taken.add(candidate);
+  return candidate;
+}
+
+// src/jsonschema-to-zod.ts
+import { z } from "zod";
+function jsonSchemaToZodShape(schema) {
+  if (!schema?.properties) return {};
+  const required = new Set(schema.required ?? []);
+  const shape = {};
+  for (const [name, prop] of Object.entries(schema.properties)) {
+    let field = propertyToZod(prop);
+    if (!required.has(name)) field = field.optional();
+    shape[name] = field;
+  }
+  return shape;
+}
+function propertyToZod(prop) {
+  let base;
+  switch (prop.type) {
+    case "string":
+      base = prop.enum ? z.enum(prop.enum) : z.string();
+      break;
+    case "number":
+      base = z.number();
+      break;
+    case "integer":
+      base = z.number().int();
+      break;
+    case "boolean":
+      base = z.boolean();
+      break;
+    case "array":
+      base = z.array(prop.items ? propertyToZod(prop.items) : z.unknown());
+      break;
+    case "object":
+      base = prop.properties ? z.object(jsonSchemaToZodShape({ properties: prop.properties, required: prop.required })) : z.record(z.unknown());
+      break;
+    default:
+      base = z.unknown();
+  }
+  return prop.description ? base.describe(prop.description) : base;
+}
+
+// src/server.ts
+var FILTER_OPS = ["eq", "neq", "gt", "lt", "like"];
+function buildSupabaseMcpServer(deps) {
+  const { cfg, tables, client, kb, incoming } = deps;
+  const server = new McpServer(
+    { name: deps.appName, version: deps.appVersion },
+    { instructions: instructionsFor(deps.warnings) }
+  );
+  const taken = /* @__PURE__ */ new Set(["search_docs"]);
+  for (const table of tables) {
+    registerQueryTool(server, table, client, cfg, taken);
+    const grants = cfg.writes.get(table.name);
+    if (grants?.has("insert")) registerInsertTool(server, table, client, taken);
+    if (grants?.has("update")) registerUpdateTool(server, table, client, taken);
+    if (grants?.has("delete")) registerDeleteTool(server, table, client, taken);
+  }
+  for (const fn of cfg.rpc) {
+    registerRpcTool(server, fn, client, deps.openapi, taken);
+  }
+  for (const [name, config] of Object.entries(cfg.functions)) {
+    registerFunctionTool(server, name, config, deps.invokeFunction, taken);
+  }
+  registerDocsTools(server, kb, cfg, incoming);
+  registerDiagnosticsResource(server, deps.warnings);
+  return server;
+}
+function instructionsFor(warnings) {
+  if (warnings.length === 0) return void 0;
+  return warnings.map((w) => `[${w.rung}] ${w.reason}`).join(" ");
+}
+function filterShape(columns) {
+  const names = columns.map((c) => c.name);
+  if (names.length === 0) return z2.array(z2.never()).optional();
+  return z2.array(
+    z2.object({
+      column: z2.enum(names).describe("Column to filter on"),
+      op: z2.enum(FILTER_OPS).describe("eq | neq | gt | lt | like"),
+      value: z2.union([z2.string(), z2.number(), z2.boolean()])
+    })
+  ).optional().describe("Filters, ANDed together");
+}
+function registerQueryTool(server, table, client, cfg, taken) {
+  const name = toolName("query", table.name, taken);
+  const columnNames = table.columns.map((c) => c.name);
+  server.registerTool(
+    name,
+    {
+      description: table.description || `Query rows from ${table.name}.`,
+      inputSchema: {
+        filter: filterShape(table.columns),
+        select: columnNames.length > 0 ? z2.array(z2.enum(columnNames)).optional().describe("Columns to return; default all") : z2.array(z2.string()).optional(),
+        order: z2.string().optional().describe('e.g. "created_at.desc"'),
+        limit: z2.number().int().min(1).max(cfg.maxRows).optional().describe(`Max rows (capped at ${cfg.maxRows})`)
+      },
+      annotations: { readOnlyHint: true }
+    },
+    async (args) => {
+      const qs = buildQueryString(args, cfg.maxRows);
+      return toResult(() => client.select(table.name, qs));
+    }
+  );
+}
+function insertBodyShape(columns) {
+  const shape = {};
+  for (const col of columns) {
+    let field = columnToZod(col);
+    if (!col.required) field = field.optional();
+    shape[col.name] = field;
+  }
+  return shape;
+}
+function columnToZod(col) {
+  let base;
+  switch (col.type) {
+    case "number":
+      base = z2.number();
+      break;
+    case "integer":
+      base = z2.number().int();
+      break;
+    case "boolean":
+      base = z2.boolean();
+      break;
+    case "object":
+      base = z2.record(z2.unknown());
+      break;
+    case "array":
+      base = z2.array(z2.unknown());
+      break;
+    default:
+      base = z2.string();
+  }
+  return col.description ? base.describe(col.description) : base;
+}
+function registerInsertTool(server, table, client, taken) {
+  const name = toolName("insert", table.name, taken);
+  server.registerTool(
+    name,
+    {
+      description: `Insert a row into ${table.name}.`,
+      inputSchema: { body: z2.object(insertBodyShape(table.columns)) },
+      annotations: { readOnlyHint: false, destructiveHint: false }
+    },
+    async (args) => toResult(() => client.insert(table.name, args.body))
+  );
+}
+function registerUpdateTool(server, table, client, taken) {
+  const name = toolName("update", table.name, taken);
+  const setShape = {};
+  for (const col of table.columns) setShape[col.name] = columnToZod(col).optional();
+  server.registerTool(
+    name,
+    {
+      description: `Update rows in ${table.name}. At least one filter is required.`,
+      inputSchema: {
+        filter: filterShape(table.columns).refine((f) => !!f && f.length > 0, {
+          message: "At least one filter is required -- refusing a table-wide update."
+        }),
+        set: z2.object(setShape)
+      },
+      annotations: { readOnlyHint: false, destructiveHint: true }
+    },
+    async (args) => toResult(() => client.update(table.name, filterQueryString(requireFilter(args.filter)), args.set))
+  );
+}
+function registerDeleteTool(server, table, client, taken) {
+  const name = toolName("delete", table.name, taken);
+  server.registerTool(
+    name,
+    {
+      description: `Delete rows from ${table.name}. At least one filter is required.`,
+      inputSchema: {
+        filter: filterShape(table.columns).refine((f) => !!f && f.length > 0, {
+          message: "At least one filter is required -- refusing a table-wide delete."
+        })
+      },
+      annotations: { readOnlyHint: false, destructiveHint: true }
+    },
+    async (args) => toResult(() => client.delete(table.name, filterQueryString(requireFilter(args.filter))))
+  );
+}
+function registerRpcTool(server, fn, client, openapi, taken) {
+  const name = toolName("rpc", fn, taken);
+  const schema = openapi ? rpcArgSchema(openapi, fn) : null;
+  if (schema) {
+    const shape = jsonSchemaToZodShape(schema);
+    server.registerTool(
+      name,
+      { description: `Call the ${fn} Postgres function.`, inputSchema: shape },
+      async (args) => toResult(() => client.rpc(fn, args))
+    );
+  } else {
+    server.registerTool(
+      name,
+      {
+        description: `Call the ${fn} Postgres function. Argument names were not available from PostgREST's OpenAPI document -- pass them as a JSON object.`,
+        inputSchema: { args: z2.record(z2.unknown()).optional().describe("RPC arguments as a JSON object") }
+      },
+      async (args) => toResult(() => client.rpc(fn, args.args ?? {}))
+    );
+  }
+}
+function registerFunctionTool(server, name, config, invokeFunction, taken) {
+  const toolNameStr = toolName("fn", name, taken);
+  server.registerTool(
+    toolNameStr,
+    { description: config.description, inputSchema: jsonSchemaToZodShape(config.input) },
+    async (args) => toResult(() => invokeFunction(name, args))
+  );
+}
+function registerDocsTools(server, kb, cfg, incoming) {
+  const docsAllowed = cfg.docsAuth === "public" || incoming.has("authorization");
+  if (!docsAllowed || kb.isEmpty) return;
+  server.registerTool(
+    "search_docs",
+    {
+      description: "Search this app's documentation and product knowledge.",
+      inputSchema: { query: z2.string().describe("Search query"), limit: z2.number().int().min(1).max(20).optional() },
+      annotations: { readOnlyHint: true }
+    },
+    async ({ query, limit }) => {
+      const hits = kb.search(query, limit ?? 5);
+      const text = hits.length ? hits.map((h) => `[${h.chunk.source} \u2014 ${h.chunk.heading}]
+${h.chunk.text}`).join("\n\n---\n\n") : "No matching documentation found.";
+      return { content: [{ type: "text", text }] };
+    }
+  );
+}
+function registerDiagnosticsResource(server, warnings) {
+  if (warnings.length === 0) return;
+  server.registerResource(
+    "agentify-diagnostics",
+    "agentify://diagnostics",
+    { title: "agentify-supabase diagnostics", mimeType: "application/json" },
+    async (uri) => ({ contents: [{ uri: uri.href, text: JSON.stringify(warnings, null, 2) }] })
+  );
+}
+async function toResult(run) {
+  let timer;
+  try {
+    const outcome = await Promise.race([
+      run(),
+      new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error("timeout")), DISPATCH_TIMEOUT_MS);
+      })
+    ]);
+    const result = toToolResult(outcome);
+    return { content: [{ type: "text", text: result.text }], isError: result.isError };
+  } catch (err) {
+    const message = err.message === "timeout" ? `Tool call timed out after ${DISPATCH_TIMEOUT_MS / 1e3}s` : "Tool call failed reaching Supabase.";
+    return { content: [{ type: "text", text: message }], isError: true };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// src/index.ts
+function denoEnv() {
+  return globalThis.Deno?.env;
+}
+function aiReady(options = {}) {
+  const cfg = resolveSupabaseConfig(options);
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const env = denoEnv();
+  const supabaseUrl = options.supabaseUrl ?? env?.get("SUPABASE_URL");
+  const anonKey = options.anonKey ?? env?.get("SUPABASE_ANON_KEY") ?? "";
+  let kbPromise = null;
+  const getKb = () => {
+    kbPromise ??= (async () => {
+      const mainModule = globalThis.Deno?.mainModule;
+      if (!mainModule) return KnowledgeBase.build([]);
+      try {
+        return KnowledgeBase.build(await loadDocsFromDeno(cfg.docs, new URL(mainModule)));
+      } catch {
+        return KnowledgeBase.build([]);
+      }
+    })();
+    return kbPromise;
+  };
+  let ladderPromise = null;
+  const getLadder = (postgrestUrl) => {
+    ladderPromise ??= resolveTableSchemas({
+      postgrestUrl,
+      headers: buildPostgrestHeaders(new Headers(), anonKey),
+      fetchImpl,
+      manifest: options.manifest
+    }).then((ladder) => {
+      for (const w of ladder.warnings) {
+        console.error(`[agentify-supabase] degradation ladder: ${w.rung}: ${w.reason}`);
+      }
+      return ladder;
+    });
+    return ladderPromise;
+  };
+  return createWebMcpHandler(
+    {
+      getServer: async (req) => {
+        if (!supabaseUrl) {
+          throw new Error(
+            "SUPABASE_URL is not set. In a deployed function this is automatic; for local dev pass { supabaseUrl } explicitly."
+          );
+        }
+        const postgrestUrl = `${supabaseUrl.replace(/\/+$/, "")}/rest/v1`;
+        const incoming = req.headers;
+        const headers = buildPostgrestHeaders(incoming, anonKey);
+        const ladder = await getLadder(postgrestUrl);
+        const client = createPostgrestClient(postgrestUrl, headers, fetchImpl);
+        const invokeFunction = async (name, body) => {
+          const res = await fetchImpl(`${supabaseUrl.replace(/\/+$/, "")}/functions/v1/${name}`, {
+            method: "POST",
+            headers: { ...Object.fromEntries(headers), "content-type": "application/json" },
+            body: JSON.stringify(body ?? {})
+          });
+          return { status: res.status, bodyText: await res.text() };
+        };
+        return buildSupabaseMcpServer({
+          appName: "agentify-supabase",
+          appVersion: "0.0.0",
+          tables: ladder.tables,
+          cfg,
+          client,
+          openapi: ladder.openapi,
+          kb: await getKb(),
+          incoming,
+          invokeFunction,
+          warnings: ladder.warnings
+        });
+      }
+    },
+    { rateLimit: cfg.rateLimit, rateWindowMs: cfg.rateWindowMs }
+  );
+}
+export {
+  MANIFEST_VERSION,
+  MissingAgentifyMetaError,
+  aiReady,
+  buildManifest,
+  columnsFromOpenApi,
+  fetchAgentifyMeta,
+  fetchOpenApi,
+  introspectTables,
+  loadManifest,
+  rpcArgSchema
+};