devframe 0.9.20 → 0.10.1

package/dist/browser-agent-rpc-BXhoSh1z.mjs

@@ -0,0 +1,70 @@
+import { nanoid } from "./utils/nanoid.mjs";
+import { n as onBrowserAgentToolsChanged, t as listBrowserAgentTools } from "./browser-agent-Pu-FLk6I.mjs";
+//#region src/client/client-id.ts
+const CLIENT_ID_STORAGE_KEY = "devframe:client-id";
+let memoryClientId;
+/**
+* This browser tab's stable client id: one nanoid per tab, persisted in
+* `sessionStorage` so it survives page reloads and RPC reconnects. The node
+* side uses it to tell connected tabs apart across reconnects (see #394).
+*
+* Tab duplication copies `sessionStorage`, so two tabs can briefly share an id
+* until per-tab disambiguation lands with the wider tab-metadata work.
+*/
+function resolveClientId(win = globalThis.window) {
+	try {
+		const storage = win?.sessionStorage;
+		if (storage) {
+			let id = storage.getItem(CLIENT_ID_STORAGE_KEY);
+			if (!id) {
+				id = nanoid();
+				storage.setItem(CLIENT_ID_STORAGE_KEY, id);
+			}
+			return id;
+		}
+	} catch {}
+	memoryClientId ??= nanoid();
+	return memoryClientId;
+}
+//#endregion
+//#region src/client/browser-agent-rpc.ts
+/** Mirror this document's browser-agent registry over its existing RPC connection. */
+function setupBrowserAgentRpcBridge(rpc) {
+	rpc.client.register({
+		name: "devframe:agent:invoke-client-tool",
+		type: "action",
+		jsonSerializable: true,
+		handler: async (id, args) => {
+			const tool = listBrowserAgentTools().find((tool) => tool.id === id);
+			if (!tool) throw new Error(`[devframe/agent] browser tool "${id}" not found`);
+			return await tool.invoke(args);
+		}
+	});
+	let queued = false;
+	let disposed = false;
+	let lastSyncedCount = 0;
+	const sync = () => {
+		if (queued || disposed) return;
+		queued = true;
+		queueMicrotask(async () => {
+			queued = false;
+			if (disposed) return;
+			const manifests = listBrowserAgentTools().map(({ invoke: _, ...manifest }) => manifest);
+			if (manifests.length === 0 && lastSyncedCount === 0) return;
+			lastSyncedCount = manifests.length;
+			await rpc.callOptional("devframe:agent:sync-client-tools", resolveClientId(), manifests).catch(() => {});
+		});
+	};
+	const stopTools = onBrowserAgentToolsChanged(sync);
+	const stopConnection = rpc.events.on("connection:status", (status) => {
+		if (status === "connected") sync();
+	});
+	sync();
+	return () => {
+		disposed = true;
+		stopTools();
+		stopConnection();
+	};
+}
+//#endregion
+export { setupBrowserAgentRpcBridge };

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--tVkJw3W.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 { a as defineDiagnostics, i as createBirpc, n as argsToJsonSchema, o as DEVFRAME_EVENTS, r as resolveAgentSafety, t as toolInputToRpcArgs } from "../tool-input-BAQXvvqL.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,83 +1669,6 @@ function createScopedClientContext(rpc, namespace) {
 	};
 }
 //#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 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/tool-input.ts
-/**
-* Convert an object-shaped tool input into positional arguments.
-*
-* Tool schemas expose positional parameters as `arg0`, `arg1`, and so on.
-* Arrays pass through for callers that already provide positional arguments.
-*/
-function collectPositionalArgs(input, argumentCount) {
-	if (Array.isArray(input)) return input;
-	if (input === void 0 || input === null) return [];
-	if (typeof input !== "object") return void 0;
-	const record = input;
-	if (argumentCount != null) return Array.from({ length: argumentCount }, (_, index) => record[`arg${index}`]);
-	if ("arg0" in record) {
-		const positional = [];
-		while (`arg${positional.length}` in record) positional.push(record[`arg${positional.length}`]);
-		return positional;
-	}
-	return Object.keys(record).length === 0 ? [] : void 0;
-}
-/** Convert tool input for an RPC, preserving an untyped payload as arg 0. */
-function toolInputToRpcArgs(input, argumentCount) {
-	return collectPositionalArgs(input, argumentCount) ?? [input];
-}
-//#endregion
 //#region src/client/webmcp.ts
 /**
 * The page's WebMCP model context, when the browser (or a polyfill)
@@ -1787,14 +1709,15 @@ function registerWebMcpTools(clientRpc, options = {}) {
 			return;
 		}
 		const controller = new AbortController();
+		const safety = resolveAgentSafety(def.type, agent);
 		const result = modelContext.registerTool({
 			name,
 			description: agent.description,
 			inputSchema: argsToJsonSchema(def.args),
 			annotations: {
 				title: agent.title ?? def.name,
-				readOnlyHint: resolveSafety(def, agent) === "read",
-				destructiveHint: resolveSafety(def, agent) === "destructive"
+				readOnlyHint: safety === "read",
+				destructiveHint: safety === "destructive"
 			},
 			execute: (args) => executeRpcTool(def, clientRpc.context, args)
 		}, { signal: controller.signal });
@@ -1824,11 +1747,6 @@ function registerWebMcpTools(clientRpc, options = {}) {
 		registered.clear();
 	};
 }
-function resolveSafety(def, agent) {
-	if (agent.safety) return agent.safety;
-	const type = def.type ?? "query";
-	return type === "static" || type === "query" ? "read" : "action";
-}
 async function executeRpcTool(def, context, args) {
 	try {
 		const positional = toolInputToRpcArgs(args, def.args?.length);
@@ -1903,6 +1821,8 @@ async function getDevframeRpcClient(options = {}) {
 	const context = { rpc: void 0 };
 	const clientRpc = new RpcFunctionsCollectorBase(context);
 	const disposeWebMcp = options.webmcp === false ? void 0 : registerWebMcpTools(clientRpc);
+	let disposeBrowserAgentBridge;
+	let closed = false;
 	async function fetchJsonFromBases(path) {
 		const candidates = [resolvedBaseURL, ...bases.filter((base) => base !== resolvedBaseURL)].filter((x) => x != null);
 		const errors = [];
@@ -1957,7 +1877,9 @@ async function getDevframeRpcClient(options = {}) {
 	}
 	/** Release authentication and transport resources even if another disposer fails. */
 	function closeRpcClient() {
+		closed = true;
 		try {
+			disposeBrowserAgentBridge?.();
 			disposeWebMcp?.();
 		} finally {
 			try {
@@ -2068,6 +1990,9 @@ async function getDevframeRpcClient(options = {}) {
 	}, () => {
 		bootstrapAuthSettled = true;
 	});
+	if (connectionMeta.mcp) import("../browser-agent-rpc-BXhoSh1z.mjs").then(({ setupBrowserAgentRpcBridge }) => {
+		if (!closed) disposeBrowserAgentBridge = setupBrowserAgentRpcBridge(rpc);
+	}).catch(() => {});
 	if (authChannel) authChannel.onmessage = (event) => {
 		if (event.data?.type === "auth-update" && event.data.authToken) rpc.requestTrustWithToken(event.data.authToken);
 	};

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";