devframe 0.9.20 → 0.10.0

package/dist/interactive-auth-BCa_iamv.mjs

@@ -0,0 +1,384 @@
+import { s as colors } from "./nostics-D0PvLZsn.mjs";
+import { n as defineRpcFunction } from "./define-BLWPsH6y.mjs";
+import { isAnonymousRpcMethod } from "./constants.mjs";
+import { a as getTempAuthCodeInfo, n as describeUA, o as refreshTempAuthCode, r as exchangeTempAuthCode, s as verifyAuthToken, t as buildOtpAuthUrl } from "./state-W4wI6X5X.mjs";
+import { t as getInternalContext } from "./context-CHpyLX8W.mjs";
+//#region src/utils/simple-schema.ts
+function ok(value) {
+	return { value };
+}
+function fail(message, path) {
+	return { issues: [path ? {
+		message,
+		path
+	} : { message }] };
+}
+function make(type, validate, extra) {
+	return {
+		type,
+		...extra,
+		"~standard": {
+			version: 1,
+			vendor: "devframe",
+			validate
+		}
+	};
+}
+/** Run a Standard Schema synchronously, rejecting async validators. */
+function runSync(schema, value) {
+	const result = schema["~standard"].validate(value);
+	if (result instanceof Promise) throw new TypeError("[devframe/utils/simple-schema] async validators are not supported inside object()/optional()/nullable()");
+	return result;
+}
+/** Any string. */
+function string() {
+	return make("string", (v) => typeof v === "string" ? ok(v) : fail("Expected a string"));
+}
+/** A finite number (rejects `NaN`). */
+function number() {
+	return make("number", (v) => typeof v === "number" && !Number.isNaN(v) ? ok(v) : fail("Expected a number"));
+}
+/** A boolean. */
+function boolean() {
+	return make("boolean", (v) => typeof v === "boolean" ? ok(v) : fail("Expected a boolean"));
+}
+/** `undefined`, mirroring valibot's `void`. */
+function voidType() {
+	return make("void", (v) => v === void 0 ? ok(void 0) : fail("Expected undefined"));
+}
+/** `null`. */
+function nullType() {
+	return make("null", (v) => v === null ? ok(null) : fail("Expected null"));
+}
+/** One of a fixed set of literal values. */
+function picklist(values) {
+	const set = new Set(values);
+	return make("picklist", (v) => set.has(v) ? ok(v) : fail(`Expected one of: ${values.join(", ")}`), { values });
+}
+/** A single literal value (string / number / boolean). */
+function literal(value) {
+	return make("literal", (v) => v === value ? ok(v) : fail(`Expected ${JSON.stringify(value)}`), { value });
+}
+/** A value matching any one of the given schemas. */
+function union(options) {
+	return make("union", (v) => {
+		const issues = [];
+		for (const option of options) {
+			const result = runSync(option, v);
+			if (!result.issues) return ok(v);
+			issues.push(...result.issues);
+		}
+		return { issues };
+	}, { options });
+}
+/** A record with string keys whose values each satisfy the value schema. */
+function record(_key, value) {
+	return make("record", (v) => {
+		if (typeof v !== "object" || v === null || Array.isArray(v)) return fail("Expected an object");
+		const obj = v;
+		const issues = [];
+		for (const key of Object.keys(obj)) {
+			const result = runSync(value, obj[key]);
+			if (result.issues) for (const issue of result.issues) issues.push({
+				message: issue.message,
+				path: [key, ...issue.path ?? []]
+			});
+		}
+		return issues.length ? { issues } : ok(v);
+	});
+}
+/** An array whose every element satisfies the item schema. */
+function array(item) {
+	return make("array", (v) => {
+		if (!Array.isArray(v)) return fail("Expected an array");
+		const issues = [];
+		for (let i = 0; i < v.length; i++) {
+			const result = runSync(item, v[i]);
+			if (result.issues) for (const issue of result.issues) issues.push({
+				message: issue.message,
+				path: [i, ...issue.path ?? []]
+			});
+		}
+		return issues.length ? { issues } : ok(v);
+	});
+}
+/** An object whose known keys each satisfy their schema (extra keys are kept). */
+function object(shape) {
+	const entries = Object.entries(shape);
+	return make("object", (v) => {
+		if (typeof v !== "object" || v === null || Array.isArray(v)) return fail("Expected an object");
+		const obj = v;
+		const issues = [];
+		for (const [key, schema] of entries) {
+			const result = runSync(schema, obj[key]);
+			if (result.issues) for (const issue of result.issues) issues.push({
+				message: issue.message,
+				path: [key, ...issue.path ?? []]
+			});
+		}
+		return issues.length ? { issues } : ok(v);
+	});
+}
+/** Allow `undefined` in addition to the inner schema. */
+function optional(inner) {
+	return make("optional", (v) => v === void 0 ? ok(void 0) : runSync(inner, v), { wrapped: inner });
+}
+/** Allow `null` in addition to the inner schema. */
+function nullable(inner) {
+	return make("nullable", (v) => v === null ? ok(null) : runSync(inner, v), { wrapped: inner });
+}
+/** Attach a human-readable description (used for CLI option help). */
+function describe(schema, description) {
+	return {
+		...schema,
+		description
+	};
+}
+/**
+* Grouped access to every builder: `s.string()`, `s.object({ ... })`,
+* `s.void()`, etc. Handy for a valibot-like `import { s } from
+* 'devframe/utils/simple-schema'` call site.
+*/
+const s = {
+	string,
+	number,
+	boolean,
+	void: voidType,
+	null: nullType,
+	literal,
+	picklist,
+	union,
+	record,
+	array,
+	object,
+	optional,
+	nullable,
+	describe
+};
+//#endregion
+//#region src/recipes/interactive-auth.ts
+/**
+* Build a {@link AuthBannerFunction} that renders the auth code + magic-link
+* URL as a small bordered box, its two rows label-aligned. `createInteractiveAuth`
+* falls back to `createAuthBanner()` when no `banner` is given; call this
+* yourself to rebrand the box (`title` / `colors`) and pass the result as
+* `options.banner`.
+*/
+function createAuthBanner(options = {}) {
+	const title = options.title ?? "Devframe";
+	const palette = {
+		border: colors.dim,
+		title: (x) => colors.gray(colors.bold(x)),
+		label: colors.dim,
+		code: (f) => colors.green(colors.bold(f)),
+		url: colors.cyan,
+		...options.colors
+	};
+	return (info) => {
+		const rows = [
+			[
+				"auth code",
+				info.code,
+				palette.code
+			],
+			[
+				"or open",
+				info.url,
+				palette.url
+			],
+			[
+				"expires at",
+				new Date(info.expireAt).toLocaleTimeString(),
+				palette.label
+			]
+		];
+		if (info.requester) {
+			rows.push([
+				"ua",
+				info.requester.ua,
+				palette.label
+			]);
+			rows.push([
+				"origin",
+				info.requester.origin,
+				palette.label
+			]);
+		}
+		const labelWidth = Math.max(...rows.map(([label]) => label.length));
+		const contentWidth = Math.max(...rows.map(([, value]) => labelWidth + 2 + value.length));
+		const titleBarLength = title.length + 2;
+		const lineWidth = Math.max(contentWidth, titleBarLength - 2);
+		const top = [
+			palette.border(`╭`),
+			palette.title(title),
+			palette.border(`${"─".repeat(Math.max(lineWidth + 2 - titleBarLength, 0))}╮`)
+		].join(" ");
+		const bottom = `╰${"─".repeat(lineWidth + 2)}╯`;
+		const body = rows.map(([label, value, color]) => {
+			const plain = `${label.padEnd(labelWidth)}  ${value}`;
+			const pad = " ".repeat(lineWidth - plain.length);
+			return `${palette.border("│")} ${palette.label(label.padEnd(labelWidth))}  ${color(value)}${pad} ${palette.border("│")}`;
+		});
+		console.log(`\n${palette.border(top)}\n${body.join("\n")}\n${palette.border(bottom)}\n`);
+	};
+}
+/**
+* Package the interactive OTP auth protocol devframe's primitives
+* (`exchangeTempAuthCode`, `verifyAuthToken`, `revokeAuthToken`,
+* `getTempAuthCode`, `buildOtpAuthUrl`) implement into a ready-made
+* {@link DevframeAuthHandler}: the handshake RPC functions, the resolver
+* gate, the connect-time trust hook, and the startup banner.
+*
+* The auth storage stays internal to this handler; callers never reach into
+* `devframe/node/hub-internals` themselves.
+*
+* ```ts
+* import { createInteractiveAuth } from 'devframe/recipes/interactive-auth'
+*
+* const auth = createInteractiveAuth(ctx)
+* auth.rpcFunctions.forEach(fn => ctx.rpc.register(fn))
+* auth.printBanner()
+*
+* // wire `auth.authorize` / `auth.onConnect` into your transport, or pass
+* // the whole handler to `initDevframe` / `initHub` via their `auth` option.
+* ```
+*/
+function createInteractiveAuth(context, options = {}) {
+	const internal = getInternalContext(context);
+	const storage = internal.storage.auth;
+	const staticTokens = new Set(options.clientAuthTokens ?? []);
+	function isStaticToken(token) {
+		return !!token && staticTokens.has(token);
+	}
+	function resolveServerUrl() {
+		return options.serverUrl?.() ?? context.host.resolveOrigin();
+	}
+	const banner = options.banner ?? createAuthBanner();
+	let bannerPrintedForCode;
+	function printBanner(info) {
+		const { code, expireAt } = getTempAuthCodeInfo();
+		if (code === bannerPrintedForCode) return;
+		bannerPrintedForCode = code;
+		const url = buildOtpAuthUrl(resolveServerUrl(), code);
+		banner({
+			code,
+			url,
+			expireAt,
+			...info?.requester ? { requester: info.requester } : {}
+		});
+	}
+	const anonymousAuth = defineRpcFunction({
+		name: "anonymous:devframe:auth",
+		type: "action",
+		jsonSerializable: true,
+		args: [s.object({
+			authToken: s.string(),
+			ua: s.string(),
+			origin: s.string()
+		})],
+		returns: s.object({ isTrusted: s.boolean() }),
+		handler(params) {
+			const session = context.rpc.getCurrentRpcSession();
+			if (!session) return { isTrusted: false };
+			if (session.meta.isTrusted) return { isTrusted: true };
+			if (isStaticToken(params.authToken)) {
+				session.meta.clientAuthToken = params.authToken;
+				session.meta.isTrusted = true;
+				return { isTrusted: true };
+			}
+			return { isTrusted: verifyAuthToken(params.authToken, session, storage) };
+		}
+	});
+	const anonymousAuthExchange = defineRpcFunction({
+		name: "anonymous:devframe:auth:exchange",
+		type: "action",
+		jsonSerializable: true,
+		args: [s.object({
+			code: s.string(),
+			ua: s.string(),
+			origin: s.string()
+		})],
+		returns: s.object({ authToken: s.nullable(s.string()) }),
+		handler(params) {
+			const session = context.rpc.getCurrentRpcSession();
+			if (!session) return { authToken: null };
+			const authToken = exchangeTempAuthCode(params.code, session, params, storage);
+			if (authToken) options.onTrusted?.({
+				session,
+				authToken
+			});
+			return { authToken };
+		}
+	});
+	const anonymousAuthRequestCode = defineRpcFunction({
+		name: "anonymous:devframe:auth:request-code",
+		type: "action",
+		jsonSerializable: true,
+		args: [s.object({
+			ua: s.string(),
+			origin: s.string(),
+			reissue: s.optional(s.boolean())
+		})],
+		returns: s.void(),
+		handler(params) {
+			if (params.reissue) refreshTempAuthCode();
+			printBanner({ requester: {
+				ua: describeUA(params.ua),
+				origin: params.origin
+			} });
+		}
+	});
+	const revoke = defineRpcFunction({
+		name: "devframe:auth:revoke",
+		type: "action",
+		jsonSerializable: true,
+		args: [],
+		returns: s.void(),
+		async handler() {
+			const token = context.rpc.getCurrentRpcSession()?.meta.clientAuthToken;
+			if (token) await internal.revokeAuthToken(token);
+		}
+	});
+	function authorize(methodName, session) {
+		if (isAnonymousRpcMethod(methodName)) return true;
+		return !!session.meta.isTrusted;
+	}
+	function onConnect(connection, session) {
+		let token;
+		let requestOrigin;
+		try {
+			token = new URL(connection.request?.url ?? "", "http://localhost").searchParams.get("devframe_auth_token") ?? void 0;
+		} catch {}
+		try {
+			requestOrigin = connection.request?.headers?.get?.("origin") ?? void 0;
+		} catch {}
+		if (!token) return;
+		if (isStaticToken(token)) {
+			session.meta.clientAuthToken = token;
+			session.meta.isTrusted = true;
+			return;
+		}
+		if (verifyAuthToken(token, session, storage)) return;
+		if (internal.isRemoteTokenTrusted(token, requestOrigin)) {
+			session.meta.clientAuthToken = token;
+			session.meta.isTrusted = true;
+		}
+	}
+	function buildOpenUrl(url) {
+		return buildOtpAuthUrl(url);
+	}
+	return {
+		rpcFunctions: [
+			anonymousAuth,
+			anonymousAuthExchange,
+			anonymousAuthRequestCode,
+			revoke
+		],
+		authorize,
+		onConnect,
+		printBanner,
+		buildOpenUrl
+	};
+}
+//#endregion
+export { createInteractiveAuth as n, createAuthBanner as t };

package/dist/internal/index.d.mts

@@ -1,21 +1,59 @@
-import { v as RpcFunctionDefinitionAny } from "../types-D2vGd7-2.mjs";
-import { At as AgentHandle, Bt as DevframeAgentHostEvents, F as DevframeDefinition, Ft as AgentTool, It as AgentToolInput, Lt as AgentToolProvider, Mt as AgentResource, Nt as AgentResourceContent, Pt as AgentResourceInput, Rt as AgentToolProviderHandle, Vt as EventEmitter, jt as AgentManifest, o as DevframeNodeContext, xt as DevframeHost, zt as DevframeAgentHost$1 } from "../context-BLHBDQcZ.mjs";
-import { a as RemoteAssetsStore, o as StaticAssetsSource } from "../remote-assets-eBvSKZMS.mjs";
-import { a as InstanceShellInit, c as StartedServer, d as samePath, f as DevframeInstanceRecord, h as registerDevframeInstance, i as InstanceShellApi, l as createInstanceShell, m as listLiveDevframeInstances, n as InstanceRegisterConfig, o as InstanceShellInternals, p as DevframeInstanceRegistration, r as InstanceShell, s as InstanceWsTier, t as CreateInstanceShellOptions, u as resolveInstanceRegister } from "../instance-shell-C6Vg97lg.mjs";
-import { a as resolveBasePath, i as normalizeBasePath, n as ResolvedMcpConfig, r as loadAutoMcpAdapter, s as resolveMcpConfig } from "../_shared-BIUet_Jh.mjs";
-import { n as CreateContextRpcServerOptions, r as createContextRpcServer, t as ContextRpcServer } from "../rpc-core-BlL-Ip8n.mjs";
-//#region src/client-assets.d.ts
+import { t as StandardSchemaV1 } from "../index-CeEtxDmK.mjs";
+import { g as RpcFunctionDefinitionAny } from "../types-BmDbfHCx.mjs";
+import { Bt as AgentTool, Et as DevframeHost, Ft as AgentHandle, Gt as DevframeAgentHostEvents, Ht as AgentToolProvider, It as AgentManifest, Kt as EventEmitter, Lt as AgentResource, Rt as AgentResourceContent, Ut as AgentToolProviderHandle, Vt as AgentToolInput, Wt as DevframeAgentHost$1, o as DevframeNodeContext, zt as AgentResourceInput } from "../context-CTAxz9ec.mjs";
+import { a as RemoteAssetsStore } from "../remote-assets-eBvSKZMS.mjs";
+import { a as InstanceShellInit, c as StartedServer, d as samePath, f as DevframeInstanceRecord, g as registerDevframeInstance, h as probeDevframeOrigin, i as InstanceShellApi, l as createInstanceShell, m as listLiveDevframeInstances, n as InstanceRegisterConfig, o as InstanceShellInternals, p as DevframeInstanceRegistration, r as InstanceShell, s as InstanceWsTier, t as CreateInstanceShellOptions, u as resolveInstanceRegister } from "../instance-shell-DOZSxst6.mjs";
+import { i as importAgenticMcp, n as MountMcpHttpOptions, r as MountedMcpHttp, t as AgenticMcpModule } from "../agentic-D4QQQUjE.mjs";
+import { a as resolveBasePath, i as normalizeBasePath, n as ResolvedMcpConfig, r as loadAutoMcpAdapter, s as resolveMcpConfig } from "../_shared-Dy1UBMUN.mjs";
+import { n as CreateContextRpcServerOptions, r as createContextRpcServer, t as ContextRpcServer } from "../rpc-core-rLrwFEcw.mjs";
+//#region src/agent/stringify.d.ts
 /**
- * Resolve a definition's client assets source: the built SPA served as its
- * UI. Prefers the top-level {@link DevframeDefinition.clientAssets} and falls
- * back to the deprecated `cli.distDir`, so both the new and legacy shapes
- * resolve. Returns `undefined` when neither is set (bridge mode, where the SPA is
- * hosted elsewhere).
+ * JSON-coercing serializer for MCP text payloads.
  *
- * Internal: exposed to first-party integrations via `devframe/internal`, not
- * part of the stable public API.
+ * MCP carries tool results and resource reads as plain text over a
+ * JSON-RPC transport, so we cannot use the `s:`-prefixed structured-clone
+ * format the WS RPC transport falls back to for non-JSON values. Instead,
+ * we coerce common non-JSON types into JSON-friendly forms so the LLM
+ * client sees something useful instead of `[object Object]`.
+ *
+ * Coercions:
+ *   - `BigInt` → `"123n"`
+ *   - `Date` → ISO string (via the native `toJSON`)
+ *   - `Map` → `{ __type: 'Map', entries: [[k, v], …] }`
+ *   - `Set` → `{ __type: 'Set', entries: [v, …] }`
+ *   - `Error` → `{ name, message, stack, cause? }` (cause recurses)
+ *   - `Function` → `"[Function: name]"`
+ *   - `Symbol` → `value.toString()`
+ *   - cycles → `"[Circular]"`
  */
-export declare function resolveClientAssets(d: DevframeDefinition): StaticAssetsSource | undefined;
+export declare function stringifyForMcp(value: unknown): string;
+/**
+ * Format a thrown value for an MCP `isError` text payload.
+ *
+ * A nostics `Diagnostic` (every coded devframe error) becomes structured
+ * JSON (`{ error: { code, message, fix?, docs? } }`), so an agent receives
+ * the actionable next step (`fix`) and the docs URL instead of a bare
+ * message string. Other errors surface `Error.name`/`message`, plus one
+ * level of `cause.message` so context isn't dropped silently.
+ */
+export declare function formatMcpError(error: unknown): string;
+//#endregion
+//#region src/agent/to-json-schema.d.ts
+/**
+ * JSON Schema for an RPC return value on the agent/MCP surface.
+ * @internal
+ */
+export declare function returnToJsonSchema(schema: StandardSchemaV1 | undefined): unknown;
+/**
+ * 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
+ */
+export declare function argsToJsonSchema(args: readonly StandardSchemaV1[] | undefined): unknown;
 //#endregion
 //#region src/node/diagnostics.d.ts
 /**
@@ -147,7 +185,7 @@ export declare const diagnostics: import("nostics").Diagnostics<{
     readonly why: (p: {
       reason: string;
     }) => string;
-    readonly fix: "Install it next to devframe (e.g. `npm install @modelcontextprotocol/client`) and run `devframe connect` again.";
+    readonly fix: "Install it next to devframe (e.g. `npm install @devframes/agentic`) and run `devframe connect` again.";
   };
   readonly DF0047: {
     readonly why: (p: {
@@ -177,7 +215,7 @@ export declare const diagnostics: import("nostics").Diagnostics<{
     readonly why: (p: {
       port: number;
     }) => string;
-    readonly fix: "Restart the instance with the --mcp flag (or set `cli.mcp: true` on its definition) to expose its tools, then list instances again.";
+    readonly fix: "Restart the instance with the --mcp flag to expose its tools, then list instances again.";
   };
   readonly DF0052: {
     readonly why: (p: {
@@ -324,6 +362,16 @@ export declare const diagnostics: import("nostics").Diagnostics<{
     }) => string;
     readonly fix: "On Bun/Deno, serve the advertised `__ws` route from `Bun.serve` / `Deno.serve` with `attachBunWsTransport` / `attachDenoWsTransport` (see the hub-deno example), or connect over the SSE endpoint instead.";
   };
+  readonly DF0078: {
+    readonly why: "This devframe exposes agent tools, but the MCP endpoint stays off: the optional peer \"@devframes/agentic\" is not installed.";
+    readonly fix: "Install `@devframes/agentic` next to devframe to serve the MCP endpoint, or set `mcp: false` to opt out silently.";
+  };
+  readonly DF0079: {
+    readonly why: (p: {
+      reason: string;
+    }) => string;
+    readonly fix: "Install `@devframes/agentic` next to devframe (the MCP adapter and the MCP SDK live there), or remove the explicit `mcp` setting.";
+  };
 }, readonly [(d: import("nostics").Diagnostic, { method }?: {
   method?: "log" | "warn" | "error";
 }) => void]>;
@@ -453,9 +501,5 @@ export declare function peekRpcWireFrame(raw: string): {
 //#region src/tool-input.d.ts
 /** Convert tool input for a command, whose arguments must be declared. */
 export declare function toolInputToCommandArgs(input: unknown, argumentCount?: number): unknown[];
-/** @deprecated Use {@link toolInputToRpcArgs} or {@link toolInputToCommandArgs}. */
-type AgentArgsFallback = 'wrap' | 'drop';
-/** @deprecated Use {@link toolInputToRpcArgs} or {@link toolInputToCommandArgs}. */
-export declare function coerceAgentPositionalArgs(input: unknown, schemas: readonly unknown[] | undefined, fallback?: AgentArgsFallback): unknown[];
 //#endregion
-export { type AgentArgsFallback, type ContextRpcServer, type CreateContextRpcServerOptions, type CreateInstanceShellOptions, type DevframeInstanceRecord, type DevframeInstanceRegistration, type InstanceRegisterConfig, type InstanceShell, type InstanceShellApi, type InstanceShellInit, type InstanceShellInternals, type InstanceWsTier, type ResolvedMcpConfig, type RpcWireCodec, type StartedServer, createContextRpcServer, createInstanceShell, listLiveDevframeInstances, loadAutoMcpAdapter, normalizeBasePath, registerDevframeInstance, resolveBasePath, resolveInstanceRegister, resolveMcpConfig, samePath };
+export { type AgenticMcpModule, type ContextRpcServer, type CreateContextRpcServerOptions, type CreateInstanceShellOptions, type DevframeInstanceRecord, type DevframeInstanceRegistration, type InstanceRegisterConfig, type InstanceShell, type InstanceShellApi, type InstanceShellInit, type InstanceShellInternals, type InstanceWsTier, type MountMcpHttpOptions, type MountedMcpHttp, type ResolvedMcpConfig, type RpcWireCodec, type StartedServer, createContextRpcServer, createInstanceShell, importAgenticMcp, listLiveDevframeInstances, loadAutoMcpAdapter, normalizeBasePath, probeDevframeOrigin, registerDevframeInstance, resolveBasePath, resolveInstanceRegister, resolveMcpConfig, samePath };

package/dist/internal/index.mjs

@@ -1,10 +1,145 @@
-import { t as resolveClientAssets } from "../client-assets-DNdhagGm.mjs";
+import { t as Diagnostic } from "../nostics-D0PvLZsn.mjs";
 import { n as peekRpcWireFrame, t as createRpcWireCodec } from "../wire-codec-B1W3zH3L.mjs";
-import { t as diagnostics } from "../diagnostics-DZA6KQ_Z.mjs";
-import { n as coerceAgentPositionalArgs, r as toolInputToCommandArgs, t as DevframeAgentHost } from "../host-agent-C3MBpNCd.mjs";
-import { a as resolveMcpConfig, n as normalizeBasePath, r as resolveBasePath, s as importRuntimeModule, t as loadAutoMcpAdapter } from "../_shared-U8D-xzrp.mjs";
+import { t as diagnostics } from "../diagnostics-Cx4_VjlG.mjs";
+import { n as toolInputToCommandArgs, t as DevframeAgentHost } from "../host-agent-ZSKgzMVu.mjs";
+import { a as resolveMcpConfig, n as normalizeBasePath, r as resolveBasePath, s as importAgenticMcp, t as loadAutoMcpAdapter } from "../_shared-B2PZsp-J.mjs";
+import { t as importRuntimeModule } from "../import-runtime-module-BzlEQ9PI.mjs";
 import { t as createH3DevframeHost } from "../host-h3-BROI6SQ4.mjs";
-import { i as registerDevframeInstance, n as listLiveDevframeInstances } from "../instance-registry-DCq762YJ.mjs";
-import { i as normalizeHttpServerUrl, n as resolveInstanceRegister, r as samePath, t as createInstanceShell } from "../instance-shell-yfrM3_vK.mjs";
-import { t as createContextRpcServer } from "../rpc-core-CvkU23bQ.mjs";
-export { DevframeAgentHost, coerceAgentPositionalArgs, createContextRpcServer, createH3DevframeHost, createInstanceShell, createRpcWireCodec, diagnostics, importRuntimeModule, listLiveDevframeInstances, loadAutoMcpAdapter, normalizeBasePath, normalizeHttpServerUrl, peekRpcWireFrame, registerDevframeInstance, resolveBasePath, resolveClientAssets, resolveInstanceRegister, resolveMcpConfig, samePath, toolInputToCommandArgs };
+import { i as registerDevframeInstance, n as listLiveDevframeInstances, r as probeDevframeOrigin } from "../instance-registry-DtvYxc0Y.mjs";
+import { i as normalizeHttpServerUrl, n as resolveInstanceRegister, r as samePath, t as createInstanceShell } from "../instance-shell-wC2sfEU_.mjs";
+import { t as createContextRpcServer } from "../rpc-core-BXyMjbKG.mjs";
+//#region src/agent/stringify.ts
+/**
+* JSON-coercing serializer for MCP text payloads.
+*
+* MCP carries tool results and resource reads as plain text over a
+* JSON-RPC transport, so we cannot use the `s:`-prefixed structured-clone
+* format the WS RPC transport falls back to for non-JSON values. Instead,
+* we coerce common non-JSON types into JSON-friendly forms so the LLM
+* client sees something useful instead of `[object Object]`.
+*
+* Coercions:
+*   - `BigInt` → `"123n"`
+*   - `Date` → ISO string (via the native `toJSON`)
+*   - `Map` → `{ __type: 'Map', entries: [[k, v], …] }`
+*   - `Set` → `{ __type: 'Set', entries: [v, …] }`
+*   - `Error` → `{ name, message, stack, cause? }` (cause recurses)
+*   - `Function` → `"[Function: name]"`
+*   - `Symbol` → `value.toString()`
+*   - cycles → `"[Circular]"`
+*/
+function stringifyForMcp(value) {
+	if (value === void 0) return "undefined";
+	if (typeof value === "string") return value;
+	const seen = /* @__PURE__ */ new WeakSet();
+	return JSON.stringify(value, (_key, val) => {
+		if (typeof val === "bigint") return `${val}n`;
+		if (val instanceof Error) {
+			const out = {
+				name: val.name,
+				message: val.message,
+				stack: val.stack
+			};
+			if (val.cause !== void 0) out.cause = val.cause;
+			return out;
+		}
+		if (val instanceof Map) return {
+			__type: "Map",
+			entries: [...val.entries()]
+		};
+		if (val instanceof Set) return {
+			__type: "Set",
+			entries: [...val]
+		};
+		if (typeof val === "function") return `[Function: ${val.name || "anonymous"}]`;
+		if (typeof val === "symbol") return val.toString();
+		if (val !== null && typeof val === "object") {
+			if (seen.has(val)) return "[Circular]";
+			seen.add(val);
+		}
+		return val;
+	}, 2);
+}
+/**
+* Format a thrown value for an MCP `isError` text payload.
+*
+* A nostics `Diagnostic` (every coded devframe error) becomes structured
+* JSON (`{ error: { code, message, fix?, docs? } }`), so an agent receives
+* the actionable next step (`fix`) and the docs URL instead of a bare
+* message string. Other errors surface `Error.name`/`message`, plus one
+* level of `cause.message` so context isn't dropped silently.
+*/
+function formatMcpError(error) {
+	if (error instanceof Diagnostic) return JSON.stringify({ error: {
+		code: error.code,
+		message: error.message,
+		...error.fix ? { fix: error.fix } : {},
+		...error.docs ? { docs: error.docs } : {}
+	} }, null, 2);
+	if (!(error instanceof Error)) return String(error);
+	const cause = error.cause;
+	const causeText = cause instanceof Error ? ` (cause: ${cause.message})` : cause !== void 0 ? ` (cause: ${String(cause)})` : "";
+	return `${error.name}: ${error.message}${causeText}`;
+}
+//#endregion
+//#region src/agent/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 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 `{ 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
+export { DevframeAgentHost, argsToJsonSchema, createContextRpcServer, createH3DevframeHost, createInstanceShell, createRpcWireCodec, diagnostics, formatMcpError, importAgenticMcp, importRuntimeModule, listLiveDevframeInstances, loadAutoMcpAdapter, normalizeBasePath, normalizeHttpServerUrl, peekRpcWireFrame, probeDevframeOrigin, registerDevframeInstance, resolveBasePath, resolveInstanceRegister, resolveMcpConfig, returnToJsonSchema, samePath, stringifyForMcp, toolInputToCommandArgs };