@voltro/mcp 0.33.0 → 0.35.0

package/dist/mcp-CZJe2Frv.js

@@ -0,0 +1,542 @@
+//#region src/manifest.ts
+var e = {
+	version: 2,
+	procedures: [],
+	workflows: [],
+	widgets: [],
+	tables: [],
+	scopes: []
+}, t = async (e, t, n = 5e3) => {
+	let r = new URL("/_voltro/inspect/manifest", e), i = await fetch(r, {
+		headers: t === void 0 ? {} : { authorization: `Bearer ${t}` },
+		signal: AbortSignal.timeout(n)
+	});
+	if (!i.ok) throw Error(`manifest fetch failed: HTTP ${i.status}`);
+	return await i.json();
+}, n = (n) => {
+	let r = n.ttlMs ?? 1e4, i = n.now ?? Date.now, a, o = -Infinity;
+	return { get: async () => {
+		if (a !== void 0 && i() - o < r) return a;
+		try {
+			a = { manifest: await t(n.baseUrl, n.token) };
+		} catch (t) {
+			a = {
+				manifest: a?.manifest ?? e,
+				error: String(t)
+			};
+		}
+		return o = i(), a;
+	} };
+}, r = {
+	maxTools: 64,
+	maxDescriptionChars: 1024,
+	maxResultBytes: 256 * 1024,
+	requestTimeoutMs: 3e4
+}, i = (e, t) => {
+	let n = Number(e);
+	return Number.isFinite(n) && n > 0 ? Math.floor(n) : t;
+}, a = (e, t) => ({
+	maxTools: t?.maxTools ?? i(e.VOLTRO_MCP_MAX_APP_TOOLS, r.maxTools),
+	maxDescriptionChars: t?.maxDescriptionChars ?? i(e.VOLTRO_MCP_MAX_DESCRIPTION_CHARS, r.maxDescriptionChars),
+	maxResultBytes: t?.maxResultBytes ?? i(e.VOLTRO_MCP_MAX_RESULT_BYTES, r.maxResultBytes),
+	requestTimeoutMs: t?.requestTimeoutMs ?? i(e.VOLTRO_MCP_TIMEOUT_MS, r.requestTimeoutMs)
+}), o = /[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F-\u009F\u200B-\u200F\u202A-\u202E\u2060-\u2064\u2066-\u2069\uFEFF\u{E0000}-\u{E007F}]/gu, s = (e, t) => {
+	let n = (typeof e == "string" ? e : e == null ? "" : String(e)).replace(o, "").replace(/\n{3,}/g, "\n\n").trim();
+	return n.length <= t ? n : `${n.slice(0, t)}… [truncated by Voltro]`;
+}, c = "app_", l = (e) => `${c}${e.replace(/[^A-Za-z0-9_-]/g, "_")}`, u = (e) => e.startsWith(c), d = {
+	type: "object",
+	properties: {},
+	additionalProperties: !0
+}, f = (e, t) => {
+	let n = [...e.dropped], r = [], i = /* @__PURE__ */ new Set(), a = [...e.tools].sort((e, t) => e.tag.localeCompare(t.tag));
+	for (let e of a) {
+		let a = l(e.tag);
+		if (i.has(a)) {
+			n.push({
+				name: e.tag,
+				reason: `its MCP tool name "${a}" collides with another tag`
+			});
+			continue;
+		}
+		if (r.length >= t.maxTools) {
+			n.push({
+				name: e.tag,
+				reason: `over maxTools (${t.maxTools})`
+			});
+			continue;
+		}
+		i.add(a);
+		let o = e.input;
+		r.push({
+			tag: e.tag,
+			tool: {
+				name: a,
+				description: `[${e.write ? "WRITE" : "read"}] ${e.tag} — ` + s(e.description, t.maxDescriptionChars),
+				inputSchema: o !== void 0 && o.type === "object" ? o : d
+			}
+		});
+	}
+	return {
+		mounted: r,
+		dropped: n
+	};
+}, p = (e, t) => {
+	let n = e.VOLTRO_INSPECT_TOKEN, r = e.VOLTRO_INSPECT_WRITE_TOKEN, i = e.VOLTRO_AGENT_TOKEN;
+	return {
+		baseUrl: e.VOLTRO_INSPECT_URL ?? "http://localhost:4000",
+		...n === void 0 ? {} : { inspectToken: n },
+		...r === void 0 ? {} : { inspectWriteToken: r },
+		...i === void 0 ? {} : { agentToken: i },
+		bounds: a(e, t)
+	};
+}, m = async (e, t) => {
+	let n = e.body;
+	if (n === null || typeof n.getReader != "function") {
+		let n = await e.text();
+		return n.length > t ? n.slice(0, t) : n;
+	}
+	let r = n.getReader(), i = new TextDecoder(), a = "", o = 0;
+	try {
+		for (;;) {
+			let { done: e, value: n } = await r.read();
+			if (e) break;
+			if (n !== void 0) {
+				if (o += n.byteLength, o > t) return `${a}\n… [truncated by Voltro: over ${t} bytes]`;
+				a += i.decode(n, { stream: !0 });
+			}
+		}
+	} finally {
+		await r.cancel().catch(() => void 0);
+	}
+	return a + i.decode();
+}, h = async (e, t, n) => {
+	let r = e.fetchImpl ?? ((...e) => fetch(...e)), i = new URL(t, e.baseUrl), a = {
+		accept: "application/json",
+		...n.extraHeaders ?? {}
+	};
+	e.inspectToken !== void 0 && (a.authorization = `Bearer ${e.inspectToken}`), n.body !== void 0 && (a["content-type"] = "application/json");
+	let o = await r(i, {
+		method: n.method,
+		headers: a,
+		...n.body === void 0 ? {} : { body: n.body },
+		signal: AbortSignal.timeout(e.bounds.requestTimeoutMs)
+	});
+	return {
+		status: o.status,
+		text: await m(o, e.bounds.maxResultBytes)
+	};
+}, g = async (e) => {
+	try {
+		let { status: t, text: n } = await h(e, "/_voltro/inspect/agent/tools", { method: "GET" });
+		if (t !== 200) return {
+			enabled: !1,
+			reason: `the app answered HTTP ${t} for /_voltro/inspect/agent/tools` + (t === 401 ? " — is VOLTRO_INSPECT_TOKEN set, and does it match the app?" : ""),
+			tools: [],
+			dropped: []
+		};
+		let r = JSON.parse(n);
+		return {
+			enabled: r.enabled === !0,
+			...r.reason === void 0 ? {} : { reason: r.reason },
+			tools: Array.isArray(r.tools) ? r.tools : [],
+			dropped: Array.isArray(r.dropped) ? r.dropped : []
+		};
+	} catch (t) {
+		return {
+			enabled: !1,
+			reason: `could not reach ${e.baseUrl}: ${String(t)}`,
+			tools: [],
+			dropped: []
+		};
+	}
+}, _ = async (e, t, n) => {
+	if (e.agentToken === void 0 || e.agentToken.trim() === "") return "Error: no VOLTRO_AGENT_TOKEN is configured for this MCP server, so there is no app identity to execute as. The inspect token authorises the transport only. Set VOLTRO_AGENT_TOKEN to an app credential (e.g. an API key) scoped to what this agent may do. Nothing was sent to the app.";
+	if (e.inspectWriteToken === void 0 || e.inspectWriteToken.trim() === "") return "Error: no VOLTRO_INSPECT_WRITE_TOKEN is configured. Executing an app tool is a non-GET inspect call and needs the write credential in addition to the read token. Nothing was sent to the app.";
+	try {
+		let { status: r, text: i } = await h(e, "/_voltro/inspect/agent/call", {
+			method: "POST",
+			body: JSON.stringify({
+				tool: t,
+				input: n
+			}),
+			extraHeaders: {
+				"x-voltro-inspect-write": e.inspectWriteToken,
+				"x-voltro-agent-authorization": `Bearer ${e.agentToken}`
+			}
+		});
+		if (r !== 200) return `Error: the app refused the call with HTTP ${r}: ${i}`;
+		let a = JSON.parse(i);
+		return a.ok === !0 ? typeof a.result == "string" ? a.result : JSON.stringify(a.result ?? null, null, 2) : `Error: ${JSON.stringify(a.error ?? "the call failed with no error payload")}`;
+	} catch (t) {
+		return `Error: could not reach the app at ${e.baseUrl}: ${String(t)}`;
+	}
+}, v = async (e) => {
+	try {
+		let { status: t, text: n } = await h(e, "/_voltro/inspect/checks", { method: "GET" });
+		return t === 200 ? n : `Error: the app answered HTTP ${t} for /_voltro/inspect/checks` + (t === 401 ? " — is VOLTRO_INSPECT_TOKEN set, and does it match the app?" : "");
+	} catch (t) {
+		return `Error: could not reach the app at ${e.baseUrl}: ${String(t)}`;
+	}
+}, y = (e, t = {}) => {
+	let n = t.ttlMs ?? 1e4, r = t.now ?? Date.now, i = -Infinity, a, o = async () => {
+		if (a !== void 0 && r() - i < n) return a;
+		let t = await g(e), o = f(t, e.bounds);
+		return a = {
+			mounted: o.mounted,
+			dropped: t.enabled ? [...o.dropped] : [...o.dropped, {
+				name: "(all)",
+				reason: t.reason ?? "the app exposes no agent tools"
+			}]
+		}, i = r(), a;
+	};
+	return {
+		appTools: o,
+		callAppTool: async (t, n) => {
+			let { mounted: r } = await o();
+			return r.some((e) => e.tag === t) ? _(e, t, n) : `Error: '${t}' is not an executable agent tool on this app right now. Call tools/list again — the set is refreshed from the app, and a tool can be withdrawn by policy.`;
+		},
+		invariantChecks: () => v(e)
+	};
+}, b = {
+	type: "object",
+	properties: {},
+	additionalProperties: !1
+}, x = [
+	{
+		name: "voltro_list_procedures",
+		description: "List every rpc procedure (queries, mutations, actions, streams) in the app with its kind. Markers: [public-rest] = also served as a public REST endpoint, [agent-tool] = exposed as an in-app agent tool. Use this to discover what the backend exposes before writing UI or agent code.",
+		inputSchema: b
+	},
+	{
+		name: "voltro_get_procedure",
+		description: "Get one procedure's full metadata by its tag (e.g. 'todos.create'): kind, input/output JSON Schema, source file(s), the tables it reads/writes (targets), and its public-REST / agent-tool projection when present. Use the input schema to drive a form / a tool call; the output schema to type the result.",
+		inputSchema: {
+			type: "object",
+			properties: { tag: {
+				type: "string",
+				description: "The rpc tag, e.g. \"todos.create\"."
+			} },
+			required: ["tag"],
+			additionalProperties: !1
+		}
+	},
+	{
+		name: "voltro_search_procedures",
+		description: "Find procedures whose tag contains the query substring (case-insensitive).",
+		inputSchema: {
+			type: "object",
+			properties: { query: { type: "string" } },
+			required: ["query"],
+			additionalProperties: !1
+		}
+	},
+	{
+		name: "voltro_list_tables",
+		description: "List the app's USER tables (framework-internal tables excluded) with column count and reactivity. Use voltro_get_table for the full column list of one table.",
+		inputSchema: b
+	},
+	{
+		name: "voltro_get_table",
+		description: "Get one table's full column list (name, type, nullability, foreign-key target, enum values) by table name.",
+		inputSchema: {
+			type: "object",
+			properties: { name: {
+				type: "string",
+				description: "The table name, e.g. \"todos\"."
+			} },
+			required: ["name"],
+			additionalProperties: !1
+		}
+	},
+	{
+		name: "voltro_list_workflows",
+		description: "List the durable workflows registered in the app.",
+		inputSchema: b
+	},
+	{
+		name: "voltro_list_widgets",
+		description: "List the schema-driven-UI widget kinds the app supports — the enumerable set a generated UI binds to.",
+		inputSchema: b
+	},
+	{
+		name: "voltro_check_invariants",
+		description: "Verify your own work: run the framework's invariant checks against the RUNNING app and get a machine-readable verdict. Checks: browser-safety (does the generated rpcGroup transitively import a server-only module — returns the exact import chain), procedure-access (does every wire-exposed procedure declare `guards:` or `openAccess:`), schema-convergence (has the live schema drifted, are operations pending), server-only-exposure (does a query output a `.serverOnly()` column). Each check answers pass | fail | unavailable; `unavailable` means THIS process cannot answer it (a deployed `voltro serve` has no source tree to walk) and is never a pass. Call this after editing schema, descriptors or shared lib/ files.",
+		inputSchema: b
+	}
+], S = (e) => {
+	let t = [...e.publicApi === void 0 ? [] : [" [public-rest]"], ...e.exposeAsTool === void 0 ? [] : [" [agent-tool]"]].join("");
+	return `${e.tag} (${e.kind})${t}`;
+}, C = (e) => `${e.name} (${e.columns.length} column${e.columns.length === 1 ? "" : "s"}${e.reactive ? ", reactive" : ""})`, w = (e, t) => t.error === void 0 ? `(no ${e})` : `(no ${e} — manifest unavailable: ${t.error}. Is the api running at VOLTRO_INSPECT_URL, and is VOLTRO_INSPECT_TOKEN set if the inspect surface is gated?)`, T = (e, t, n) => {
+	let r = e.manifest;
+	switch (t) {
+		case "voltro_list_procedures": return r.procedures.length === 0 ? w("procedures", e) : r.procedures.map(S).join("\n");
+		case "voltro_get_procedure": {
+			let e = String(n.tag ?? ""), t = r.procedures.find((t) => t.tag === e);
+			return t === void 0 ? `No procedure with tag "${e}". Call voltro_list_procedures to see available tags.` : JSON.stringify({
+				tag: t.tag,
+				kind: t.kind,
+				input: t.input,
+				output: t.output,
+				...t.source === void 0 ? {} : { source: t.source },
+				...t.targets === void 0 ? {} : { targets: t.targets },
+				...t.publicApi === void 0 ? {} : { publicApi: t.publicApi },
+				...t.exposeAsTool === void 0 ? {} : { exposeAsTool: t.exposeAsTool }
+			}, null, 2);
+		}
+		case "voltro_search_procedures": {
+			let e = String(n.query ?? "").toLowerCase(), t = r.procedures.filter((t) => t.tag.toLowerCase().includes(e));
+			return t.length === 0 ? `(no procedures matching "${e}")` : t.map(S).join("\n");
+		}
+		case "voltro_list_tables": {
+			let t = r.tables ?? [];
+			return t.length === 0 ? w("tables", e) : t.map(C).join("\n");
+		}
+		case "voltro_get_table": {
+			let e = String(n.name ?? ""), t = (r.tables ?? []).find((t) => t.name === e);
+			return t === void 0 ? `No table named "${e}". Call voltro_list_tables to see available tables.` : JSON.stringify(t, null, 2);
+		}
+		case "voltro_list_workflows": return r.workflows.length === 0 ? w("workflows", e) : r.workflows.map((e) => e.name).join("\n");
+		case "voltro_list_widgets": {
+			let t = r.widgets ?? [];
+			return t.length === 0 ? w("widgets", e) : t.join("\n");
+		}
+		case "voltro_check_invariants": throw Error(`'${t}' needs a live connection to the app and must be dispatched through handleMcpRequestAsync; this transport routed it to the pure handler.`);
+		default: throw Error(`unknown tool: ${t}`);
+	}
+}, E = "application/json", D = "voltro://manifest", O = (e) => `voltro://procedure/${e}`, k = (e) => `voltro://table/${e}`, A = (e) => {
+	let t = e.manifest;
+	return [
+		{
+			uri: D,
+			name: "Capability manifest",
+			description: "The full app capability manifest: every procedure, table, workflow and widget kind as JSON.",
+			mimeType: E
+		},
+		...t.procedures.map((e) => ({
+			uri: O(e.tag),
+			name: e.tag,
+			description: `The ${e.kind} "${e.tag}" — its input/output JSON Schema, source, and table targets.`,
+			mimeType: E
+		})),
+		...(t.tables ?? []).map((e) => ({
+			uri: k(e.name),
+			name: e.name,
+			description: `The "${e.name}" table — its full column list (types, nullability, foreign keys, enums).`,
+			mimeType: E
+		}))
+	];
+}, j = class extends Error {
+	uri;
+	_tag = "UnknownResourceError";
+	constructor(e) {
+		super(`no resource at "${e}"`), this.uri = e, this.name = "UnknownResourceError";
+	}
+}, M = (e, t) => {
+	let n = e.manifest, r = (e) => [{
+		uri: t,
+		mimeType: E,
+		text: JSON.stringify(e, null, 2)
+	}];
+	if (t === "voltro://manifest") return r(n);
+	let i = t.startsWith("voltro://procedure/") ? t.slice(19) : void 0;
+	if (i !== void 0) {
+		let e = n.procedures.find((e) => e.tag === i);
+		if (e === void 0) throw new j(t);
+		return r(e);
+	}
+	let a = t.startsWith("voltro://table/") ? t.slice(15) : void 0;
+	if (a !== void 0) {
+		let e = (n.tables ?? []).find((e) => e.name === a);
+		if (e === void 0) throw new j(t);
+		return r(e);
+	}
+	throw new j(t);
+}, N = [
+	{
+		name: "scaffold_procedure",
+		description: "Draft a new Voltro rpc procedure (query/mutation/action) following the app's existing conventions, grounded in the current manifest so it references real tables and matches the shape of siblings.",
+		arguments: [{
+			name: "kind",
+			description: "query | mutation | action",
+			required: !0
+		}, {
+			name: "purpose",
+			description: "What the procedure should do, in one sentence.",
+			required: !0
+		}]
+	},
+	{
+		name: "explain_table",
+		description: "Explain one table's schema and how the app's procedures read/write it, from the live manifest.",
+		arguments: [{
+			name: "table",
+			description: "The table name, e.g. \"todos\".",
+			required: !0
+		}]
+	},
+	{
+		name: "wire_ui_for_procedure",
+		description: "Generate the client code to call one procedure and render its result, using the procedure's real input/output JSON Schema from the manifest.",
+		arguments: [{
+			name: "tag",
+			description: "The rpc tag, e.g. \"todos.list\".",
+			required: !0
+		}]
+	}
+], P = class extends Error {
+	promptName;
+	_tag = "UnknownPromptError";
+	constructor(e) {
+		super(`no prompt named "${e}"`), this.promptName = e, this.name = "UnknownPromptError";
+	}
+}, F = class extends Error {
+	promptName;
+	argument;
+	_tag = "MissingPromptArgumentError";
+	constructor(e, t) {
+		super(`prompt "${e}" requires the "${t}" argument`), this.promptName = e, this.argument = t, this.name = "MissingPromptArgumentError";
+	}
+}, I = () => N, L = (e) => ({
+	role: "user",
+	content: {
+		type: "text",
+		text: e
+	}
+}), R = (e, t, n) => {
+	let r = t[n];
+	if (typeof r != "string" || r === "") throw new F(e, n);
+	return r;
+}, z = (e, t, n = {}) => {
+	let r = e.manifest;
+	switch (t) {
+		case "scaffold_procedure": {
+			let e = R(t, n, "kind"), i = R(t, n, "purpose"), a = (r.tables ?? []).map((e) => e.name).join(", ") || "(none discovered)", o = r.procedures.filter((t) => t.kind === e).map((e) => e.tag).slice(0, 10).join(", ") || "(none yet)";
+			return {
+				description: `Scaffold a ${e} procedure`,
+				messages: [L(`Write a new Voltro ${e} procedure that: ${i}.\n\nThe app's tables are: ${a}.\nExisting ${e} procedures (match their file-convention and shape): ${o}.\n\nFollow the Voltro file conventions for a ${e} descriptor + its server handler, define the input/output with the schema DSL, and only reference tables that exist above.`)]
+			};
+		}
+		case "explain_table": {
+			let e = R(t, n, "table"), i = (r.tables ?? []).find((t) => t.name === e), a = r.procedures.filter((t) => (t.targets ?? []).some((t) => t.table === e)).map((t) => `${t.tag} (${(t.targets ?? []).filter((t) => t.table === e).map((e) => e.op).join("/")})`).join(", ") || "(none)", o = i === void 0 ? `(no table named "${e}" in the manifest)` : JSON.stringify(i, null, 2);
+			return {
+				description: `Explain the ${e} table`,
+				messages: [L(`Explain the "${e}" table of this Voltro app: its columns and their meaning, and how the app uses it.\n\nSchema:\n${o}\n\nProcedures touching it: ${a}.`)]
+			};
+		}
+		case "wire_ui_for_procedure": {
+			let e = R(t, n, "tag"), i = r.procedures.find((t) => t.tag === e), a = i === void 0 ? `(no procedure with tag "${e}" in the manifest)` : JSON.stringify({
+				tag: i.tag,
+				kind: i.kind,
+				input: i.input,
+				output: i.output
+			}, null, 2);
+			return {
+				description: `Wire UI for ${e}`,
+				messages: [L(`Write the Voltro client code to call the "${e}" procedure and render its result.\n\nProcedure:\n${a}\n\nUse the correct Voltro hook for this procedure kind, type the call from the input/output schema above, and render a minimal but complete UI for the result.`)]
+			};
+		}
+		default: throw new P(t);
+	}
+}, B = "2025-06-18", V = [
+	B,
+	"2025-03-26",
+	"2024-11-05"
+], H = {
+	name: "voltro-mcp",
+	version: "0.1.0"
+}, U = (e) => typeof e == "string" && V.includes(e) ? e : B, W = (e, t, n = H) => {
+	if ((t.id === void 0 || t.id === null) && t.method.startsWith("notifications/")) return null;
+	let r = t.id ?? null, i = (e) => ({
+		jsonrpc: "2.0",
+		id: r,
+		result: e
+	}), a = (e, t) => ({
+		jsonrpc: "2.0",
+		id: r,
+		error: {
+			code: e,
+			message: t
+		}
+	});
+	switch (t.method) {
+		case "initialize": return i({
+			protocolVersion: U(t.params?.protocolVersion),
+			capabilities: {
+				tools: {},
+				resources: {},
+				prompts: {}
+			},
+			serverInfo: n
+		});
+		case "ping": return i({});
+		case "tools/list": return i({ tools: x });
+		case "tools/call": {
+			let n = t.params ?? {}, r = String(n.name ?? ""), a = n.arguments ?? {};
+			try {
+				return i({ content: [{
+					type: "text",
+					text: T(e, r, a)
+				}] });
+			} catch (e) {
+				return i({
+					content: [{
+						type: "text",
+						text: `Error: ${String(e)}`
+					}],
+					isError: !0
+				});
+			}
+		}
+		case "resources/list": return i({ resources: A(e) });
+		case "resources/read": {
+			let n = String(t.params?.uri ?? "");
+			try {
+				return i({ contents: M(e, n) });
+			} catch (e) {
+				if (e instanceof j) return a(-32602, e.message);
+				throw e;
+			}
+		}
+		case "prompts/list": return i({ prompts: I() });
+		case "prompts/get": {
+			let n = String(t.params?.name ?? ""), r = t.params?.arguments ?? {};
+			try {
+				return i(z(e, n, r));
+			} catch (e) {
+				if (e instanceof P || e instanceof F) return a(-32602, e.message);
+				throw e;
+			}
+		}
+		default: return t.method.startsWith("notifications/") ? null : a(-32601, `method not found: ${t.method}`);
+	}
+}, G = async (e, t, n = H, r) => {
+	let i = t.id ?? null, a = (e) => ({
+		jsonrpc: "2.0",
+		id: i,
+		result: e
+	}), o = (e, t = !1) => a({
+		content: [{
+			type: "text",
+			text: e
+		}],
+		...t ? { isError: !0 } : {}
+	});
+	if (t.method === "tools/list") {
+		let i = W(e, t, n);
+		if (r === void 0 || i === null) return i;
+		let { mounted: o } = await r.appTools(), s = i.result;
+		return a({ tools: [...s.tools, ...o.map((e) => e.tool)] });
+	}
+	if (t.method === "tools/call") {
+		let e = t.params ?? {}, n = String(e.name ?? ""), i = e.arguments ?? {};
+		if (u(n)) {
+			if (r === void 0) return o(`Error: '${n}' is an app tool and this server has no live connection configured. Set VOLTRO_INSPECT_URL / VOLTRO_INSPECT_TOKEN.`, !0);
+			let { mounted: e } = await r.appTools(), t = e.find((e) => e.tool.name === n);
+			return t === void 0 ? o(`Error: no app tool named '${n}'. The set is refreshed from the running app — call tools/list again.`, !0) : o(await r.callAppTool(t.tag, i));
+		}
+		if (n === "voltro_check_invariants") return r === void 0 ? o("Error: the invariant checks need a live connection to the app. Set VOLTRO_INSPECT_URL / VOLTRO_INSPECT_TOKEN and reconnect.", !0) : o(await r.invariantChecks());
+	}
+	return W(e, t, n);
+};
+//#endregion
+export { e as A, g as C, y as D, p as E, t as M, f as O, _ as S, u as T, T as _, G as a, l as b, N as c, I as d, D as f, x as g, M as h, W as i, n as j, a as k, P as l, A as m, H as n, U as o, j as p, V as r, F as s, B as t, z as u, c as v, v as w, s as x, r as y };

package/dist/serve-ZSmqUcRM.js

@@ -0,0 +1,47 @@
+import { D as e, E as t, a as n, j as r, n as i } from "./mcp-CZJe2Frv.js";
+import { createRequire as a } from "node:module";
+//#region src/serve.ts
+var o = () => {
+	try {
+		let e = a(import.meta.url)("../package.json");
+		return {
+			name: i.name,
+			version: e.version ?? i.version
+		};
+	} catch {
+		return i;
+	}
+}, s = async (i) => {
+	let a = i.env.VOLTRO_INSPECT_URL ?? "http://localhost:4000", s = i.env.VOLTRO_INSPECT_TOKEN, c = i.serverInfo ?? o(), l = r({
+		baseUrl: a,
+		...s === void 0 ? {} : { token: s },
+		...i.manifestTtlMs === void 0 ? {} : { ttlMs: i.manifestTtlMs }
+	}), u = i.live ?? e(t(i.env), ...i.manifestTtlMs === void 0 ? [] : [{ ttlMs: i.manifestTtlMs }]), d = await l.get();
+	d.error === void 0 ? i.errput.write(`voltro-mcp: loaded ${d.manifest.procedures.length} procedures from ${a}\n`) : i.errput.write(`voltro-mcp: could not fetch manifest from ${a}: ${d.error} — serving empty manifest\n`);
+	let f = async (e) => {
+		if (e === "") return;
+		let t;
+		try {
+			t = JSON.parse(e);
+		} catch {
+			return;
+		}
+		let r = Array.isArray(t) ? t : [t];
+		for (let e of r) {
+			(e.method === "tools/call" || e.method === "tools/list") && (d = await l.get());
+			let t = await n(d, e, c, u);
+			t !== null && i.output.write(`${JSON.stringify(t)}\n`);
+		}
+	}, p = "";
+	for await (let e of i.input) {
+		p += String(e);
+		let t = p.indexOf("\n");
+		for (; t !== -1;) {
+			let e = p.slice(0, t).trim();
+			p = p.slice(t + 1), await f(e), t = p.indexOf("\n");
+		}
+	}
+	await f(p.trim());
+};
+//#endregion
+export { s as n, o as t };

package/dist/server.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { n as e } from "./serve-CRW_Na4H.js";
+import { n as e } from "./serve-ZSmqUcRM.js";
 //#region src/server.ts
 e({
 	input: process.stdin,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voltro/mcp",
-  "version": "0.33.0",
+  "version": "0.35.0",
   "description": "MCP server for coding agents over a running Voltro api — exposes the app's procedures, tables, workflows and their JSON Schemas as MCP tools, resources and prompts, over stdio (voltro-mcp) or Streamable HTTP (voltro-mcp-http). Zero dependencies.",
   "keywords": [
     "voltro",