devframe 0.9.19 → 0.10.0

package/dist/cli/main.mjs

@@ -1,118 +1,19 @@
-import { t as Diagnostic } from "../nostics-D0PvLZsn.mjs";
-import { t as diagnostics } from "../diagnostics-DZA6KQ_Z.mjs";
-import { n as listLiveDevframeInstances, r as probeDevframeOrigin } from "../instance-registry-DCq762YJ.mjs";
-import { t as toAgentToolName } from "../agent-tool-name-DGzeuWcO.mjs";
+import { t as diagnostics } from "../diagnostics-Cx4_VjlG.mjs";
+import { t as importRuntimeModule } from "../import-runtime-module-BzlEQ9PI.mjs";
 import process from "node:process";
-import { joinURL } from "ufo";
 import { cac } from "cac";
-//#region src/cli/connect.ts
-/**
-* Resolve the per-record bearer from the {@link ConnectServerOptions.authToken}
-* option. Exported for focused tests of the credential resolution.
-*/
-function resolveAuthToken(authToken, record) {
-	return typeof authToken === "function" ? authToken(record) : authToken;
-}
-/**
-* Build the request headers the connector sends to one instance's MCP route:
-* the instance's own (loopback) `origin` so the route's origin gate accepts
-* this native client, plus `Authorization: Bearer <token>` when a bearer is
-* configured. The bearer appears **only** here, never in the connection URL,
-* the registry records, or the indexed results. Exported for focused tests.
-*/
-function buildInstanceRequestHeaders(url, token) {
-	const headers = { origin: new URL(url).origin };
-	if (token) headers.authorization = `Bearer ${token}`;
-	return headers;
+//#region src/cli/main.ts
+/** Parse the repeatable `--port` flag value(s) from cac into numbers. */
+function parsePortsFlag(value) {
+	return (Array.isArray(value) ? value : value === void 0 ? [] : [value]).map((v) => Number(v)).filter((n) => Number.isInteger(n) && n > 0 && n < 65536);
 }
-const INDEX_TOOL = toAgentToolName("devframe:connect:list-instances");
-const CALL_TOOL = toAgentToolName("devframe:connect:call-tool");
-const MCP_DISABLED_HINT = "This instance runs without an MCP route. Restart it with the --mcp flag (or set `cli.mcp: true` on its definition) to expose its tools, then list instances again.";
-const GATEWAY_TOOLS = [{
-	name: INDEX_TOOL,
-	title: "Discover running devframes",
-	description: "Discover every running devframe dev server on this machine and list each one's MCP tools. Call this FIRST, before assuming which devtools are available; the result names the instance (id, project root, origin) and the port to pass to the call tool. Safe to call freely.",
-	inputSchema: {
-		type: "object",
-		properties: {}
-	},
-	annotations: {
-		readOnlyHint: true,
-		destructiveHint: false
-	}
-}, {
-	name: CALL_TOOL,
-	title: "Call a devframe tool",
-	description: "Invoke one MCP tool on one running devframe instance discovered via the list-instances tool. Pass the instance's port, the tool name, and the tool's arguments object.",
-	inputSchema: {
-		type: "object",
-		properties: {
-			port: {
-				type: "number",
-				description: "The instance's port, from the list-instances tool."
-			},
-			tool: {
-				type: "string",
-				description: "Tool name, from the instance's tool list."
-			},
-			args: {
-				type: "object",
-				description: "Arguments object for the tool. Omit for zero-argument tools."
-			}
-		},
-		required: ["port", "tool"],
-		additionalProperties: false
-	}
-}];
 /**
-* Start the devframe MCP connector on stdio: a thin discovery + proxy server
-* in the shape Vercel's next-devtools-mcp (https://github.com/vercel/next-devtools-mcp)
-* validated; credit is due there for the architecture this connector follows.
-* It exposes two gateway tools:
-* `devframe_connect_list-instances` (discover running devframe instances via
-* the instance registry and list each one's MCP tools) and
-* `devframe_connect_call-tool` (invoke one tool on one instance over its
-* Streamable-HTTP endpoint), and holds no domain knowledge of its own.
+* Load the connector from the optional `@devframes/agentic` peer, mapping a
+* failed load (typically: the peer is not installed) to a thrown `DF0046`.
 */
-async function startConnectServer(options = {}) {
-	const sdk = await importSdk();
-	const server = new sdk.Server({
-		name: "devframe-connect",
-		version: "0.0.0"
-	}, { capabilities: { tools: {} } });
-	server.setRequestHandler("tools/list", async () => ({ tools: GATEWAY_TOOLS }));
-	server.setRequestHandler("tools/call", async (request) => {
-		const { name, arguments: args } = request.params;
-		try {
-			if (name === INDEX_TOOL) return textResult(await index(sdk, options));
-			if (name === CALL_TOOL) return textResult(await call(sdk, options, args ?? {}));
-			return errorResult({
-				message: `unknown tool "${name}"`,
-				fix: `Call ${INDEX_TOOL} or ${CALL_TOOL}.`
-			});
-		} catch (error) {
-			return errorResult(toErrorPayload(error));
-		}
-	});
-	const transport = new sdk.StdioServerTransport();
-	await server.connect(transport);
-	return { stop: async () => {
-		await server.close();
-	} };
-}
-async function importSdk() {
+async function importConnect() {
 	try {
-		const [serverMod, stdioMod, clientMod] = await Promise.all([
-			import("@modelcontextprotocol/server"),
-			import("@modelcontextprotocol/server/stdio"),
-			import("@modelcontextprotocol/client")
-		]);
-		return {
-			Server: serverMod.Server,
-			StdioServerTransport: stdioMod.StdioServerTransport,
-			Client: clientMod.Client,
-			StreamableHTTPClientTransport: clientMod.StreamableHTTPClientTransport
-		};
+		return await importRuntimeModule("@devframes/agentic/connect");
 	} catch (error) {
 		const reason = error instanceof Error ? error.message : String(error);
 		throw diagnostics.DF0046({
@@ -121,156 +22,6 @@ async function importSdk() {
 		});
 	}
 }
-/** Discover instances: registry (prune-on-read) + explicit port probes. */
-async function index(sdk, options) {
-	const { live } = await listLiveDevframeInstances({
-		instancesDir: options.instancesDir,
-		timeoutMs: options.timeoutMs
-	});
-	const records = [...live];
-	for (const port of options.ports ?? []) {
-		if (records.some((r) => r.port === port)) continue;
-		const probed = await probePort(port, options.timeoutMs);
-		if (probed) records.push(probed);
-	}
-	const instances = await Promise.all(records.map(async (record) => {
-		const { mcp, ...rest } = record;
-		const entry = {
-			...rest,
-			mcp: null
-		};
-		if (!mcp) {
-			entry.hint = MCP_DISABLED_HINT;
-			return entry;
-		}
-		const url = `${record.origin}${mcp.path}`;
-		try {
-			entry.mcp = {
-				url,
-				tools: await listInstanceTools(sdk, url, resolveAuthToken(options.authToken, record))
-			};
-		} catch (error) {
-			entry.mcp = {
-				url,
-				error: error instanceof Error ? error.message : String(error)
-			};
-		}
-		return entry;
-	}));
-	return {
-		instances,
-		...instances.length === 0 ? { hint: "No running devframe instances found. Start a devframe dev server (with --mcp for tools), or pass --port <n> to devframe connect if the instance predates the registry." } : {}
-	};
-}
-/**
-* Probe an explicit port for a devframe serving `__connection.json` at `/`,
-* reusing the registry's origin-candidate probe (a `localhost`-bound server
-* may listen on either address family).
-*/
-async function probePort(port, timeoutMs) {
-	const probed = await probeDevframeOrigin(`http://localhost:${port}`, "/", timeoutMs);
-	if (!probed) return null;
-	const mcpPath = probed.meta.mcp ? joinURL("/", probed.meta.mcp.path) : null;
-	return {
-		pid: -1,
-		port,
-		origin: probed.origin,
-		basePath: "/",
-		id: `port-${port}`,
-		rootDir: "",
-		mcp: mcpPath ? { path: mcpPath } : null,
-		startedAt: 0
-	};
-}
-async function listInstanceTools(sdk, url, token) {
-	return withInstanceClient(sdk, url, token, async (client) => {
-		return (await client.listTools()).tools.map((tool) => ({
-			name: tool.name,
-			description: tool.description
-		}));
-	});
-}
-async function call(sdk, options, args) {
-	if (typeof args.port !== "number" || typeof args.tool !== "string") throw diagnostics.DF0049();
-	const { live } = await listLiveDevframeInstances({
-		instancesDir: options.instancesDir,
-		timeoutMs: options.timeoutMs
-	});
-	const record = live.find((r) => r.port === args.port) ?? await probePort(args.port, options.timeoutMs);
-	if (!record) throw diagnostics.DF0050({ port: args.port });
-	if (!record.mcp) throw diagnostics.DF0051({ port: args.port });
-	return withInstanceClient(sdk, `${record.origin}${record.mcp.path}`, resolveAuthToken(options.authToken, record), async (client) => {
-		const result = await client.callTool({
-			name: args.tool,
-			arguments: args.args ?? {}
-		});
-		return {
-			instance: {
-				id: record.id,
-				port: record.port
-			},
-			tool: args.tool,
-			isError: result.isError ?? false,
-			content: result.content,
-			...result.structuredContent ? { structuredContent: result.structuredContent } : {}
-		};
-	});
-}
-async function withInstanceClient(sdk, url, token, fn) {
-	const transport = new sdk.StreamableHTTPClientTransport(new URL(url), { requestInit: { headers: buildInstanceRequestHeaders(url, token) } });
-	const client = new sdk.Client({
-		name: "devframe-connect",
-		version: "0.0.0"
-	}, { versionNegotiation: { mode: "auto" } });
-	await client.connect(transport);
-	try {
-		return await fn(client);
-	} finally {
-		await client.close().catch(() => {});
-	}
-}
-function textResult(value) {
-	return { content: [{
-		type: "text",
-		text: JSON.stringify(value, null, 2)
-	}] };
-}
-/**
-* Project a thrown value into the connector's structured error payload. A
-* nostics `Diagnostic` carries its code, `fix`, and docs URL across so the
-* calling agent gets the actionable next step.
-*/
-function toErrorPayload(error) {
-	if (error instanceof Diagnostic) return {
-		code: error.code,
-		message: error.message,
-		...error.fix ? { fix: error.fix } : {},
-		...error.docs ? { docs: error.docs } : {}
-	};
-	return {
-		message: error instanceof Error ? error.message : String(error),
-		...error && typeof error === "object" && "fix" in error && typeof error.fix === "string" ? { fix: error.fix } : {}
-	};
-}
-function errorResult(error) {
-	return {
-		isError: true,
-		content: [{
-			type: "text",
-			text: JSON.stringify({ error }, null, 2)
-		}]
-	};
-}
-/** Parse the repeatable `--port` flag value(s) from cac into numbers. */
-function parsePortsFlag(value) {
-	return (Array.isArray(value) ? value : value === void 0 ? [] : [value]).map((v) => Number(v)).filter((n) => Number.isInteger(n) && n > 0 && n < 65536);
-}
-/** Keep the connector process alive until the stdio transport closes it. */
-function keepAlive() {
-	process.stdin.resume();
-}
-//#endregion
-//#region src/cli/main.ts
 /**
 * The `devframe` bin is the framework's own CLI, distinct from the per-app
 * CLI shells authors build with `createCac(definition)`. It hosts the
@@ -279,6 +30,7 @@ function keepAlive() {
 async function runDevframeCli(argv = process.argv) {
 	const cli = cac("devframe");
 	cli.command("connect", "Run the devframe MCP connector on stdio (discovers running devframe dev servers and proxies their tools)").option("--port <port>", "Probe an explicit port besides the instance registry (repeatable)").option("--instances-dir <dir>", "Override the instance registry directory (default: ~/.devframe/instances, or $DEVFRAME_INSTANCES_DIR)").option("--timeout <ms>", "Probe timeout per instance in milliseconds", { default: 1e3 }).action(async (options) => {
+		const { startConnectServer } = await importConnect();
 		await startConnectServer({
 			ports: parsePortsFlag(options.port),
 			instancesDir: options.instancesDir,
@@ -290,7 +42,7 @@ async function runDevframeCli(argv = process.argv) {
 			*/
 			authToken: process.env.DEVFRAME_MCP_AUTH_TOKEN
 		});
-		keepAlive();
+		process.stdin.resume();
 	});
 	cli.help();
 	cli.parse(argv, { run: false });

package/dist/client/index.d.mts

@@ -1,9 +1,9 @@
-import { f as RpcCacheManager, p as RpcCacheOptions } from "../index-CiA6C705.mjs";
-import { E as RpcFunctionsCollector, _ as RpcFunctionDefinition } from "../types-D2vGd7-2.mjs";
-import { Q as DevframeServiceMeta, Vt as EventEmitter, b as StreamSink, ct as DevframeSettings, d as RpcSharedStateHost, et as DevframeServiceScopeOf, gt as SettingsForNamespace, ht as ScopedSharedStates, it as DevframeServicesState, k as SharedState, mt as ScopedServerFunctions, pt as ScopedRpcFn, t as ConnectionMeta, u as RpcSharedStateGetOptions, vt as DevframeRpcClientFunctions, y as StreamReader, yt as DevframeRpcServerFunctions } from "../context-BLHBDQcZ.mjs";
-import { t as SseRpcChannelOptions } from "../sse-client-BcbYwXdD.mjs";
-import { t as WsRpcChannelOptions } from "../ws-client-CNpP6Ium.mjs";
-import { BirpcOptions, BirpcReturn } from "birpc";
+import { i as BirpcReturn, r as BirpcOptions } from "../index-Bia1vKjL.mjs";
+import { f as RpcCacheManager, p as RpcCacheOptions } from "../index-DuEm0sDH.mjs";
+import { h as RpcFunctionDefinition, w as RpcFunctionsCollector } from "../types-BmDbfHCx.mjs";
+import { Ct as DevframeRpcClientFunctions, Kt as EventEmitter, at as DevframeServiceScopeOf, b as StreamSink, bt as ScopedSharedStates, d as RpcSharedStateHost, k as SharedState, lt as DevframeServicesState, pt as DevframeSettings, rt as DevframeServiceMeta, t as ConnectionMeta, u as RpcSharedStateGetOptions, vt as ScopedRpcFn, wt as DevframeRpcServerFunctions, xt as SettingsForNamespace, y as StreamReader, yt as ScopedServerFunctions } from "../context-CTAxz9ec.mjs";
+import { t as SseRpcChannelOptions } from "../sse-client-DNdscfu_.mjs";
+import { t as WsRpcChannelOptions } from "../ws-client-6Mrz6eC4.mjs";
 //#region src/client/connection.d.ts
 export interface DevframeConnection {
   /** Server-advertised transport and serialization metadata. */

package/dist/client/index.mjs

@@ -1,12 +1,11 @@
-import { n as DEVFRAME_EVENTS, t as defineDiagnostics } from "../nostics-DD6gsDZA.mjs";
+import { n as defineDiagnostics, r as DEVFRAME_EVENTS, t as createBirpc } from "../dist-Bw3EbMj4.mjs";
 import { t as hash } from "../hash-DdPnc4k3.mjs";
 import { createEventEmitter } from "../utils/events.mjs";
+import { withBase, withProtocol } from "../utils/url.mjs";
 import { t as createSharedState } from "../shared-state-eQVYHNqA.mjs";
 import { i as structuredCloneStringify, n as structuredCloneParse, t as structuredCloneDeserialize } from "../structured-clone-CgtQ61SA.mjs";
 import { createStreamReader, createStreamSink } from "../utils/streaming-channel.mjs";
 import { toAgentToolName } from "../utils/agent-tool-name.mjs";
-import { withBase, withProtocol } from "ufo";
-import { createBirpc } from "birpc";
 //#region src/constants.ts
 /** Devframe runtime routes and static output conventions. */
 const DEVFRAME_CONNECTION_META_FILENAME = "__connection.json";
@@ -1670,7 +1669,7 @@ function createScopedClientContext(rpc, namespace) {
 	};
 }
 //#endregion
-//#region src/adapters/mcp/to-json-schema.ts
+//#region src/agent/to-json-schema.ts
 const FALLBACK_OBJECT_SCHEMA = Object.freeze({
 	type: "object",
 	additionalProperties: true

package/dist/constants.d.mts

@@ -113,7 +113,8 @@ export declare const DEVFRAME_SSE_SESSION_HEADER = "x-birpc-session";
  * Route the Streamable-HTTP MCP endpoint is bound to, relative to a
  * devframe's base path. Sits next to `__connection.json` and the WS route
  * so an MCP client reaches it on the same origin the SPA loaded from; the
- * dev server shares one port for HTTP, WS, and MCP. Opt-in via `cli.mcp`.
+ * dev server shares one port for HTTP, WS, and MCP. Opt-in via the host's
+ * `mcp` setting.
  */
 export declare const DEVFRAME_MCP_ROUTE = "__mcp";
 export declare const DEVFRAME_RPC_DUMP_MANIFEST_FILENAME = "__rpc-dump/index.json";

package/dist/constants.mjs

@@ -36,7 +36,8 @@ const DEVFRAME_SSE_SESSION_HEADER = "x-birpc-session";
 * Route the Streamable-HTTP MCP endpoint is bound to, relative to a
 * devframe's base path. Sits next to `__connection.json` and the WS route
 * so an MCP client reaches it on the same origin the SPA loaded from; the
-* dev server shares one port for HTTP, WS, and MCP. Opt-in via `cli.mcp`.
+* dev server shares one port for HTTP, WS, and MCP. Opt-in via the host's
+* `mcp` setting.
 */
 const DEVFRAME_MCP_ROUTE = "__mcp";
 const DEVFRAME_RPC_DUMP_MANIFEST_FILENAME = "__rpc-dump/index.json";

package/dist/{context-BA5FPz7K.d.mts → context-B4BKPuaa.d.mts}

@@ -1,4 +1,4 @@
-import { k as SharedState, o as DevframeNodeContext } from "./context-BLHBDQcZ.mjs";
+import { k as SharedState, o as DevframeNodeContext } from "./context-CTAxz9ec.mjs";
 //#region src/node/hub-internals/context.d.ts
 interface InternalAnonymousAuthStorage {
   trusted: Record<string, {

package/dist/{context-BLXXjoBW.mjs → context-C141q8H4.mjs}

@@ -4,11 +4,11 @@ import { RpcFunctionsCollectorBase } from "./rpc/index.mjs";
 import { defineRpcFunction } from "./index.mjs";
 import { t as DEVFRAME_EVENTS } from "./events-BV4Dj59a.mjs";
 import { DEVFRAME_SERVICES_STATE_KEY } from "./constants.mjs";
-import { t as diagnostics$1 } from "./diagnostics-DZA6KQ_Z.mjs";
-import { i as createEventEmitter, t as DevframeAgentHost } from "./host-agent-C3MBpNCd.mjs";
-import { n as createDebug, t as resolveStaticAssetsSource } from "./remote-assets-D0StJVLp.mjs";
-import { i as satisfiesVersionRange, n as expandResolveFrom, r as importServicePackage, t as deepMergeOptionSets } from "./services-install-Ben4yh52.mjs";
-import { t as createStorage } from "./storage-B70AXK64.mjs";
+import { t as diagnostics$1 } from "./diagnostics-Cx4_VjlG.mjs";
+import { r as createEventEmitter, t as DevframeAgentHost } from "./host-agent-ZSKgzMVu.mjs";
+import { n as createDebug, t as resolveStaticAssetsSource } from "./remote-assets-B9MeWmW6.mjs";
+import { a as satisfiesVersionRange, n as expandResolveFrom, r as importServicePackage, t as deepMergeOptionSets } from "./services-install-D5YUwFXW.mjs";
+import { t as createStorage } from "./storage-CHD1IkqU.mjs";
 import { join } from "pathe";
 import { createSharedState } from "devframe/utils/shared-state";
 import process from "node:process";

package/dist/{context-jXO5vzjH.mjs → context-CHpyLX8W.mjs}

@@ -1,5 +1,5 @@
 import { n as randomToken } from "./crypto-token-TVbGGFuj.mjs";
-import { t as createStorage } from "./storage-B70AXK64.mjs";
+import { t as createStorage } from "./storage-CHD1IkqU.mjs";
 import { n as revokeAuthToken, t as revokeActiveConnectionsForToken } from "./revoke-cqztiCX4.mjs";
 import { join } from "pathe";
 //#region src/node/hub-internals/context.ts

package/dist/{context-BLHBDQcZ.d.mts → context-CTAxz9ec.d.mts}

@@ -1,10 +1,10 @@
-import { d as RpcFunctionsCollectorBase } from "./index-CiA6C705.mjs";
-import { _ as RpcFunctionDefinition, v as RpcFunctionDefinitionAny } from "./types-D2vGd7-2.mjs";
+import { i as BirpcReturn } from "./index-Bia1vKjL.mjs";
+import { d as RpcFunctionsCollectorBase } from "./index-DuEm0sDH.mjs";
+import { t as StandardSchemaV1 } from "./index-CeEtxDmK.mjs";
+import { g as RpcFunctionDefinitionAny, h as RpcFunctionDefinition } from "./types-BmDbfHCx.mjs";
 import { n as DevframeRpcConnection, t as DevframeNodeRpcSessionMeta } from "./session-r6PDixP6.mjs";
 import { a as RemoteAssetsStore, o as StaticAssetsSource } from "./remote-assets-eBvSKZMS.mjs";
-import { m as defineDiagnostics } from "./nostics-0sKe5HIj.mjs";
-import { BirpcReturn } from "birpc";
-import { StandardSchemaV1 } from "@standard-schema/spec";
+import { h as defineDiagnostics } from "./nostics-DWvukRwa.mjs";
 import { CAC } from "cac";
 //#region src/types/events.d.ts
 interface EventsMap {
@@ -1204,17 +1204,20 @@ interface DevframeSseOptions {
 type McpAuthorization = string | ((request: Request) => boolean | Promise<boolean>) | false;
 /**
  * The route-based MCP setting accepted everywhere a host mounts a devframe
- * (`cli.mcp`, `initDevframe` / `initHub` / `createDevServer` options, the
- * framework kits):
+ * (`initDevframe` / `initHub` / `createDevServer` options, `createCac` /
+ * `--mcp`, the framework kits):
  *
  * - `'auto'`, the default: mount the route when the devframe exposes an
  *   agent surface (an `agent`-flagged RPC function, or a tool / resource /
- *   provider registered on `ctx.agent`). An empty agent surface mounts
- *   nothing and loads no MCP code.
- * - `true`: always mount at the default `__mcp` route.
- * - `false`: never mount.
- * - {@link McpRouteOptions}: always mount, with a custom route path, origin
- *   allow-list, or {@link McpAuthorization} identity check.
+ *   provider registered on `ctx.agent`) AND the optional `@devframes/agentic`
+ *   peer (the MCP adapter and SDK) is installed. An empty agent surface
+ *   mounts nothing and loads no MCP code; a non-empty one without the peer
+ *   warns once (DF0078) and mounts nothing.
+ * - `true`: always mount at the default `__mcp` route; a missing
+ *   `@devframes/agentic` throws DF0079.
+ * - `false`: never mount, and never probe or warn.
+ * - {@link McpRouteOptions}: always mount (like `true`), with a custom route
+ *   path, origin allow-list, or {@link McpAuthorization} identity check.
  *
  * A mounted route trusts same-machine callers by default (the loopback
  * origin gate), exactly like `mcp: true`.
@@ -1298,36 +1301,6 @@ interface DevframeCliOptions {
    * @default true
    */
   auth?: boolean | DevframeAuthHandler;
-  /**
-   * Expose a route-based MCP server alongside the standalone dev server,
-   * speaking the MCP Streamable-HTTP transport at `/__mcp` (relative to the
-   * base path). It surfaces the same `ctx.agent` tools + shared-state
-   * resources as the stdio `mcp` command, but against the live server.
-   *
-   * Defaults to `'auto'`: the route mounts once the devframe exposes an
-   * agent surface (an `agent`-flagged RPC, a registered tool / resource).
-   * See {@link McpSetting} for the full contract, and
-   * {@link McpRouteOptions} for the route path, origin allow-list, and
-   * {@link McpAuthorization} identity check.
-   *
-   * The `--mcp` / `--no-mcp` CLI flags override this per run. Whether to expose
-   * MCP is a hosting decision, so programmatic hosts pass it to
-   * `initDevframe` / `initHub` / `createDevServer` instead.
-   *
-   * @deprecated Whether to expose MCP is a hosting decision, not a capability
-   * of the tool. Pass `mcp` to `createCac` (or the programmatic host) instead.
-   * This field is still read as a fallback, and will be removed in a future
-   * release.
-   */
-  mcp?: McpSetting;
-  /**
-   * Author's SPA dist, served as the devframe's UI.
-   *
-   * @deprecated Moved to the top-level {@link DevframeDefinition.clientAssets}.
-   * Set `clientAssets` on the definition instead. This field is still read as a
-   * fallback when `clientAssets` is unset, so existing definitions keep working.
-   */
-  distDir?: StaticAssetsSource;
   /**
    * How the browser reaches the RPC WebSocket. Defaults to sharing the HTTP
    * port on the `__ws` route. See {@link DevframeWsOptions} for the
@@ -1545,8 +1518,7 @@ interface DevframeDefinition {
    * ship inside the node package.
    *
    * Consumed by every adapter that serves the UI (`dev`, `build`, `vite`,
-   * `next`, and the hub install path). When unset, the deprecated
-   * {@link DevframeCliOptions.distDir} is read as a fallback.
+   * `next`, and the hub install path).
    */
   clientAssets?: StaticAssetsSource;
   /** RPC-level configuration for this devframe (see {@link DevframeRpcOptions}). */
@@ -1583,6 +1555,95 @@ type DevframeSnapshotRpcEntry = string | {
   inputs: DevframeSnapshotRpcInputs;
 };
 //#endregion
+//#region src/types/mcp.d.ts
+/**
+ * The MCP adapter surface, typed here so `devframe` (which probes for and
+ * lazily loads `@devframes/agentic`) and `@devframes/agentic/mcp` (which
+ * implements it) share one contract without a type-level dependency cycle.
+ * None of these shapes reference the MCP SDK: the SDK is an implementation
+ * detail of `@devframes/agentic`, freely swappable behind this surface.
+ * The h3-bound `mountMcpHttp` shapes live in `node/agentic.ts` (exported via
+ * `devframe/internal`) instead: `devframe/types` must stay lib-neutral, and
+ * h3's declarations are not.
+ */
+interface CreateMcpServerOptions {
+  /**
+   * Transport to use. `createMcpServer` itself runs `'stdio'` (a standalone
+   * process with its own host context); the Streamable-HTTP transport is
+   * served route-based by the dev server instead; see `mountMcpHttp` and
+   * the `mcp` option on `createDevServer` / `createCac`'s `--mcp` flag.
+   */
+  transport?: 'stdio';
+  /**
+   * Expose shared-state keys as MCP resources.
+   * - `true` (default): every key the host publishes
+   * - `false`: none
+   * - `(key) => boolean`: filter
+   */
+  exposeSharedState?: boolean | ((key: string) => boolean);
+  /** Override the name reported in the MCP handshake. */
+  serverName?: string;
+  /** Override the version reported in the MCP handshake. Defaults to `definition.version ?? '0.0.0'`. */
+  serverVersion?: string;
+  /** Called once the transport is connected. */
+  onReady?: (info: {
+    transport: 'stdio';
+  }) => void;
+}
+interface McpServerHandle {
+  stop: () => Promise<void>;
+}
+interface CreateMcpFetchHandlerOptions {
+  /** Name reported in the MCP handshake. */
+  serverName: string;
+  /** Version reported in the MCP handshake. */
+  serverVersion: string;
+  /** Expose shared-state keys as MCP resources; see {@link CreateMcpServerOptions.exposeSharedState}. */
+  exposeSharedState: boolean | ((key: string) => boolean);
+  /**
+   * Optional identity check, layered on top of the origin gate and checked
+   * **after** it: a bearer token string (matched in constant time against
+   * `Authorization: Bearer <token>`), a `(request) => boolean` callback, or
+   * `false` (the default) for origin-only, trusting same-machine callers. A
+   * callback governs identity only and cannot relax the origin gate. See
+   * {@link McpAuthorization}.
+   */
+  authorization?: McpAuthorization;
+  /**
+   * Origin allow-list beyond the loopback default. `false` disables the
+   * origin gate entirely. Default: loopback-only.
+   *
+   * Unlike the WS transport, the MCP route does **not** allow `Origin`-less
+   * requests: a route-based endpoint is reachable by any local process, so a
+   * request must carry an `Origin` that passes the gate. Native clients
+   * (e.g. `devframe connect`) send their loopback origin explicitly.
+   */
+  allowedOrigins?: readonly string[] | false;
+}
+/** Connection facts a host knows about a request beyond the `Request` itself. */
+interface McpConnectionInfo {
+  /**
+   * The connecting peer's remote address (a node socket's `remoteAddress`),
+   * used to prove a same-machine caller when the endpoint relies on the
+   * loopback origin default with no identity check. A host that can resolve a
+   * trustworthy peer address (the h3/node mount) supplies it; when it's
+   * omitted the origin gate stays the only locality signal.
+   */
+  remoteAddress?: string;
+}
+interface McpFetchHandler {
+  /**
+   * WHATWG-`fetch` handler for the MCP endpoint. Hand every method
+   * (POST/GET/DELETE) on the endpoint's path to it; routing by path is the
+   * host's job. Pass {@link McpConnectionInfo} when the host can resolve the
+   * peer address so the default trust boundary can enforce same-machine
+   * locality.
+   */
+  fetch: (request: Request, connection?: McpConnectionInfo) => Promise<Response>;
+  /** Tear down the handler (aborts in-flight exchanges, drops the change bridge). */
+  dispose: () => Promise<void>;
+}
+//#endregion
 //#region src/utils/shared-state.d.ts
 type ImmutablePrimitive = undefined | null | boolean | string | number | Function;
 type Immutable<T> = T extends ImmutablePrimitive ? T : T extends Array<infer U> ? ImmutableArray<U> : T extends Map<infer K, infer V> ? ImmutableMap<K, V> : T extends Set<infer M> ? ImmutableSet<M> : ImmutableObject<T>;
@@ -2089,7 +2150,7 @@ interface ConnectionMeta {
   sse?: string | ConnectionMetaSse;
   /**
    * Present when the dev server exposes a route-based MCP endpoint
-   * (`cli.mcp`). Advertises the MCP Streamable-HTTP route so in-browser
+   * (the host's `mcp` setting). Advertises the MCP Streamable-HTTP route so in-browser
    * tooling (e.g. an MCP inspector) can discover it without guessing the
    * path. `path` is relative to `__connection.json`'s location, like the
    * WebSocket `path`. `port` is set when the endpoint lives on a side-car
@@ -2184,4 +2245,4 @@ interface ConnectionMeta {
  */
 interface DevframeConnectionConfigsRegistry {}
 //#endregion
-export { DevframeServiceOf as $, SharedStateEvents as A, AgentHandle as At, DevframeSetupInfo as B, DevframeAgentHostEvents as Bt, createStreamSink as C, DevframeDiagnosticsHost as Ct, ImmutableObject as D, InferCliFlags as Dt, ImmutableMap as E, CliFlagsSchema as Et, DevframeDefinition as F, AgentTool as Ft, McpAuthorization as G, DevframeSnapshotRpcInputs as H, EventUnsubscribe as Ht, DevframeDeploymentKind as I, AgentToolInput as It, DevframeServiceDefinition as J, McpRouteOptions as K, DevframeDockDefaults as L, AgentToolProvider as Lt, SharedStatePatch as M, AgentResource as Mt, createSharedState as N, AgentResourceContent as Nt, ImmutableSet as O, defineCliFlags as Ot, DevframeCliOptions as P, AgentResourceInput as Pt, DevframeServiceMeta as Q, DevframeDuplicationStrategy as R, AgentToolProviderHandle as Rt, createStreamReader as S, DevframeStorageScope as St, ImmutableArray as T, DevframeAuthHandler as Tt, DevframeSseOptions as U, EventsMap as Ut, DevframeSnapshotRpcEntry as V, EventEmitter as Vt, DevframeWsOptions as W, DevframeServiceId as X, DevframeServiceDescriptor as Y, DevframeServiceInput as Z, CreateStreamSinkOptions as _, DevframeViewHost as _t, DevframeConnectionConfigsRegistry as a, DevframeScopedNodeContext as at, StreamSink as b, DevframeRpcSharedStates as bt, RpcBroadcastOptions as c, DevframeSettings as ct, RpcSharedStateHost as d, ScopedBroadcastOptions as dt, DevframeServiceScopeOf as et, RpcStreamingChannel as f, ScopedClientFunctions as ft, CreateStreamReaderOptions as g, SettingsForNamespace as gt, BufferedChunk as h, ScopedSharedStates as ht, DevframeCapabilities as i, DevframeServicesState as it, SharedStateOptions as j, AgentManifest as jt, SharedState as k, parseCliFlags as kt, RpcFunctionsHost as l, DevframeSettingsRegistry as lt, RpcStreamingHost as m, ScopedServerFunctions as mt, ConnectionMetaSse as n, DevframeServicesRegistry as nt, DevframeNodeContext as o, DevframeScopedNodeRpc as ot, RpcStreamingChannelOptions as p, ScopedRpcFn as pt, McpSetting as q, ConnectionMetaWebsocket as r, DevframeServicesScopeRegistry as rt, DevframeNodeRpcSession as s, DevframeScopedStreamingHost as st, ConnectionMeta as t, DevframeServicesHost as tt, RpcSharedStateGetOptions as u, DevframeSettingsStore as ut, StreamErrorPayload as v, DevframeRpcClientFunctions as vt, Immutable as w, DevframeDiagnosticsLogger as wt, StreamSinkEvents as x, DevframeHost as xt, StreamReader as y, DevframeRpcServerFunctions as yt, DevframeRpcOptions as z, DevframeAgentHost as zt };
+export { DevframeServiceDefinition as $, SharedStateEvents as A, DevframeAuthHandler as At, DevframeDefinition as B, AgentTool as Bt, createStreamSink as C, DevframeRpcClientFunctions as Ct, ImmutableObject as D, DevframeStorageScope as Dt, ImmutableMap as E, DevframeHost as Et, CreateMcpServerOptions as F, AgentHandle as Ft, DevframeSetupInfo as G, DevframeAgentHostEvents as Gt, DevframeDockDefaults as H, AgentToolProvider as Ht, McpConnectionInfo as I, AgentManifest as It, DevframeSseOptions as J, EventsMap as Jt, DevframeSnapshotRpcEntry as K, EventEmitter as Kt, McpFetchHandler as L, AgentResource as Lt, SharedStatePatch as M, InferCliFlags as Mt, createSharedState as N, defineCliFlags as Nt, ImmutableSet as O, DevframeDiagnosticsHost as Ot, CreateMcpFetchHandlerOptions as P, parseCliFlags as Pt, McpSetting as Q, McpServerHandle as R, AgentResourceContent as Rt, createStreamReader as S, DevframeViewHost as St, ImmutableArray as T, DevframeRpcSharedStates as Tt, DevframeDuplicationStrategy as U, AgentToolProviderHandle as Ut, DevframeDeploymentKind as V, AgentToolInput as Vt, DevframeRpcOptions as W, DevframeAgentHost as Wt, McpAuthorization as X, DevframeWsOptions as Y, McpRouteOptions as Z, CreateStreamSinkOptions as _, ScopedClientFunctions as _t, DevframeConnectionConfigsRegistry as a, DevframeServiceScopeOf as at, StreamSink as b, ScopedSharedStates as bt, RpcBroadcastOptions as c, DevframeServicesScopeRegistry as ct, RpcSharedStateHost as d, DevframeScopedNodeRpc as dt, DevframeServiceDescriptor as et, RpcStreamingChannel as f, DevframeScopedStreamingHost as ft, CreateStreamReaderOptions as g, ScopedBroadcastOptions as gt, BufferedChunk as h, DevframeSettingsStore as ht, DevframeCapabilities as i, DevframeServiceOf as it, SharedStateOptions as j, CliFlagsSchema as jt, SharedState as k, DevframeDiagnosticsLogger as kt, RpcFunctionsHost as l, DevframeServicesState as lt, RpcStreamingHost as m, DevframeSettingsRegistry as mt, ConnectionMetaSse as n, DevframeServiceInput as nt, DevframeNodeContext as o, DevframeServicesHost as ot, RpcStreamingChannelOptions as p, DevframeSettings as pt, DevframeSnapshotRpcInputs as q, EventUnsubscribe as qt, ConnectionMetaWebsocket as r, DevframeServiceMeta as rt, DevframeNodeRpcSession as s, DevframeServicesRegistry as st, ConnectionMeta as t, DevframeServiceId as tt, RpcSharedStateGetOptions as u, DevframeScopedNodeContext as ut, StreamErrorPayload as v, ScopedRpcFn as vt, Immutable as w, DevframeRpcServerFunctions as wt, StreamSinkEvents as x, SettingsForNamespace as xt, StreamReader as y, ScopedServerFunctions as yt, DevframeCliOptions as z, AgentResourceInput as zt };