@devframes/plugin-inspect 0.0.1

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-PRESENT Anthony Fu <https://github.com/antfu>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,60 @@
+# @devframes/plugin-inspect
+
+> [!WARNING] Experimental
+> This plugin is experimental and may change without a major version bump until
+> it stabilizes.
+
+A devframe plugin that inspects *its own* connection (and, when mounted in a
+host, the host's): browse every registered RPC function with its metadata,
+invoke read-only `query`/`static` functions and inspect the results, watch
+shared-state keys update live, and explore the agent-exposed surface.
+
+Ported in spirit from the RPC & State panels of
+[`vitejs/devtools`](https://github.com/vitejs/devtools); rebuilt on devframe's
+framework-neutral client (`connectDevframe`, `rpc.sharedState`) with a Vue + Vite SPA.
+
+## Use it standalone
+
+```bash
+npx @devframes/plugin-inspect
+```
+
+Opens the inspector against a fresh standalone devframe connection — useful as a
+reference and for poking at the introspection RPCs themselves.
+
+## Mount into a Vite host
+
+```ts
+// vite.config.ts
+import { inspectVitePlugin } from '@devframes/plugin-inspect/vite'
+import { defineConfig } from 'vite'
+
+export default defineConfig({
+  plugins: [
+    inspectVitePlugin(),
+  ],
+})
+```
+
+## Programmatic
+
+```ts
+import { createInspectDevframe } from '@devframes/plugin-inspect'
+
+const devframe = createInspectDevframe({ port: 9100 })
+```
+
+## RPC surface
+
+All functions are namespaced `devframes-plugin-inspect:*`:
+
+| Function | Type | What it returns |
+|----------|------|-----------------|
+| `list-functions` | `query` (snapshot) | Every registered RPC function with metadata (type, JSON-serializable/snapshot flags, args/return JSON Schema, agent exposure). |
+| `invoke` | `action` | Invokes a read-only `query`/`static` function by name and returns a result envelope. Refuses `action`/`event` functions. |
+| `list-state-keys` | `query` (snapshot) | The keys of every shared-state entry on the connection. |
+| `describe-agent` | `query` (snapshot) | The agent manifest — tools and readable resources. |
+
+The three `query` functions are agent-exposed (read-only) and bake into the
+static dump, so the inspector still lists functions, state keys, and the agent
+surface when deployed as a static SPA.

package/bin.mjs

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+import process from 'node:process'
+import { createInspectCli } from './dist/cli.mjs'
+
+async function main() {
+  const cli = createInspectCli()
+  await cli.parse()
+}
+
+main().catch((error) => {
+  console.error(error)
+  process.exit(1)
+})

package/dist/cli.d.mts

@@ -0,0 +1,12 @@
+import { CliHandle } from "devframe/adapters/cli";
+
+//#region src/cli.d.ts
+/**
+ * Build the standalone CLI for the inspector — backs the package `bin`
+ * (`devframe-inspect`) and `npx @devframes/plugin-inspect`. Wraps the
+ * default {@link createInspectDevframe} definition with devframe's
+ * `dev` / `build` / `spa` / `mcp` command shell.
+ */
+declare function createInspectCli(): CliHandle;
+//#endregion
+export { createInspectCli };

package/dist/cli.mjs

@@ -0,0 +1,14 @@
+import { n as inspectDevframe } from "./src-9kAqdLdh.mjs";
+import { createCli } from "devframe/adapters/cli";
+//#region src/cli.ts
+/**
+* Build the standalone CLI for the inspector — backs the package `bin`
+* (`devframe-inspect`) and `npx @devframes/plugin-inspect`. Wraps the
+* default {@link createInspectDevframe} definition with devframe's
+* `dev` / `build` / `spa` / `mcp` command shell.
+*/
+function createInspectCli() {
+	return createCli(inspectDevframe);
+}
+//#endregion
+export { createInspectCli };

package/dist/client/index.d.mts

@@ -0,0 +1,12 @@
+import { i as RpcFunctionInfo, n as InvokeResult, r as RpcFunctionAgentInfo, t as AgentManifest } from "../types-Cz7H8Eh1.mjs";
+import { DevframeRpcClient, DevframeRpcClientOptions } from "devframe/client";
+
+//#region src/client/index.d.ts
+/**
+ * Connect to the inspector's devframe backend. A thin, typed wrapper
+ * around devframe's {@link connectDevframe}; the SPA derives its base
+ * from `document.baseURI`, so no options are required in the common case.
+ */
+declare function connectInspect(options?: DevframeRpcClientOptions): Promise<DevframeRpcClient>;
+//#endregion
+export { type AgentManifest, type DevframeRpcClient, type InvokeResult, type RpcFunctionAgentInfo, type RpcFunctionInfo, connectInspect };

package/dist/client/index.mjs

@@ -0,0 +1,12 @@
+import { connectDevframe } from "devframe/client";
+//#region src/client/index.ts
+/**
+* Connect to the inspector's devframe backend. A thin, typed wrapper
+* around devframe's {@link connectDevframe}; the SPA derives its base
+* from `document.baseURI`, so no options are required in the common case.
+*/
+function connectInspect(options) {
+	return connectDevframe(options);
+}
+//#endregion
+export { connectInspect };

package/dist/index-E4zIjo1K.d.mts

@@ -0,0 +1,37 @@
+import { DevframeDefinition } from "devframe/types";
+
+//#region src/index.d.ts
+interface InspectDevframeOptions {
+  /** Override the devframe id (and default CLI command / mount path). */
+  id?: string;
+  /** Override the display name shown in a host dock. */
+  name?: string;
+  /** Override the dock icon. */
+  icon?: string;
+  /**
+   * Override the mount path. Left unset, the SPA mounts at `/` standalone
+   * and `/__<id>/` when hosted (Vite/embedded).
+   */
+  basePath?: string;
+  /** Preferred standalone CLI port. */
+  port?: number;
+  /**
+   * Require the trust handshake on the standalone server. Defaults to
+   * `false` (auto-trust) since the inspector is a single-user localhost
+   * tool. Hosted adapters manage their own auth.
+   */
+  auth?: boolean;
+}
+/**
+ * Build a {@link DevframeDefinition} for the Devframe Inspector. The
+ * same definition runs standalone (`/cli`, `/spa`, `/build`) and mounts
+ * into a host (`/vite`, hub).
+ *
+ * @experimental This plugin is experimental and may change without a major
+ * version bump until it stabilizes.
+ */
+declare function createInspectDevframe(options?: InspectDevframeOptions): DevframeDefinition;
+/** The default inspector devframe definition. */
+declare const inspectDevframe: DevframeDefinition;
+//#endregion
+export { createInspectDevframe as n, inspectDevframe as r, InspectDevframeOptions as t };

package/dist/index.d.mts

@@ -0,0 +1,3 @@
+import { i as RpcFunctionInfo, n as InvokeResult } from "./types-Cz7H8Eh1.mjs";
+import { n as createInspectDevframe, r as inspectDevframe, t as InspectDevframeOptions } from "./index-E4zIjo1K.mjs";
+export { InspectDevframeOptions, InvokeResult, RpcFunctionInfo, createInspectDevframe, inspectDevframe as default };

package/dist/index.mjs

@@ -0,0 +1,2 @@
+import { n as inspectDevframe, t as createInspectDevframe } from "./src-9kAqdLdh.mjs";
+export { createInspectDevframe, inspectDevframe as default };

package/dist/node/index.d.mts

@@ -0,0 +1,12 @@
+import { serverFunctions } from "../rpc/index.mjs";
+import { DevframeNodeContext } from "devframe/types";
+
+//#region src/node/index.d.ts
+/**
+ * Register the inspector's introspection RPC functions on a devframe
+ * node context. Called from the definition's `setup(ctx)` and reusable
+ * by host adapters that wire their own context.
+ */
+declare function setupInspect(ctx: DevframeNodeContext): void;
+//#endregion
+export { serverFunctions, setupInspect };

package/dist/node/index.mjs

@@ -0,0 +1,12 @@
+import { t as serverFunctions } from "../rpc-Cb6r6pvt.mjs";
+//#region src/node/index.ts
+/**
+* Register the inspector's introspection RPC functions on a devframe
+* node context. Called from the definition's `setup(ctx)` and reusable
+* by host adapters that wire their own context.
+*/
+function setupInspect(ctx) {
+	for (const fn of serverFunctions) ctx.rpc.register(fn);
+}
+//#endregion
+export { serverFunctions, setupInspect };

package/dist/rpc/index.d.mts

@@ -0,0 +1,100 @@
+import { i as RpcFunctionInfo, n as InvokeResult } from "../types-Cz7H8Eh1.mjs";
+import * as _$devframe from "devframe";
+import * as _$devframe_rpc0 from "devframe/rpc";
+import { RpcDefinitionsToFunctions } from "devframe/rpc";
+
+//#region src/rpc/index.d.ts
+/**
+ * The introspection RPC functions registered by the inspector plugin.
+ * Namespaced `devframes-plugin-inspect:*` per the plugin convention.
+ */
+declare const serverFunctions: readonly [{
+  name: "devframes-plugin-inspect:list-functions";
+  type?: "query" | undefined;
+  cacheable?: boolean;
+  args?: undefined;
+  returns?: undefined;
+  jsonSerializable?: boolean;
+  agent?: _$devframe.RpcFunctionAgentOptions;
+  setup?: ((context: _$devframe.DevframeNodeContext) => _$devframe_rpc0.Thenable<_$devframe_rpc0.RpcFunctionSetupResult<[], Promise<RpcFunctionInfo[]>>>) | undefined;
+  handler?: (() => Promise<RpcFunctionInfo[]>) | undefined;
+  dump?: _$devframe_rpc0.RpcDump<[], Promise<RpcFunctionInfo[]>, _$devframe.DevframeNodeContext> | undefined;
+  snapshot?: boolean;
+  __cache?: WeakMap<object, _$devframe_rpc0.Thenable<_$devframe_rpc0.RpcFunctionSetupResult<[], Promise<RpcFunctionInfo[]>>>> | undefined;
+  __promise?: _$devframe_rpc0.Thenable<_$devframe_rpc0.RpcFunctionSetupResult<[], Promise<RpcFunctionInfo[]>>> | undefined;
+}, {
+  name: "devframes-plugin-inspect:invoke";
+  type?: "action" | undefined;
+  cacheable?: boolean;
+  args?: undefined;
+  returns?: undefined;
+  jsonSerializable?: boolean;
+  agent?: _$devframe.RpcFunctionAgentOptions;
+  setup?: ((context: _$devframe.DevframeNodeContext) => _$devframe_rpc0.Thenable<_$devframe_rpc0.RpcFunctionSetupResult<[name: string, args?: unknown[] | undefined], Promise<InvokeResult>>>) | undefined;
+  handler?: ((name: string, args?: unknown[] | undefined) => Promise<InvokeResult>) | undefined;
+  dump?: _$devframe_rpc0.RpcDump<[name: string, args?: unknown[] | undefined], Promise<InvokeResult>, _$devframe.DevframeNodeContext> | undefined;
+  snapshot?: boolean;
+  __cache?: WeakMap<object, _$devframe_rpc0.Thenable<_$devframe_rpc0.RpcFunctionSetupResult<[name: string, args?: unknown[] | undefined], Promise<InvokeResult>>>> | undefined;
+  __promise?: _$devframe_rpc0.Thenable<_$devframe_rpc0.RpcFunctionSetupResult<[name: string, args?: unknown[] | undefined], Promise<InvokeResult>>> | undefined;
+}, {
+  name: "devframes-plugin-inspect:list-state-keys";
+  type?: "query" | undefined;
+  cacheable?: boolean;
+  args?: undefined;
+  returns?: undefined;
+  jsonSerializable?: boolean;
+  agent?: _$devframe.RpcFunctionAgentOptions;
+  setup?: ((context: _$devframe.DevframeNodeContext) => _$devframe_rpc0.Thenable<_$devframe_rpc0.RpcFunctionSetupResult<[], Promise<string[]>>>) | undefined;
+  handler?: (() => Promise<string[]>) | undefined;
+  dump?: _$devframe_rpc0.RpcDump<[], Promise<string[]>, _$devframe.DevframeNodeContext> | undefined;
+  snapshot?: boolean;
+  __cache?: WeakMap<object, _$devframe_rpc0.Thenable<_$devframe_rpc0.RpcFunctionSetupResult<[], Promise<string[]>>>> | undefined;
+  __promise?: _$devframe_rpc0.Thenable<_$devframe_rpc0.RpcFunctionSetupResult<[], Promise<string[]>>> | undefined;
+}, {
+  name: "devframes-plugin-inspect:describe-agent";
+  type?: "query" | undefined;
+  cacheable?: boolean;
+  args?: undefined;
+  returns?: undefined;
+  jsonSerializable?: boolean;
+  agent?: _$devframe.RpcFunctionAgentOptions;
+  setup?: ((context: _$devframe.DevframeNodeContext) => _$devframe_rpc0.Thenable<_$devframe_rpc0.RpcFunctionSetupResult<[], Promise<_$devframe.AgentManifest>>>) | undefined;
+  handler?: (() => Promise<_$devframe.AgentManifest>) | undefined;
+  dump?: _$devframe_rpc0.RpcDump<[], Promise<_$devframe.AgentManifest>, _$devframe.DevframeNodeContext> | undefined;
+  snapshot?: boolean;
+  __cache?: WeakMap<object, _$devframe_rpc0.Thenable<_$devframe_rpc0.RpcFunctionSetupResult<[], Promise<_$devframe.AgentManifest>>>> | undefined;
+  __promise?: _$devframe_rpc0.Thenable<_$devframe_rpc0.RpcFunctionSetupResult<[], Promise<_$devframe.AgentManifest>>> | undefined;
+}, {
+  name: "devframes-plugin-inspect:invoke-agent-tool";
+  type?: "action" | undefined;
+  cacheable?: boolean;
+  args?: undefined;
+  returns?: undefined;
+  jsonSerializable?: boolean;
+  agent?: _$devframe.RpcFunctionAgentOptions;
+  setup?: ((context: _$devframe.DevframeNodeContext) => _$devframe_rpc0.Thenable<_$devframe_rpc0.RpcFunctionSetupResult<[id: string, args: unknown], Promise<InvokeResult>>>) | undefined;
+  handler?: ((id: string, args: unknown) => Promise<InvokeResult>) | undefined;
+  dump?: _$devframe_rpc0.RpcDump<[id: string, args: unknown], Promise<InvokeResult>, _$devframe.DevframeNodeContext> | undefined;
+  snapshot?: boolean;
+  __cache?: WeakMap<object, _$devframe_rpc0.Thenable<_$devframe_rpc0.RpcFunctionSetupResult<[id: string, args: unknown], Promise<InvokeResult>>>> | undefined;
+  __promise?: _$devframe_rpc0.Thenable<_$devframe_rpc0.RpcFunctionSetupResult<[id: string, args: unknown], Promise<InvokeResult>>> | undefined;
+}, {
+  name: "devframes-plugin-inspect:read-agent-resource";
+  type?: "action" | undefined;
+  cacheable?: boolean;
+  args?: undefined;
+  returns?: undefined;
+  jsonSerializable?: boolean;
+  agent?: _$devframe.RpcFunctionAgentOptions;
+  setup?: ((context: _$devframe.DevframeNodeContext) => _$devframe_rpc0.Thenable<_$devframe_rpc0.RpcFunctionSetupResult<[id: string], Promise<InvokeResult>>>) | undefined;
+  handler?: ((id: string) => Promise<InvokeResult>) | undefined;
+  dump?: _$devframe_rpc0.RpcDump<[id: string], Promise<InvokeResult>, _$devframe.DevframeNodeContext> | undefined;
+  snapshot?: boolean;
+  __cache?: WeakMap<object, _$devframe_rpc0.Thenable<_$devframe_rpc0.RpcFunctionSetupResult<[id: string], Promise<InvokeResult>>>> | undefined;
+  __promise?: _$devframe_rpc0.Thenable<_$devframe_rpc0.RpcFunctionSetupResult<[id: string], Promise<InvokeResult>>> | undefined;
+}];
+declare module 'devframe' {
+  interface DevframeRpcServerFunctions extends RpcDefinitionsToFunctions<typeof serverFunctions> {}
+}
+//#endregion
+export { serverFunctions };

package/dist/rpc/index.mjs

@@ -0,0 +1,2 @@
+import { t as serverFunctions } from "../rpc-Cb6r6pvt.mjs";
+export { serverFunctions };

package/dist/rpc-Cb6r6pvt.mjs

@@ -0,0 +1,256 @@
+import { createDefineWrapperWithContext } from "devframe/rpc";
+import { defineDiagnostics } from "nostics";
+import { toJsonSchema } from "@valibot/to-json-schema";
+//#region src/rpc/functions/_define.ts
+/**
+* `defineRpcFunction` pre-bound to the framework-neutral
+* {@link DevframeNodeContext}, so each inspector function's `setup(ctx)`
+* receives the typed node context (`ctx.rpc`, `ctx.agent`, …) instead of
+* the default `undefined` context.
+*/
+const defineInspectRpc = createDefineWrapperWithContext();
+//#endregion
+//#region src/rpc/functions/describe-agent.ts
+/**
+* Surface the agent-exposed surface of the connection: the unified
+* manifest of tools (RPC functions flagged with `agent`, plus
+* host-registered tools) and readable resources. `snapshot: true` bakes
+* the manifest into the static dump for `build`/`spa` mode.
+*/
+const describeAgent = defineInspectRpc({
+	name: "devframes-plugin-inspect:describe-agent",
+	type: "query",
+	jsonSerializable: true,
+	snapshot: true,
+	agent: {
+		description: "Describe the agent-exposed surface of this devframe: the list of tools (agent-flagged RPC functions and host-registered tools) and readable resources, with their titles, descriptions, safety hints, and schemas. Read-only.",
+		title: "Describe agent surface"
+	},
+	setup: (ctx) => ({ handler: async () => {
+		return ctx.agent.list();
+	} })
+});
+//#endregion
+//#region src/diagnostics.ts
+/**
+* Structured diagnostics for `@devframes/plugin-inspect`. Node-side only.
+* Codes use the plugin-private `DP_INSPECT_` band (see the built-in
+* plugins planning index) so they never collide with devframe core
+* (`DF00xx`) or `@devframes/hub` (`DF80xx`).
+*/
+const diagnostics = defineDiagnostics({
+	docsBase: "https://devfra.me/errors",
+	codes: {
+		DP_INSPECT_0001: {
+			why: (p) => `Cannot invoke "${p.name}" — no RPC function with that name is registered on this connection.`,
+			fix: "Call `devframes-plugin-inspect:list-functions` to see the registered names, or check for a typo."
+		},
+		DP_INSPECT_0002: {
+			why: (p) => `Refusing to invoke "${p.name}" — only read-only "query" and "static" functions are invokable from the inspector, but this one is "${p.type}".`,
+			fix: "The inspector deliberately blocks `action`/`event` functions to avoid triggering side effects. Invoke those through their own UI instead."
+		}
+	}
+});
+//#endregion
+//#region src/rpc/functions/invoke.ts
+const INVOKABLE_TYPES$1 = new Set(["query", "static"]);
+/**
+* Invoke a read-only RPC function by name and return a result envelope.
+*
+* Deliberately gated to `query` / `static` functions — `action` and
+* `event` functions may carry side effects, so the inspector refuses to
+* fire them (`DP_INSPECT_0002`). Uses structured-clone serialization
+* (default) so arbitrary return values round-trip without the strict-JSON
+* constraints that `jsonSerializable: true` would impose.
+*/
+const invoke = defineInspectRpc({
+	name: "devframes-plugin-inspect:invoke",
+	type: "action",
+	setup: (ctx) => ({ handler: async (name, args = []) => {
+		const def = ctx.rpc.definitions.get(name);
+		if (!def) throw diagnostics.DP_INSPECT_0001({ name });
+		const type = def.type ?? "query";
+		if (!INVOKABLE_TYPES$1.has(type)) throw diagnostics.DP_INSPECT_0002({
+			name,
+			type
+		});
+		const start = Date.now();
+		try {
+			return {
+				ok: true,
+				result: await ctx.rpc.invokeLocal(name, ...args),
+				durationMs: Date.now() - start
+			};
+		} catch (error) {
+			const e = error;
+			return {
+				ok: false,
+				error: {
+					name: e?.name ?? "Error",
+					message: e?.message ?? String(error),
+					stack: e?.stack
+				},
+				durationMs: Date.now() - start
+			};
+		}
+	} })
+});
+//#endregion
+//#region src/rpc/functions/invoke-agent-tool.ts
+const invokeAgentTool = defineInspectRpc({
+	name: "devframes-plugin-inspect:invoke-agent-tool",
+	type: "action",
+	setup: (ctx) => ({ handler: async (id, args) => {
+		const start = Date.now();
+		try {
+			return {
+				ok: true,
+				result: await ctx.agent.invoke(id, args),
+				durationMs: Date.now() - start
+			};
+		} catch (error) {
+			const e = error;
+			return {
+				ok: false,
+				error: {
+					name: e?.name ?? "Error",
+					message: e?.message ?? String(error),
+					stack: e?.stack
+				},
+				durationMs: Date.now() - start
+			};
+		}
+	} })
+});
+//#endregion
+//#region src/rpc/functions/_schema.ts
+const FALLBACK_SCHEMA = Object.freeze({
+	type: "object",
+	additionalProperties: true
+});
+/**
+* Convert a valibot return schema to JSON Schema, swallowing
+* conversion failures (unsupported valibot actions) into a permissive
+* fallback so introspection never throws.
+*/
+function returnSchemaToJson(schema) {
+	if (!schema) return void 0;
+	try {
+		return toJsonSchema(schema);
+	} catch {
+		return FALLBACK_SCHEMA;
+	}
+}
+/**
+* Convert the positional args valibot schemas to a single JSON Schema
+* tuple (`type: 'array'` + `prefixItems`). Returns `undefined` when the
+* function declares no args.
+*/
+function argsSchemaToJson(args) {
+	if (!args || args.length === 0) return void 0;
+	return {
+		type: "array",
+		prefixItems: args.map((arg) => {
+			try {
+				return toJsonSchema(arg);
+			} catch {
+				return FALLBACK_SCHEMA;
+			}
+		})
+	};
+}
+//#endregion
+//#region src/rpc/functions/list-functions.ts
+const INVOKABLE_TYPES = new Set(["query", "static"]);
+//#endregion
+//#region src/rpc/index.ts
+/**
+* The introspection RPC functions registered by the inspector plugin.
+* Namespaced `devframes-plugin-inspect:*` per the plugin convention.
+*/
+const serverFunctions = [
+	defineInspectRpc({
+		name: "devframes-plugin-inspect:list-functions",
+		type: "query",
+		jsonSerializable: true,
+		snapshot: true,
+		agent: {
+			description: "List every RPC function registered on this devframe connection, with metadata (name, type, JSON-serializable/snapshot flags, args/return schema, agent exposure). Read-only — the canonical way to discover what the running devframe can do.",
+			title: "List RPC functions"
+		},
+		setup: (ctx) => ({ handler: async () => {
+			const out = [];
+			for (const [name, fn] of ctx.rpc.definitions) {
+				const type = fn.type ?? "query";
+				let agent;
+				if (fn.agent) agent = {
+					description: fn.agent.description,
+					title: fn.agent.title,
+					safety: fn.agent.safety,
+					tags: fn.agent.tags
+				};
+				out.push({
+					name,
+					type,
+					jsonSerializable: fn.jsonSerializable === true,
+					snapshot: fn.snapshot === true,
+					cacheable: fn.cacheable === true,
+					hasArgs: !!fn.args,
+					hasReturns: !!fn.returns,
+					hasDump: !!fn.dump,
+					hasSetup: !!fn.setup,
+					hasHandler: !!fn.handler,
+					invokable: INVOKABLE_TYPES.has(type),
+					agent,
+					argsSchema: argsSchemaToJson(fn.args),
+					returnsSchema: returnSchemaToJson(fn.returns)
+				});
+			}
+			out.sort((a, b) => a.name.localeCompare(b.name));
+			return out;
+		} })
+	}),
+	invoke,
+	defineInspectRpc({
+		name: "devframes-plugin-inspect:list-state-keys",
+		type: "query",
+		jsonSerializable: true,
+		snapshot: true,
+		agent: {
+			description: "List the keys of all shared-state entries published by this devframe connection. Read-only. Pair with the built-in shared-state reads to inspect individual values.",
+			title: "List shared-state keys"
+		},
+		setup: (ctx) => ({ handler: async () => {
+			return [...ctx.rpc.sharedState.keys()].sort();
+		} })
+	}),
+	describeAgent,
+	invokeAgentTool,
+	defineInspectRpc({
+		name: "devframes-plugin-inspect:read-agent-resource",
+		type: "action",
+		setup: (ctx) => ({ handler: async (id) => {
+			const start = Date.now();
+			try {
+				return {
+					ok: true,
+					result: await ctx.agent.read(id),
+					durationMs: Date.now() - start
+				};
+			} catch (error) {
+				const e = error;
+				return {
+					ok: false,
+					error: {
+						name: e?.name ?? "Error",
+						message: e?.message ?? String(error),
+						stack: e?.stack
+					},
+					durationMs: Date.now() - start
+				};
+			}
+		} })
+	})
+];
+//#endregion
+export { serverFunctions as t };