@payloadcms/plugin-mcp 4.0.0-internal.d28e9fb → 4.0.0-internal.d927017

package/LICENSE.md

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2018-2024 Payload CMS, Inc. <info@payloadcms.com>
+Copyright (c) 2018-2026 Payload CMS, LLC <info@payloadcms.com>
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

package/bin.js

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+/**
+ * stdio MCP server for Payload.
+ *
+ * Loads the project's `payload.config.{ts,js}` (via `findConfig`), boots Payload,
+ * and serves MCP over stdin/stdout. Intended for local-dev MCP clients (Claude
+ * Desktop, IDEs) that spawn stdio MCP servers - no running Next.js dev server required.
+ *
+ * Mirrors `payload/bin.js`: by default, transpiles TS on the fly via `tsx`. Pass
+ * `--disable-transpile` if your config is already JS (or you've registered your
+ * own loader).
+ */
+import path from 'path'
+import { fileURLToPath, pathToFileURL } from 'url'
+
+const disableTranspile = process.argv.includes('--disable-transpile')
+
+const filename = fileURLToPath(import.meta.url)
+const dirname = path.dirname(filename)
+const baseURL = pathToFileURL(dirname).toString() + '/'
+
+const loadBin = async () => {
+  if (disableTranspile) {
+    process.argv = process.argv.filter((arg) => arg !== '--disable-transpile')
+    return import('./dist/bin/index.js')
+  }
+
+  // tsx 4.22.4's synchronous loader leaks its namespace query onto Node built-ins on Node 23.5+.
+  // Force the stable asynchronous loader path, matching payload/bin.js.
+  const nodeModule = await import('node:module')
+  if (typeof nodeModule.default.registerHooks === 'function') {
+    nodeModule.default.registerHooks = undefined
+  }
+
+  const { tsImport } = await import('tsx/esm/api')
+  return tsImport('@payloadcms/plugin-mcp/bin', baseURL)
+}
+
+const start = async () => {
+  const { bin } = await loadBin()
+  await bin()
+}
+
+start().catch((err) => {
+  // eslint-disable-next-line no-console
+  console.error('[payload-mcp] error:', err)
+  process.exit(1)
+})

package/dist/bin/index.d.ts

@@ -0,0 +1,2 @@
+export declare const bin: () => Promise<void>;
+//# sourceMappingURL=index.d.ts.map

package/dist/bin/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/bin/index.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,GAAG,QAAa,OAAO,CAAC,IAAI,CAaxC,CAAA"}

package/dist/bin/index.js

@@ -0,0 +1,12 @@
+import { runMcpStdio } from '../stdio.js';
+export const bin = async ()=>{
+    let viteHMR;
+    if (process.env.NODE_ENV !== 'production' && process.env.NODE_ENV !== 'test' && process.env.DISABLE_PAYLOAD_HMR !== 'true') {
+        const { initializeViteHMR } = await import('./initializeViteHMR.js');
+        viteHMR = await initializeViteHMR();
+    }
+    await runMcpStdio(viteHMR?.config);
+    await viteHMR?.connect();
+};
+
+//# sourceMappingURL=index.js.map

package/dist/bin/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/bin/index.ts"],"sourcesContent":["import { runMcpStdio } from '../stdio.js'\n\nexport const bin = async (): Promise<void> => {\n  let viteHMR\n  if (\n    process.env.NODE_ENV !== 'production' &&\n    process.env.NODE_ENV !== 'test' &&\n    process.env.DISABLE_PAYLOAD_HMR !== 'true'\n  ) {\n    const { initializeViteHMR } = await import('./initializeViteHMR.js')\n    viteHMR = await initializeViteHMR()\n  }\n\n  await runMcpStdio(viteHMR?.config)\n  await viteHMR?.connect()\n}\n"],"names":["runMcpStdio","bin","viteHMR","process","env","NODE_ENV","DISABLE_PAYLOAD_HMR","initializeViteHMR","config","connect"],"mappings":"AAAA,SAASA,WAAW,QAAQ,cAAa;AAEzC,OAAO,MAAMC,MAAM;IACjB,IAAIC;IACJ,IACEC,QAAQC,GAAG,CAACC,QAAQ,KAAK,gBACzBF,QAAQC,GAAG,CAACC,QAAQ,KAAK,UACzBF,QAAQC,GAAG,CAACE,mBAAmB,KAAK,QACpC;QACA,MAAM,EAAEC,iBAAiB,EAAE,GAAG,MAAM,MAAM,CAAC;QAC3CL,UAAU,MAAMK;IAClB;IAEA,MAAMP,YAAYE,SAASM;IAC3B,MAAMN,SAASO;AACjB,EAAC"}

package/dist/bin/initializeViteHMR.d.ts

@@ -0,0 +1,8 @@
+import type { SanitizedConfig } from 'payload';
+type ViteHMR = {
+    config: SanitizedConfig;
+    connect: () => Promise<void>;
+};
+export declare const initializeViteHMR: () => Promise<ViteHMR>;
+export {};
+//# sourceMappingURL=initializeViteHMR.d.ts.map

package/dist/bin/initializeViteHMR.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"initializeViteHMR.d.ts","sourceRoot":"","sources":["../../src/bin/initializeViteHMR.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAY9C,KAAK,OAAO,GAAG;IACb,MAAM,EAAE,eAAe,CAAA;IACvB,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CAC7B,CAAA;AAED,eAAO,MAAM,iBAAiB,QAAa,OAAO,CAAC,OAAO,CA0CzD,CAAA"}

package/dist/bin/initializeViteHMR.js

@@ -0,0 +1,63 @@
+/* eslint-disable no-console */ import { fileURLToPath } from 'node:url';
+import { getPayload, reload } from 'payload';
+import { findConfig } from 'payload/node';
+import { createServer, createServerModuleRunner, normalizePath } from 'vite';
+import { resolveProjectRoot } from '../utils/resolveProjectRoot.js';
+export const initializeViteHMR = async ()=>{
+    const projectRoot = resolveProjectRoot(fileURLToPath(import.meta.url));
+    if (projectRoot) {
+        process.chdir(projectRoot);
+    }
+    const vite = await createServer({
+        clearScreen: false,
+        configFile: false,
+        envDir: false,
+        logLevel: 'error',
+        optimizeDeps: {
+            noDiscovery: true
+        },
+        publicDir: false,
+        resolve: {
+            alias: {
+                'payload-mcp:config': normalizePath(findConfig())
+            },
+            tsconfigPaths: true
+        },
+        server: {
+            middlewareMode: true,
+            ws: false
+        },
+        ssr: {
+            noExternal: [
+                /^@payloadcms\//,
+                /^payload$/
+            ]
+        }
+    });
+    const runner = createServerModuleRunner(vite.environments.ssr);
+    const boundaryPath = fileURLToPath(new URL('./viteConfigBoundary.js', import.meta.url));
+    const boundary = await runner.import(boundaryPath);
+    const config = boundary.getConfig();
+    return {
+        config,
+        connect: async ()=>{
+            const payload = await getPayload({
+                config,
+                cron: false,
+                disableOnInit: true
+            });
+            let payloadReloadQueue = Promise.resolve();
+            const reloadPayload = (nextConfig)=>{
+                payloadReloadQueue = payloadReloadQueue.then(()=>reload(nextConfig, payload, false)).catch((error)=>console.error('[payload-mcp] config reload failed:', error));
+                return payloadReloadQueue;
+            };
+            boundary.subscribe(reloadPayload);
+            const latestConfig = boundary.getConfig();
+            if (config !== latestConfig) {
+                await reloadPayload(latestConfig);
+            }
+        }
+    };
+};
+
+//# sourceMappingURL=initializeViteHMR.js.map

package/dist/bin/initializeViteHMR.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/bin/initializeViteHMR.ts"],"sourcesContent":["import type { SanitizedConfig } from 'payload'\n\n/* eslint-disable no-console */\nimport { fileURLToPath } from 'node:url'\nimport { getPayload, reload } from 'payload'\nimport { findConfig } from 'payload/node'\nimport { createServer, createServerModuleRunner, normalizePath } from 'vite'\n\nimport type * as ConfigBoundary from './viteConfigBoundary.js'\n\nimport { resolveProjectRoot } from '../utils/resolveProjectRoot.js'\n\ntype ViteHMR = {\n  config: SanitizedConfig\n  connect: () => Promise<void>\n}\n\nexport const initializeViteHMR = async (): Promise<ViteHMR> => {\n  const projectRoot = resolveProjectRoot(fileURLToPath(import.meta.url))\n  if (projectRoot) {\n    process.chdir(projectRoot)\n  }\n\n  const vite = await createServer({\n    clearScreen: false,\n    configFile: false,\n    envDir: false,\n    logLevel: 'error',\n    optimizeDeps: { noDiscovery: true },\n    publicDir: false,\n    resolve: { alias: { 'payload-mcp:config': normalizePath(findConfig()) }, tsconfigPaths: true },\n    server: { middlewareMode: true, ws: false },\n    ssr: { noExternal: [/^@payloadcms\\//, /^payload$/] },\n  })\n  const runner = createServerModuleRunner(vite.environments.ssr)\n  const boundaryPath = fileURLToPath(new URL('./viteConfigBoundary.js', import.meta.url))\n  const boundary = await runner.import<typeof ConfigBoundary>(boundaryPath)\n  const config = boundary.getConfig()\n\n  return {\n    config,\n    connect: async () => {\n      const payload = await getPayload({ config, cron: false, disableOnInit: true })\n      let payloadReloadQueue = Promise.resolve()\n      const reloadPayload = (nextConfig: SanitizedConfig): Promise<void> => {\n        payloadReloadQueue = payloadReloadQueue\n          .then(() => reload(nextConfig, payload, false))\n          .catch((error) => console.error('[payload-mcp] config reload failed:', error))\n        return payloadReloadQueue\n      }\n\n      boundary.subscribe(reloadPayload)\n\n      const latestConfig = boundary.getConfig()\n      if (config !== latestConfig) {\n        await reloadPayload(latestConfig)\n      }\n    },\n  }\n}\n"],"names":["fileURLToPath","getPayload","reload","findConfig","createServer","createServerModuleRunner","normalizePath","resolveProjectRoot","initializeViteHMR","projectRoot","url","process","chdir","vite","clearScreen","configFile","envDir","logLevel","optimizeDeps","noDiscovery","publicDir","resolve","alias","tsconfigPaths","server","middlewareMode","ws","ssr","noExternal","runner","environments","boundaryPath","URL","boundary","import","config","getConfig","connect","payload","cron","disableOnInit","payloadReloadQueue","Promise","reloadPayload","nextConfig","then","catch","error","console","subscribe","latestConfig"],"mappings":"AAEA,6BAA6B,GAC7B,SAASA,aAAa,QAAQ,WAAU;AACxC,SAASC,UAAU,EAAEC,MAAM,QAAQ,UAAS;AAC5C,SAASC,UAAU,QAAQ,eAAc;AACzC,SAASC,YAAY,EAAEC,wBAAwB,EAAEC,aAAa,QAAQ,OAAM;AAI5E,SAASC,kBAAkB,QAAQ,iCAAgC;AAOnE,OAAO,MAAMC,oBAAoB;IAC/B,MAAMC,cAAcF,mBAAmBP,cAAc,YAAYU,GAAG;IACpE,IAAID,aAAa;QACfE,QAAQC,KAAK,CAACH;IAChB;IAEA,MAAMI,OAAO,MAAMT,aAAa;QAC9BU,aAAa;QACbC,YAAY;QACZC,QAAQ;QACRC,UAAU;QACVC,cAAc;YAAEC,aAAa;QAAK;QAClCC,WAAW;QACXC,SAAS;YAAEC,OAAO;gBAAE,sBAAsBhB,cAAcH;YAAc;YAAGoB,eAAe;QAAK;QAC7FC,QAAQ;YAAEC,gBAAgB;YAAMC,IAAI;QAAM;QAC1CC,KAAK;YAAEC,YAAY;gBAAC;gBAAkB;aAAY;QAAC;IACrD;IACA,MAAMC,SAASxB,yBAAyBQ,KAAKiB,YAAY,CAACH,GAAG;IAC7D,MAAMI,eAAe/B,cAAc,IAAIgC,IAAI,2BAA2B,YAAYtB,GAAG;IACrF,MAAMuB,WAAW,MAAMJ,OAAOK,MAAM,CAAwBH;IAC5D,MAAMI,SAASF,SAASG,SAAS;IAEjC,OAAO;QACLD;QACAE,SAAS;YACP,MAAMC,UAAU,MAAMrC,WAAW;gBAAEkC;gBAAQI,MAAM;gBAAOC,eAAe;YAAK;YAC5E,IAAIC,qBAAqBC,QAAQrB,OAAO;YACxC,MAAMsB,gBAAgB,CAACC;gBACrBH,qBAAqBA,mBAClBI,IAAI,CAAC,IAAM3C,OAAO0C,YAAYN,SAAS,QACvCQ,KAAK,CAAC,CAACC,QAAUC,QAAQD,KAAK,CAAC,uCAAuCA;gBACzE,OAAON;YACT;YAEAR,SAASgB,SAAS,CAACN;YAEnB,MAAMO,eAAejB,SAASG,SAAS;YACvC,IAAID,WAAWe,cAAc;gBAC3B,MAAMP,cAAcO;YACtB;QACF;IACF;AACF,EAAC"}

package/dist/bin/viteConfigBoundary.d.ts

@@ -0,0 +1,6 @@
+import type { SanitizedConfig } from 'payload';
+type ConfigListener = (config: SanitizedConfig) => Promise<void> | void;
+export declare const getConfig: () => SanitizedConfig;
+export declare const subscribe: (nextListener: ConfigListener) => void;
+export {};
+//# sourceMappingURL=viteConfigBoundary.d.ts.map

package/dist/bin/viteConfigBoundary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"viteConfigBoundary.d.ts","sourceRoot":"","sources":["../../src/bin/viteConfigBoundary.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAM9C,KAAK,cAAc,GAAG,CAAC,MAAM,EAAE,eAAe,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAA;AAavE,eAAO,MAAM,SAAS,QAAO,eAAyB,CAAA;AAEtD,eAAO,MAAM,SAAS,GAAI,cAAc,cAAc,KAAG,IAExD,CAAA"}

package/dist/bin/viteConfigBoundary.js

@@ -0,0 +1,25 @@
+/// <reference types="vite/client" />
+/* eslint-disable no-console */ // @ts-expect-error - The Vite initializer resolves this ID to the Payload config.
+import * as configModule from 'payload-mcp:config';
+let listener;
+let configQueue = Promise.resolve();
+const resolveConfig = async (module)=>{
+    const config = module;
+    return await (config.default ?? module);
+};
+let config = await resolveConfig(configModule);
+export const getConfig = ()=>config;
+export const subscribe = (nextListener)=>{
+    listener = nextListener;
+};
+import.meta.hot?.accept('payload-mcp:config', (nextModule)=>{
+    if (!nextModule) {
+        return;
+    }
+    configQueue = configQueue.then(async ()=>{
+        config = await resolveConfig(nextModule);
+        await listener?.(config);
+    }).catch((error)=>console.error('[payload-mcp] config reload failed:', error));
+});
+
+//# sourceMappingURL=viteConfigBoundary.js.map

package/dist/bin/viteConfigBoundary.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/bin/viteConfigBoundary.ts"],"sourcesContent":["/// <reference types=\"vite/client\" />\n\nimport type { SanitizedConfig } from 'payload'\n\n/* eslint-disable no-console */\n// @ts-expect-error - The Vite initializer resolves this ID to the Payload config.\nimport * as configModule from 'payload-mcp:config'\n\ntype ConfigListener = (config: SanitizedConfig) => Promise<void> | void\n\nlet listener: ConfigListener | undefined\nlet configQueue = Promise.resolve()\n\nconst resolveConfig = async (module: unknown): Promise<SanitizedConfig> => {\n  const config = module as { default?: unknown }\n\n  return (await (config.default ?? module)) as SanitizedConfig\n}\n\nlet config = await resolveConfig(configModule)\n\nexport const getConfig = (): SanitizedConfig => config\n\nexport const subscribe = (nextListener: ConfigListener): void => {\n  listener = nextListener\n}\n\nimport.meta.hot?.accept('payload-mcp:config', (nextModule) => {\n  if (!nextModule) {\n    return\n  }\n\n  configQueue = configQueue\n    .then(async () => {\n      config = await resolveConfig(nextModule)\n      await listener?.(config)\n    })\n    .catch((error) => console.error('[payload-mcp] config reload failed:', error))\n})\n"],"names":["configModule","listener","configQueue","Promise","resolve","resolveConfig","module","config","default","getConfig","subscribe","nextListener","hot","accept","nextModule","then","catch","error","console"],"mappings":"AAAA,qCAAqC;AAIrC,6BAA6B,GAC7B,kFAAkF;AAClF,YAAYA,kBAAkB,qBAAoB;AAIlD,IAAIC;AACJ,IAAIC,cAAcC,QAAQC,OAAO;AAEjC,MAAMC,gBAAgB,OAAOC;IAC3B,MAAMC,SAASD;IAEf,OAAQ,MAAOC,CAAAA,OAAOC,OAAO,IAAIF,MAAK;AACxC;AAEA,IAAIC,SAAS,MAAMF,cAAcL;AAEjC,OAAO,MAAMS,YAAY,IAAuBF,OAAM;AAEtD,OAAO,MAAMG,YAAY,CAACC;IACxBV,WAAWU;AACb,EAAC;AAED,YAAYC,GAAG,EAAEC,OAAO,sBAAsB,CAACC;IAC7C,IAAI,CAACA,YAAY;QACf;IACF;IAEAZ,cAAcA,YACXa,IAAI,CAAC;QACJR,SAAS,MAAMF,cAAcS;QAC7B,MAAMb,WAAWM;IACnB,GACCS,KAAK,CAAC,CAACC,QAAUC,QAAQD,KAAK,CAAC,uCAAuCA;AAC3E"}

package/dist/defaultAccess.d.ts

@@ -0,0 +1,3 @@
+import type { MCPAccessArgs } from './types.js';
+export declare const defaultAccess: ({ req }: MCPAccessArgs) => boolean;
+//# sourceMappingURL=defaultAccess.d.ts.map

package/dist/defaultAccess.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaultAccess.d.ts","sourceRoot":"","sources":["../src/defaultAccess.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAE/C,eAAO,MAAM,aAAa,GAAI,SAAS,aAAa,KAAG,OAA4B,CAAA"}

package/dist/defaultAccess.js

@@ -0,0 +1,3 @@
+export const defaultAccess = ({ req })=>Boolean(req.user);
+
+//# sourceMappingURL=defaultAccess.js.map

package/dist/defaultAccess.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/defaultAccess.ts"],"sourcesContent":["import type { MCPAccessArgs } from './types.js'\n\nexport const defaultAccess = ({ req }: MCPAccessArgs): boolean => Boolean(req.user)\n"],"names":["defaultAccess","req","Boolean","user"],"mappings":"AAEA,OAAO,MAAMA,gBAAgB,CAAC,EAAEC,GAAG,EAAiB,GAAcC,QAAQD,IAAIE,IAAI,EAAC"}

package/dist/defineTool.d.ts

@@ -0,0 +1,26 @@
+import type { CollectionTool, GlobalTool, Prompt, Tool, ToolInputSchema } from './types.js';
+/**
+ * Two-stage builder: pass the schema/metadata first, then chain `.handler(fn)`. Splitting the
+ * call lets TypeScript resolve `TSchema` from `input` (call 1) before contextually typing the
+ * handler (call 2). A single-call API hit a TS limitation where property order in the literal
+ * decided whether `TSchema` was inferred or pinned to its default.
+ *
+ *     defineCollectionTool({ description, input })
+ *       .handler(({ input }) => …)   // ← input is fully typed here regardless of order
+ *
+ * Config and handler signatures are derived from `Tool` / `CollectionTool` / `GlobalTool` /
+ * `Prompt` via `Omit` + indexed access so there's no duplication with `types.ts`.
+ */
+export declare const defineTool: <TSchema extends ToolInputSchema | undefined = ToolInputSchema | undefined>(args: Omit<Tool<TSchema>, "handler">) => {
+    handler: (fn: Tool<TSchema>["handler"]) => Tool;
+};
+export declare const defineCollectionTool: <TSchema extends ToolInputSchema | undefined = ToolInputSchema | undefined>(args: Omit<CollectionTool<TSchema>, "handler">) => {
+    handler: (fn: CollectionTool<TSchema>["handler"]) => CollectionTool;
+};
+export declare const defineGlobalTool: <TSchema extends ToolInputSchema | undefined = ToolInputSchema | undefined>(args: Omit<GlobalTool<TSchema>, "handler">) => {
+    handler: (fn: GlobalTool<TSchema>["handler"]) => GlobalTool;
+};
+export declare const definePrompt: <TSchema extends ToolInputSchema = ToolInputSchema>(args: Omit<Prompt<TSchema>, "handler">) => {
+    handler: (fn: Prompt<TSchema>["handler"]) => Prompt;
+};
+//# sourceMappingURL=defineTool.d.ts.map

package/dist/defineTool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defineTool.d.ts","sourceRoot":"","sources":["../src/defineTool.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAE3F;;;;;;;;;;;GAWG;AAEH,eAAO,MAAM,UAAU,GACrB,OAAO,SAAS,eAAe,GAAG,SAAS,GAAG,eAAe,GAAG,SAAS,EAEzE,MAAM,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,SAAS,CAAC,KACnC;IAAE,OAAO,EAAE,CAAC,EAAE,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,SAAS,CAAC,KAAK,IAAI,CAAA;CAElD,CAAA;AAEF,eAAO,MAAM,oBAAoB,GAC/B,OAAO,SAAS,eAAe,GAAG,SAAS,GAAG,eAAe,GAAG,SAAS,EAEzE,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC,EAAE,SAAS,CAAC,KAC7C;IAAE,OAAO,EAAE,CAAC,EAAE,EAAE,cAAc,CAAC,OAAO,CAAC,CAAC,SAAS,CAAC,KAAK,cAAc,CAAA;CAEtE,CAAA;AAEF,eAAO,MAAM,gBAAgB,GAC3B,OAAO,SAAS,eAAe,GAAG,SAAS,GAAG,eAAe,GAAG,SAAS,EAEzE,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,EAAE,SAAS,CAAC,KACzC;IAAE,OAAO,EAAE,CAAC,EAAE,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,SAAS,CAAC,KAAK,UAAU,CAAA;CAE9D,CAAA;AAEF,eAAO,MAAM,YAAY,GAAI,OAAO,SAAS,eAAe,GAAG,eAAe,EAC5E,MAAM,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,SAAS,CAAC,KACrC;IAAE,OAAO,EAAE,CAAC,EAAE,EAAE,MAAM,CAAC,OAAO,CAAC,CAAC,SAAS,CAAC,KAAK,MAAM,CAAA;CAEtD,CAAA"}

package/dist/defineTool.js

@@ -0,0 +1,37 @@
+/**
+ * Two-stage builder: pass the schema/metadata first, then chain `.handler(fn)`. Splitting the
+ * call lets TypeScript resolve `TSchema` from `input` (call 1) before contextually typing the
+ * handler (call 2). A single-call API hit a TS limitation where property order in the literal
+ * decided whether `TSchema` was inferred or pinned to its default.
+ *
+ *     defineCollectionTool({ description, input })
+ *       .handler(({ input }) => …)   // ← input is fully typed here regardless of order
+ *
+ * Config and handler signatures are derived from `Tool` / `CollectionTool` / `GlobalTool` /
+ * `Prompt` via `Omit` + indexed access so there's no duplication with `types.ts`.
+ */ export const defineTool = (args)=>({
+        handler: (fn)=>({
+                ...args,
+                handler: fn
+            })
+    });
+export const defineCollectionTool = (args)=>({
+        handler: (fn)=>({
+                ...args,
+                handler: fn
+            })
+    });
+export const defineGlobalTool = (args)=>({
+        handler: (fn)=>({
+                ...args,
+                handler: fn
+            })
+    });
+export const definePrompt = (args)=>({
+        handler: (fn)=>({
+                ...args,
+                handler: fn
+            })
+    });
+
+//# sourceMappingURL=defineTool.js.map

package/dist/defineTool.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/defineTool.ts"],"sourcesContent":["import type { CollectionTool, GlobalTool, Prompt, Tool, ToolInputSchema } from './types.js'\n\n/**\n * Two-stage builder: pass the schema/metadata first, then chain `.handler(fn)`. Splitting the\n * call lets TypeScript resolve `TSchema` from `input` (call 1) before contextually typing the\n * handler (call 2). A single-call API hit a TS limitation where property order in the literal\n * decided whether `TSchema` was inferred or pinned to its default.\n *\n *     defineCollectionTool({ description, input })\n *       .handler(({ input }) => …)   // ← input is fully typed here regardless of order\n *\n * Config and handler signatures are derived from `Tool` / `CollectionTool` / `GlobalTool` /\n * `Prompt` via `Omit` + indexed access so there's no duplication with `types.ts`.\n */\n\nexport const defineTool = <\n  TSchema extends ToolInputSchema | undefined = ToolInputSchema | undefined,\n>(\n  args: Omit<Tool<TSchema>, 'handler'>,\n): { handler: (fn: Tool<TSchema>['handler']) => Tool } => ({\n  handler: (fn) => ({ ...args, handler: fn }) as unknown as Tool,\n})\n\nexport const defineCollectionTool = <\n  TSchema extends ToolInputSchema | undefined = ToolInputSchema | undefined,\n>(\n  args: Omit<CollectionTool<TSchema>, 'handler'>,\n): { handler: (fn: CollectionTool<TSchema>['handler']) => CollectionTool } => ({\n  handler: (fn) => ({ ...args, handler: fn }) as unknown as CollectionTool,\n})\n\nexport const defineGlobalTool = <\n  TSchema extends ToolInputSchema | undefined = ToolInputSchema | undefined,\n>(\n  args: Omit<GlobalTool<TSchema>, 'handler'>,\n): { handler: (fn: GlobalTool<TSchema>['handler']) => GlobalTool } => ({\n  handler: (fn) => ({ ...args, handler: fn }) as unknown as GlobalTool,\n})\n\nexport const definePrompt = <TSchema extends ToolInputSchema = ToolInputSchema>(\n  args: Omit<Prompt<TSchema>, 'handler'>,\n): { handler: (fn: Prompt<TSchema>['handler']) => Prompt } => ({\n  handler: (fn) => ({ ...args, handler: fn }) as unknown as Prompt,\n})\n"],"names":["defineTool","args","handler","fn","defineCollectionTool","defineGlobalTool","definePrompt"],"mappings":"AAEA;;;;;;;;;;;CAWC,GAED,OAAO,MAAMA,aAAa,CAGxBC,OACyD,CAAA;QACzDC,SAAS,CAACC,KAAQ,CAAA;gBAAE,GAAGF,IAAI;gBAAEC,SAASC;YAAG,CAAA;IAC3C,CAAA,EAAE;AAEF,OAAO,MAAMC,uBAAuB,CAGlCH,OAC6E,CAAA;QAC7EC,SAAS,CAACC,KAAQ,CAAA;gBAAE,GAAGF,IAAI;gBAAEC,SAASC;YAAG,CAAA;IAC3C,CAAA,EAAE;AAEF,OAAO,MAAME,mBAAmB,CAG9BJ,OACqE,CAAA;QACrEC,SAAS,CAACC,KAAQ,CAAA;gBAAE,GAAGF,IAAI;gBAAEC,SAASC;YAAG,CAAA;IAC3C,CAAA,EAAE;AAEF,OAAO,MAAMG,eAAe,CAC1BL,OAC6D,CAAA;QAC7DC,SAAS,CAACC,KAAQ,CAAA;gBAAE,GAAGF,IAAI;gBAAEC,SAASC;YAAG,CAAA;IAC3C,CAAA,EAAE"}

package/dist/endpoint/access.d.ts

@@ -0,0 +1,17 @@
+import type { PayloadRequest } from 'payload';
+import type { AuthorizedMCP, MCPItem } from '../types.js';
+export type GetAuthorizedMCPArgs = {
+    overrideAccess: boolean;
+    req: PayloadRequest;
+};
+/**
+ * Authenticates an MCP request and removes items the user cannot access.
+ * `overrideAccess` skips Payload and MCP item access checks.
+ */
+export declare const getAuthorizedMCP: (args: GetAuthorizedMCPArgs) => Promise<AuthorizedMCP>;
+export declare const filterMCPItems: ({ items, overrideAccess, req, }: {
+    items: MCPItem[];
+    overrideAccess: boolean;
+    req: PayloadRequest;
+}) => Promise<MCPItem[]>;
+//# sourceMappingURL=access.d.ts.map

package/dist/endpoint/access.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"access.d.ts","sourceRoot":"","sources":["../../src/endpoint/access.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAwB,MAAM,SAAS,CAAA;AAInE,OAAO,KAAK,EAAE,aAAa,EAAE,OAAO,EAAE,MAAM,aAAa,CAAA;AAIzD,MAAM,MAAM,oBAAoB,GAAG;IACjC,cAAc,EAAE,OAAO,CAAA;IACvB,GAAG,EAAE,cAAc,CAAA;CACpB,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,gBAAgB,EAAE,CAAC,IAAI,EAAE,oBAAoB,KAAK,OAAO,CAAC,aAAa,CAkCnF,CAAA;AAED,eAAO,MAAM,cAAc,GAAU,iCAIlC;IACD,KAAK,EAAE,OAAO,EAAE,CAAA;IAChB,cAAc,EAAE,OAAO,CAAA;IACvB,GAAG,EAAE,cAAc,CAAA;CACpB,KAAG,OAAO,CAAC,OAAO,EAAE,CAkBpB,CAAA"}

package/dist/endpoint/access.js

@@ -0,0 +1,93 @@
+import { getAccessResults, UnauthorizedError } from 'payload';
+import { getPluginConfig } from '../utils/getPluginConfig.js';
+/**
+ * Authenticates an MCP request and removes items the user cannot access.
+ * `overrideAccess` skips Payload and MCP item access checks.
+ */ export const getAuthorizedMCP = async ({ overrideAccess, req })=>{
+    const pluginConfig = getPluginConfig({
+        config: req.payload.config
+    });
+    if (pluginConfig.overrideGetAuthorizedMCP) {
+        return await pluginConfig.overrideGetAuthorizedMCP({
+            overrideAccess,
+            pluginConfig,
+            req
+        });
+    }
+    if (req.headers) {
+        const headers = new Headers(req.headers);
+        const hasAuthorization = headers.has('Authorization');
+        headers.set('DisableAutologin', 'true');
+        req.user = (await req.payload.auth({
+            headers,
+            req
+        })).user;
+        if (hasAuthorization && !req.user) {
+            throw new UnauthorizedError(req.t);
+        }
+    }
+    return {
+        items: await filterMCPItems({
+            items: pluginConfig.items,
+            overrideAccess,
+            req
+        }),
+        overrideAccess
+    };
+};
+export const filterMCPItems = async ({ items, overrideAccess, req })=>{
+    // Match Payload core: overrideAccess bypasses access evaluation
+    if (overrideAccess) {
+        return items;
+    }
+    const authorizedItems = [];
+    const permissions = await getAccessResults({
+        req
+    });
+    for (const item of items){
+        if (!await checkItemAccess({
+            item,
+            permissions,
+            req
+        })) {
+            continue;
+        }
+        authorizedItems.push(item);
+    }
+    return authorizedItems;
+};
+/**
+ * Runs MCP item access callbacks
+ */ const checkItemAccess = async ({ item, permissions, req })=>{
+    switch(item.type){
+        case 'collectionTool':
+            return !item.tool.access || await item.tool.access({
+                collectionSlug: item.collectionSlug,
+                permissions,
+                req
+            });
+        case 'globalTool':
+            return !item.tool.access || await item.tool.access({
+                globalSlug: item.globalSlug,
+                permissions,
+                req
+            });
+        case 'prompt':
+            return !item.prompt.access || await item.prompt.access({
+                permissions,
+                req
+            });
+        case 'resource':
+            return !item.resource.access || await item.resource.access({
+                permissions,
+                req
+            });
+        case 'tool':
+            return !item.tool.access || await item.tool.access({
+                permissions,
+                req
+            });
+    }
+};
+
+//# sourceMappingURL=access.js.map

package/dist/endpoint/access.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/endpoint/access.ts"],"sourcesContent":["import type { PayloadRequest, SanitizedPermissions } from 'payload'\n\nimport { getAccessResults, UnauthorizedError } from 'payload'\n\nimport type { AuthorizedMCP, MCPItem } from '../types.js'\n\nimport { getPluginConfig } from '../utils/getPluginConfig.js'\n\nexport type GetAuthorizedMCPArgs = {\n  overrideAccess: boolean\n  req: PayloadRequest\n}\n\n/**\n * Authenticates an MCP request and removes items the user cannot access.\n * `overrideAccess` skips Payload and MCP item access checks.\n */\nexport const getAuthorizedMCP: (args: GetAuthorizedMCPArgs) => Promise<AuthorizedMCP> = async ({\n  overrideAccess,\n  req,\n}) => {\n  const pluginConfig = getPluginConfig({ config: req.payload.config })\n\n  if (pluginConfig.overrideGetAuthorizedMCP) {\n    return await pluginConfig.overrideGetAuthorizedMCP({\n      overrideAccess,\n      pluginConfig,\n      req,\n    })\n  }\n\n  if (req.headers) {\n    const headers = new Headers(req.headers)\n    const hasAuthorization = headers.has('Authorization')\n\n    headers.set('DisableAutologin', 'true')\n    req.user = (await req.payload.auth({ headers, req })).user\n\n    if (hasAuthorization && !req.user) {\n      throw new UnauthorizedError(req.t)\n    }\n  }\n\n  return {\n    items: await filterMCPItems({\n      items: pluginConfig.items,\n      overrideAccess,\n      req,\n    }),\n    overrideAccess,\n  }\n}\n\nexport const filterMCPItems = async ({\n  items,\n  overrideAccess,\n  req,\n}: {\n  items: MCPItem[]\n  overrideAccess: boolean\n  req: PayloadRequest\n}): Promise<MCPItem[]> => {\n  // Match Payload core: overrideAccess bypasses access evaluation\n  if (overrideAccess) {\n    return items\n  }\n\n  const authorizedItems: MCPItem[] = []\n\n  const permissions = await getAccessResults({ req })\n\n  for (const item of items) {\n    if (!(await checkItemAccess({ item, permissions, req }))) {\n      continue\n    }\n    authorizedItems.push(item)\n  }\n\n  return authorizedItems\n}\n\n/**\n * Runs MCP item access callbacks\n */\nconst checkItemAccess = async ({\n  item,\n  permissions,\n  req,\n}: {\n  item: MCPItem\n  permissions?: SanitizedPermissions\n  req: PayloadRequest\n}): Promise<boolean> => {\n  switch (item.type) {\n    case 'collectionTool':\n      return (\n        !item.tool.access ||\n        (await item.tool.access({ collectionSlug: item.collectionSlug, permissions, req }))\n      )\n    case 'globalTool':\n      return (\n        !item.tool.access ||\n        (await item.tool.access({ globalSlug: item.globalSlug, permissions, req }))\n      )\n    case 'prompt':\n      return !item.prompt.access || (await item.prompt.access({ permissions, req }))\n    case 'resource':\n      return !item.resource.access || (await item.resource.access({ permissions, req }))\n    case 'tool':\n      return !item.tool.access || (await item.tool.access({ permissions, req }))\n  }\n}\n"],"names":["getAccessResults","UnauthorizedError","getPluginConfig","getAuthorizedMCP","overrideAccess","req","pluginConfig","config","payload","overrideGetAuthorizedMCP","headers","Headers","hasAuthorization","has","set","user","auth","t","items","filterMCPItems","authorizedItems","permissions","item","checkItemAccess","push","type","tool","access","collectionSlug","globalSlug","prompt","resource"],"mappings":"AAEA,SAASA,gBAAgB,EAAEC,iBAAiB,QAAQ,UAAS;AAI7D,SAASC,eAAe,QAAQ,8BAA6B;AAO7D;;;CAGC,GACD,OAAO,MAAMC,mBAA2E,OAAO,EAC7FC,cAAc,EACdC,GAAG,EACJ;IACC,MAAMC,eAAeJ,gBAAgB;QAAEK,QAAQF,IAAIG,OAAO,CAACD,MAAM;IAAC;IAElE,IAAID,aAAaG,wBAAwB,EAAE;QACzC,OAAO,MAAMH,aAAaG,wBAAwB,CAAC;YACjDL;YACAE;YACAD;QACF;IACF;IAEA,IAAIA,IAAIK,OAAO,EAAE;QACf,MAAMA,UAAU,IAAIC,QAAQN,IAAIK,OAAO;QACvC,MAAME,mBAAmBF,QAAQG,GAAG,CAAC;QAErCH,QAAQI,GAAG,CAAC,oBAAoB;QAChCT,IAAIU,IAAI,GAAG,AAAC,CAAA,MAAMV,IAAIG,OAAO,CAACQ,IAAI,CAAC;YAAEN;YAASL;QAAI,EAAC,EAAGU,IAAI;QAE1D,IAAIH,oBAAoB,CAACP,IAAIU,IAAI,EAAE;YACjC,MAAM,IAAId,kBAAkBI,IAAIY,CAAC;QACnC;IACF;IAEA,OAAO;QACLC,OAAO,MAAMC,eAAe;YAC1BD,OAAOZ,aAAaY,KAAK;YACzBd;YACAC;QACF;QACAD;IACF;AACF,EAAC;AAED,OAAO,MAAMe,iBAAiB,OAAO,EACnCD,KAAK,EACLd,cAAc,EACdC,GAAG,EAKJ;IACC,gEAAgE;IAChE,IAAID,gBAAgB;QAClB,OAAOc;IACT;IAEA,MAAME,kBAA6B,EAAE;IAErC,MAAMC,cAAc,MAAMrB,iBAAiB;QAAEK;IAAI;IAEjD,KAAK,MAAMiB,QAAQJ,MAAO;QACxB,IAAI,CAAE,MAAMK,gBAAgB;YAAED;YAAMD;YAAahB;QAAI,IAAK;YACxD;QACF;QACAe,gBAAgBI,IAAI,CAACF;IACvB;IAEA,OAAOF;AACT,EAAC;AAED;;CAEC,GACD,MAAMG,kBAAkB,OAAO,EAC7BD,IAAI,EACJD,WAAW,EACXhB,GAAG,EAKJ;IACC,OAAQiB,KAAKG,IAAI;QACf,KAAK;YACH,OACE,CAACH,KAAKI,IAAI,CAACC,MAAM,IAChB,MAAML,KAAKI,IAAI,CAACC,MAAM,CAAC;gBAAEC,gBAAgBN,KAAKM,cAAc;gBAAEP;gBAAahB;YAAI;QAEpF,KAAK;YACH,OACE,CAACiB,KAAKI,IAAI,CAACC,MAAM,IAChB,MAAML,KAAKI,IAAI,CAACC,MAAM,CAAC;gBAAEE,YAAYP,KAAKO,UAAU;gBAAER;gBAAahB;YAAI;QAE5E,KAAK;YACH,OAAO,CAACiB,KAAKQ,MAAM,CAACH,MAAM,IAAK,MAAML,KAAKQ,MAAM,CAACH,MAAM,CAAC;gBAAEN;gBAAahB;YAAI;QAC7E,KAAK;YACH,OAAO,CAACiB,KAAKS,QAAQ,CAACJ,MAAM,IAAK,MAAML,KAAKS,QAAQ,CAACJ,MAAM,CAAC;gBAAEN;gBAAahB;YAAI;QACjF,KAAK;YACH,OAAO,CAACiB,KAAKI,IAAI,CAACC,MAAM,IAAK,MAAML,KAAKI,IAAI,CAACC,MAAM,CAAC;gBAAEN;gBAAahB;YAAI;IAC3E;AACF"}

package/dist/endpoint/index.d.ts

@@ -0,0 +1,3 @@
+import type { PayloadHandler } from 'payload';
+export declare const mcpEndpoint: PayloadHandler;
+//# sourceMappingURL=index.d.ts.map

package/dist/endpoint/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/endpoint/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAkB,MAAM,SAAS,CAAA;AAa7D,eAAO,MAAM,WAAW,EAAE,cA+DzB,CAAA"}

package/dist/endpoint/index.js

@@ -0,0 +1,87 @@
+import { createMcpHandler, isLegacyRequest, WebStandardStreamableHTTPServerTransport } from '@modelcontextprotocol/server';
+import { APIError } from 'payload';
+import { buildMcpServer } from '../mcp/buildMcpServer.js';
+import { getPluginConfig } from '../utils/getPluginConfig.js';
+import { getAuthorizedMCP } from './access.js';
+export const mcpEndpoint = async (req)=>{
+    if (!req.url) {
+        throw new APIError('Missing request URL', 400);
+    }
+    req.payloadAPI = 'MCP';
+    const pluginConfig = getPluginConfig({
+        config: req.payload.config
+    });
+    const overrideAccessParam = new URL(req.url).searchParams.get('overrideAccess');
+    if (overrideAccessParam !== null && process.env.NODE_ENV !== 'development') {
+        throw new APIError('MCP overrideAccess is only available in development.', 400);
+    }
+    let overrideAccess = false;
+    if (overrideAccessParam === 'true') {
+        overrideAccess = true;
+    } else if (overrideAccessParam !== null && overrideAccessParam !== 'false') {
+        throw new APIError('MCP overrideAccess must be "true" or "false".', 400);
+    }
+    const authorizedMCP = await getAuthorizedMCP({
+        overrideAccess,
+        req
+    });
+    // Payload augments the original web-standard Request in place.
+    const mcpRequest = req;
+    // Keep the old JSON-only, stateless behavior because the SDK's 2025 fallback uses SSE.
+    if (await isLegacyRequest(mcpRequest)) {
+        const server = buildMcpServer({
+            authorizedMCP,
+            pluginConfig,
+            req
+        });
+        const transport = new WebStandardStreamableHTTPServerTransport({
+            enableJsonResponse: true,
+            sessionIdGenerator: undefined
+        });
+        transport.onerror = (err)=>{
+            req.payload.logger.error({
+                err,
+                msg: 'Error serving legacy MCP request'
+            });
+        };
+        try {
+            await server.connect(transport);
+            return await transport.handleRequest(mcpRequest);
+        } finally{
+            await server.close().catch((err)=>{
+                req.payload.logger.error({
+                    err,
+                    msg: 'Error closing MCP server'
+                });
+            });
+        }
+    }
+    const handler = createMcpHandler(()=>buildMcpServer({
+            authorizedMCP,
+            pluginConfig,
+            req
+        }), {
+        legacy: 'reject',
+        // SDK subscriptions always use SSE, so disable them to keep every response JSON-only.
+        maxSubscriptions: 0,
+        onerror: (err)=>{
+            req.payload.logger.error({
+                err,
+                msg: 'Error serving modern MCP request'
+            });
+        },
+        responseMode: 'json'
+    });
+    try {
+        return await handler.fetch(mcpRequest);
+    } finally{
+        await handler.close().catch((err)=>{
+            req.payload.logger.error({
+                err,
+                msg: 'Error closing modern MCP handler'
+            });
+        });
+    }
+};
+
+//# sourceMappingURL=index.js.map

package/dist/endpoint/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/endpoint/index.ts"],"sourcesContent":["import type { PayloadHandler, PayloadRequest } from 'payload'\n\nimport {\n  createMcpHandler,\n  isLegacyRequest,\n  WebStandardStreamableHTTPServerTransport,\n} from '@modelcontextprotocol/server'\nimport { APIError } from 'payload'\n\nimport { buildMcpServer } from '../mcp/buildMcpServer.js'\nimport { getPluginConfig } from '../utils/getPluginConfig.js'\nimport { getAuthorizedMCP } from './access.js'\n\nexport const mcpEndpoint: PayloadHandler = async (req) => {\n  if (!req.url) {\n    throw new APIError('Missing request URL', 400)\n  }\n\n  req.payloadAPI = 'MCP' as const\n\n  const pluginConfig = getPluginConfig({ config: req.payload.config })\n  const overrideAccessParam = new URL(req.url).searchParams.get('overrideAccess')\n\n  if (overrideAccessParam !== null && process.env.NODE_ENV !== 'development') {\n    throw new APIError('MCP overrideAccess is only available in development.', 400)\n  }\n\n  let overrideAccess = false\n  if (overrideAccessParam === 'true') {\n    overrideAccess = true\n  } else if (overrideAccessParam !== null && overrideAccessParam !== 'false') {\n    throw new APIError('MCP overrideAccess must be \"true\" or \"false\".', 400)\n  }\n\n  const authorizedMCP = await getAuthorizedMCP({ overrideAccess, req })\n  // Payload augments the original web-standard Request in place.\n  const mcpRequest = req as PayloadRequest & Request\n\n  // Keep the old JSON-only, stateless behavior because the SDK's 2025 fallback uses SSE.\n  if (await isLegacyRequest(mcpRequest)) {\n    const server = buildMcpServer({ authorizedMCP, pluginConfig, req })\n    const transport = new WebStandardStreamableHTTPServerTransport({\n      enableJsonResponse: true,\n      sessionIdGenerator: undefined, // stateless mode\n    })\n    transport.onerror = (err) => {\n      req.payload.logger.error({ err, msg: 'Error serving legacy MCP request' })\n    }\n\n    try {\n      await server.connect(transport)\n      return await transport.handleRequest(mcpRequest)\n    } finally {\n      await server.close().catch((err) => {\n        req.payload.logger.error({ err, msg: 'Error closing MCP server' })\n      })\n    }\n  }\n\n  const handler = createMcpHandler(() => buildMcpServer({ authorizedMCP, pluginConfig, req }), {\n    legacy: 'reject',\n    // SDK subscriptions always use SSE, so disable them to keep every response JSON-only.\n    maxSubscriptions: 0,\n    onerror: (err) => {\n      req.payload.logger.error({ err, msg: 'Error serving modern MCP request' })\n    },\n    responseMode: 'json',\n  })\n\n  try {\n    return await handler.fetch(mcpRequest)\n  } finally {\n    await handler.close().catch((err) => {\n      req.payload.logger.error({ err, msg: 'Error closing modern MCP handler' })\n    })\n  }\n}\n"],"names":["createMcpHandler","isLegacyRequest","WebStandardStreamableHTTPServerTransport","APIError","buildMcpServer","getPluginConfig","getAuthorizedMCP","mcpEndpoint","req","url","payloadAPI","pluginConfig","config","payload","overrideAccessParam","URL","searchParams","get","process","env","NODE_ENV","overrideAccess","authorizedMCP","mcpRequest","server","transport","enableJsonResponse","sessionIdGenerator","undefined","onerror","err","logger","error","msg","connect","handleRequest","close","catch","handler","legacy","maxSubscriptions","responseMode","fetch"],"mappings":"AAEA,SACEA,gBAAgB,EAChBC,eAAe,EACfC,wCAAwC,QACnC,+BAA8B;AACrC,SAASC,QAAQ,QAAQ,UAAS;AAElC,SAASC,cAAc,QAAQ,2BAA0B;AACzD,SAASC,eAAe,QAAQ,8BAA6B;AAC7D,SAASC,gBAAgB,QAAQ,cAAa;AAE9C,OAAO,MAAMC,cAA8B,OAAOC;IAChD,IAAI,CAACA,IAAIC,GAAG,EAAE;QACZ,MAAM,IAAIN,SAAS,uBAAuB;IAC5C;IAEAK,IAAIE,UAAU,GAAG;IAEjB,MAAMC,eAAeN,gBAAgB;QAAEO,QAAQJ,IAAIK,OAAO,CAACD,MAAM;IAAC;IAClE,MAAME,sBAAsB,IAAIC,IAAIP,IAAIC,GAAG,EAAEO,YAAY,CAACC,GAAG,CAAC;IAE9D,IAAIH,wBAAwB,QAAQI,QAAQC,GAAG,CAACC,QAAQ,KAAK,eAAe;QAC1E,MAAM,IAAIjB,SAAS,wDAAwD;IAC7E;IAEA,IAAIkB,iBAAiB;IACrB,IAAIP,wBAAwB,QAAQ;QAClCO,iBAAiB;IACnB,OAAO,IAAIP,wBAAwB,QAAQA,wBAAwB,SAAS;QAC1E,MAAM,IAAIX,SAAS,iDAAiD;IACtE;IAEA,MAAMmB,gBAAgB,MAAMhB,iBAAiB;QAAEe;QAAgBb;IAAI;IACnE,+DAA+D;IAC/D,MAAMe,aAAaf;IAEnB,uFAAuF;IACvF,IAAI,MAAMP,gBAAgBsB,aAAa;QACrC,MAAMC,SAASpB,eAAe;YAAEkB;YAAeX;YAAcH;QAAI;QACjE,MAAMiB,YAAY,IAAIvB,yCAAyC;YAC7DwB,oBAAoB;YACpBC,oBAAoBC;QACtB;QACAH,UAAUI,OAAO,GAAG,CAACC;YACnBtB,IAAIK,OAAO,CAACkB,MAAM,CAACC,KAAK,CAAC;gBAAEF;gBAAKG,KAAK;YAAmC;QAC1E;QAEA,IAAI;YACF,MAAMT,OAAOU,OAAO,CAACT;YACrB,OAAO,MAAMA,UAAUU,aAAa,CAACZ;QACvC,SAAU;YACR,MAAMC,OAAOY,KAAK,GAAGC,KAAK,CAAC,CAACP;gBAC1BtB,IAAIK,OAAO,CAACkB,MAAM,CAACC,KAAK,CAAC;oBAAEF;oBAAKG,KAAK;gBAA2B;YAClE;QACF;IACF;IAEA,MAAMK,UAAUtC,iBAAiB,IAAMI,eAAe;YAAEkB;YAAeX;YAAcH;QAAI,IAAI;QAC3F+B,QAAQ;QACR,sFAAsF;QACtFC,kBAAkB;QAClBX,SAAS,CAACC;YACRtB,IAAIK,OAAO,CAACkB,MAAM,CAACC,KAAK,CAAC;gBAAEF;gBAAKG,KAAK;YAAmC;QAC1E;QACAQ,cAAc;IAChB;IAEA,IAAI;QACF,OAAO,MAAMH,QAAQI,KAAK,CAACnB;IAC7B,SAAU;QACR,MAAMe,QAAQF,KAAK,GAAGC,KAAK,CAAC,CAACP;YAC3BtB,IAAIK,OAAO,CAACkB,MAAM,CAACC,KAAK,CAAC;gBAAEF;gBAAKG,KAAK;YAAmC;QAC1E;IACF;AACF,EAAC"}

package/dist/exports/client.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=client.d.ts.map

package/dist/exports/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/exports/client.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAA"}

package/dist/exports/client.js

@@ -0,0 +1,4 @@
+'use client';
+export { };
+
+//# sourceMappingURL=client.js.map

package/dist/exports/client.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/exports/client.ts"],"sourcesContent":["'use client'\n\nexport {}\n"],"names":[],"mappings":"AAAA;AAEA,WAAS"}

package/dist/exports/internal.d.ts

@@ -0,0 +1,2 @@
+export { filterMCPItems, getAuthorizedMCP } from '../endpoint/access.js';
+//# sourceMappingURL=internal.d.ts.map

package/dist/exports/internal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal.d.ts","sourceRoot":"","sources":["../../src/exports/internal.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAA"}

package/dist/exports/internal.js

@@ -0,0 +1,3 @@
+export { filterMCPItems, getAuthorizedMCP } from '../endpoint/access.js';
+
+//# sourceMappingURL=internal.js.map

package/dist/exports/internal.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/exports/internal.ts"],"sourcesContent":["export { filterMCPItems, getAuthorizedMCP } from '../endpoint/access.js'\n"],"names":["filterMCPItems","getAuthorizedMCP"],"mappings":"AAAA,SAASA,cAAc,EAAEC,gBAAgB,QAAQ,wBAAuB"}

package/dist/index.d.ts

@@ -1,17 +1,14 @@
-import type { MCPAccessSettings, MCPPluginConfig } from './types.js';
+import type { AuthorizedMCP, MCPPluginConfig, SanitizedMCPPluginConfig } from './types.js';
 declare module 'payload' {
-    interface PayloadRequest {
-        payloadAPI: 'GraphQL' | 'local' | 'MCP' | 'REST';
+    interface PayloadRequestAPI {
+        MCP: true;
     }
     interface RegisteredPlugins {
+        /** After the plugin's `plugin` callback runs, `options` holds the sanitized config. */
         '@payloadcms/plugin-mcp': MCPPluginConfig;
     }
 }
-export type { MCPAccessSettings, MCPPluginConfig };
-/**
- * The MCP Plugin for Payload. This plugin allows you to add MCP capabilities to your Payload project.
- *
- * @param pluginOptions - The options for the MCP plugin.
- */
+export type { AuthorizedMCP, MCPPluginConfig, SanitizedMCPPluginConfig };
+export { defineCollectionTool, defineGlobalTool, definePrompt, defineTool } from './defineTool.js';
 export declare const mcpPlugin: (options: MCPPluginConfig) => import("payload").Plugin;
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAKpE,OAAO,QAAQ,SAAS,CAAC;IACvB,UAAiB,cAAc;QAC7B,UAAU,EAAE,SAAS,GAAG,OAAO,GAAG,KAAK,GAAG,MAAM,CAAA;KACjD;IACD,UAAU,iBAAiB;QACzB,wBAAwB,EAAE,eAAe,CAAA;KAC1C;CACF;AAID,YAAY,EAAE,iBAAiB,EAAE,eAAe,EAAE,CAAA;AAElD;;;;GAIG;AACH,eAAO,MAAM,SAAS,wDAuFpB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAA;AAK1F,OAAO,QAAQ,SAAS,CAAC;IACvB,UAAiB,iBAAiB;QAChC,GAAG,EAAE,IAAI,CAAA;KACV;IACD,UAAU,iBAAiB;QACzB,uFAAuF;QACvF,wBAAwB,EAAE,eAAe,CAAA;KAC1C;CACF;AAED,YAAY,EAAE,aAAa,EAAE,eAAe,EAAE,wBAAwB,EAAE,CAAA;AAExE,OAAO,EAAE,oBAAoB,EAAE,gBAAgB,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAElG,eAAO,MAAM,SAAS,wDAiCpB,CAAA"}