@questpie/mcp 3.3.0

package/dist/index-Cxta5KOn.d.mts

@@ -0,0 +1,58 @@
+import * as questpie0 from "questpie";
+import { RouteDefinition, RouteParamsFromKey } from "questpie/types";
+
+//#region src/server/modules/mcp/routes/mcp.d.ts
+declare const _default$4: questpie0.RawRouteDefinition<questpie0.JsonRouteParams>;
+//#endregion
+//#region src/server/modules/mcp/routes/mcp.delete.d.ts
+declare const _default$3: questpie0.RawRouteDefinition<questpie0.JsonRouteParams>;
+//#endregion
+//#region src/server/modules/mcp/routes/mcp.get.d.ts
+declare const _default$2: questpie0.RawRouteDefinition<questpie0.JsonRouteParams>;
+//#endregion
+//#region src/server/modules/mcp/routes/mcp.options.d.ts
+declare const _default$1: questpie0.RawRouteDefinition<questpie0.JsonRouteParams>;
+//#endregion
+//#region src/server/modules/mcp/plugin.d.ts
+declare const _default: questpie0.CodegenPlugin;
+//#endregion
+//#region src/server/modules/mcp/.generated/module.d.ts
+type McpCollections = Record<never, never>;
+type McpGlobals = Record<never, never>;
+type McpJobs = Record<never, never>;
+type McpRoutes = {
+  mcp: typeof _default$4 extends {
+    __brand: "route";
+  } ? RouteDefinition<unknown, unknown, RouteParamsFromKey<"mcp">> : typeof _default$4;
+  "mcp:DELETE": typeof _default$3 extends {
+    __brand: "route";
+  } ? RouteDefinition<unknown, unknown, RouteParamsFromKey<"mcp:DELETE">> : typeof _default$3;
+  "mcp:GET": typeof _default$2 extends {
+    __brand: "route";
+  } ? RouteDefinition<unknown, unknown, RouteParamsFromKey<"mcp:GET">> : typeof _default$2;
+  "mcp:OPTIONS": typeof _default$1 extends {
+    __brand: "route";
+  } ? RouteDefinition<unknown, unknown, RouteParamsFromKey<"mcp:OPTIONS">> : typeof _default$1;
+};
+type McpFieldTypes = Record<never, never>;
+type McpMcpTools = Record<never, never>;
+type McpModule = {
+  name: "questpie-mcp";
+  routes: McpRoutes;
+  collections: McpCollections;
+  globals: McpGlobals;
+  jobs: McpJobs;
+  fieldTypes: McpFieldTypes;
+  mcpTools: McpMcpTools;
+  messages: Record<never, never>;
+  services: Record<never, never>;
+  emails: Record<never, never>;
+  migrations: readonly unknown[];
+  seeds: readonly unknown[];
+  plugin: typeof _default;
+};
+//#endregion
+//#region src/server/modules/mcp/index.d.ts
+declare const mcpModule: McpModule;
+//#endregion
+export { McpModule as n, mcpModule as t };

package/dist/index.d.mts

@@ -0,0 +1,122 @@
+import { t as mcpModule } from "./index-Cxta5KOn.mjs";
+import { _ as McpToolDefinition, a as McpAccessRuleContext, c as McpCrudDefaults, d as McpHttpConfig, f as McpRequiredScopes, g as McpToolConfig, h as McpStdioConfig, i as McpAccessRule, l as McpEntityPolicy, m as McpRoutesConfig, n as QuestpieApp, o as McpConfig, p as McpResourcesConfig, r as McpAccessMode, s as McpCrudConfig, t as startStdioServer, u as McpExecutionOptions, v as McpToolHandlerArgs, y as McpTransportKind } from "./stdio-t_9rKayH.mjs";
+import { t as mcpPlugin } from "./plugin-CMR-wkeP.mjs";
+import { AppContext, RequestContext, ScopeOperationKind, defaultOperationScope } from "questpie";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+
+//#region src/server/create-server.d.ts
+declare function createMcpServer(app: QuestpieApp, options?: McpExecutionOptions): Promise<McpServer>;
+//#endregion
+//#region src/server/config.d.ts
+declare function mcpConfig<TConfig extends McpConfig>(config: TConfig): TConfig;
+//#endregion
+//#region src/server/mcp-tool.d.ts
+declare class McpToolBuilder<TInputSchema extends z.ZodTypeAny, TOutputSchema extends z.ZodTypeAny> {
+  private readonly name;
+  private readonly config;
+  constructor(name: string, config: McpToolConfig<TInputSchema, TOutputSchema>);
+  handler(handler: (args: McpToolHandlerArgs<z.infer<TInputSchema>>) => ReturnType<McpToolDefinition<TInputSchema, TOutputSchema>["handler"]>): McpToolDefinition<TInputSchema, TOutputSchema>;
+}
+/**
+ * Define a custom MCP tool, contributed by a module the same way collections and
+ * routes are (via `ModuleDefinition.mcpTools`). `mcpTool(name, config).handler(fn)`
+ * returns a frozen, branded {@link McpToolDefinition}; the CRUD/route tools the
+ * framework auto-generates are the same shape.
+ *
+ * `config` mirrors the MCP tool contract: `inputSchema`/`outputSchema` (Zod),
+ * `title`/`description`/`annotations` for discovery, plus the two QUESTPIE
+ * authorization hooks that compose exactly like the built-in tools:
+ * - `access` — an {@link McpAccessRule} run against the caller's transport /
+ *   accessMode / session (and, for an OAuth caller, its scopes). Same RBAC-style
+ *   gate the CRUD tools use.
+ * - `scopes` — the OAuth scopes an `oauth` caller must hold ({@link McpToolConfig.scopes}).
+ *   Custom tools have no default scope mapping (unlike CRUD, there is no
+ *   resource/operation to derive one from), so an omitted value requires no
+ *   scope. The shipped scope gate ({@link scopeGateAllows}) enforces this at both
+ *   `tools/list` (hidden) and `tools/call` (denied); `system`/`user` callers
+ *   carry no scopes and skip it, so the effective bound is always `scopes ∩ RBAC`.
+ *
+ * @example
+ * ```ts
+ * export const ping = mcpTool("ops.ping", {
+ *   description: "Health probe",
+ *   inputSchema: z.object({}),
+ *   scopes: "routes:ops/ping:invoke", // only OAuth callers holding this scope
+ * }).handler(async () => ({ content: [{ type: "text", text: "pong" }] }));
+ * ```
+ */
+declare function mcpTool<TInputSchema extends z.ZodTypeAny = z.ZodTypeAny, TOutputSchema extends z.ZodTypeAny = z.ZodTypeAny>(name: string, config?: McpToolConfig<TInputSchema, TOutputSchema>): McpToolBuilder<TInputSchema, TOutputSchema>;
+//#endregion
+//#region src/server/policy.d.ts
+type EntityKind = "collection" | "global" | "route";
+interface ResolvedMcpPolicy {
+  expose: boolean;
+  read?: boolean | McpAccessRule;
+  write?: boolean | McpAccessRule;
+  delete?: boolean | McpAccessRule;
+  operations: Record<string, boolean | McpAccessRule>;
+  requiredScopes?: McpRequiredScopes;
+  operationScopes: Record<string, McpRequiredScopes>;
+  fields?: {
+    include?: string[];
+    exclude?: string[];
+  };
+  description?: string;
+}
+/** Normalize an {@link McpRequiredScopes} declaration to a scope list. */
+declare function normalizeRequiredScopes(required: McpRequiredScopes | undefined): string[];
+/**
+ * Resolve the scopes an OAuth caller must hold for a given entity operation.
+ *
+ * Precedence (most specific wins), each level is declarative data:
+ * 1. `policy.operationScopes[operationName]` — per-operation override.
+ * 2. `policy.requiredScopes` — entity-level requirement (all operations).
+ * 3. the default `<resource>:<name>:<verb>` mapping derived from the kind.
+ *
+ * A level set to `false` explicitly requires no scope (stops the fallback).
+ * Returns a (possibly empty) scope list; empty means "no scope required". This
+ * resolves the requirement; the deny/register decision that consumes it is
+ * {@link scopeGateAllows}.
+ */
+declare function requiredScopesForOperation(policy: ResolvedMcpPolicy, kind: EntityKind, name: string, operationName: string, operationKind: ScopeOperationKind): string[];
+/**
+ * The consented scopes carried by the request, or `undefined` when the caller
+ * is not OAuth-authenticated. Reads `ctx.principal` (populated by MO6): only the
+ * `oauth` principal carries `scopes`; `user` and `system` do not.
+ */
+declare function scopesFromContext(ctx: AppContext & Partial<RequestContext>): string[] | undefined;
+/**
+ * The OAuth scope gate (MO8, extended by the umbrella model — LOCKED #2).
+ *
+ * Given the scopes the caller holds (from {@link scopesFromContext}) and the
+ * scopes an operation requires (from {@link requiredScopesForOperation} or a
+ * custom tool's `config.scopes`), decide whether the scope gate passes.
+ *
+ * Semantics:
+ * - `heldScopes === undefined` → the caller is not OAuth-authenticated (`user`,
+ *   `system`, or unauthenticated). The scope gate does not apply and PASSES;
+ *   authorization is left entirely to RBAC / MCP rules. This is what keeps the
+ *   first-party admin (`user`) and stdio (`system`) paths unchanged.
+ * - Otherwise the caller is an `oauth` principal: the gate PASSES iff EVERY
+ *   required scope is satisfied — a required scope is satisfied when the caller
+ *   holds it directly OR holds its applicable coarse umbrella
+ *   ({@link umbrellaScopeFor}). An empty `required` needs nothing, so it passes
+ *   for everyone.
+ *
+ * The umbrella widening is deliberately narrow — it can only satisfy a
+ * granular `<resource>:<name>:read|write` with the matching `<resource>:read`
+ * or `<resource>:write` umbrella. `read` and `write` are independent (holding
+ * `collections:write` never satisfies a `<name>:read` requirement, and vice
+ * versa), and there is NO umbrella for `:delete` or `routes:…:invoke`. So the
+ * umbrella grants convenience without ever over-granting across verb, resource
+ * kind, or into delete/invoke.
+ *
+ * This gate is **additive** — it can only ever REMOVE access from an `oauth`
+ * caller. It never grants access on its own: callers still run the MCP rule and
+ * the collection/global `.access()` RBAC independently, and all must pass. The
+ * effective `oauth` permission is therefore `scopes ∩ RBAC`.
+ */
+declare function scopeGateAllows(heldScopes: string[] | undefined, required: string[]): boolean;
+//#endregion
+export { type McpAccessMode, type McpAccessRule, type McpAccessRuleContext, type McpConfig, type McpCrudConfig, type McpCrudDefaults, type McpEntityPolicy, type McpExecutionOptions, type McpHttpConfig, type McpRequiredScopes, type McpResourcesConfig, type McpRoutesConfig, type McpStdioConfig, type McpToolConfig, type McpToolDefinition, type McpToolHandlerArgs, type McpTransportKind, type ScopeOperationKind, createMcpServer, mcpModule as default, mcpModule, defaultOperationScope, mcpConfig, mcpPlugin, mcpTool, normalizeRequiredScopes, requiredScopesForOperation, scopeGateAllows, scopesFromContext, startStdioServer };

package/dist/index.mjs

@@ -0,0 +1,12 @@
+import { a as requiredScopesForOperation, i as normalizeRequiredScopes, n as mcpTool, o as scopeGateAllows, r as defaultOperationScope, s as scopesFromContext, t as createMcpServer } from "./create-server-DIvtVlma.mjs";
+import { n as mcp_default, t as mcpModule } from "./mcp-DapXh3Mk.mjs";
+import { t as mcpPlugin } from "./plugin-BJ6gELRj.mjs";
+import { t as startStdioServer } from "./stdio-qyQFVEyU.mjs";
+
+//#region src/server/config.ts
+function mcpConfig(config) {
+	return config;
+}
+
+//#endregion
+export { createMcpServer, mcp_default as default, defaultOperationScope, mcpConfig, mcpModule, mcpPlugin, mcpTool, normalizeRequiredScopes, requiredScopesForOperation, scopeGateAllows, scopesFromContext, startStdioServer };

package/dist/mcp-DapXh3Mk.mjs

@@ -0,0 +1,163 @@
+import { t as createMcpServer } from "./create-server-DIvtVlma.mjs";
+import { t as mcpPlugin } from "./plugin-BJ6gELRj.mjs";
+import { route } from "questpie";
+import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
+
+//#region src/server/mcp-http.ts
+/**
+* Shared MCP Streamable-HTTP handler.
+*
+* `route()` is single-method, so the MCP endpoint's four verbs (POST = JSON-RPC
+* messages, GET = SSE stream, DELETE = session end, OPTIONS = CORS preflight)
+* are registered as separate method-suffixed route files under `routes/`
+* (`mcp.ts` = POST, `mcp.get.ts`, `mcp.delete.ts`, `mcp.options.ts`) per the
+* codegen file convention — NOT method chaining and NOT a hand-written
+* `module.ts`. All four share THIS handler, which dispatches on
+* `request.method` internally because the transport needs one object for every
+* verb on the path.
+*/
+const mcpMeta = {
+	title: "MCP endpoint",
+	description: "Model Context Protocol endpoint for QUESTPIE."
+};
+function appFromRouteContext(ctx) {
+	return ctx.app;
+}
+function executionContextFromRouteContext(ctx) {
+	const routeCtx = { ...ctx };
+	delete routeCtx.app;
+	delete routeCtx.request;
+	return routeCtx;
+}
+function withCors(response, request) {
+	const headers = new Headers(response.headers);
+	const origin = request.headers.get("origin");
+	if (origin) {
+		headers.set("Access-Control-Allow-Origin", origin);
+		headers.set("Vary", "Origin");
+	}
+	headers.set("Access-Control-Allow-Methods", "POST, GET, DELETE, OPTIONS");
+	headers.set("Access-Control-Allow-Headers", "Content-Type, Authorization, x-api-key, Mcp-Session-Id, Last-Event-ID");
+	return new Response(response.body, {
+		status: response.status,
+		statusText: response.statusText,
+		headers
+	});
+}
+/**
+* Build the `WWW-Authenticate` challenge value for an unauthenticated HTTP MCP
+* request. `resource_metadata` points at this app's Protected Resource metadata
+* document (RFC 9728), served at the server root by the core `oauth-protected-
+* resource` route (MO4). An MCP client reads it to discover the authorization
+* server and start the OAuth 2.1 flow.
+*
+* The origin is derived from `app.config.app.url` — the same base MO2/MO6 use to
+* bind and verify token audience — so the advertised metadata URL always matches
+* where discovery actually lives. `new URL(...).origin` strips any path/query and
+* yields a bare `scheme://host[:port]`, so an app URL with a subpath still
+* produces a root-mounted metadata URL.
+*/
+function protectedResourceChallenge(appUrl) {
+	return `Bearer resource_metadata="${new URL(appUrl).origin}/.well-known/oauth-protected-resource"`;
+}
+/**
+* A verified principal is required to reach MCP tool execution over HTTP. The
+* request context resolves one for a cookie/bearer session (`kind: "user"`) or a
+* valid OAuth access token (`kind: "oauth"`); an unauthenticated request has
+* none. Read it structurally — the handler-args type does not surface it.
+*/
+function hasVerifiedPrincipal(ctx) {
+	return Boolean(ctx.principal);
+}
+async function mcpHandler(ctx) {
+	const { request } = ctx;
+	const app = appFromRouteContext(ctx);
+	if (request.method === "OPTIONS") return withCors(new Response(null, { status: 204 }), request);
+	if (!hasVerifiedPrincipal(ctx)) return withCors(new Response(null, {
+		status: 401,
+		headers: { "WWW-Authenticate": protectedResourceChallenge(app.config.app.url) }
+	}), request);
+	const config = app.state?.config?.mcp ?? {};
+	const server = await createMcpServer(app, {
+		transport: "http",
+		accessMode: "user",
+		request,
+		ctx: executionContextFromRouteContext(ctx)
+	});
+	const transport = new WebStandardStreamableHTTPServerTransport({
+		sessionIdGenerator: void 0,
+		allowedOrigins: config.http?.allowedOrigins,
+		allowedHosts: config.http?.allowedHosts,
+		enableJsonResponse: config.http?.enableJsonResponse ?? true
+	});
+	await server.connect(transport);
+	return withCors(await transport.handleRequest(request), request);
+}
+
+//#endregion
+//#region src/server/modules/mcp/routes/mcp.ts
+var mcp_default$1 = route().post().raw().meta(mcpMeta).handler(mcpHandler);
+
+//#endregion
+//#region src/server/modules/mcp/routes/mcp.delete.ts
+var mcp_delete_default = route().delete().raw().meta(mcpMeta).handler(mcpHandler);
+
+//#endregion
+//#region src/server/modules/mcp/routes/mcp.get.ts
+var mcp_get_default = route().get().raw().meta(mcpMeta).handler(mcpHandler);
+
+//#endregion
+//#region src/server/modules/mcp/routes/mcp.options.ts
+var mcp_options_default = route().options().raw().meta(mcpMeta).handler(mcpHandler);
+
+//#endregion
+//#region src/server/modules/mcp/plugin.ts
+/**
+* MCP module plugin — re-exports the MCP codegen plugin so that module
+* codegen discovers it and embeds it in the generated module definition.
+* This allows `extractPluginsFromModules` to pick it up automatically at
+* root-app codegen time (so consuming apps get the `mcp-tools` category,
+* `config/mcp.ts` discover, and scaffolds).
+*/
+var plugin_default = mcpPlugin();
+
+//#endregion
+//#region src/server/modules/mcp/.generated/module.ts
+const _module = {
+	name: "questpie-mcp",
+	routes: {
+		mcp: mcp_default$1,
+		"mcp:DELETE": mcp_delete_default,
+		"mcp:GET": mcp_get_default,
+		"mcp:OPTIONS": mcp_options_default
+	},
+	collections: {},
+	globals: {},
+	jobs: {},
+	messages: {},
+	services: {},
+	emails: {},
+	migrations: [],
+	seeds: [],
+	fieldTypes: {},
+	mcpTools: {},
+	plugin: plugin_default
+};
+var module_default = _module;
+
+//#endregion
+//#region src/server/modules/mcp/index.ts
+/**
+* MCP Module
+*
+* Backend module for the QUESTPIE Model Context Protocol endpoint.
+*
+* Exports:
+* - `mcpModule` — static module definition (generated by codegen from file convention)
+* - `McpModule` — type of the static module
+*/
+const mcpModule = module_default;
+var mcp_default = mcpModule;
+
+//#endregion
+export { mcp_default as n, mcpModule as t };

package/dist/modules/mcp.d.mts

@@ -0,0 +1,2 @@
+import { n as McpModule, t as mcpModule } from "../index-Cxta5KOn.mjs";
+export { type McpModule, mcpModule };

package/dist/modules/mcp.mjs

@@ -0,0 +1,3 @@
+import { t as mcpModule } from "../mcp-DapXh3Mk.mjs";
+
+export { mcpModule };

package/dist/plugin-BJ6gELRj.mjs

@@ -0,0 +1,39 @@
+//#region src/server/plugin.ts
+function mcpPlugin() {
+	return {
+		name: "questpie-mcp",
+		targets: { server: {
+			root: ".",
+			outputFile: "index.ts",
+			categories: { mcpTools: {
+				dirs: ["mcp-tools"],
+				prefix: "mcpTool",
+				factoryFunctions: ["mcpTool"],
+				registryKey: true,
+				includeInAppState: true,
+				extractFromModules: true,
+				typeEmit: "standard"
+			} },
+			discover: { mcpConfig: {
+				pattern: "config/mcp.ts",
+				configKey: "mcp"
+			} },
+			registries: { singletonFactories: { mcpConfig: {
+				configType: "McpConfig",
+				imports: [{
+					name: "McpConfig",
+					from: "@questpie/mcp"
+				}],
+				isCallback: true
+			} } },
+			scaffolds: { "mcp-tool": {
+				dir: "mcp-tools",
+				description: "MCP custom tool definition",
+				template: ({ kebab, camel }) => `import { mcpTool } from "@questpie/mcp";\nimport { z } from "zod";\n\nexport default mcpTool("${kebab}", {\n\tdescription: "Run ${kebab}.",\n\tinputSchema: z.object({}),\n}).handler(async ({ ctx }) => {\n\treturn {\n\t\tstructuredContent: { ok: true },\n\t\tcontent: [{ type: "text", text: "${camel} completed" }],\n\t};\n});\n`
+			} }
+		} }
+	};
+}
+
+//#endregion
+export { mcpPlugin as t };

package/dist/plugin-CMR-wkeP.d.mts

@@ -0,0 +1,6 @@
+import { CodegenPlugin } from "questpie/codegen";
+
+//#region src/server/plugin.d.ts
+declare function mcpPlugin(): CodegenPlugin;
+//#endregion
+export { mcpPlugin as t };

package/dist/plugin.d.mts

@@ -0,0 +1,2 @@
+import { t as mcpPlugin } from "./plugin-CMR-wkeP.mjs";
+export { mcpPlugin };

package/dist/plugin.mjs

@@ -0,0 +1,3 @@
+import { t as mcpPlugin } from "./plugin-BJ6gELRj.mjs";
+
+export { mcpPlugin };

package/dist/stdio-qyQFVEyU.mjs

@@ -0,0 +1,16 @@
+import { t as createMcpServer } from "./create-server-DIvtVlma.mjs";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+//#region src/server/stdio.ts
+async function startStdioServer(app, options = {}) {
+	const server = await createMcpServer(app, {
+		...options,
+		transport: "stdio"
+	});
+	const transport = new StdioServerTransport();
+	await server.connect(transport);
+	return server;
+}
+
+//#endregion
+export { startStdioServer as t };

package/dist/stdio-t_9rKayH.d.mts

@@ -0,0 +1,154 @@
+import { AppContext, RequestContext, createContextFactory } from "questpie";
+import { z } from "zod";
+import { CallToolResult, ToolAnnotations } from "@modelcontextprotocol/sdk/types.js";
+import * as _modelcontextprotocol_sdk_server_mcp0 from "@modelcontextprotocol/sdk/server/mcp";
+
+//#region src/server/types.d.ts
+type McpTransportKind = "http" | "stdio";
+type McpAccessMode = "user" | "system";
+interface McpAccessRuleContext {
+  transport: McpTransportKind;
+  accessMode: McpAccessMode;
+  session?: RequestContext["session"];
+  /**
+   * The consented OAuth scopes carried by the caller, when the request was
+   * authenticated by an OAuth access token (`ctx.principal.kind === "oauth"`).
+   * `undefined` for the `user` (first-party) and `system` (stdio/trusted)
+   * principals, which carry no scopes. This is the model input the scope gate
+   * (`scopeGateAllows`) reads when deciding whether a tool is visible/callable.
+   */
+  scopes?: string[];
+  ctx: AppContext & Partial<RequestContext>;
+}
+type McpAccessRule = boolean | ((ctx: McpAccessRuleContext) => boolean | Promise<boolean>);
+/**
+ * OAuth scope requirement declaration. A single scope string, a list (all
+ * required — AND), or `false` to explicitly require no scope (public even to
+ * scoped OAuth callers). `undefined` means "fall back to the default mapping".
+ */
+type McpRequiredScopes = string | string[] | false;
+type McpEntityPolicy = boolean | {
+  expose?: boolean;
+  read?: boolean | McpAccessRule;
+  write?: boolean | McpAccessRule;
+  delete?: boolean | McpAccessRule;
+  operations?: Record<string, boolean | McpAccessRule>;
+  /**
+   * Scopes an OAuth caller must hold to reach this entity. Declarable at
+   * the entity level (applies to every operation) and/or per operation via
+   * {@link McpEntityPolicy.operationScopes}. When omitted, the default
+   * operation→scope mapping is derived from the operation kind (e.g.
+   * `collections:<name>:read`). Resolved by `requiredScopesForOperation`
+   * and enforced by the scope gate (`scopeGateAllows`) at both
+   * `tools/list` and `tools/call`.
+   */
+  requiredScopes?: McpRequiredScopes;
+  /**
+   * Per-operation scope requirements, keyed by operation name
+   * (`list`/`get`/`create`/`update`/`delete`/`invoke`/…). Overrides both
+   * {@link McpEntityPolicy.requiredScopes} and the default mapping for the
+   * named operation.
+   */
+  operationScopes?: Record<string, McpRequiredScopes>;
+  fields?: {
+    include?: string[];
+    exclude?: string[];
+  };
+  description?: string;
+};
+interface McpCrudDefaults {
+  collections?: {
+    read?: boolean | McpAccessRule;
+    write?: boolean | McpAccessRule;
+    delete?: boolean | McpAccessRule;
+  };
+  globals?: {
+    read?: boolean | McpAccessRule;
+    write?: boolean | McpAccessRule;
+  };
+}
+interface McpCrudConfig {
+  defaults?: McpCrudDefaults;
+  collections?: Record<string, McpEntityPolicy>;
+  globals?: Record<string, McpEntityPolicy>;
+  maxLimit?: number;
+}
+interface McpRoutesConfig {
+  exposeAnnotated?: boolean;
+  routes?: Record<string, McpEntityPolicy>;
+}
+interface McpResourcesConfig {
+  schemas?: boolean;
+  routes?: boolean;
+}
+interface McpTransportConfig {
+  accessMode?: McpAccessMode;
+}
+interface McpHttpConfig extends McpTransportConfig {
+  allowedOrigins?: string[];
+  allowedHosts?: string[];
+  enableJsonResponse?: boolean;
+}
+interface McpStdioConfig extends McpTransportConfig {}
+interface McpConfig {
+  name?: string;
+  version?: string;
+  crud?: McpCrudConfig;
+  routes?: McpRoutesConfig;
+  resources?: McpResourcesConfig;
+  http?: McpHttpConfig;
+  stdio?: McpStdioConfig;
+}
+interface McpExecutionOptions {
+  transport?: McpTransportKind;
+  accessMode?: McpAccessMode;
+  ctx?: AppContext & Partial<RequestContext>;
+  request?: Request;
+  config?: McpConfig;
+}
+interface McpToolHandlerArgs<TInput = unknown> {
+  input: TInput;
+  ctx: AppContext & Partial<RequestContext>;
+  transport: McpTransportKind;
+  accessMode: McpAccessMode;
+  request?: Request;
+}
+interface McpToolConfig<TInputSchema extends z.ZodTypeAny = z.ZodTypeAny, TOutputSchema extends z.ZodTypeAny = z.ZodTypeAny> {
+  title?: string;
+  description?: string;
+  inputSchema?: TInputSchema;
+  outputSchema?: TOutputSchema;
+  annotations?: ToolAnnotations;
+  access?: McpAccessRule;
+  /**
+   * Scopes an OAuth caller must hold to reach this custom tool (all required —
+   * AND). Custom tools have no default mapping (there is no resource/operation
+   * to derive one from), so an omitted value requires no scope. Enforced by the
+   * scope gate (`scopeGateAllows`) at both `tools/list` (hidden) and
+   * `tools/call` (denied); `system`/`user` callers carry no scopes and skip it.
+   */
+  scopes?: McpRequiredScopes;
+  _meta?: Record<string, unknown>;
+}
+interface McpToolDefinition<TInputSchema extends z.ZodTypeAny = z.ZodTypeAny, TOutputSchema extends z.ZodTypeAny = z.ZodTypeAny> {
+  readonly __brand: "mcpTool";
+  readonly name: string;
+  readonly config: McpToolConfig<TInputSchema, TOutputSchema>;
+  readonly handler: (args: McpToolHandlerArgs<z.infer<TInputSchema>>) => CallToolResult | Promise<CallToolResult>;
+}
+declare module "questpie" {
+  interface AppStateConfig {
+    mcp?: McpConfig;
+  }
+  interface ModuleDefinition {
+    mcpTools?: Record<string, McpToolDefinition>;
+  }
+}
+//#endregion
+//#region src/server/runtime.d.ts
+type QuestpieApp = Parameters<typeof createContextFactory>[0];
+//#endregion
+//#region src/server/stdio.d.ts
+declare function startStdioServer(app: QuestpieApp, options?: Omit<McpExecutionOptions, "transport">): Promise<_modelcontextprotocol_sdk_server_mcp0.McpServer>;
+//#endregion
+export { McpToolDefinition as _, McpAccessRuleContext as a, McpCrudDefaults as c, McpHttpConfig as d, McpRequiredScopes as f, McpToolConfig as g, McpStdioConfig as h, McpAccessRule as i, McpEntityPolicy as l, McpRoutesConfig as m, QuestpieApp as n, McpConfig as o, McpResourcesConfig as p, McpAccessMode as r, McpCrudConfig as s, startStdioServer as t, McpExecutionOptions as u, McpToolHandlerArgs as v, McpTransportKind as y };

package/dist/stdio.d.mts

@@ -0,0 +1,2 @@
+import { t as startStdioServer } from "./stdio-t_9rKayH.mjs";
+export { startStdioServer };

package/dist/stdio.mjs

@@ -0,0 +1,3 @@
+import { t as startStdioServer } from "./stdio-qyQFVEyU.mjs";
+
+export { startStdioServer };