devframe 0.9.20 → 0.10.0

package/dist/adapters/mcp.mjs

@@ -1,598 +1,2 @@
-import { t as Diagnostic } from "../nostics-D0PvLZsn.mjs";
-import { t as DEVFRAME_EVENTS } from "../events-BV4Dj59a.mjs";
-import { n as isLoopbackAddress, t as isAllowedOrigin } from "../origin-D_eBKEzr.mjs";
-import { r as timingSafeEqual } from "../crypto-token-TVbGGFuj.mjs";
-import { t as diagnostics } from "../diagnostics-DZA6KQ_Z.mjs";
-import { t as createHostContext } from "../context-BLXXjoBW.mjs";
-import { t as toAgentToolName } from "../agent-tool-name-DGzeuWcO.mjs";
-import { join } from "pathe";
-import process from "node:process";
-import { homedir } from "node:os";
-import { defineHandler, getRequestIP } from "h3";
-import { Server, createMcpHandler } from "@modelcontextprotocol/server";
-//#region src/adapters/mcp/stringify.ts
-/**
-* JSON-coercing serializer for MCP text payloads.
-*
-* MCP carries tool results and resource reads as plain text over a
-* JSON-RPC transport, so we cannot use the `s:`-prefixed structured-clone
-* format the WS RPC transport falls back to for non-JSON values. Instead,
-* we coerce common non-JSON types into JSON-friendly forms so the LLM
-* client sees something useful instead of `[object Object]`.
-*
-* Coercions:
-*   - `BigInt` → `"123n"`
-*   - `Date` → ISO string (via the native `toJSON`)
-*   - `Map` → `{ __type: 'Map', entries: [[k, v], …] }`
-*   - `Set` → `{ __type: 'Set', entries: [v, …] }`
-*   - `Error` → `{ name, message, stack, cause? }` (cause recurses)
-*   - `Function` → `"[Function: name]"`
-*   - `Symbol` → `value.toString()`
-*   - cycles → `"[Circular]"`
-*/
-function stringifyForMcp(value) {
-	if (value === void 0) return "undefined";
-	if (typeof value === "string") return value;
-	const seen = /* @__PURE__ */ new WeakSet();
-	return JSON.stringify(value, (_key, val) => {
-		if (typeof val === "bigint") return `${val}n`;
-		if (val instanceof Error) {
-			const out = {
-				name: val.name,
-				message: val.message,
-				stack: val.stack
-			};
-			if (val.cause !== void 0) out.cause = val.cause;
-			return out;
-		}
-		if (val instanceof Map) return {
-			__type: "Map",
-			entries: [...val.entries()]
-		};
-		if (val instanceof Set) return {
-			__type: "Set",
-			entries: [...val]
-		};
-		if (typeof val === "function") return `[Function: ${val.name || "anonymous"}]`;
-		if (typeof val === "symbol") return val.toString();
-		if (val !== null && typeof val === "object") {
-			if (seen.has(val)) return "[Circular]";
-			seen.add(val);
-		}
-		return val;
-	}, 2);
-}
-/**
-* Format a thrown value for an MCP `isError` text payload.
-*
-* A nostics `Diagnostic` (every coded devframe error) becomes structured
-* JSON (`{ error: { code, message, fix?, docs? } }`), so an agent receives
-* the actionable next step (`fix`) and the docs URL instead of a bare
-* message string. Other errors surface `Error.name`/`message`, plus one
-* level of `cause.message` so context isn't dropped silently.
-*/
-function formatMcpError(error) {
-	if (error instanceof Diagnostic) return JSON.stringify({ error: {
-		code: error.code,
-		message: error.message,
-		...error.fix ? { fix: error.fix } : {},
-		...error.docs ? { docs: error.docs } : {}
-	} }, null, 2);
-	if (!(error instanceof Error)) return String(error);
-	const cause = error.cause;
-	const causeText = cause instanceof Error ? ` (cause: ${cause.message})` : cause !== void 0 ? ` (cause: ${String(cause)})` : "";
-	return `${error.name}: ${error.message}${causeText}`;
-}
-//#endregion
-//#region src/adapters/mcp/to-json-schema.ts
-const FALLBACK_OBJECT_SCHEMA = Object.freeze({
-	type: "object",
-	additionalProperties: true
-});
-/**
-* Convert a Standard Schema to JSON Schema for the agent/MCP surface.
-*
-* Devframe stays validator-neutral, so conversion uses the schema's own
-* [Standard JSON Schema](https://standardschema.dev/) converter
-* (`~standard.jsonSchema`) when the validator provides one; zod 4 does,
-* for example. Validators without a native converter (e.g. valibot) degrade
-* to a permissive object schema rather than pulling in a converter library.
-*/
-function safeToJsonSchema(schema) {
-	const standard = schema["~standard"];
-	if (standard.jsonSchema) try {
-		return standard.jsonSchema.input({ target: "draft-2020-12" });
-	} catch {
-		return FALLBACK_OBJECT_SCHEMA;
-	}
-	return FALLBACK_OBJECT_SCHEMA;
-}
-/**
-* JSON Schema for an RPC return value on the agent/MCP surface.
-* @internal
-*/
-function returnToJsonSchema(schema) {
-	if (!schema) return void 0;
-	return safeToJsonSchema(schema);
-}
-/**
-* JSON Schema for an RPC function's positional args on the agent/MCP
-* surface. Each positional arg is advertised under `arg0` / `arg1` / …,
-* matching how the agent bridge coerces the incoming object payload back
-* into positional arguments.
-*
-* Returns `{ type: 'object', properties: {} }` when there are no args.
-* @internal
-*/
-function argsToJsonSchema(args) {
-	if (!args || args.length === 0) return {
-		type: "object",
-		properties: {}
-	};
-	const properties = {};
-	const required = [];
-	for (let i = 0; i < args.length; i++) {
-		const key = `arg${i}`;
-		properties[key] = safeToJsonSchema(args[i]);
-		required.push(key);
-	}
-	return {
-		type: "object",
-		properties,
-		required,
-		additionalProperties: false
-	};
-}
-//#endregion
-//#region src/adapters/mcp/build-server.ts
-/**
-* Build a fresh MCP {@link Server} over a devframe context, registering its
-* tool and resource handlers. This is a pure factory: it sets up no
-* long-lived subscriptions and holds no per-connection state, so it is safe
-* to call once per request under `createMcpHandler` or once per connection
-* under `serveStdio`. Change notifications are published separately: over
-* HTTP through the handler's `notify` bus (see `createMcpFetchHandler`), and
-* on stdio through the connection's own `send*ListChanged` calls (see
-* {@link bridgeListChanged}, wired by `serveStdio`).
-*
-* @internal
-*/
-function buildMcpServerFromContext(ctx, options) {
-	const server = new Server({
-		name: options.serverName,
-		version: options.serverVersion
-	}, { capabilities: {
-		tools: { listChanged: true },
-		resources: { listChanged: true }
-	} });
-	registerToolHandlers(server, ctx, options.exposeSharedState);
-	registerResourceHandlers(server, ctx, options.exposeSharedState);
-	return server;
-}
-/**
-* Publish devframe's `list_changed` events through a set of typed sinks:
-* `tools()` for tool-list changes and `resources()` for resource-list
-* changes (shared-state keys are surfaced as resources). Returns an
-* unsubscribe function.
-*
-* The HTTP path passes the handler's `notify` bus sugar; the stdio path
-* passes the pinned server's `send*ListChanged` methods, which `serveStdio`
-* routes onto the connection's active `subscriptions/listen` streams.
-*
-* @internal
-*/
-function bridgeListChanged(ctx, sinks) {
-	const offManifest = ctx.agent.events.on(DEVFRAME_EVENTS.bus.agentManifestChanged, () => {
-		sinks.tools();
-		sinks.resources();
-	});
-	const offKeyAdded = ctx.rpc.sharedState.onKeyAdded(() => {
-		sinks.resources();
-	});
-	return () => {
-		offManifest();
-		offKeyAdded();
-	};
-}
-/**
-* Build an MCP server over the agent surface of a devframe definition.
-* Currently supports `stdio` transport only.
-*/
-async function createMcpServer(definition, options = {}) {
-	const transport = options.transport ?? "stdio";
-	if (transport !== "stdio") throw diagnostics.DF0017({
-		transport,
-		reason: "Only stdio transport is supported in this release."
-	});
-	const ctx = await createHostContext({
-		cwd: process.cwd(),
-		mode: "dev",
-		host: {
-			mountStatic: () => {},
-			resolveOrigin: () => "mcp://devframe",
-			getStorageDir: (scope) => {
-				if (scope === "workspace") return join(process.cwd(), ".devframe");
-				if (scope === "project") return join(process.cwd(), `node_modules/.${definition.id}/devframe`);
-				return join(homedir(), `.${definition.id}/devframe`);
-			}
-		},
-		importMetaUrl: definition.importMetaUrl
-	});
-	for (const input of definition.services ?? []) ctx.services.install(input, { resolveFrom: definition.importMetaUrl });
-	await ctx.services.ready();
-	await definition.setup(ctx);
-	const buildOptions = {
-		serverName: options.serverName ?? `${definition.id} (devframe)`,
-		serverVersion: options.serverVersion ?? definition.version ?? "0.0.0",
-		exposeSharedState: options.exposeSharedState ?? true
-	};
-	let handle;
-	try {
-		const { serveStdio } = await import("@modelcontextprotocol/server/stdio");
-		handle = serveStdio(() => {
-			const server = buildMcpServerFromContext(ctx, buildOptions);
-			const unbridge = bridgeListChanged(ctx, {
-				tools: () => {
-					server.sendToolListChanged().catch(() => {});
-				},
-				resources: () => {
-					server.sendResourceListChanged().catch(() => {});
-				}
-			});
-			const priorOnClose = server.onclose;
-			server.onclose = () => {
-				unbridge();
-				priorOnClose?.();
-			};
-			return server;
-		});
-	} catch (error) {
-		const reason = error instanceof Error ? error.message : String(error);
-		throw diagnostics.DF0017({
-			transport,
-			reason,
-			cause: error
-		});
-	}
-	options.onReady?.({ transport: "stdio" });
-	return { async stop() {
-		await handle.close();
-	} };
-}
-/**
-* Id of the built-in shared-state read tool, namespaced like every other
-* built-in (`devframe:<area>:<fn>`). Tool-shaped access matters because many
-* MCP clients only consume tools; the parallel `devframe://state/<key>`
-* resource projection stays for the clients that do read resources.
-*/
-const READ_STATE_TOOL = "devframe:state:read";
-/** Wire name of the built-in shared-state read tool: `devframe_state_read`. */
-const READ_STATE_NAME = toAgentToolName(READ_STATE_TOOL);
-function sharedStateFilter(exposeSharedState) {
-	if (exposeSharedState === false) return void 0;
-	return typeof exposeSharedState === "function" ? exposeSharedState : () => true;
-}
-function readStateToolProjection() {
-	return {
-		name: READ_STATE_NAME,
-		title: "Read shared state",
-		description: "Read this devtool's live shared state. Call without arguments to list the available keys, then with a key to get that value as JSON. Safe to call freely.",
-		inputSchema: {
-			type: "object",
-			properties: { key: {
-				type: "string",
-				description: "A shared-state key from the key list. Omit to list all keys."
-			} }
-		},
-		annotations: {
-			title: "Read shared state",
-			readOnlyHint: true,
-			destructiveHint: false
-		}
-	};
-}
-async function readStateResult(ctx, filter, key) {
-	const keys = ctx.rpc.sharedState.keys().filter(filter);
-	if (key === void 0) return { keys };
-	if (!keys.includes(key)) throw diagnostics.DF0048({ key });
-	return {
-		key,
-		value: (await ctx.rpc.sharedState.get(key)).value()
-	};
-}
-function registerToolHandlers(server, ctx, exposeSharedState) {
-	const stateFilter = sharedStateFilter(exposeSharedState);
-	const warnedCollisions = /* @__PURE__ */ new Set();
-	/**
-	* Resolve a wire tool name back to the registered {@link AgentTool}.
-	* Wire-name matching runs first, in manifest order (the same tool the
-	* list projection advertises under that name), with a raw-id fallback so
-	* a colon-namespaced id keeps working as a call name.
-	*/
-	const resolveTool = (name) => {
-		return ctx.agent.list().tools.find((tool) => toAgentToolName(tool.id) === name) ?? ctx.agent.getTool(name);
-	};
-	server.setRequestHandler("tools/list", async () => {
-		const byName = /* @__PURE__ */ new Map();
-		for (const tool of ctx.agent.list().tools) {
-			const name = toAgentToolName(tool.id);
-			const existing = byName.get(name);
-			if (existing) {
-				if (!warnedCollisions.has(`${name}|${tool.id}`)) {
-					warnedCollisions.add(`${name}|${tool.id}`);
-					diagnostics.DF0047({
-						name,
-						id: tool.id,
-						existing: existing.id
-					});
-				}
-				continue;
-			}
-			byName.set(name, tool);
-		}
-		const tools = [...byName.entries()].map(([name, tool]) => projectTool(name, tool, ctx));
-		if (stateFilter && !byName.has(READ_STATE_NAME)) tools.push(readStateToolProjection());
-		return { tools };
-	});
-	server.setRequestHandler("tools/call", async (request) => {
-		const { name, arguments: args } = request.params;
-		try {
-			const tool = resolveTool(name);
-			if (stateFilter && !tool && (name === READ_STATE_NAME || name === READ_STATE_TOOL)) {
-				const key = args?.key;
-				const result = await readStateResult(ctx, stateFilter, key);
-				return {
-					content: [{
-						type: "text",
-						text: stringifyForMcp(result)
-					}],
-					structuredContent: result
-				};
-			}
-			const outputSchema = tool ? usableOutputSchema(tool.outputSchema ?? computeOutputSchema(tool, ctx)) : void 0;
-			const result = await ctx.agent.invoke(tool?.id ?? name, args ?? {});
-			return {
-				content: [{
-					type: "text",
-					text: stringifyForMcp(result)
-				}],
-				...outputSchema ? { structuredContent: result } : {}
-			};
-		} catch (error) {
-			return {
-				isError: true,
-				content: [{
-					type: "text",
-					text: `Error invoking "${name}": ${formatMcpError(error)}`
-				}]
-			};
-		}
-	});
-}
-function registerResourceHandlers(server, ctx, exposeSharedState) {
-	const stateFilter = sharedStateFilter(exposeSharedState);
-	server.setRequestHandler("resources/list", async () => {
-		const resources = ctx.agent.list().resources.map((resource) => ({
-			uri: resource.uri,
-			name: resource.name,
-			description: resource.description,
-			mimeType: resource.mimeType
-		}));
-		if (stateFilter) for (const key of ctx.rpc.sharedState.keys()) {
-			if (!stateFilter(key)) continue;
-			resources.push({
-				uri: `devframe://state/${encodeURIComponent(key)}`,
-				name: key,
-				description: `Shared state: ${key}`,
-				mimeType: "application/json"
-			});
-		}
-		return { resources };
-	});
-	server.setRequestHandler("resources/read", async (request) => {
-		const { uri } = request.params;
-		const parsed = parseResourceUri(uri);
-		if (parsed.kind === "resource") {
-			const content = await ctx.agent.read(parsed.id);
-			return { contents: [{
-				uri,
-				mimeType: content.mimeType ?? "application/json",
-				text: content.text ?? stringifyForMcp(content.json)
-			}] };
-		}
-		if (parsed.kind === "state") {
-			if (!stateFilter || !stateFilter(parsed.key)) throw diagnostics.DF0048({ key: parsed.key });
-			return { contents: [{
-				uri,
-				mimeType: "application/json",
-				text: stringifyForMcp((await ctx.rpc.sharedState.get(parsed.key)).value())
-			}] };
-		}
-		throw new Error(`[devframe/mcp] unknown resource URI "${uri}"`);
-	});
-}
-/**
-* MCP constrains a tool's `outputSchema` to a JSON Schema of `type:
-* "object"`; clients (the SDK included) reject anything else. Non-object
-* return schemas (e.g. a schema for `void` / a bare string) simply project
-* no output schema; the text content still carries the result.
-*/
-function usableOutputSchema(schema) {
-	return schema && typeof schema === "object" && schema.type === "object" ? schema : void 0;
-}
-function projectTool(name, tool, ctx) {
-	const inputSchema = tool.inputSchema ?? computeInputSchema(tool, ctx);
-	const outputSchema = usableOutputSchema(tool.outputSchema ?? computeOutputSchema(tool, ctx));
-	return {
-		name,
-		title: tool.title,
-		description: tool.description,
-		inputSchema,
-		...outputSchema ? { outputSchema } : {},
-		annotations: {
-			title: tool.title,
-			readOnlyHint: tool.safety === "read",
-			destructiveHint: tool.safety === "destructive"
-		}
-	};
-}
-function computeInputSchema(tool, ctx) {
-	if (tool.kind === "tool") return argsToJsonSchema(tool.args);
-	if (tool.kind !== "rpc" || !tool.rpcName) return {
-		type: "object",
-		properties: {}
-	};
-	const def = ctx.rpc.definitions.get(tool.rpcName);
-	if (!def) return {
-		type: "object",
-		properties: {}
-	};
-	const args = def.args;
-	return argsToJsonSchema(args);
-}
-function computeOutputSchema(tool, ctx) {
-	if (tool.kind !== "rpc" || !tool.rpcName) return void 0;
-	const def = ctx.rpc.definitions.get(tool.rpcName);
-	if (!def) return void 0;
-	return returnToJsonSchema(def.returns);
-}
-function parseResourceUri(uri) {
-	const match = uri.match(/^devframe:\/\/(resource|state)\/(.+)$/);
-	if (!match) return { kind: "unknown" };
-	const [, kind, rest] = match;
-	const decoded = decodeURIComponent(rest);
-	if (kind === "resource") return {
-		kind: "resource",
-		id: decoded
-	};
-	return {
-		kind: "state",
-		key: decoded
-	};
-}
-//#endregion
-//#region src/adapters/mcp/fetch.ts
-/**
-* Parse exactly one `Authorization: Bearer <token>` credential, returning the
-* token or `undefined` for a missing, malformed, empty, or multi-credential
-* header. The token itself is never logged. `\S+` rejects the whitespace that
-* a second credential (fetch merges duplicate headers as `a, b`) or an empty
-* value would introduce.
-*/
-function parseBearerToken(header) {
-	if (!header) return void 0;
-	const match = /^Bearer (\S+)$/i.exec(header.trim());
-	return match ? match[1] : void 0;
-}
-/**
-* Resolve the identity gate for one request. `false` is the origin-only
-* opt-out; a callback delegates identity; a string requires a constant-time
-* bearer match. Never reveals whether a supplied token was close to correct.
-*/
-async function isAuthorized(req, authorization) {
-	if (authorization === false) return true;
-	if (typeof authorization === "function") return await authorization(req) === true;
-	const token = parseBearerToken(req.headers.get("authorization"));
-	if (token === void 0) return false;
-	return timingSafeEqual(token, authorization);
-}
-/**
-* Build a framework-agnostic MCP endpoint over a devframe context: a
-* web-standard `Request → Response` handler any host can mount: h3 (see
-* `mountMcpHttp`), a Next.js App Router route, or any other fetch-shaped
-* server.
-*
-* The endpoint is **stateless**: it serves the 2026-07-28 revision per request
-* through the SDK's {@link createMcpHandler}, which builds a fresh MCP server
-* (from the shared, live `ctx` via `buildMcpServerFromContext`) for each
-* request: no `Mcp-Session-Id` registry, no session-local routing, no
-* GET/DELETE teardown protocol. 2025-era clients are still served through the
-* SDK's default stateless legacy path. `list_changed` events reach modern
-* `subscriptions/listen` streams through the handler's `notify` bus.
-*
-* The origin gate guards every request: loopback-default DNS-rebinding
-* protection that (unlike the WS upgrade's `isAllowedOrigin`) also rejects
-* `Origin`-less requests, so a browser can't reach the route across origins (a
-* disallowed origin gets `403`). The `Origin` header is only browser hardening:
-* a non-browser client forges it. So on the zero-config default (no widened
-* `allowedOrigins`, no identity check) a second locality gate requires the
-* connected peer to be loopback, proven from the host-supplied
-* {@link McpConnectionInfo.remoteAddress} (which a client cannot forge), so the
-* "trusts same-machine callers" default holds against a remote raw client.
-* When same-machine isn't your trust boundary, add an identity gate
-* ({@link CreateMcpFetchHandlerOptions.authorization}), checked after the
-* origin gate: a bearer/callback check that proves *who* is calling (a
-* missing/invalid credential gets `401` with a `WWW-Authenticate: Bearer`
-* challenge), which also lifts the loopback-peer restriction for authenticated
-* callers.
-*/
-function createMcpFetchHandler(ctx, options) {
-	const allowedOrigins = options.allowedOrigins;
-	const authorization = options.authorization ?? false;
-	const handler = createMcpHandler(() => buildMcpServerFromContext(ctx, {
-		serverName: options.serverName,
-		serverVersion: options.serverVersion,
-		exposeSharedState: options.exposeSharedState
-	}));
-	const unbridge = bridgeListChanged(ctx, {
-		tools: () => {
-			handler.notify.toolsChanged();
-		},
-		resources: () => {
-			handler.notify.resourcesChanged();
-		}
-	});
-	const originOnlyDefault = allowedOrigins === void 0 && authorization === false;
-	async function handle(req, connection) {
-		const origin = req.headers.get("origin") ?? void 0;
-		if (allowedOrigins !== false && (origin === void 0 || !isAllowedOrigin(origin, allowedOrigins ?? []))) return new Response("Forbidden", { status: 403 });
-		if (originOnlyDefault && connection?.remoteAddress !== void 0 && !isLoopbackAddress(connection.remoteAddress)) return new Response("Forbidden", { status: 403 });
-		if (!await isAuthorized(req, authorization)) return new Response("Unauthorized", {
-			status: 401,
-			headers: { "WWW-Authenticate": "Bearer" }
-		});
-		return handler.fetch(req);
-	}
-	return {
-		fetch: handle,
-		dispose: async () => {
-			unbridge();
-			await handler.close();
-		}
-	};
-}
-//#endregion
-//#region src/adapters/mcp/http.ts
-/**
-* Mount a stateless MCP endpoint on an h3 app at `path`: the h3 binding over
-* {@link createMcpFetchHandler}, which owns the per-request serving, the
-* origin gate, and the transport plumbing.
-*
-* The handler is web-standard: it takes the h3 event's web `Request` and
-* returns a web `Response` (an SSE `ReadableStream` body for a
-* `subscriptions/listen` stream). We copy that response onto `event.res` and
-* return its body rather than returning the `Response` object directly, so an
-* MCP error response (e.g. a 4xx) isn't swallowed by h3's "Response-with-404
-* falls through to the next handler" rule (which would otherwise hand the
-* request to the SPA static catch-all).
-*/
-function mountMcpHttp(app, ctx, path, options) {
-	const handler = createMcpFetchHandler(ctx, options);
-	app.use(path, defineHandler(async (event) => respond(event, await handler.fetch(event.req, { remoteAddress: getRequestIP(event) }))));
-	return { dispose: handler.dispose };
-}
-/**
-* Copy a web `Response` from the MCP transport onto the h3 event's response
-* and return its body. Returning the body (a `ReadableStream` or `null`)
-* rather than the `Response` object avoids h3's 404-fall-through behavior.
-*/
-function respond(event, response) {
-	event.res.status = response.status;
-	event.res.statusText = response.statusText;
-	response.headers.forEach((value, key) => {
-		event.res.headers.set(key, value);
-	});
-	return response.body ?? "";
-}
-//#endregion
+import { createMcpFetchHandler, createMcpServer, mountMcpHttp } from "@devframes/agentic/mcp";
 export { createMcpFetchHandler, createMcpServer, mountMcpHttp };

package/dist/agentic-D4QQQUjE.d.mts

@@ -0,0 +1,30 @@
+import { B as DevframeDefinition, F as CreateMcpServerOptions, L as McpFetchHandler, P as CreateMcpFetchHandlerOptions, R as McpServerHandle, o as DevframeNodeContext } from "./context-CTAxz9ec.mjs";
+import { H3 } from "h3";
+//#region src/node/agentic.d.ts
+/**
+ * The h3-bound half of the MCP adapter contract (the SDK-neutral half lives
+ * in `types/mcp.ts`, which must stay lib-neutral; h3's declarations are not).
+ */
+interface MountMcpHttpOptions extends CreateMcpFetchHandlerOptions {}
+interface MountedMcpHttp {
+  /** Tear down the MCP handler (aborts in-flight exchanges, drops the change bridge). */
+  dispose: () => Promise<void>;
+}
+/** The surface `@devframes/agentic/mcp` exports, as devframe's loaders consume it. */
+interface AgenticMcpModule {
+  /** Build an MCP server over the agent surface of a devframe definition (stdio). */
+  createMcpServer: (definition: DevframeDefinition, options?: CreateMcpServerOptions) => Promise<McpServerHandle>;
+  /** Build a framework-agnostic `Request → Response` MCP endpoint over a devframe context. */
+  createMcpFetchHandler: (ctx: DevframeNodeContext, options: CreateMcpFetchHandlerOptions) => McpFetchHandler;
+  /** Mount a stateless MCP endpoint on an h3 app at `path`. */
+  mountMcpHttp: (app: H3, ctx: DevframeNodeContext, path: string, options: MountMcpHttpOptions) => MountedMcpHttp;
+}
+/**
+ * Load the MCP adapter from `@devframes/agentic/mcp`, mapping a failed load
+ * (typically: the optional peer is not installed) to a thrown `DF0079`.
+ * Loads through `importRuntimeModule`, so the adapter and the MCP SDK behind
+ * it never enter a consumer's bundle graph.
+ */
+declare function importAgenticMcp(specifier?: string): Promise<AgenticMcpModule>;
+//#endregion
+export { importAgenticMcp as i, MountMcpHttpOptions as n, MountedMcpHttp as r, AgenticMcpModule as t };