devframe 0.9.19 → 0.10.0

package/dist/_shared-B2PZsp-J.mjs

@@ -0,0 +1,191 @@
+import "./constants.mjs";
+import { t as diagnostics } from "./diagnostics-Cx4_VjlG.mjs";
+import { n as getPort } from "./dist-CZXfGEkd.mjs";
+import { n as isRuntimeModuleResolvable, t as importRuntimeModule } from "./import-runtime-module-BzlEQ9PI.mjs";
+//#region src/utils/url.ts
+/**
+* URL path-joining and slash-normalization helpers shared by the adapters,
+* the RPC clients, and the hub's mount-path plumbing. In-house replacements
+* for the handful of `ufo` functions devframe used, kept dependency-free and
+* browser-safe (pure string operations, no `node:` imports).
+*/
+/** Matches an explicit protocol prefix: `http://`, `wss://`, `file://`, … */
+const PROTOCOL_RE = /^[\w+.-]{2,}:\/\//;
+/** `input` with a leading `/` added when missing. */
+function withLeadingSlash(input) {
+	return input.startsWith("/") ? input : `/${input}`;
+}
+/** `input` with a leading `/` removed; a bare `/` stays `/`. */
+function withoutLeadingSlash(input) {
+	return (input.startsWith("/") ? input.slice(1) : input) || "/";
+}
+/** `input` with a trailing `/` added when missing. */
+function withTrailingSlash(input) {
+	return input.endsWith("/") ? input : `${input}/`;
+}
+/** `input` with a trailing `/` removed; a bare `/` stays `/`. */
+function withoutTrailingSlash(input) {
+	return (input.endsWith("/") ? input.slice(0, -1) : input) || "/";
+}
+/** Collapses runs of `/` in every path portion, preserving `://`. */
+function cleanDoubleSlashes(input) {
+	return input.split("://").map((part) => part.replace(/\/{2,}/g, "/")).join("://");
+}
+/**
+* Joins path segments onto `base` with exactly one `/` at each seam.
+* A segment's leading `/` or `./` is dropped; empty and bare-`/` segments
+* are skipped; the last segment's trailing slash is preserved.
+*/
+function joinURL(base, ...segments) {
+	let url = base;
+	for (const segment of segments) {
+		if (!segment || segment === "/") continue;
+		url = url ? withTrailingSlash(url) + segment.replace(/^\.?\//, "") : segment;
+	}
+	return url;
+}
+/**
+* Prefixes `input` with `base` unless it already carries the prefix or is an
+* absolute URL with a protocol. An empty or `/` base is a no-op.
+*/
+function withBase(input, base) {
+	if (!base || base === "/" || PROTOCOL_RE.test(input)) return input;
+	const prefix = withoutTrailingSlash(base);
+	return input.startsWith(prefix) ? input : joinURL(prefix, input);
+}
+//#endregion
+//#region src/node/agentic.ts
+const AGENTIC_PACKAGE = "@devframes/agentic";
+/**
+* Whether `@devframes/agentic` is resolvable from devframe's own location
+* (where its optional peer is linked). A pure `require.resolve` probe: no
+* module is loaded, so the `'auto'` miss path stays zero-cost.
+*/
+function isAgenticInstalled(pkg = AGENTIC_PACKAGE) {
+	return isRuntimeModuleResolvable(`${pkg}/package.json`);
+}
+let warnedMissing = false;
+/** Report DF0078 (agent surface without `@devframes/agentic`) once per process. */
+function warnAgenticMcpMissingOnce() {
+	if (warnedMissing) return;
+	warnedMissing = true;
+	diagnostics.DF0078();
+}
+/**
+* Load the MCP adapter from `@devframes/agentic/mcp`, mapping a failed load
+* (typically: the optional peer is not installed) to a thrown `DF0079`.
+* Loads through `importRuntimeModule`, so the adapter and the MCP SDK behind
+* it never enter a consumer's bundle graph.
+*/
+async function importAgenticMcp(specifier = `${AGENTIC_PACKAGE}/mcp`) {
+	try {
+		return await importRuntimeModule(specifier);
+	} catch (error) {
+		const reason = error instanceof Error ? error.message : String(error);
+		throw diagnostics.DF0079({
+			reason,
+			cause: error
+		});
+	}
+}
+//#endregion
+//#region src/adapters/_shared.ts
+const DEFAULT_PORT = 9999;
+/**
+* Resolve the mount base path for a devframe's SPA. Hosted adapters
+* (`vite`, `embedded`) default to `/__<id>/` so they don't collide
+* with the host app; standalone adapters (`cli`, `build`)
+* default to `/` because they own the origin.
+*
+* The devframe author can override with `basePath` on the definition.
+*/
+function resolveBasePath(def, kind) {
+	if (def.basePath) return normalizeBasePath(def.basePath);
+	return kind === "standalone" ? "/" : `/__${def.id}/`;
+}
+function normalizeBasePath(base) {
+	return cleanDoubleSlashes(withTrailingSlash(withLeadingSlash(base)));
+}
+/**
+* Resolve the listening port for `createDevServer` (and `createHandler`'s
+* side-car tiers), honoring the definition's `cli.port` / `cli.portRange` /
+* `cli.random` settings. Exposed separately so authors who run their own
+* argv parsing can resolve a port up-front (to print it, log it, etc.)
+* before starting the server.
+*/
+async function resolveDevServerPort(def, options = {}) {
+	const host = options.host ?? def.cli?.host ?? "localhost";
+	const portOptions = {
+		port: options.defaultPort ?? def.cli?.port ?? DEFAULT_PORT,
+		host
+	};
+	if (def.cli?.portRange) portOptions.portRange = def.cli.portRange;
+	if (def.cli?.random) portOptions.random = def.cli.random;
+	return getPort(portOptions);
+}
+/**
+* Normalize an *explicit* `mcp` setting into a fully-resolved config, or
+* `undefined` when the MCP route is disabled. `'auto'` also resolves to
+* `undefined` here: whether it mounts depends on the live agent surface,
+* which only the mounting adapter can consult (through
+* {@link loadAutoMcpAdapter}) - static resolvers like
+* `resolveMcpConnectionMeta` treat it as unadvertisable.
+*
+* An enabled route trusts same-machine callers by default: the authorization
+* resolves to origin-only (`false`) unless the object config opts into a
+* bearer/callback identity check. An empty-string bearer is treated as no
+* bearer (origin-only) rather than a usable credential.
+*/
+function resolveMcpConfig(mcp) {
+	if (!mcp || mcp === "auto") return void 0;
+	if (mcp === true) return { authorization: false };
+	const authorization = typeof mcp.authorization === "string" && mcp.authorization.length === 0 ? false : mcp.authorization ?? false;
+	return {
+		...mcp.path !== void 0 ? { path: mcp.path } : {},
+		...mcp.allowedOrigins !== void 0 ? { allowedOrigins: mcp.allowedOrigins } : {},
+		authorization
+	};
+}
+/**
+* Resolve the `mcp: 'auto'` default at mount time: import the MCP adapter
+* from the optional `@devframes/agentic` peer when the devframe's agent
+* surface is non-empty, or return `undefined` (mount nothing) when the
+* surface is empty - the zero-cost path, loading no MCP code at all. A
+* non-empty surface with the peer absent also mounts nothing, reporting a
+* one-time DF0078 warning instead. The adapter (and the MCP SDK behind it)
+* loads through `importRuntimeModule`, so it never enters a consumer's
+* bundle graph.
+*/
+async function loadAutoMcpAdapter(agent) {
+	if (!agent.hasSurface()) return void 0;
+	if (!isAgenticInstalled()) {
+		warnAgenticMcpMissingOnce();
+		return;
+	}
+	return await importAgenticMcp();
+}
+/**
+* Resolve the `mcp` entry a `__connection.json` should advertise for a dev
+* server started with the given `mcp` option, or `undefined` when the route
+* is disabled. `'auto'` (the omitted default) resolves at mount time against
+* the live agent surface, so hand-rolled meta advertises it only for an
+* explicit setting; the adapters advertise the actually-mounted route
+* themselves.
+*
+* Hosted bridges that hand-roll their connection meta pass the side-car
+* `port`: the advertised path becomes absolute (the side-car mounts at `/`)
+* and the client dials `<page-host>:<port><path>`. Without `port` the path
+* stays relative, resolved against `__connection.json`'s own location (the
+* same-server default).
+*/
+function resolveMcpConnectionMeta(mcp, port) {
+	const config = resolveMcpConfig(mcp);
+	if (!config) return void 0;
+	const route = withoutLeadingSlash(config.path ?? "__mcp");
+	return port != null ? {
+		path: withLeadingSlash(route),
+		port
+	} : { path: route };
+}
+//#endregion
+export { resolveMcpConfig as a, joinURL as c, withoutLeadingSlash as d, withoutTrailingSlash as f, resolveDevServerPort as i, withBase as l, normalizeBasePath as n, resolveMcpConnectionMeta as o, resolveBasePath as r, importAgenticMcp as s, loadAutoMcpAdapter as t, withLeadingSlash as u };

package/dist/{_shared-BIUet_Jh.d.mts → _shared-Dy1UBMUN.d.mts}

@@ -1,4 +1,5 @@
-import { F as DevframeDefinition, G as McpAuthorization, I as DevframeDeploymentKind, q as McpSetting, t as ConnectionMeta, zt as DevframeAgentHost } from "./context-BLHBDQcZ.mjs";
+import { B as DevframeDefinition, Q as McpSetting, V as DevframeDeploymentKind, Wt as DevframeAgentHost, X as McpAuthorization, t as ConnectionMeta } from "./context-CTAxz9ec.mjs";
+import { t as AgenticMcpModule } from "./agentic-D4QQQUjE.mjs";
 //#region src/adapters/_shared.d.ts
 /**
  * Resolve the mount base path for a devframe's SPA. Hosted adapters
@@ -53,21 +54,19 @@ interface ResolvedMcpConfig {
 declare function resolveMcpConfig(mcp: McpSetting | undefined): ResolvedMcpConfig | undefined;
 /**
  * Resolve the `mcp: 'auto'` default at mount time: import the MCP adapter
- * when the devframe's agent surface is non-empty, or return `undefined`
- * (mount nothing) when the surface is empty - the zero-cost path, loading
- * no MCP code at all. The adapter (and the MCP SDK behind it) loads through
- * `importRuntimeModule`, so it never enters a consumer's bundle graph.
- *
- * Generic like `importRuntimeModule`: the caller names the module type
- * (`typeof import('devframe/adapters/mcp')`) so this shared helper carries
- * no type-level dependency on the MCP adapter.
+ * from the optional `@devframes/agentic` peer when the devframe's agent
+ * surface is non-empty, or return `undefined` (mount nothing) when the
+ * surface is empty - the zero-cost path, loading no MCP code at all. A
+ * non-empty surface with the peer absent also mounts nothing, reporting a
+ * one-time DF0078 warning instead. The adapter (and the MCP SDK behind it)
+ * loads through `importRuntimeModule`, so it never enters a consumer's
+ * bundle graph.
  */
-declare function loadAutoMcpAdapter<T>(agent: Pick<DevframeAgentHost, 'hasSurface'>): Promise<T | undefined>;
+declare function loadAutoMcpAdapter(agent: Pick<DevframeAgentHost, 'hasSurface'>): Promise<AgenticMcpModule | undefined>;
 /**
  * Resolve the `mcp` entry a `__connection.json` should advertise for a dev
- * server started with the given `mcp` option (falling back to `def.cli?.mcp`,
- * exactly like `createDevServer`), or `undefined` when the route is
- * disabled. `'auto'` (the omitted default) resolves at mount time against
+ * server started with the given `mcp` option, or `undefined` when the route
+ * is disabled. `'auto'` (the omitted default) resolves at mount time against
  * the live agent surface, so hand-rolled meta advertises it only for an
  * explicit setting; the adapters advertise the actually-mounted route
  * themselves.
@@ -78,6 +77,6 @@ declare function loadAutoMcpAdapter<T>(agent: Pick<DevframeAgentHost, 'hasSurfac
  * stays relative, resolved against `__connection.json`'s own location (the
  * same-server default).
  */
-declare function resolveMcpConnectionMeta(def: DevframeDefinition, mcp: McpSetting | undefined, port?: number): ConnectionMeta['mcp'];
+declare function resolveMcpConnectionMeta(mcp: McpSetting | undefined, port?: number): ConnectionMeta['mcp'];
 //#endregion
 export { resolveBasePath as a, resolveMcpConnectionMeta as c, normalizeBasePath as i, ResolvedMcpConfig as n, resolveDevServerPort as o, loadAutoMcpAdapter as r, resolveMcpConfig as s, ResolveDevServerPortOptions as t };

package/dist/adapters/build.d.mts

@@ -1,4 +1,4 @@
-import { F as DevframeDefinition, V as DevframeSnapshotRpcEntry, o as DevframeNodeContext } from "../context-BLHBDQcZ.mjs";
+import { B as DevframeDefinition, K as DevframeSnapshotRpcEntry, o as DevframeNodeContext } from "../context-CTAxz9ec.mjs";
 import { o as StaticAssetsSource } from "../remote-assets-eBvSKZMS.mjs";
 //#region src/adapters/build.d.ts
 export interface CreateBuildOptions {
@@ -7,9 +7,8 @@ export interface CreateBuildOptions {
   /**
    * Override the SPA dist to copy into `outDir`: a local directory or a
    * remote-assets declaration (materialized in full at build time). When
-   * omitted the adapter reads `devframe.clientAssets` (or the deprecated
-   * `devframe.cli?.distDir`); authors typically set this once on the
-   * definition itself.
+   * omitted the adapter reads `devframe.clientAssets`; authors typically set
+   * this once on the definition itself.
    */
   distDir?: StaticAssetsSource;
   /**

package/dist/adapters/build.mjs

@@ -1,10 +1,9 @@
 import { s as colors } from "../nostics-D0PvLZsn.mjs";
-import { t as resolveClientAssets } from "../client-assets-DNdhagGm.mjs";
 import { DEVFRAME_CONNECTION_META_FILENAME, DEVFRAME_RPC_DUMP_MANIFEST_FILENAME } from "../constants.mjs";
 import { n as collectStaticRpcDump, t as writeStaticRpcDump } from "../write-DoXJzGUH.mjs";
-import { t as diagnostics } from "../diagnostics-DZA6KQ_Z.mjs";
-import { t as createHostContext } from "../context-BLXXjoBW.mjs";
-import { t as resolveStaticAssetsSource } from "../remote-assets-D0StJVLp.mjs";
+import { t as diagnostics } from "../diagnostics-Cx4_VjlG.mjs";
+import { t as createHostContext } from "../context-C141q8H4.mjs";
+import { t as resolveStaticAssetsSource } from "../remote-assets-B9MeWmW6.mjs";
 import { t as createH3DevframeHost } from "../host-h3-BROI6SQ4.mjs";
 import fs from "node:fs/promises";
 import { resolve } from "pathe";
@@ -25,7 +24,7 @@ import { existsSync } from "node:fs";
 async function createBuild(d, options = {}) {
 	if (d.capabilities?.build === false && !options.force) throw diagnostics.DF0042({ id: d.id });
 	const outDir = resolve(options.outDir ?? "dist-static");
-	const distSource = options.distDir ?? resolveClientAssets(d);
+	const distSource = options.distDir ?? d.clientAssets;
 	if (!distSource) throw new Error(`[devframe] createBuild: no client assets for "${d.id}". Set \`clientAssets\` on the definition or pass it as an option.`);
 	if (existsSync(outDir)) await fs.rm(outDir, { recursive: true });
 	await fs.mkdir(outDir, { recursive: true });

package/dist/adapters/cac.d.mts

@@ -1,4 +1,4 @@
-import { Dt as InferCliFlags, Et as CliFlagsSchema, F as DevframeDefinition, Ot as defineCliFlags, kt as parseCliFlags, q as McpSetting } from "../context-BLHBDQcZ.mjs";
+import { B as DevframeDefinition, Mt as InferCliFlags, Nt as defineCliFlags, Pt as parseCliFlags, Q as McpSetting, jt as CliFlagsSchema } from "../context-CTAxz9ec.mjs";
 import { CAC } from "cac";
 import { H3 } from "h3";
 //#region src/adapters/cac.d.ts
@@ -9,9 +9,8 @@ export interface CreateCacOptions {
    * Expose a route-based MCP server alongside the dev server, speaking the
    * MCP Streamable-HTTP transport at `<base>__mcp`. Whether to expose MCP is
    * a hosting decision made at the CLI assembly stage, so it lives here rather
-   * than on the definition. When unset, falls back to the definition's
-   * deprecated `cli.mcp`, then to the `'auto'` default (mount once the agent
-   * surface is non-empty). See {@link McpSetting}.
+   * than on the definition. When unset, falls back to the `'auto'` default
+   * (mount once the agent surface is non-empty). See {@link McpSetting}.
    *
    * The `--mcp` / `--no-mcp` flags override this per run.
    */

package/dist/adapters/cac.mjs

@@ -1,7 +1,7 @@
 import { s as colors } from "../nostics-D0PvLZsn.mjs";
-import { i as resolveDevServerPort, s as importRuntimeModule } from "../_shared-U8D-xzrp.mjs";
+import { i as resolveDevServerPort, s as importAgenticMcp } from "../_shared-B2PZsp-J.mjs";
 import { createBuild } from "./build.mjs";
-import { t as createDevServer } from "../dev-DbWecpjA.mjs";
+import { t as createDevServer } from "../dev-DM1mIlgi.mjs";
 import process from "node:process";
 import cac$1 from "cac";
 //#region src/adapters/flags.ts
@@ -125,7 +125,7 @@ function createCac(d, options = {}) {
 		});
 	});
 	cli.command("mcp", "Start an MCP server exposing agent-facing tools (stdio)").action(async () => {
-		const { createMcpServer } = await importRuntimeModule("devframe/adapters/mcp");
+		const { createMcpServer } = await importAgenticMcp();
 		await createMcpServer(d, {
 			transport: "stdio",
 			/** Deliberately go to stderr: stdout is the MCP transport. */

package/dist/adapters/dev.d.mts

@@ -1,9 +1,9 @@
-import { F as DevframeDefinition, Tt as DevframeAuthHandler, U as DevframeSseOptions, W as DevframeWsOptions, q as McpSetting, s as DevframeNodeRpcSession } from "../context-BLHBDQcZ.mjs";
+import { At as DevframeAuthHandler, B as DevframeDefinition, J as DevframeSseOptions, Q as McpSetting, Y as DevframeWsOptions, s as DevframeNodeRpcSession } from "../context-CTAxz9ec.mjs";
 import { n as DevframeRpcConnection, t as DevframeNodeRpcSessionMeta } from "../session-r6PDixP6.mjs";
 import { o as StaticAssetsSource } from "../remote-assets-eBvSKZMS.mjs";
-import { n as WsOriginRegistry } from "../ws-server-BB8jhxeT.mjs";
-import { c as StartedServer } from "../instance-shell-C6Vg97lg.mjs";
-import { c as resolveMcpConnectionMeta, o as resolveDevServerPort, t as ResolveDevServerPortOptions } from "../_shared-BIUet_Jh.mjs";
+import { n as WsOriginRegistry } from "../ws-server-y2R76aSW.mjs";
+import { c as StartedServer } from "../instance-shell-DOZSxst6.mjs";
+import { c as resolveMcpConnectionMeta, o as resolveDevServerPort, t as ResolveDevServerPortOptions } from "../_shared-Dy1UBMUN.mjs";
 import { H3 } from "h3";
 //#region src/adapters/dev.d.ts
 export interface CreateDevServerOptions {
@@ -22,7 +22,7 @@ export interface CreateDevServerOptions {
    */
   flags?: Record<string, unknown>;
   /**
-   * Override the definition's `clientAssets` (or deprecated `cli.distDir`).
+   * Override the definition's `clientAssets`.
    * When neither this option nor the definition's client assets are set, the
    * dev server runs in **bridge mode**: only `__connection.json` and the WS
    * endpoint are mounted; the SPA is expected to be hosted elsewhere (e.g. by
@@ -82,9 +82,9 @@ export interface CreateDevServerOptions {
   auth?: boolean | DevframeAuthHandler;
   /**
    * Expose a route-based MCP server on the dev server (Streamable-HTTP).
-   * Overrides `def.cli?.mcp`; `undefined` falls through to it, then to the
-   * `'auto'` default (mount once the agent surface is non-empty). `false`
-   * disables the route regardless. See {@link McpSetting}.
+   * `undefined` falls through to the `'auto'` default (mount once the agent
+   * surface is non-empty). `false` disables the route regardless. See
+   * {@link McpSetting}.
    */
   mcp?: McpSetting;
   /**

package/dist/adapters/dev.mjs

@@ -1,3 +1,3 @@
-import { i as resolveDevServerPort, o as resolveMcpConnectionMeta } from "../_shared-U8D-xzrp.mjs";
-import { t as createDevServer } from "../dev-DbWecpjA.mjs";
+import { i as resolveDevServerPort, o as resolveMcpConnectionMeta } from "../_shared-B2PZsp-J.mjs";
+import { t as createDevServer } from "../dev-DM1mIlgi.mjs";
 export { createDevServer, resolveDevServerPort, resolveMcpConnectionMeta };

package/dist/adapters/embedded.d.mts

@@ -1,4 +1,4 @@
-import { F as DevframeDefinition, o as DevframeNodeContext } from "../context-BLHBDQcZ.mjs";
+import { B as DevframeDefinition, o as DevframeNodeContext } from "../context-CTAxz9ec.mjs";
 //#region src/adapters/embedded.d.ts
 export interface CreateEmbeddedOptions {
   /** Target context the devframe is registered into. Required. */

package/dist/adapters/initiate.d.mts

@@ -1,8 +1,8 @@
-import { F as DevframeDefinition, St as DevframeStorageScope, Tt as DevframeAuthHandler, U as DevframeSseOptions, W as DevframeWsOptions, o as DevframeNodeContext, q as McpSetting, s as DevframeNodeRpcSession, t as ConnectionMeta } from "../context-BLHBDQcZ.mjs";
+import { At as DevframeAuthHandler, B as DevframeDefinition, Dt as DevframeStorageScope, J as DevframeSseOptions, Q as McpSetting, Y as DevframeWsOptions, o as DevframeNodeContext, s as DevframeNodeRpcSession, t as ConnectionMeta } from "../context-CTAxz9ec.mjs";
 import { n as DevframeRpcConnection, t as DevframeNodeRpcSessionMeta } from "../session-r6PDixP6.mjs";
 import { o as StaticAssetsSource } from "../remote-assets-eBvSKZMS.mjs";
-import { n as WsOriginRegistry } from "../ws-server-BB8jhxeT.mjs";
-import { c as StartedServer, f as DevframeInstanceRecord } from "../instance-shell-C6Vg97lg.mjs";
+import { n as WsOriginRegistry } from "../ws-server-y2R76aSW.mjs";
+import { c as StartedServer, f as DevframeInstanceRecord } from "../instance-shell-DOZSxst6.mjs";
 import { H3 } from "h3";
 import { Buffer } from "node:buffer";
 import { IncomingMessage, Server, ServerResponse } from "node:http";
@@ -19,8 +19,8 @@ export interface InitDevframeOptions {
    */
   base: string;
   /**
-   * Override the definition's `clientAssets` (or deprecated `cli.distDir`).
-   * When neither is set (or `false` is passed to suppress the definition's
+   * Override the definition's `clientAssets`.
+   * When it is unset (or `false` is passed to suppress the definition's
    * own client assets), the handler runs in **bridge mode**: only
    * `__connection.json`, the WS endpoint, and the MCP route (when enabled) are
    * served; the SPA is hosted elsewhere.
@@ -73,9 +73,9 @@ export interface InitDevframeOptions {
   auth?: boolean | DevframeAuthHandler;
   /**
    * Expose a route-based MCP server (Streamable-HTTP) at `<base>__mcp` and
-   * advertise it in `__connection.json`. Overrides `def.cli?.mcp`;
-   * `undefined` falls through to it, then to the `'auto'` default (mount
-   * once the agent surface is non-empty). See {@link McpSetting}.
+   * advertise it in `__connection.json`. `undefined` falls through to the
+   * `'auto'` default (mount once the agent surface is non-empty). See
+   * {@link McpSetting}.
    */
   mcp?: McpSetting;
   /**

package/dist/adapters/initiate.mjs

@@ -1,2 +1,2 @@
-import { n as getInstanceInternals, r as initDevframe } from "../dev-DbWecpjA.mjs";
+import { n as getInstanceInternals, r as initDevframe } from "../dev-DM1mIlgi.mjs";
 export { getInstanceInternals, initDevframe };

package/dist/adapters/mcp.d.mts

@@ -1,123 +1,4 @@
-import { F as DevframeDefinition, G as McpAuthorization, o as DevframeNodeContext } from "../context-BLHBDQcZ.mjs";
-import { H3 } from "h3";
-import "@modelcontextprotocol/server";
-//#region src/adapters/mcp/build-server.d.ts
-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>;
-}
-/**
- * Build an MCP server over the agent surface of a devframe definition.
- * Currently supports `stdio` transport only.
- */
-export declare function createMcpServer(definition: DevframeDefinition, options?: CreateMcpServerOptions): Promise<McpServerHandle>;
-//#endregion
-//#region src/adapters/mcp/fetch.d.ts
-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 `buildMcpServerFromContext`. */
-  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;
-}
-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.
-   */
-  fetch: (request: Request) => Promise<Response>;
-  /** Tear down the handler (aborts in-flight exchanges, drops the change bridge). */
-  dispose: () => Promise<void>;
-}
-/**
- * Build a framework-agnostic MCP endpoint over a devframe context: a
- * web-standard `Request → Response` handler any host can mount: h3 (see
- * `mountMcpHttp`), a Next.js App Router route, or any other fetch-shaped
- * server.
- *
- * The endpoint is **stateless**: it serves the 2026-07-28 revision per request
- * through the SDK's {@link createMcpHandler}, which builds a fresh MCP server
- * (from the shared, live `ctx` via `buildMcpServerFromContext`) for each
- * request: no `Mcp-Session-Id` registry, no session-local routing, no
- * GET/DELETE teardown protocol. 2025-era clients are still served through the
- * SDK's default stateless legacy path. `list_changed` events reach modern
- * `subscriptions/listen` streams through the handler's `notify` bus.
- *
- * The origin gate guards every request: loopback-default DNS-rebinding
- * protection that (unlike the WS upgrade's `isAllowedOrigin`) also rejects
- * `Origin`-less requests, so a route-based endpoint isn't reachable by a
- * browser or a remote host (a disallowed origin gets `403`). It trusts
- * same-machine callers by default. When that isn't your trust boundary, add
- * an optional identity gate ({@link CreateMcpFetchHandlerOptions.authorization}),
- * checked after the origin gate: a bearer/callback check that proves *who* is
- * calling (a missing/invalid credential gets `401` with a
- * `WWW-Authenticate: Bearer` challenge).
- */
-export declare function createMcpFetchHandler(ctx: DevframeNodeContext, options: CreateMcpFetchHandlerOptions): McpFetchHandler;
-//#endregion
-//#region src/adapters/mcp/http.d.ts
-interface MountMcpHttpOptions extends CreateMcpFetchHandlerOptions {}
-interface MountedMcpHttp {
-  /** Tear down the MCP handler (aborts in-flight exchanges, drops the change bridge). */
-  dispose: () => Promise<void>;
-}
-/**
- * Mount a stateless MCP endpoint on an h3 app at `path`: the h3 binding over
- * {@link createMcpFetchHandler}, which owns the per-request serving, the
- * origin gate, and the transport plumbing.
- *
- * The handler is web-standard: it takes the h3 event's web `Request` and
- * returns a web `Response` (an SSE `ReadableStream` body for a
- * `subscriptions/listen` stream). We copy that response onto `event.res` and
- * return its body rather than returning the `Response` object directly, so an
- * MCP error response (e.g. a 4xx) isn't swallowed by h3's "Response-with-404
- * falls through to the next handler" rule (which would otherwise hand the
- * request to the SPA static catch-all).
- */
-export declare function mountMcpHttp(app: H3, ctx: DevframeNodeContext, path: string, options: MountMcpHttpOptions): MountedMcpHttp;
-//#endregion
-export type { CreateMcpFetchHandlerOptions, CreateMcpServerOptions, McpFetchHandler, McpServerHandle, MountMcpHttpOptions, MountedMcpHttp };
+import { F as CreateMcpServerOptions, I as McpConnectionInfo, L as McpFetchHandler, P as CreateMcpFetchHandlerOptions, R as McpServerHandle } from "../context-CTAxz9ec.mjs";
+import { n as MountMcpHttpOptions, r as MountedMcpHttp } from "../agentic-D4QQQUjE.mjs";
+import { createMcpFetchHandler, createMcpServer, mountMcpHttp } from "@devframes/agentic/mcp";
+export { type CreateMcpFetchHandlerOptions, type CreateMcpServerOptions, type McpConnectionInfo, type McpFetchHandler, type McpServerHandle, type MountMcpHttpOptions, type MountedMcpHttp, createMcpFetchHandler, createMcpServer, mountMcpHttp };