devframe 0.9.20 → 0.10.1

package/dist/dist-CO98PBnQ.mjs

@@ -0,0 +1,265 @@
+//#region ../../node_modules/.pnpm/birpc@4.2.0/node_modules/birpc/dist/index.mjs
+function createPromiseWithResolvers() {
+	let resolve;
+	let reject;
+	return {
+		promise: new Promise((res, rej) => {
+			resolve = res;
+			reject = rej;
+		}),
+		resolve,
+		reject
+	};
+}
+const _cacheMap = /* @__PURE__ */ new WeakMap();
+function cachedMap(items, fn) {
+	return items.map((i) => {
+		let r = _cacheMap.get(i);
+		if (!r) {
+			r = fn(i);
+			_cacheMap.set(i, r);
+		}
+		return r;
+	});
+}
+const random = Math.random.bind(Math);
+const urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+function nanoid(size = 21) {
+	let id = "";
+	let i = size;
+	while (i--) id += urlAlphabet[random() * 64 | 0];
+	return id;
+}
+const DEFAULT_TIMEOUT = 6e4;
+const defaultSerialize = (i) => i;
+const defaultDeserialize = defaultSerialize;
+const { clearTimeout, setTimeout } = globalThis;
+function createBirpc($functions, options) {
+	const { post, on, off = () => {}, eventNames = [], serialize = defaultSerialize, deserialize = defaultDeserialize, resolver, bind = "rpc", timeout = DEFAULT_TIMEOUT, proxify = true } = options;
+	let $closed = false;
+	const _rpcPromiseMap = /* @__PURE__ */ new Map();
+	let _promiseInit;
+	let rpc;
+	async function _call(method, args, event, optional) {
+		if ($closed) throw new Error(`[birpc] rpc is closed, cannot call "${method}"`);
+		const req = {
+			m: method,
+			a: args,
+			t: "q"
+		};
+		if (optional) req.o = true;
+		const send = async (_req) => post(serialize(_req));
+		if (event) {
+			await send(req);
+			return;
+		}
+		if (_promiseInit) try {
+			await _promiseInit;
+		} finally {
+			_promiseInit = void 0;
+		}
+		let { promise, resolve, reject } = createPromiseWithResolvers();
+		const id = nanoid();
+		req.i = id;
+		let timeoutId;
+		async function handler(newReq = req) {
+			if (timeout >= 0) {
+				timeoutId = setTimeout(() => {
+					try {
+						if (options.onTimeoutError?.call(rpc, method, args) !== true) throw new Error(`[birpc] timeout on calling "${method}"`);
+					} catch (e) {
+						reject(e);
+					}
+					_rpcPromiseMap.delete(id);
+				}, timeout);
+				if (typeof timeoutId === "object") timeoutId = timeoutId.unref?.();
+			}
+			_rpcPromiseMap.set(id, {
+				resolve,
+				reject,
+				timeoutId,
+				method
+			});
+			await send(newReq);
+			return promise;
+		}
+		try {
+			if (options.onRequest) await options.onRequest.call(rpc, req, handler, resolve);
+			else await handler();
+		} catch (e) {
+			if (options.onGeneralError?.call(rpc, e) !== true) throw e;
+			return;
+		} finally {
+			clearTimeout(timeoutId);
+			_rpcPromiseMap.delete(id);
+		}
+		return promise;
+	}
+	const builtinMethods = {
+		$call: (method, ...args) => _call(method, args, false),
+		$callOptional: (method, ...args) => _call(method, args, false, true),
+		$callEvent: (method, ...args) => _call(method, args, true),
+		$callRaw: (options) => _call(options.method, options.args, options.event, options.optional),
+		$rejectPendingCalls,
+		get $closed() {
+			return $closed;
+		},
+		get $meta() {
+			return options.meta;
+		},
+		$close,
+		$functions
+	};
+	if (proxify) rpc = new Proxy({}, { get(_, method) {
+		if (Object.hasOwn(builtinMethods, method)) return builtinMethods[method];
+		if (method === "then" && !eventNames.includes("then") && !("then" in $functions)) return void 0;
+		const sendEvent = (...args) => _call(method, args, true);
+		if (eventNames.includes(method)) {
+			sendEvent.asEvent = sendEvent;
+			return sendEvent;
+		}
+		const sendCall = (...args) => _call(method, args, false);
+		sendCall.asEvent = sendEvent;
+		return sendCall;
+	} });
+	else rpc = builtinMethods;
+	function $close(customError) {
+		$closed = true;
+		_rpcPromiseMap.forEach(({ reject, method }) => {
+			const error = /* @__PURE__ */ new Error(`[birpc] rpc is closed, cannot call "${method}"`);
+			if (customError) {
+				customError.cause ??= error;
+				return reject(customError);
+			}
+			reject(error);
+		});
+		_rpcPromiseMap.clear();
+		off(onMessage);
+	}
+	function $rejectPendingCalls(handler) {
+		const handlerResults = Array.from(_rpcPromiseMap.values()).map(({ method, reject }) => {
+			if (!handler) return reject(/* @__PURE__ */ new Error(`[birpc]: rejected pending call "${method}".`));
+			return handler({
+				method,
+				reject
+			});
+		});
+		_rpcPromiseMap.clear();
+		return handlerResults;
+	}
+	async function onMessage(data, ...extra) {
+		let msg;
+		try {
+			msg = deserialize(data);
+		} catch (e) {
+			if (options.onGeneralError?.call(rpc, e) !== true) throw e;
+			return;
+		}
+		if (msg.t === "q") {
+			const { m: method, a: args, o: optional } = msg;
+			let result, error;
+			let fn = await (resolver ? resolver.call(rpc, method, $functions[method]) : $functions[method]);
+			if (optional) fn ||= () => void 0;
+			if (!fn) error = /* @__PURE__ */ new Error(`[birpc] function "${method}" not found`);
+			else try {
+				result = await fn.apply(bind === "rpc" ? rpc : $functions, args);
+			} catch (e) {
+				error = e;
+			}
+			if (msg.i) {
+				if (error && options.onFunctionError) {
+					if (options.onFunctionError.call(rpc, error, method, args) === true) return;
+				}
+				if (!error) try {
+					await post(serialize({
+						t: "s",
+						i: msg.i,
+						r: result
+					}), ...extra);
+					return;
+				} catch (e) {
+					error = e;
+					if (options.onGeneralError?.call(rpc, e, method, args) !== true) throw e;
+				}
+				try {
+					await post(serialize({
+						t: "s",
+						i: msg.i,
+						e: error
+					}), ...extra);
+				} catch (e) {
+					if (options.onGeneralError?.call(rpc, e, method, args) !== true) throw e;
+				}
+			}
+		} else {
+			const { i: ack, r: result, e: error } = msg;
+			const promise = _rpcPromiseMap.get(ack);
+			if (promise) {
+				clearTimeout(promise.timeoutId);
+				if (error) promise.reject(error);
+				else promise.resolve(result);
+			}
+			_rpcPromiseMap.delete(ack);
+		}
+	}
+	_promiseInit = on(onMessage);
+	return rpc;
+}
+function createBirpcGroup(functions, channels, options = {}) {
+	const { proxify = true } = options;
+	const getChannels = () => typeof channels === "function" ? channels() : channels;
+	const getClients = (channels = getChannels()) => cachedMap(channels, (s) => createBirpc(functions, {
+		...options,
+		...s
+	}));
+	function _boardcast(options) {
+		const clients = getClients();
+		return Promise.all(clients.map((c) => c.$callRaw(options)));
+	}
+	const broadcastBuiltin = {
+		$call: (method, ...args) => _boardcast({
+			method,
+			args,
+			event: false
+		}),
+		$callOptional: (method, ...args) => _boardcast({
+			method,
+			args,
+			event: false,
+			optional: true
+		}),
+		$callEvent: (method, ...args) => _boardcast({
+			method,
+			args,
+			event: true
+		}),
+		$callRaw: (options) => _boardcast(options)
+	};
+	const broadcastProxy = proxify ? new Proxy({}, { get(_, method) {
+		if (Object.hasOwn(broadcastBuiltin, method)) return broadcastBuiltin[method];
+		const callbacks = getClients().map((c) => c[method]);
+		const sendCall = (...args) => {
+			return Promise.all(callbacks.map((i) => i(...args)));
+		};
+		sendCall.asEvent = async (...args) => {
+			await Promise.all(callbacks.map((i) => i.asEvent(...args)));
+		};
+		return sendCall;
+	} }) : broadcastBuiltin;
+	function updateChannels(fn) {
+		const channels = getChannels();
+		fn?.(channels);
+		return getClients(channels);
+	}
+	getClients();
+	return {
+		get clients() {
+			return getClients();
+		},
+		functions,
+		updateChannels,
+		broadcast: broadcastProxy
+	};
+}
+//#endregion
+export { createBirpcGroup as n, createBirpc as t };

package/dist/{host-agent-C3MBpNCd.mjs → host-agent-mIbQ6Qi5.mjs}

@@ -1,5 +1,5 @@
 import { t as DEVFRAME_EVENTS } from "./events-BV4Dj59a.mjs";
-import { t as diagnostics } from "./diagnostics-DZA6KQ_Z.mjs";
+import { t as diagnostics } from "./diagnostics-Cx4_VjlG.mjs";
 //#region src/utils/events.ts
 /**
 * Create event emitter.
@@ -39,6 +39,17 @@ function createEventEmitter() {
 	};
 }
 //#endregion
+//#region src/agent/safety.ts
+/**
+* An agent tool's safety classification: the explicit `agent.safety`, else
+* inferred from the function `type` (`static`/`query` are read-only, the rest
+* mutate). Shared by every agent surface (MCP host, WebMCP, in-page bridge).
+*/
+function resolveAgentSafety(type, agent) {
+	if (agent.safety) return agent.safety;
+	return type === "static" || type === "query" || type == null ? "read" : "action";
+}
+//#endregion
 //#region src/tool-input.ts
 /**
 * Convert an object-shaped tool input into positional arguments.
@@ -67,11 +78,6 @@ function toolInputToRpcArgs(input, argumentCount) {
 function toolInputToCommandArgs(input, argumentCount) {
 	return collectPositionalArgs(input, argumentCount) ?? [];
 }
-/** @deprecated Use {@link toolInputToRpcArgs} or {@link toolInputToCommandArgs}. */
-function coerceAgentPositionalArgs(input, schemas, fallback = "wrap") {
-	const argumentCount = schemas?.length;
-	return fallback === "drop" ? toolInputToCommandArgs(input, argumentCount) : toolInputToRpcArgs(input, argumentCount);
-}
 //#endregion
 //#region src/node/host-agent.ts
 /**
@@ -248,8 +254,7 @@ var DevframeAgentHost = class {
 			const agent = def.agent;
 			if (!agent) continue;
 			if (!agent.description || typeof agent.description !== "string") throw diagnostics.DF0014({ name });
-			const type = def.type ?? "query";
-			const safety = agent.safety ?? inferSafety(type);
+			const safety = resolveAgentSafety(def.type, agent);
 			out.push({
 				id: name,
 				kind: "rpc",
@@ -268,9 +273,5 @@ var DevframeAgentHost = class {
 		if (def?.agent) return def;
 	}
 };
-function inferSafety(type) {
-	if (type === "static" || type === "query") return "read";
-	return "action";
-}
 //#endregion
-export { createEventEmitter as i, coerceAgentPositionalArgs as n, toolInputToCommandArgs as r, DevframeAgentHost as t };
+export { toolInputToCommandArgs as n, createEventEmitter as r, DevframeAgentHost as t };

package/dist/import-runtime-module-BzlEQ9PI.mjs

@@ -0,0 +1,24 @@
+import { i as resolveServicePackage, r as importServicePackage } from "./services-install-D5YUwFXW.mjs";
+//#region src/node/import-runtime-module.ts
+/**
+* Resolve and import a package at runtime without adding it to a consumer's
+* bundle graph. First-party adapters use this for modules whose code is
+* needed only when the matching feature is enabled (optional peers, and the
+* MCP adapter with the SDK behind it).
+*
+* @internal
+*/
+async function importRuntimeModule(specifier) {
+	return await importServicePackage(specifier, [import.meta.url]);
+}
+/**
+* Whether {@link importRuntimeModule} would resolve `specifier`, without
+* importing anything. The zero-cost probe behind optional-peer decisions.
+*
+* @internal
+*/
+function isRuntimeModuleResolvable(specifier) {
+	return resolveServicePackage(specifier, [import.meta.url]) !== void 0;
+}
+//#endregion
+export { isRuntimeModuleResolvable as n, importRuntimeModule as t };

package/dist/in-page-channel/index.d.mts

@@ -1,6 +1,5 @@
-import { A as InferReturnType, D as RpcReturnSchema, O as Thenable, i as RpcArgsSchema, k as InferArgsType } from "../types-D2vGd7-2.mjs";
-import { Vt as EventEmitter, k as SharedState } from "../context-BLHBDQcZ.mjs";
-import { BirpcReturn } from "birpc";
+import { D as InferArgsType, E as Thenable, O as InferReturnType, T as RpcReturnSchema, m as RpcFunctionAgentOptions, n as RpcArgsSchema } from "../types-BmDbfHCx.mjs";
+import { Kt as EventEmitter, k as SharedState } from "../context--tVkJw3W.mjs";
 //#region src/in-page-channel/types.d.ts
 /**
  * The shared contract of one in-page channel, declared once (usually in a
@@ -49,11 +48,15 @@ type ProtocolHandler<F> = F extends ((...args: any[]) => any) ? (...args: FnArgs
  * fan-out), `action` performs, `query` requests data (the default).
  */
 type InPageFunctionType = 'action' | 'event' | 'query';
-interface InPageFunctionDefinitionBase<NAME extends string> {
+interface InPageDefinitionBase<NAME extends string> {
   name: NAME;
   jsonSerializable?: boolean;
 }
-interface InPageEventFunctionDefinition<NAME extends string, HANDLER> extends InPageFunctionDefinitionBase<NAME> {
+interface InPageFunctionDefinitionBase<NAME extends string> extends InPageDefinitionBase<NAME> {
+  /** Expose this function through DevFrame's browser-to-node agent bridge. */
+  agent?: RpcFunctionAgentOptions;
+}
+interface InPageEventFunctionDefinition<NAME extends string, HANDLER> extends InPageDefinitionBase<NAME> {
   type: 'event';
   handler?: HANDLER;
 }
@@ -80,7 +83,8 @@ type InPageFunctionDefinitionHandler<ARGS extends any[], RETURN, AS extends RpcA
  * An in-page channel function definition: the `defineRpcFunction` authoring
  * shape (`name`, `type`, Standard-Schema `args`/`returns`,
  * `jsonSerializable`, `handler`) narrowed to the browser: there is no
- * `dump`/`snapshot`/`cacheable`/`agent`. When `jsonSerializable` is `true`,
+ * `dump`/`snapshot`/`cacheable`. An optional `agent` exposes the function to
+ * DevFrame's browser-to-node agent bridge. When `jsonSerializable` is `true`,
  * payloads are strictly validated at the receiving endpoint and misshapen
  * values reject the call with a descriptive `InPageChannelError` instead of
  * a cryptic `DataCloneError` in the port. Event definitions may omit their
@@ -92,14 +96,18 @@ type InPageFunctionDefinition<NAME extends string, TYPE extends InPageFunctionTy
  *
  * @internal
  */
-interface InPageFunctionOptionBase {
+interface InPageDefinitionOptionBase {
   /** Optional Standard Schema array validating the arguments. */
   args?: RpcArgsSchema;
   /** Optional Standard Schema validating the resolved return value. */
   returns?: RpcReturnSchema;
   jsonSerializable?: boolean;
 }
-interface InPageEventFunctionOption<F> extends InPageFunctionOptionBase {
+interface InPageFunctionOptionBase extends InPageDefinitionOptionBase {
+  /** Expose this function through DevFrame's browser-to-node agent bridge. */
+  agent?: RpcFunctionAgentOptions;
+}
+interface InPageEventFunctionOption<F> extends InPageDefinitionOptionBase {
   type?: 'event';
   handler?: ProtocolHandler<F>;
 }
@@ -269,8 +277,6 @@ interface PageScriptChannel<P extends InPageChannelProtocol> {
   readonly events: Pick<EventEmitter<PageScriptChannelEvents<P>>, 'on' | 'once'>;
   /** Fan an event out to every connected panel. */
   emit: <K extends keyof PanelEvents<P> & string>(name: K, ...args: FnArgs<PanelEvents<P>[K]>) => void;
-  /** @deprecated Use `emit()` instead. */
-  callEvent: <K extends keyof PanelEvents<P> & string>(name: K, ...args: FnArgs<PanelEvents<P>[K]>) => void;
   /** Subscribe to an event emitted by a panel. Returns an unsubscribe function. */
   on: <K extends keyof PageScriptEvents<P> & string>(name: K, listener: (...args: FnArgs<PageScriptEvents<P>[K]>) => void) => () => void;
   /** Page-script-authoritative shared states, replayed to joining panels. */
@@ -314,8 +320,6 @@ interface PanelChannel<P extends InPageChannelProtocol> {
    * (up to `eventBufferLimit`) and flushed on connect.
    */
   emit: <K extends keyof PageScriptEvents<P> & string>(name: K, ...args: FnArgs<PageScriptEvents<P>[K]>) => void;
-  /** @deprecated Use `emit()` instead. */
-  callEvent: <K extends keyof PageScriptEvents<P> & string>(name: K, ...args: FnArgs<PageScriptEvents<P>[K]>) => void;
   /** Subscribe to an event emitted by the page script. Returns an unsubscribe function. */
   on: <K extends keyof PanelEvents<P> & string>(name: K, listener: (...args: FnArgs<PanelEvents<P>[K]>) => void) => () => void;
   /** Shared states mirrored from the page-script authority. */

package/dist/in-page-channel/index.mjs

@@ -1,15 +1,21 @@
-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 { createEventEmitter } from "../utils/events.mjs";
 import { t as createSharedState } from "../shared-state-eQVYHNqA.mjs";
 import { nanoid } from "../utils/nanoid.mjs";
-import { createBirpc } from "birpc";
+import { r as registerBrowserAgentTool } from "../browser-agent-Pu-FLk6I.mjs";
 //#region src/in-page-channel/diagnostics.ts
 const diagnostics = /* #__PURE__ */ defineDiagnostics({
 	docsBase: "https://devfra.me/errors",
-	codes: { DF0077: {
-		why: (p) => `In-page channel function "${p.name}" is not registered on this endpoint.`,
-		fix: "Declare the function in this endpoint's `functions` option."
-	} }
+	codes: {
+		DF0077: {
+			why: (p) => `In-page channel function "${p.name}" is not registered on this endpoint.`,
+			fix: "Declare the function in this endpoint's `functions` option."
+		},
+		DF0080: {
+			why: (p) => `In-page channel function "${p.name}" has \`agent\` set but \`jsonSerializable\` is \`false\`; MCP requires JSON-serializable data.`,
+			fix: "Remove `jsonSerializable: false`, or remove `agent` to keep it channel-only."
+		}
+	}
 });
 //#endregion
 //#region src/in-page-channel/protocol.ts
@@ -173,17 +179,16 @@ function channelMethod(type, name) {
 	return `devframe:in-page:${type === "event" ? "event" : "function"}:${name}`;
 }
 const FUNCTION_METHOD_PREFIX = channelMethod("function", "");
-/**
-* An endpoint's local function table, resolved by name when the remote side
-* calls in. Each handler is wrapped with the receive pipeline: deserialize
-* hook, `jsonSerializable` enforcement, Standard-Schema argument validation,
-* then serialize hook + `jsonSerializable` enforcement on the result.
-*/
 function createLocalFunctionRegistry(codec) {
 	const definitions = /* @__PURE__ */ new Map();
 	const listeners = /* @__PURE__ */ new Map();
 	return {
+		definitions,
 		register(definition) {
+			if ("agent" in definition && definition.agent) {
+				if (definition.jsonSerializable === false) throw diagnostics.DF0080({ name: definition.name });
+				definition.jsonSerializable = true;
+			}
 			definitions.set(channelMethod(definition.type, definition.name), definition);
 		},
 		registerInternal(method, handler) {
@@ -237,6 +242,27 @@ function resolveLocalHandler(name, registries) {
 		throw diagnostics.DF0077({ name: name.slice(FUNCTION_METHOD_PREFIX.length) });
 	};
 }
+/** Register an endpoint's local agent functions for browser-backed transports. */
+function registerInPageAgentTools(channelName, registry) {
+	const disposals = [];
+	for (const definition of registry.definitions.values()) {
+		if (definition.type === "event" || !("agent" in definition) || !definition.agent) continue;
+		const agent = definition.agent;
+		disposals.push(registerBrowserAgentTool({
+			id: `${channelName}:${definition.name}`,
+			title: agent.title ?? definition.name,
+			description: agent.description,
+			safety: resolveAgentSafety(definition.type, agent),
+			tags: agent.tags,
+			inputSchema: argsToJsonSchema(definition.args),
+			invoke: (args) => {
+				const positional = toolInputToRpcArgs(args, definition.args?.length);
+				return registry.resolve(channelMethod(definition.type, definition.name))(...positional);
+			}
+		}));
+	}
+	return () => disposals.forEach((dispose) => dispose());
+}
 function wrapPostError(error) {
 	if (error instanceof DOMException && error.name === "DataCloneError") return new InPageChannelError("not-cloneable", `a payload could not be structured-cloned across the in-page channel: ${error.message}. Strip non-cloneable values (functions, DOM nodes, framework reactivity proxies) before sending: declare the function \`jsonSerializable: true\` for a precise error, or provide a \`serialize\` hook.`, { cause: error });
 	return error;
@@ -513,6 +539,7 @@ function createPageScriptChannel(options) {
 		name: eventName,
 		type: "event"
 	});
+	const disposeAgentTools = registerInPageAgentTools(name, registry);
 	const stateHost = createPageScriptStateHost(function* () {
 		for (const peer of peers.values()) yield {
 			subscribedStates: peer.subscribedStates,
@@ -632,13 +659,13 @@ function createPageScriptChannel(options) {
 			once: events.once
 		},
 		emit,
-		callEvent: emit,
 		on: (fnName, listener) => registry.on(fnName, listener),
 		sharedState: stateHost,
 		addPanelPort: (port) => addPeer(port, `transport:${nanoid(8)}`),
 		close: () => {
 			if (closed) return;
 			closed = true;
+			disposeAgentTools();
 			win?.removeEventListener("message", onWindowMessage);
 			for (const id of [...peers.keys()]) removePeer(id, {
 				bye: true,
@@ -689,6 +716,7 @@ function connectPanelChannel(options) {
 		name: eventName,
 		type: "event"
 	});
+	const disposeAgentTools = registerInPageAgentTools(name, registry);
 	let status = "connecting";
 	let attached;
 	let pageScriptInfo;
@@ -867,12 +895,12 @@ function connectPanelChannel(options) {
 		},
 		call: (fnName, ...args) => enqueueCall(channelMethod("function", fnName), serializeArgs(codec, args)),
 		emit: (fnName, ...args) => sendEvent(channelMethod("event", fnName), serializeArgs(codec, args)),
-		callEvent: (fnName, ...args) => sendEvent(channelMethod("event", fnName), serializeArgs(codec, args)),
 		on: (fnName, listener) => registry.on(fnName, listener),
 		sharedState: stateHost,
 		close: () => {
 			if (status === "closed") return;
 			setStatus("closed");
+			disposeAgentTools();
 			stopTimers();
 			win?.removeEventListener("message", onWindowMessage);
 			attached?.dispose({