devframe 0.7.16 → 0.8.0

package/dist/{build-server-C7vTKjiQ.mjs → fetch-BZyK4v6W.mjs}

@@ -1,12 +1,13 @@
-import { a as diagnostics } from "./storage-gEnj9ASQ.mjs";
-import { n as createHostContext } from "./host-h3-CgOetlNE.mjs";
+import { isAllowedOrigin } from "./rpc/transports/ws-server.mjs";
+import { n as createHostContext } from "./host-h3-Kz7t5Xab.mjs";
+import { t as diagnostics } from "./diagnostics-B5-qHeqD.mjs";
+import { t as toAgentToolName } from "./agent-tool-name-C3b5vEwJ.mjs";
+import { randomUUID } from "node:crypto";
 import { Diagnostic } from "nostics";
 import { join } from "pathe";
 import process from "node:process";
 import { homedir } from "node:os";
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { CallToolRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema } from "@modelcontextprotocol/sdk/types.js";
-import { toJsonSchema } from "@valibot/to-json-schema";
+import { Server, WebStandardStreamableHTTPServerTransport, isInitializeRequest } from "@modelcontextprotocol/server";
 //#region src/adapters/mcp/stringify.ts
 /**
 * JSON-coercing serializer for MCP text payloads.
@@ -87,27 +88,41 @@ const FALLBACK_OBJECT_SCHEMA = Object.freeze({
 	additionalProperties: true
 });
 /**
-* Convert a valibot return schema to JSON Schema.
-* @internal
+* 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 valibotReturnToJsonSchema(schema) {
-	if (!schema) return void 0;
-	try {
-		return toJsonSchema(schema);
+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;
 }
 /**
-* Convert positional RPC args schemas to a single MCP-friendly object
-* schema. When the RPC declares `args: [v.object(...)]`, unwrap the
-* single-object schema directly (nicer agent UX than `{ arg0: {...} }`).
+* 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 `undefined` when there are no args (the MCP SDK treats this
-* as `{ type: 'object', properties: {} }`).
+* Returns `{ type: 'object', properties: {} }` when there are no args.
 * @internal
 */
-function valibotArgsToJsonSchema(args) {
+function argsToJsonSchema(args) {
 	if (!args || args.length === 0) return {
 		schema: {
 			type: "object",
@@ -115,13 +130,6 @@ function valibotArgsToJsonSchema(args) {
 		},
 		unwrapped: false
 	};
-	if (args.length === 1) {
-		const inner = safeToJsonSchema(args[0]);
-		if (isObjectJsonSchema(inner)) return {
-			schema: inner,
-			unwrapped: true
-		};
-	}
 	const properties = {};
 	const required = [];
 	for (let i = 0; i < args.length; i++) {
@@ -139,16 +147,6 @@ function valibotArgsToJsonSchema(args) {
 		unwrapped: false
 	};
 }
-function safeToJsonSchema(schema) {
-	try {
-		return toJsonSchema(schema);
-	} catch {
-		return FALLBACK_OBJECT_SCHEMA;
-	}
-}
-function isObjectJsonSchema(value) {
-	return !!value && typeof value === "object" && value.type === "object";
-}
 //#endregion
 //#region src/adapters/mcp/build-server.ts
 /**
@@ -167,7 +165,7 @@ function buildMcpServerFromContext(ctx, options) {
 		tools: { listChanged: true },
 		resources: { listChanged: true }
 	} });
-	registerToolHandlers(server, ctx);
+	registerToolHandlers(server, ctx, options.exposeSharedState);
 	registerResourceHandlers(server, ctx, options.exposeSharedState);
 	const notify = (method) => {
 		server.notification({ method }).catch(() => {});
@@ -219,7 +217,7 @@ async function createMcpServer(definition, options = {}) {
 		serverVersion: options.serverVersion ?? definition.version ?? "0.0.0",
 		exposeSharedState: options.exposeSharedState ?? true
 	});
-	const { startStdioTransport } = await import("./transports-BmDVn4SF.mjs");
+	const { startStdioTransport } = await import("./transports-vhizgqXM.mjs");
 	let stop;
 	try {
 		stop = await startStdioTransport(server);
@@ -237,16 +235,98 @@ async function createMcpServer(definition, options = {}) {
 		await stop();
 	} };
 }
-function registerToolHandlers(server, ctx) {
-	server.setRequestHandler(ListToolsRequestSchema, async () => {
-		return { tools: ctx.agent.list().tools.map((tool) => projectTool(tool, ctx)) };
+/**
+* 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(CallToolRequestSchema, async (request) => {
+	server.setRequestHandler("tools/call", async (request) => {
 		const { name, arguments: args } = request.params;
 		try {
-			const tool = ctx.agent.getTool(name);
-			const outputSchema = tool ? tool.outputSchema ?? computeOutputSchema(tool, ctx) : void 0;
-			const result = await ctx.agent.invoke(name, args ?? {});
+			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",
@@ -266,7 +346,7 @@ function registerToolHandlers(server, ctx) {
 	});
 }
 function registerResourceHandlers(server, ctx, exposeSharedState) {
-	server.setRequestHandler(ListResourcesRequestSchema, async () => {
+	server.setRequestHandler("resources/list", async () => {
 		const resources = ctx.agent.list().resources.map((resource) => ({
 			uri: resource.uri,
 			name: resource.name,
@@ -287,7 +367,7 @@ function registerResourceHandlers(server, ctx, exposeSharedState) {
 		}
 		return { resources };
 	});
-	server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+	server.setRequestHandler("resources/read", async (request) => {
 		const { uri } = request.params;
 		const parsed = parseResourceUri(uri);
 		if (parsed.kind === "resource") {
@@ -306,11 +386,20 @@ function registerResourceHandlers(server, ctx, exposeSharedState) {
 		throw new Error(`[devframe/mcp] unknown resource URI "${uri}"`);
 	});
 }
-function projectTool(tool, ctx) {
+/**
+* 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 = tool.outputSchema ?? computeOutputSchema(tool, ctx);
+	const outputSchema = usableOutputSchema(tool.outputSchema ?? computeOutputSchema(tool, ctx));
 	return {
-		name: tool.id,
+		name,
 		title: tool.title,
 		description: tool.description,
 		inputSchema,
@@ -323,6 +412,7 @@ function projectTool(tool, ctx) {
 	};
 }
 function computeInputSchema(tool, ctx) {
+	if (tool.kind === "tool") return argsToJsonSchema(tool.args).schema;
 	if (tool.kind !== "rpc" || !tool.rpcName) return {
 		type: "object",
 		properties: {}
@@ -333,13 +423,13 @@ function computeInputSchema(tool, ctx) {
 		properties: {}
 	};
 	const args = def.args;
-	return valibotArgsToJsonSchema(args).schema;
+	return argsToJsonSchema(args).schema;
 }
 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 valibotReturnToJsonSchema(def.returns);
+	return returnToJsonSchema(def.returns);
 }
 function parseResourceUri(uri) {
 	const match = uri.match(/^devframe:\/\/(resource|state)\/(.+)$/);
@@ -356,4 +446,88 @@ function parseResourceUri(uri) {
 	};
 }
 //#endregion
-export { createMcpServer as n, buildMcpServerFromContext as t };
+//#region src/adapters/mcp/fetch.ts
+/**
+* Build a framework-agnostic MCP Streamable-HTTP 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.
+*
+* Each MCP session gets its own {@link WebStandardStreamableHTTPServerTransport}
+* and MCP server (built from the shared, live `ctx` via
+* `buildMcpServerFromContext`), correlated by the `Mcp-Session-Id` header: an
+* `initialize` POST spins up a session; later requests route to it; a `DELETE`
+* (or client disconnect) tears it down. The origin gate applies devframe's
+* loopback-default DNS-rebinding protection (identical semantics to the WS
+* upgrade's `isAllowedOrigin`).
+*
+* @experimental
+*/
+function createMcpFetchHandler(ctx, options) {
+	const sessions = /* @__PURE__ */ new Map();
+	const allowedOrigins = options.allowedOrigins;
+	function drop(sessionId) {
+		const session = sessions.get(sessionId);
+		if (!session) return;
+		sessions.delete(sessionId);
+		session.dispose();
+	}
+	async function createSession() {
+		let session;
+		const transport = new WebStandardStreamableHTTPServerTransport({
+			sessionIdGenerator: () => randomUUID(),
+			onsessioninitialized: (id) => {
+				sessions.set(id, session);
+			},
+			onsessionclosed: (id) => {
+				drop(id);
+			}
+		});
+		const { server, dispose } = buildMcpServerFromContext(ctx, {
+			serverName: options.serverName,
+			serverVersion: options.serverVersion,
+			exposeSharedState: options.exposeSharedState
+		});
+		session = {
+			transport,
+			dispose: async () => {
+				dispose();
+				await server.close();
+			}
+		};
+		transport.onclose = () => {
+			if (transport.sessionId) drop(transport.sessionId);
+		};
+		await server.connect(transport);
+		return session;
+	}
+	async function handle(req) {
+		const origin = req.headers.get("origin") ?? void 0;
+		if (allowedOrigins !== false && !isAllowedOrigin(origin, allowedOrigins ?? [])) return new Response("Forbidden: origin not allowed", { status: 403 });
+		const sessionId = req.headers.get("mcp-session-id") ?? void 0;
+		let session = sessionId ? sessions.get(sessionId) : void 0;
+		if (!session && req.method === "POST") {
+			let body;
+			try {
+				body = await req.json();
+			} catch {
+				body = void 0;
+			}
+			if (!sessionId && isInitializeRequest(body)) session = await createSession();
+			else return new Response(sessionId ? "Not Found: unknown MCP session" : "Bad Request: no valid session ID and not an initialize request", { status: sessionId ? 404 : 400 });
+			return session.transport.handleRequest(req, { parsedBody: body });
+		}
+		if (!session) return new Response(sessionId ? "Not Found: unknown MCP session" : "Bad Request: missing MCP session ID", { status: sessionId ? 404 : 400 });
+		return session.transport.handleRequest(req);
+	}
+	return {
+		fetch: handle,
+		dispose: async () => {
+			const live = [...sessions.values()];
+			sessions.clear();
+			await Promise.all(live.map((session) => session.dispose()));
+		}
+	};
+}
+//#endregion
+export { createMcpServer as n, createMcpFetchHandler as t };

package/dist/helpers/vite.d.mts

@@ -1,4 +1,4 @@
-import { d as McpRouteOptions, p as DevframeAuthHandler, r as DevframeDefinition } from "../devframe-Ckhf3kFw.mjs";
+import { d as McpRouteOptions, p as DevframeAuthHandler, r as DevframeDefinition } from "../devframe-Dsjn_Xtq.mjs";
 //#region src/helpers/vite.d.ts
 interface ViteDevBridgeOptions {
   /**

package/dist/helpers/vite.mjs

@@ -1,8 +1,8 @@
 import { DEVFRAME_CONNECTION_META_FILENAME, DEVFRAME_WS_ROUTE } from "../constants.mjs";
-import { a as diagnostics } from "../storage-gEnj9ASQ.mjs";
+import { t as diagnostics } from "../diagnostics-B5-qHeqD.mjs";
 import { n as resolveBasePath, t as normalizeBasePath } from "../_shared-bWRzeSa0.mjs";
 import { serveStaticNodeMiddleware } from "../utils/serve-static.mjs";
-import { n as resolveDevServerPort, r as resolveMcpConnectionMeta, t as createDevServer } from "../dev-BCeaQuGE.mjs";
+import { n as resolveDevServerPort, r as resolveMcpConnectionMeta, t as createDevServer } from "../dev-D4M7Veo7.mjs";
 import { resolve } from "pathe";
 //#region src/helpers/vite.ts
 /**

package/dist/{host-h3-CgOetlNE.mjs → host-h3-Kz7t5Xab.mjs}

@@ -1,8 +1,9 @@
 import { t as devframeReporter } from "./diagnostics-reporter-CsIG85Q5.mjs";
-import { t as diagnostics } from "./diagnostics-BXwBQmoN.mjs";
+import { t as diagnostics } from "./diagnostics-hwjXp_UV.mjs";
 import { RpcFunctionsCollectorBase } from "./rpc/index.mjs";
 import { defineRpcFunction } from "./index.mjs";
-import { a as diagnostics$1, i as createEventEmitter, n as createSharedState, r as nanoid, t as createStorage } from "./storage-gEnj9ASQ.mjs";
+import { t as diagnostics$1 } from "./diagnostics-B5-qHeqD.mjs";
+import { i as createEventEmitter, n as createSharedState, r as nanoid, t as createStorage } from "./storage-Dzoc3NVC.mjs";
 import { defineDiagnostics } from "nostics";
 import { isatty } from "node:tty";
 import { formatWithOptions, inspect } from "node:util";
@@ -10,6 +11,43 @@ import { existsSync } from "node:fs";
 import { join } from "pathe";
 import process$1 from "node:process";
 import { homedir } from "node:os";
+//#region src/node/agent-args.ts
+/**
+* Map the args payload an agent surface receives (MCP sends an object
+* keyed `arg0`/`arg1`/…, matching the schema the adapter advertises) onto
+* a handler's positional parameters. Shared by the agent host's RPC
+* bridge and the hub's command-derived tools so the coercion cannot
+* drift between them.
+*
+* - an array passes through as-is
+* - `null`/`undefined` become a zero-argument call
+* - with declared schemas, each schema reads its own `argN` key, in order
+* - without schemas, `arg0`/`arg1`/… keys are collected when present
+* - an empty object becomes a zero-argument call
+* - anything else follows the {@link AgentArgsFallback}
+*
+* @experimental
+*/
+function coerceAgentPositionalArgs(args, schemas, fallback = "wrap") {
+	if (Array.isArray(args)) return args;
+	if (args === void 0 || args === null) return [];
+	if (typeof args === "object") {
+		const obj = args;
+		if (schemas && schemas.length) return schemas.map((_, i) => obj[`arg${i}`]);
+		if ("arg0" in obj) {
+			const out = [];
+			let i = 0;
+			while (`arg${i}` in obj) {
+				out.push(obj[`arg${i}`]);
+				i++;
+			}
+			return out;
+		}
+		if (Object.keys(obj).length === 0) return [];
+	}
+	return fallback === "drop" ? [] : [args];
+}
+//#endregion
 //#region src/node/host-agent.ts
 /**
 * Framework-neutral host aggregating the agent-exposed surface of a
@@ -24,6 +62,7 @@ var DevframeAgentHost = class {
 	events = createEventEmitter();
 	tools = /* @__PURE__ */ new Map();
 	resources = /* @__PURE__ */ new Map();
+	providers = /* @__PURE__ */ new Set();
 	_rpcUnsubscribe;
 	constructor(context) {
 		this.context = context;
@@ -50,6 +89,19 @@ var DevframeAgentHost = class {
 		}
 		return existed;
 	}
+	registerToolProvider(provider) {
+		this.providers.add(provider);
+		this.events.emit("agent:manifest:changed");
+		const notifyChanged = () => {
+			if (this.providers.has(provider)) this.events.emit("agent:manifest:changed");
+		};
+		return {
+			notifyChanged,
+			unregister: () => {
+				if (this.providers.delete(provider)) this.events.emit("agent:manifest:changed");
+			}
+		};
+	}
 	registerResource(input) {
 		if (this.resources.has(input.id)) throw diagnostics$1.DF0016({ id: input.id });
 		const resource = {
@@ -79,15 +131,28 @@ var DevframeAgentHost = class {
 		const rpcTools = this._collectRpcTools();
 		const plainTools = Array.from(this.tools.values()).map((t) => t.tool);
 		const resources = Array.from(this.resources.values()).map((r) => r.resource);
+		const seen = new Set([...rpcTools, ...plainTools].map((t) => t.id));
+		const providerTools = [];
+		for (const { tool } of this._collectProviderTools()) {
+			if (seen.has(tool.id)) continue;
+			seen.add(tool.id);
+			providerTools.push(tool);
+		}
 		return {
-			tools: [...rpcTools, ...plainTools],
+			tools: [
+				...rpcTools,
+				...plainTools,
+				...providerTools
+			],
 			resources
 		};
 	}
 	getTool(id) {
 		const plain = this.tools.get(id);
 		if (plain) return plain.tool;
-		return this._collectRpcTools().find((t) => t.id === id);
+		const rpc = this._collectRpcTools().find((t) => t.id === id);
+		if (rpc) return rpc;
+		return this._collectProviderTools().find((t) => t.tool.id === id)?.tool;
 	}
 	getResource(id) {
 		return this.resources.get(id)?.resource;
@@ -97,9 +162,11 @@ var DevframeAgentHost = class {
 		if (plain?.handler) return await plain.handler(args);
 		const rpcDef = this._findRpcDefinition(id);
 		if (rpcDef) {
-			const positional = this._coercePositionalArgs(args, rpcDef);
+			const positional = coerceAgentPositionalArgs(args, rpcDef.args, "wrap");
 			return await this.context.rpc.invokeLocal(id, ...positional);
 		}
+		const provided = this._collectProviderTools().find((t) => t.tool.id === id);
+		if (provided) return await provided.input.handler(args);
 		throw new Error(`[devframe/agent] tool "${id}" not found`);
 	}
 	async read(id) {
@@ -125,11 +192,21 @@ var DevframeAgentHost = class {
 			description: input.description,
 			safety: input.safety ?? "action",
 			tags: input.tags,
+			args: input.args,
 			inputSchema: input.inputSchema,
 			outputSchema: input.outputSchema,
 			examples: input.examples
 		};
 	}
+	/** Query every registered provider, projecting inputs to serializable tools. */
+	_collectProviderTools() {
+		const out = [];
+		for (const provider of this.providers) for (const input of provider()) out.push({
+			input,
+			tool: this._projectTool(input)
+		});
+		return out;
+	}
 	_collectRpcTools() {
 		const out = [];
 		for (const [name, def] of this.context.rpc.definitions) {
@@ -155,33 +232,11 @@ var DevframeAgentHost = class {
 		const def = this.context.rpc.definitions.get(id);
 		if (def?.agent) return def;
 	}
-	_coercePositionalArgs(args, def) {
-		if (Array.isArray(args)) return args;
-		if (args === void 0 || args === null) return [];
-		if (args && typeof args === "object") {
-			const obj = args;
-			const schemas = def.args;
-			if (schemas && schemas.length) return schemas.map((_, i) => obj[`arg${i}`]);
-			if (hasPositionalKeys(obj)) {
-				const out = [];
-				let i = 0;
-				while (`arg${i}` in obj) {
-					out.push(obj[`arg${i}`]);
-					i++;
-				}
-				return out;
-			}
-		}
-		return [args];
-	}
 };
 function inferSafety(type) {
 	if (type === "static" || type === "query") return "read";
 	return "action";
 }
-function hasPositionalKeys(obj) {
-	return "arg0" in obj;
-}
 //#endregion
 //#region src/node/host-diagnostics.ts
 var DevframeDiagnosticsHost = class {
@@ -1517,4 +1572,4 @@ function createH3DevframeHost(options) {
 	};
 }
 //#endregion
-export { DevframeViewHost as a, createRpcSharedStateServerHost as c, createNodeSettings as i, DevframeDiagnosticsHost as l, createHostContext as n, DevframeServicesHostImpl as o, createScopedNodeContext as r, createRpcStreamingServerHost as s, createH3DevframeHost as t, DevframeAgentHost as u };
+export { DevframeViewHost as a, createRpcSharedStateServerHost as c, coerceAgentPositionalArgs as d, createNodeSettings as i, DevframeDiagnosticsHost as l, createHostContext as n, DevframeServicesHostImpl as o, createScopedNodeContext as r, createRpcStreamingServerHost as s, createH3DevframeHost as t, DevframeAgentHost as u };

package/dist/http-BghOqfTD.mjs

@@ -0,0 +1,38 @@
+import { t as createMcpFetchHandler } from "./fetch-BZyK4v6W.mjs";
+import { defineHandler } from "h3";
+//#region src/adapters/mcp/http.ts
+/**
+* Mount an MCP Streamable-HTTP endpoint on an h3 app at `path` — the h3
+* binding over {@link createMcpFetchHandler}, which owns the sessions, 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 the
+* server→client stream). We copy that response onto `event.res` and return
+* its body rather than returning the `Response` object directly, so a
+* legitimate MCP 404 (unknown session) 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).
+*
+* @experimental
+*/
+function mountMcpHttp(app, ctx, path, options) {
+	const handler = createMcpFetchHandler(ctx, options);
+	app.use(path, defineHandler(async (event) => respond(event, await handler.fetch(event.req))));
+	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
+export { mountMcpHttp };

package/dist/{index-8dndvIxR.d.mts → index-CeBbry0R.d.mts}

@@ -1,5 +1,5 @@
-import { W as DevframeNodeRpcSession, b as DevframeNodeContext, ht as SharedState } from "./devframe-Ckhf3kFw.mjs";
-import { n as InternalAnonymousAuthStorage } from "./context-CzqPrJSz.mjs";
+import { W as DevframeNodeRpcSession, b as DevframeNodeContext, ht as SharedState } from "./devframe-Dsjn_Xtq.mjs";
+import { n as InternalAnonymousAuthStorage } from "./context-7BbaIUSI.mjs";
 //#region src/node/auth/revoke.d.ts
 /**
  * Flip `isTrusted` to false on any live WS clients connected with `token`