drizzle-cube 0.5.8 → 0.6.1

package/dist/adapters/hono/index.js

@@ -1,6 +1,6 @@
-import { a as e, f as t, o as n, r, u as i } from "../utils-D9JPLmfl.js";
-import { i as a, n as o, r as s, t as c } from "../locale-BPB7flIG.js";
-import { C as l, S as u, _ as d, a as f, b as p, c as m, g as h, h as g, i as _, l as v, m as y, o as b, r as x, u as S, v as C, x as w, y as T } from "../mcp-transport-D0B3S1tB.js";
+import { a as e, l as t, o as n, r, u as i } from "../utils-BPWZsX7k.js";
+import { i as a, n as o, r as s, t as c } from "../locale-DDvZDFVn.js";
+import { C as l, S as u, _ as d, a as f, b as p, c as m, g as h, h as g, i as _, l as v, m as y, o as b, r as x, u as S, v as C, x as w, y as T } from "../mcp-transport-Dfuj4j4q.js";
 import { Hono as E } from "hono";
 //#region node_modules/hono/dist/middleware/cors/index.js
 var D = (e) => {
@@ -42,37 +42,164 @@ var D = (e) => {
 	};
 };
 //#endregion
+//#region src/adapters/hono/mcp-handler.ts
+async function O(e, t) {
+	if (t.resourceMetadataUrl && !S(e.req.header("authorization"))) return e.header("WWW-Authenticate", m(t.resourceMetadataUrl)), { response: e.json({ error: "Bearer token required" }, 401) };
+	let n = u(e.req.header("origin"), t.allowedOrigins ? { allowedOrigins: t.allowedOrigins } : {});
+	if (!n.valid) return { response: e.json(_(null, -32600, n.reason), 403) };
+	let r = e.req.header("accept");
+	if (!w(r)) return { response: e.json(_(null, -32600, "Accept header must include both application/json and text/event-stream"), 400) };
+	let i = g(e.req.header());
+	if (!i.ok) return { response: e.json({
+		error: "Unsupported MCP protocol version",
+		supported: i.supported
+	}, 426) };
+	let a = h(await e.req.json().catch(() => null));
+	return a ? {
+		rpcRequest: a,
+		acceptHeader: r,
+		negotiatedProtocol: i.negotiated
+	} : { response: e.json(_(null, -32600, "Invalid JSON-RPC 2.0 request"), 400) };
+}
+function k(e, t) {
+	let n = new TextEncoder(), r = d(), i = new ReadableStream({ start(t) {
+		t.enqueue(n.encode(`id: ${r}\n\n`)), t.enqueue(n.encode(p(e, r))), t.close();
+	} });
+	return new Response(i, {
+		status: 200,
+		headers: {
+			"Content-Type": "text/event-stream",
+			"Cache-Control": "no-cache",
+			Connection: "keep-alive",
+			...t
+		}
+	});
+}
+function A(e, t, n) {
+	let r = e && t && typeof t == "object" && "sessionId" in t ? t.sessionId : void 0;
+	return r ? { [n]: r } : {};
+}
+function j(e, t) {
+	let n = e?.code ?? -32603, r = e?.data, i = e.message || "MCP request failed";
+	return _(t ?? null, n, i, r);
+}
+function M(e) {
+	return l(e);
+}
+function N(e, t, n, r) {
+	if (y(t)) return e.body(null, 202);
+	let i = f(t.id ?? null, n), a = A(t.method === "initialize", n, x);
+	return r ? k(i, a) : e.json(i, 200, a);
+}
+function P(e, t, n, r) {
+	if (y(t)) return console.error("MCP notification processing error:", n), e.body(null, 202);
+	console.error("MCP RPC error:", n);
+	let i = j(n, t.id);
+	return r ? k(i) : e.json(i, 200);
+}
+async function F(e, t, n, r) {
+	try {
+		return N(e, t, await v(t.method, t.params, r), n);
+	} catch (r) {
+		return P(e, t, r, n);
+	}
+}
+//#endregion
+//#region src/adapters/hono/agent-handler.ts
+function I(e, t) {
+	let n = (t.apiKey || "").trim();
+	if (t.allowClientApiKey) {
+		let t = e.req.header("x-agent-api-key");
+		t && (n = t.trim());
+	}
+	return n;
+}
+function L(e, t) {
+	return t.allowClientApiKey ? {
+		providerOverride: e.req.header("x-agent-provider"),
+		modelOverride: e.req.header("x-agent-model"),
+		baseURLOverride: e.req.header("x-agent-provider-endpoint")
+	} : {};
+}
+function R(e) {
+	let t = new TextEncoder(), n = new ReadableStream({ async start(n) {
+		try {
+			for await (let r of e) n.enqueue(t.encode(`data: ${JSON.stringify(r)}\n\n`));
+		} catch (e) {
+			let r = {
+				type: "error",
+				data: { message: e instanceof Error ? e.message : "Stream failed" }
+			};
+			n.enqueue(t.encode(`data: ${JSON.stringify(r)}\n\n`));
+		} finally {
+			n.close();
+		}
+	} });
+	return new Response(n, {
+		status: 200,
+		headers: {
+			"Content-Type": "text/event-stream",
+			"Cache-Control": "no-cache",
+			Connection: "keep-alive"
+		}
+	});
+}
+async function z(e, t, n, r) {
+	try {
+		let { handleAgentChat: i } = await import("../handler-CfgE0JSL.js"), { message: a, sessionId: o, history: s } = await e.req.json();
+		if (!a || typeof a != "string") return e.json({ error: "message is required and must be a string" }, 400);
+		let c = I(e, t);
+		if (!c) return e.json({ error: "No API key configured. Set agent.apiKey in server config or send X-Agent-Api-Key header." }, 401);
+		let { providerOverride: l, modelOverride: u, baseURLOverride: d } = L(e, t), f = await r(e), p = t.buildSystemContext?.(f);
+		return R(i({
+			message: a,
+			sessionId: o,
+			history: s,
+			semanticLayer: n,
+			securityContext: f,
+			agentConfig: t,
+			apiKey: c,
+			systemContext: p,
+			providerOverride: l,
+			modelOverride: u,
+			baseURLOverride: d
+		}));
+	} catch (t) {
+		return console.error("Agent chat error:", t), e.json({ error: t instanceof Error ? t.message : "Agent chat failed" }, 500);
+	}
+}
+//#endregion
 //#region src/adapters/hono/index.ts
-function O(O) {
-	let { cubes: k, drizzle: A, schema: j, extractSecurityContext: M, engineType: N, cors: P, basePath: F = "/cubejs-api/v1", cache: I, mcp: L = { enabled: !0 }, agent: R } = O;
-	if (!O.semanticLayer && (!k || k.length === 0)) throw Error("Either semanticLayer or a non-empty cubes array must be provided");
-	let z = new E(), B = async (e) => s(await M(e), o((t) => e.req.header(t)));
-	if (P) {
+function B(l) {
+	let { cubes: u, drizzle: f, schema: h, extractSecurityContext: g, engineType: _, cors: v, basePath: y = "/cubejs-api/v1", cache: x, mcp: w = { enabled: !0 }, agent: k } = l;
+	if (!l.semanticLayer && (!u || u.length === 0)) throw Error("Either semanticLayer or a non-empty cubes array must be provided");
+	let A = new E(), j = async (e) => s(await g(e), o((t) => e.req.header(t)));
+	if (v) {
 		let e = {
-			...P,
-			allowHeaders: c(P.allowHeaders)
+			...v,
+			allowHeaders: c(v.allowHeaders)
 		};
-		z.use("/*", D(e));
+		A.use("/*", D(e));
 	}
-	let V = O.semanticLayer ?? new a({
-		drizzle: A,
-		schema: j,
-		engineType: N,
-		cache: I,
-		rlsSetup: O.rlsSetup
+	let N = l.semanticLayer ?? new a({
+		drizzle: f,
+		schema: h,
+		engineType: _,
+		cache: x,
+		rlsSetup: l.rlsSetup
 	});
-	if (!O.semanticLayer && k && k.forEach((e) => {
-		V.registerCube(e);
-	}), z.post(`${F}/load`, async (e) => {
+	if (!l.semanticLayer && u && u.forEach((e) => {
+		N.registerCube(e);
+	}), A.post(`${y}/load`, async (e) => {
 		try {
-			let t = await e.req.json(), n = t.query || t, i = await B(e), a = V.validateQuery(n);
+			let t = await e.req.json(), n = t.query || t, i = await j(e), a = N.validateQuery(n);
 			if (!a.isValid) return e.json({ error: `Query validation failed: ${a.errors.join(", ")}` }, 400);
-			let o = e.req.header("x-cache-control") === "no-cache", s = await V.executeMultiCubeQuery(n, i, { skipCache: o });
-			return e.json(r(n, s, V));
+			let o = e.req.header("x-cache-control") === "no-cache", s = await N.executeMultiCubeQuery(n, i, { skipCache: o });
+			return e.json(r(n, s, N));
 		} catch (t) {
 			return console.error("Query execution error:", t), e.json({ error: t instanceof Error ? t.message : "Query execution failed" }, 500);
 		}
-	}), z.get(`${F}/load`, async (e) => {
+	}), A.get(`${y}/load`, async (e) => {
 		try {
 			let t = e.req.query("query");
 			if (!t) return e.json({ error: "Query parameter is required" }, 400);
@@ -82,206 +209,109 @@ function O(O) {
 			} catch {
 				return e.json({ error: "Invalid JSON in query parameter" }, 400);
 			}
-			let i = await B(e), a = V.validateQuery(n);
+			let i = await j(e), a = N.validateQuery(n);
 			if (!a.isValid) return e.json({ error: `Query validation failed: ${a.errors.join(", ")}` }, 400);
-			let o = e.req.header("x-cache-control") === "no-cache", s = await V.executeMultiCubeQuery(n, i, { skipCache: o });
-			return e.json(r(n, s, V));
+			let o = e.req.header("x-cache-control") === "no-cache", s = await N.executeMultiCubeQuery(n, i, { skipCache: o });
+			return e.json(r(n, s, N));
 		} catch (t) {
 			return console.error("Query execution error:", t), e.json({ error: t instanceof Error ? t.message : "Query execution failed" }, 500);
 		}
-	}), z.post(`${F}/batch`, async (e) => {
+	}), A.post(`${y}/batch`, async (e) => {
 		try {
-			let { queries: t } = await e.req.json();
-			if (!t || !Array.isArray(t)) return e.json({ error: "Request body must contain a \"queries\" array" }, 400);
-			if (t.length === 0) return e.json({ error: "Queries array cannot be empty" }, 400);
-			let n = await i(t, await B(e), V, { skipCache: e.req.header("x-cache-control") === "no-cache" });
-			return e.json(n);
+			let { queries: n } = await e.req.json();
+			if (!n || !Array.isArray(n)) return e.json({ error: "Request body must contain a \"queries\" array" }, 400);
+			if (n.length === 0) return e.json({ error: "Queries array cannot be empty" }, 400);
+			let r = await t(n, await j(e), N, { skipCache: e.req.header("x-cache-control") === "no-cache" });
+			return e.json(r);
 		} catch (t) {
 			return console.error("Batch execution error:", t), e.json({ error: t instanceof Error ? t.message : "Batch execution failed" }, 500);
 		}
-	}), z.get(`${F}/meta`, (t) => {
+	}), A.get(`${y}/meta`, (t) => {
 		try {
-			let n = V.getMetadata();
+			let n = N.getMetadata();
 			return t.json(e(n));
 		} catch (e) {
 			return console.error("Metadata error:", e), t.json({ error: e instanceof Error ? e.message : "Failed to fetch metadata" }, 500);
 		}
-	}), z.post(`${F}/sql`, async (e) => {
+	}), A.post(`${y}/sql`, async (e) => {
 		try {
-			let t = await e.req.json(), r = await B(e), i = V.validateQuery(t);
+			let t = await e.req.json(), r = await j(e), i = N.validateQuery(t);
 			if (!i.isValid) return e.json({ error: `Query validation failed: ${i.errors.join(", ")}` }, 400);
 			let a = t.measures?.[0] || t.dimensions?.[0];
 			if (!a) return e.json({ error: "No measures or dimensions specified" }, 400);
-			let o = a.split(".")[0], s = await V.generateSQL(o, t, r);
+			let o = a.split(".")[0], s = await N.generateSQL(o, t, r);
 			return e.json(n(t, s));
 		} catch (t) {
 			return console.error("SQL generation error:", t), e.json({ error: t instanceof Error ? t.message : "SQL generation failed" }, 500);
 		}
-	}), z.get(`${F}/sql`, async (e) => {
+	}), A.get(`${y}/sql`, async (e) => {
 		try {
 			let t = e.req.query("query");
 			if (!t) return e.json({ error: "Query parameter is required" }, 400);
-			let r = JSON.parse(t), i = await B(e), a = V.validateQuery(r);
+			let r = JSON.parse(t), i = await j(e), a = N.validateQuery(r);
 			if (!a.isValid) return e.json({ error: `Query validation failed: ${a.errors.join(", ")}` }, 400);
 			let o = r.measures?.[0] || r.dimensions?.[0];
 			if (!o) return e.json({ error: "No measures or dimensions specified" }, 400);
-			let s = o.split(".")[0], c = await V.generateSQL(s, r, i);
+			let s = o.split(".")[0], c = await N.generateSQL(s, r, i);
 			return e.json(n(r, c));
 		} catch (t) {
 			return console.error("SQL generation error:", t), e.json({ error: t instanceof Error ? t.message : "SQL generation failed" }, 500);
 		}
-	}), z.post(`${F}/dry-run`, async (e) => {
+	}), A.post(`${y}/dry-run`, async (e) => {
 		try {
-			let n = await e.req.json(), r = await t(n.query || n, await B(e), V);
-			return e.json(r);
+			let t = await e.req.json(), n = await i(t.query || t, await j(e), N);
+			return e.json(n);
 		} catch (t) {
 			return console.error("Dry-run error:", t), e.json({
 				error: t instanceof Error ? t.message : "Dry-run validation failed",
 				valid: !1
 			}, 400);
 		}
-	}), z.get(`${F}/dry-run`, async (e) => {
+	}), A.get(`${y}/dry-run`, async (e) => {
 		try {
-			let n = e.req.query("query");
-			if (!n) return e.json({
+			let t = e.req.query("query");
+			if (!t) return e.json({
 				error: "Query parameter is required",
 				valid: !1
 			}, 400);
-			let r = await t(JSON.parse(n), await B(e), V);
-			return e.json(r);
+			let n = await i(JSON.parse(t), await j(e), N);
+			return e.json(n);
 		} catch (t) {
 			return console.error("Dry-run error:", t), e.json({
 				error: t instanceof Error ? t.message : "Dry-run validation failed",
 				valid: !1
 			}, 400);
 		}
-	}), z.post(`${F}/explain`, async (e) => {
+	}), A.post(`${y}/explain`, async (e) => {
 		try {
-			let t = await e.req.json(), n = t.query || t, r = t.options || {}, i = await B(e), a = V.validateQuery(n);
+			let t = await e.req.json(), n = t.query || t, r = t.options || {}, i = await j(e), a = N.validateQuery(n);
 			if (!a.isValid) return e.json({ error: `Query validation failed: ${a.errors.join(", ")}` }, 400);
-			let o = await V.explainQuery(n, i, r);
+			let o = await N.explainQuery(n, i, r);
 			return e.json(o);
 		} catch (t) {
 			return console.error("Explain error:", t), e.json({ error: t instanceof Error ? t.message : "Explain query failed" }, 500);
 		}
-	}), R && z.post(`${F}/agent/chat`, async (e) => {
-		try {
-			let { handleAgentChat: t } = await import("../handler-Cx8QYLk6.js"), { message: n, sessionId: r, history: i } = await e.req.json();
-			if (!n || typeof n != "string") return e.json({ error: "message is required and must be a string" }, 400);
-			let a = (R.apiKey || "").trim();
-			if (R.allowClientApiKey) {
-				let t = e.req.header("x-agent-api-key");
-				t && (a = t.trim());
-			}
-			if (!a) return e.json({ error: "No API key configured. Set agent.apiKey in server config or send X-Agent-Api-Key header." }, 401);
-			let o = R.allowClientApiKey ? e.req.header("x-agent-provider") : void 0, s = R.allowClientApiKey ? e.req.header("x-agent-model") : void 0, c = R.allowClientApiKey ? e.req.header("x-agent-provider-endpoint") : void 0, l = await B(e), u = R.buildSystemContext?.(l), d = new TextEncoder(), f = new ReadableStream({ async start(e) {
-				try {
-					let f = t({
-						message: n,
-						sessionId: r,
-						history: i,
-						semanticLayer: V,
-						securityContext: l,
-						agentConfig: R,
-						apiKey: a,
-						systemContext: u,
-						providerOverride: o,
-						modelOverride: s,
-						baseURLOverride: c
-					});
-					for await (let t of f) {
-						let n = `data: ${JSON.stringify(t)}\n\n`;
-						e.enqueue(d.encode(n));
-					}
-				} catch (t) {
-					let n = {
-						type: "error",
-						data: { message: t instanceof Error ? t.message : "Stream failed" }
-					};
-					e.enqueue(d.encode(`data: ${JSON.stringify(n)}\n\n`));
-				} finally {
-					e.close();
-				}
-			} });
-			return new Response(f, {
-				status: 200,
-				headers: {
-					"Content-Type": "text/event-stream",
-					"Cache-Control": "no-cache",
-					Connection: "keep-alive"
-				}
+	}), k && A.post(`${y}/agent/chat`, (e) => z(e, k, N, j)), w.enabled !== !1) {
+		let e = b(N, w.resources), t = T(w.prompts), n = C(w.instructions), r = w.basePath ?? "/mcp";
+		A.post(`${r}`, async (r) => {
+			let i = await O(r, w);
+			if (i.response) return i.response;
+			let a = i.rpcRequest;
+			return F(r, a, M(i.acceptHeader), {
+				semanticLayer: N,
+				extractSecurityContext: (e, t) => j(e),
+				rawRequest: r,
+				rawResponse: null,
+				negotiatedProtocol: i.negotiatedProtocol,
+				resources: e,
+				prompts: t,
+				instructions: n,
+				appEnabled: !!w.app,
+				appConfig: typeof w.app == "object" ? w.app : void 0,
+				serverName: w.serverName
 			});
-		} catch (t) {
-			return console.error("Agent chat error:", t), e.json({ error: t instanceof Error ? t.message : "Agent chat failed" }, 500);
-		}
-	}), L.enabled !== !1) {
-		let e = b(V, L.resources), t = T(L.prompts), n = C(L.instructions), r = L.basePath ?? "/mcp";
-		z.post(`${r}`, async (r) => {
-			if (L.resourceMetadataUrl && !S(r.req.header("authorization"))) return r.header("WWW-Authenticate", m(L.resourceMetadataUrl)), r.json({ error: "Bearer token required" }, 401);
-			let i = u(r.req.header("origin"), L.allowedOrigins ? { allowedOrigins: L.allowedOrigins } : {});
-			if (!i.valid) return r.json(_(null, -32600, i.reason), 403);
-			let a = r.req.header("accept");
-			if (!w(a)) return r.json(_(null, -32600, "Accept header must include both application/json and text/event-stream"), 400);
-			let o = g(r.req.header());
-			if (!o.ok) return r.json({
-				error: "Unsupported MCP protocol version",
-				supported: o.supported
-			}, 426);
-			let s = h(await r.req.json().catch(() => null));
-			if (!s) return r.json(_(null, -32600, "Invalid JSON-RPC 2.0 request"), 400);
-			let c = l(a), b = s.method === "initialize";
-			try {
-				let i = await v(s.method, s.params, {
-					semanticLayer: V,
-					extractSecurityContext: (e, t) => B(e),
-					rawRequest: r,
-					rawResponse: null,
-					negotiatedProtocol: o.negotiated,
-					resources: e,
-					prompts: t,
-					instructions: n,
-					appEnabled: !!L.app,
-					appConfig: typeof L.app == "object" ? L.app : void 0,
-					serverName: L.serverName
-				});
-				if (y(s)) return r.body(null, 202);
-				let a = f(s.id ?? null, i), l = b && i && typeof i == "object" && "sessionId" in i ? i.sessionId : void 0, u = {};
-				if (l && (u[x] = l), c) {
-					let e = new TextEncoder(), t = d(), n = new ReadableStream({ start(n) {
-						n.enqueue(e.encode(`id: ${t}\n\n`)), n.enqueue(e.encode(p(a, t))), n.close();
-					} });
-					return new Response(n, {
-						status: 200,
-						headers: {
-							"Content-Type": "text/event-stream",
-							"Cache-Control": "no-cache",
-							Connection: "keep-alive",
-							...u
-						}
-					});
-				}
-				return r.json(a, 200, u);
-			} catch (e) {
-				if (y(s)) return console.error("MCP notification processing error:", e), r.body(null, 202);
-				console.error("MCP RPC error:", e);
-				let t = e?.code ?? -32603, n = e?.data, i = e.message || "MCP request failed", a = _(s.id ?? null, t, i, n);
-				if (c) {
-					let e = new TextEncoder(), t = d(), n = new ReadableStream({ start(n) {
-						n.enqueue(e.encode(`id: ${t}\n\n`)), n.enqueue(e.encode(p(a, t))), n.close();
-					} });
-					return new Response(n, {
-						status: 200,
-						headers: {
-							"Content-Type": "text/event-stream",
-							"Cache-Control": "no-cache",
-							Connection: "keep-alive"
-						}
-					});
-				}
-				return r.json(a, 200);
-			}
-		}), z.delete(`${r}`, (e) => L.resourceMetadataUrl && !S(e.req.header("authorization")) ? (e.header("WWW-Authenticate", m(L.resourceMetadataUrl)), e.json({ error: "Bearer token required" }, 401)) : e.json({ error: "Session termination not supported" }, 405)), z.get(`${r}`, (e) => {
-			if (L.resourceMetadataUrl && !S(e.req.header("authorization"))) return e.header("WWW-Authenticate", m(L.resourceMetadataUrl)), e.json({ error: "Bearer token required" }, 401);
+		}), A.delete(`${r}`, (e) => w.resourceMetadataUrl && !S(e.req.header("authorization")) ? (e.header("WWW-Authenticate", m(w.resourceMetadataUrl)), e.json({ error: "Bearer token required" }, 401)) : e.json({ error: "Session termination not supported" }, 405)), A.get(`${r}`, (e) => {
+			if (w.resourceMetadataUrl && !S(e.req.header("authorization"))) return e.header("WWW-Authenticate", m(w.resourceMetadataUrl)), e.json({ error: "Bearer token required" }, 401);
 			let t = new TextEncoder(), n = d(), r, i = new ReadableStream({
 				start(e) {
 					e.enqueue(t.encode(p({
@@ -306,14 +336,14 @@ function O(O) {
 			});
 		});
 	}
-	return z;
+	return A;
 }
-function k(e, t) {
-	let n = O(t);
+function V(e, t) {
+	let n = B(t);
 	return e.route("/", n), e;
 }
-function A(e) {
-	return k(new E(), e);
+function H(e) {
+	return V(new E(), e);
 }
 //#endregion
-export { A as createCubeApp, O as createCubeRoutes, k as mountCubeRoutes };
+export { H as createCubeApp, B as createCubeRoutes, V as mountCubeRoutes };

package/dist/adapters/hono/mcp-handler.d.ts

@@ -0,0 +1,37 @@
+import { Context } from 'hono';
+import { JsonRpcRequest, McpDispatchContext } from '../mcp-transport.js';
+/** MCP endpoint config fields the handler helpers depend on. */
+export interface HonoMcpHandlerConfig {
+    resourceMetadataUrl?: string;
+    allowedOrigins?: string[];
+}
+/**
+ * Result of the pre-dispatch validation gauntlet. When `response` is set the
+ * caller must return it immediately (short-circuit); otherwise `rpcRequest`,
+ * `acceptHeader`, and `protocol` are populated for dispatch.
+ */
+export interface McpRequestPrep {
+    response?: Response;
+    rpcRequest?: JsonRpcRequest;
+    acceptHeader?: string;
+    negotiatedProtocol?: string | null;
+}
+/**
+ * Run the MCP POST validation sequence (auth, origin, Accept, protocol, body).
+ * Returns a short-circuit `response` on the first failure, or the parsed
+ * request + negotiated protocol on success.
+ */
+export declare function prepareMcpPostRequest(c: Context, mcp: HonoMcpHandlerConfig): Promise<McpRequestPrep>;
+/** Build a single-event SSE `Response` carrying one JSON-RPC payload. */
+export declare function buildMcpSseResponse(payload: unknown, extraHeaders?: Record<string, string>): Response;
+/** Extract the MCP-Session-Id header value from an `initialize` result, if present. */
+export declare function extractMcpSessionHeaders(isInitialize: boolean, result: unknown, headerName: string): Record<string, string>;
+/** Build a JSON-RPC error response from a thrown error (preserving code/data). */
+export declare function buildMcpErrorPayload(error: unknown, id: JsonRpcRequest['id']): import('../mcp-transport.js').JsonRpcResponse;
+/** Wrap `wantsEventStream` so the handler imports a single helper module. */
+export declare function clientWantsStream(acceptHeader?: string): boolean;
+/**
+ * Dispatch a validated MCP JSON-RPC request and build the Hono `Response`
+ * (success or error path). Keeps the route handler a thin wrapper.
+ */
+export declare function dispatchMcpPost(c: Context, rpcRequest: JsonRpcRequest, wantsStream: boolean, ctx: McpDispatchContext): Promise<Response>;