@plitzi/sdk-server 0.32.9 → 0.32.11

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # @plitzi/sdk-server
 
+## 0.32.11
+
+### Patch Changes
+
+- v0.32.11
+- Updated dependencies
+  - @plitzi/plitzi-sdk@0.32.11
+  - @plitzi/sdk-schema@0.32.11
+  - @plitzi/sdk-shared@0.32.11
+
+## 0.32.10
+
+### Patch Changes
+
+- v0.32.10
+- Updated dependencies
+  - @plitzi/plitzi-sdk@0.32.10
+  - @plitzi/sdk-schema@0.32.10
+  - @plitzi/sdk-shared@0.32.10
+
 ## 0.32.9
 
 ### Patch Changes

package/dist/core/http/dispatcher.js

@@ -2,21 +2,57 @@ import { applySecurityHeaders } from "./securityHeaders.js";
 import { buildResponseHelpers } from "../../helpers/buildResponseHelpers.js";
 import { parseRequest } from "../requestParser.js";
 //#region src/core/http/dispatcher.ts
-var runPipeline = async (raw, rawRes, buildContext, stages) => {
+var safePath = (url) => {
+	const [path = "/", query] = url.split("?");
+	if (!query) return path;
+	const keys = [...new Set(new URLSearchParams(query).keys())];
+	return keys.length > 0 ? `${path}?${keys.join("&")}` : path;
+};
+var errorText = (error) => error instanceof Error ? error.message : String(error);
+var statusOf = (rawRes, res) => rawRes.headersSent ? rawRes.statusCode : res.status;
+var runPipeline = async (raw, rawRes, buildContext, stages, server) => {
+	const startedAt = Date.now();
 	const req = parseRequest(raw);
 	const res = buildResponseHelpers(rawRes, req.headers["accept-encoding"]);
-	if (req.path === "\0") {
-		res.setStatus(400);
-		res.end();
-		return;
-	}
 	const ctx = buildContext(raw, rawRes, req, res);
-	applySecurityHeaders(res, ctx.config, ctx.port);
-	for (const stage of stages) if (await stage(ctx)) return;
+	const logger = ctx.config.logger;
+	const logRequest = (error) => {
+		if (!logger) return;
+		const status = statusOf(rawRes, res);
+		logger({
+			kind: "request",
+			server,
+			method: req.method,
+			path: safePath(req.url),
+			...ctx.operation === void 0 ? {} : { operation: ctx.operation },
+			status,
+			durationMs: Date.now() - startedAt,
+			ok: !error && status < 400,
+			...error ? { error: errorText(error) } : {},
+			timestamp: (/* @__PURE__ */ new Date()).toISOString()
+		});
+	};
+	try {
+		if (req.path === "\0") {
+			res.setStatus(400);
+			res.end();
+			logRequest();
+			return;
+		}
+		applySecurityHeaders(res, ctx.config, ctx.port);
+		for (const stage of stages) if (await stage(ctx)) {
+			logRequest();
+			return;
+		}
+		logRequest();
+	} catch (error) {
+		logRequest(error);
+		throw error;
+	}
 };
 var makeHandler = (label, buildContext, stages) => {
 	return (raw, rawRes) => {
-		runPipeline(raw, rawRes, buildContext, stages).catch((err) => {
+		runPipeline(raw, rawRes, buildContext, stages, label).catch((err) => {
 			console.error(`[${label}] Unhandled error:`, err);
 			try {
 				if (!rawRes.headersSent) rawRes.writeHead(500, { "Content-Type": "text/plain" });

package/dist/core/services/mcp.js

@@ -2,15 +2,17 @@ import { handleMcp } from "../../modules/mcp/handler.js";
 import { createHttpPreviewClient } from "../../modules/mcp/previewClient.js";
 import { createHttpScreenshotClient } from "../../modules/mcp/screenshotClient.js";
 //#region src/core/services/mcp.ts
-var mcpPathOf = (path) => path ?? "/";
-var serveMcp = (ctx) => {
-	const { previewClient, screenshot } = ctx.config;
-	const preview = previewClient ? createHttpPreviewClient(previewClient) : void 0;
-	const screenshotClient = screenshot ? createHttpScreenshotClient(screenshot) : void 0;
-	return handleMcp(ctx.raw, ctx.rawRes, ctx.req, ctx.config.adapters, preview, screenshotClient, ctx.config.mcpLogger, ctx.config.renderApp);
+var mcpPathOf = (config) => config.mcpAi?.path ?? config.mcp?.path ?? "/mcp";
+var serveMcp = async (ctx) => {
+	const { previewClient, screenshot, adapters, logger } = ctx.config;
+	ctx.operation = await handleMcp(ctx.raw, ctx.rawRes, ctx.req, adapters, {
+		preview: previewClient ? createHttpPreviewClient(previewClient) : void 0,
+		screenshot: screenshot ? createHttpScreenshotClient(screenshot) : void 0,
+		logger
+	});
 };
 var mcpStage = async (ctx) => {
-	if (!ctx.req.path.startsWith(mcpPathOf(ctx.config.mcp?.path))) return false;
+	if (!ctx.req.path.startsWith(mcpPathOf(ctx.config))) return false;
 	await serveMcp(ctx);
 	return true;
 };

package/dist/helpers/serverLog.js

@@ -0,0 +1,33 @@
+//#region src/helpers/serverLog.ts
+var outcomeOf = (event) => event.ok ? "ok" : `ERROR ${event.error ?? ""}`.trim();
+var renderRequest = (event) => {
+	const operation = event.operation ? ` ${event.operation}` : "";
+	const timing = `${Math.round(event.durationMs)}ms`;
+	return `[${event.server}] ${event.method} ${event.path}${operation} ${event.status} ${timing} ${outcomeOf(event)}`;
+};
+var renderTool = (event) => {
+	const args = event.argsSummary ? ` ${event.argsSummary}` : "";
+	return `[mcp] tools/call ${event.name}${args} ${Math.round(event.durationMs)}ms ${outcomeOf(event)}`;
+};
+var renderResource = (event) => `[mcp] resources/read ${event.name} ${Math.round(event.durationMs)}ms ${outcomeOf(event)}`;
+/** One line for any {@link ServerLogEvent}: an HTTP request reads as an access-log line
+*  (`[SSR] GET /pricing 200 12ms ok`), the MCP events as what happened inside one
+*  (`[mcp] tools/call plitzi_apply {operations:[3]} 41ms ok`). Events arrive PII-free — the dispatcher strips
+*  query values and collects no headers, cookies or IPs, and tool args are summarised by shape — so rendering is
+*  a pure format. */
+var renderLogEvent = (event) => {
+	switch (event.kind) {
+		case "request": return renderRequest(event);
+		case "tool": return renderTool(event);
+		case "resource": return renderResource(event);
+	}
+};
+/** A drop-in `SSRServerConfig.logger` for consumers that just want the log on the console. Consumers with their
+*  own logging stack should pass their own sink instead and read the structured event. */
+var consoleLogger = (event) => {
+	const line = renderLogEvent(event);
+	if (event.ok) console.log(line);
+	else console.error(line);
+};
+//#endregion
+export { consoleLogger, renderLogEvent };

package/dist/index.js

@@ -1,4 +1,5 @@
 import { buildAgentGuide } from "./modules/mcp/helpers/agentPrompt.js";
+import { consoleLogger, renderLogEvent } from "./helpers/serverLog.js";
 import { operation } from "./modules/mcp/tools/operations/index.js";
 import { apply, applyShape } from "./modules/mcp/tools/apply/index.js";
 import { read, readShape } from "./modules/mcp/tools/read.js";
@@ -19,4 +20,4 @@ import { createSSRServer } from "./core/server/ssrServer.js";
 import { createServer } from "./core/createServer.js";
 import { createJsonAdapters } from "./adapters/jsonAdapters.js";
 import AIEngine from "./modules/ai/AIEngine.js";
-export { AIEngine, PREVIEW_TOKEN_PARAM, apply, applyShape, bindTools, buildAgentGuide, buildHealthPayload, createHttpPreviewClient, createHttpScreenshotClient, createJsonAdapters, createMCPServer, createMcpServer, createMemoryDraftStore, createPreview, createSSRServer, createServer, getAllowedModes, handleMcp, isCallToolResult, isToolActive, operation, read, readMcpBody, readShape, registerHealthCheck, resolveServices, resolveToolHandler, search, searchShape, serveMcp, toolResponseErr, toolResponseFromResult, toolResponseOk, tools, validate, validateShape, zodToJsonSchema };
+export { AIEngine, PREVIEW_TOKEN_PARAM, apply, applyShape, bindTools, buildAgentGuide, buildHealthPayload, consoleLogger, createHttpPreviewClient, createHttpScreenshotClient, createJsonAdapters, createMCPServer, createMcpServer, createMemoryDraftStore, createPreview, createSSRServer, createServer, getAllowedModes, handleMcp, isCallToolResult, isToolActive, operation, read, readMcpBody, readShape, registerHealthCheck, renderLogEvent, resolveServices, resolveToolHandler, search, searchShape, serveMcp, toolResponseErr, toolResponseFromResult, toolResponseOk, tools, validate, validateShape, zodToJsonSchema };

package/dist/mcp.d.ts

@@ -0,0 +1,2 @@
+export * from './src/mcp.js'
+export {}

package/dist/mcp.js

@@ -0,0 +1,7 @@
+import { consoleLogger, renderLogEvent } from "./helpers/serverLog.js";
+import { createMcpServer } from "./modules/mcp/server.js";
+import { handleMcp, readMcpBody, serveMcp } from "./modules/mcp/handler.js";
+import { createHttpPreviewClient } from "./modules/mcp/previewClient.js";
+import { createHttpScreenshotClient } from "./modules/mcp/screenshotClient.js";
+import { createMCPServer } from "./core/server/mcpServer.js";
+export { consoleLogger, createHttpPreviewClient, createHttpScreenshotClient, createMCPServer, createMcpServer, handleMcp, readMcpBody, renderLogEvent, serveMcp };

package/dist/modules/mcp/apps/example/view.tsx

@@ -0,0 +1,70 @@
+/* eslint-disable react-refresh/only-export-components -- one bundled entry: components cannot move out. */
+import { useApp, useHostStyles } from '@modelcontextprotocol/ext-apps/react';
+import { useState } from 'react';
+import { createRoot } from 'react-dom/client';
+
+import type { McpUiHostContext } from '@modelcontextprotocol/ext-apps';
+import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+
+/** The smallest MCP App view there is — copy this folder to start a new one. It shows the whole contract:
+ *  connect, receive the tool call and its result, call a tool back, and inherit the host's look. Everything it
+ *  imports is bundled into the page, so a view that stays this small stays a few KB. */
+
+// Host CSS variables: the chat's own palette and fonts, applied by useHostStyles below.
+const panel = {
+  padding: 16,
+  font: 'var(--font-sans, system-ui, sans-serif)',
+  color: 'var(--color-text-primary, #0f172a)',
+  background: 'var(--color-background-secondary, #f8fafc)',
+  borderRadius: 'var(--border-radius-md, 8px)'
+} as const;
+
+const textOf = (result: CallToolResult): string => result.content.find(entry => entry.type === 'text')?.text ?? '';
+
+const ExampleApp = () => {
+  const [result, setResult] = useState<CallToolResult | null>(null);
+  const [context, setContext] = useState<McpUiHostContext | undefined>(undefined);
+
+  // useApp creates the App, runs onAppCreated so every handler is in place BEFORE the handshake, and connects.
+  const { app, error } = useApp({
+    appInfo: { name: 'Plitzi Example', version: '1.0.0' },
+    capabilities: {},
+    onAppCreated: instance => {
+      // The result of the tool that opened this view. `ontoolinput` gives its arguments instead.
+      instance.ontoolresult = setResult;
+      instance.onhostcontextchanged = params => setContext(previous => ({ ...previous, ...params }));
+      instance.onteardown = () => ({});
+    }
+  });
+
+  useHostStyles(app, context);
+
+  if (error) {
+    return <div style={panel}>Could not connect to the host: {error.message}</div>;
+  }
+
+  if (!app) {
+    return null;
+  }
+
+  const insets = context?.safeAreaInsets;
+  const message = result ? textOf(result) : 'Waiting for the tool result…';
+
+  return (
+    <div style={{ ...panel, margin: `${insets?.top ?? 0}px ${insets?.right ?? 0}px` }}>
+      <p>{message}</p>
+      {/* An app can call the server's tools on its own — each call is a round-trip, so plan for latency. */}
+      <button
+        type="button"
+        onClick={() => void app.callServerTool({ name: 'plitzi_search', arguments: {} }).then(setResult)}
+      >
+        Call plitzi_search
+      </button>
+    </div>
+  );
+};
+
+const root = document.getElementById('app');
+if (root) {
+  createRoot(root).render(<ExampleApp />);
+}

package/dist/modules/mcp/apps/index.js

@@ -0,0 +1,12 @@
+import { registerApp } from "./shared/registerApp.js";
+import { RENDER_APP_URI, renderApp } from "./render/index.js";
+//#region src/modules/mcp/apps/index.ts
+/** Every MCP App this server serves. A new one is a folder beside `render/` (its definition + its view) and one
+*  line here — the tool that opens it points at its `uri` through `ui: { resourceUri }`. Start from `example/`,
+*  which is that same shape stripped to the minimum. */
+var apps = [renderApp];
+var registerApps = (server) => {
+	for (const app of apps) registerApp(server, app);
+};
+//#endregion
+export { RENDER_APP_URI, apps, registerApps };

package/dist/modules/mcp/apps/render/index.js

@@ -0,0 +1,16 @@
+import { require } from "../shared/resolve.js";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+//#region src/modules/mcp/apps/render/index.ts
+var RENDER_APP_URI = "ui://plitzi/render.html";
+var HERE = path.dirname(fileURLToPath(import.meta.url));
+var renderApp = {
+	uri: RENDER_APP_URI,
+	name: "plitzi-render-app",
+	title: "Plitzi widget",
+	description: "Interactive view that renders a plitzi_render widget with the Plitzi SDK.",
+	entry: path.join(HERE, "view.tsx"),
+	styles: () => [path.join(path.dirname(require.resolve("@plitzi/plitzi-sdk")), "plitzi-sdk.css")]
+};
+//#endregion
+export { RENDER_APP_URI, renderApp };

package/dist/modules/mcp/apps/render/view.tsx

@@ -0,0 +1,108 @@
+/* eslint-disable react-refresh/only-export-components -- one bundled entry: components cannot move out. */
+import { useApp, useHostStyles } from '@modelcontextprotocol/ext-apps/react';
+import PlitziSdk from '@plitzi/plitzi-sdk';
+import { Component, useEffect, useState } from 'react';
+import { createRoot } from 'react-dom/client';
+
+import type { McpUiHostContext } from '@modelcontextprotocol/ext-apps';
+import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import type { OfflineDataRaw } from '@plitzi/sdk-shared';
+import type { ReactNode } from 'react';
+
+/** The view for plitzi_render: the entry the server bundles (React, the MCP Apps runtime and the Plitzi SDK
+ *  included) and inlines in the shared ui:// page shell — which is what lets it run in a sandbox that can fetch
+ *  nothing. It mounts on `#app`, the shell's root. */
+
+const panelStyle = { padding: 16, font: '13px/1.5 system-ui, sans-serif', color: '#b91c1c' } as const;
+
+// Every failure ends up here: an iframe left on its placeholder would hide the reason in the sandbox's console.
+const ErrorPanel = ({ title, details }: { title: string; details: string }) => (
+  <div style={panelStyle}>
+    <strong>{title}</strong>
+    <pre style={{ margin: '8px 0 0', whiteSpace: 'pre-wrap', color: '#7f1d1d', fontSize: 12 }}>{details}</pre>
+  </div>
+);
+
+class RenderBoundary extends Component<{ children: ReactNode }, { error?: Error }> {
+  state: { error?: Error } = {};
+
+  static getDerivedStateFromError(error: Error) {
+    return { error };
+  }
+
+  render() {
+    if (this.state.error) {
+      return <ErrorPanel title="Widget failed to render" details={this.state.error.message} />;
+    }
+
+    return this.props.children;
+  }
+}
+
+const RenderApp = () => {
+  const [result, setResult] = useState<CallToolResult | null>(null);
+  const [cancelled, setCancelled] = useState<string | undefined>(undefined);
+  const [context, setContext] = useState<McpUiHostContext | undefined>(undefined);
+
+  // useApp creates the App, runs onAppCreated so every handler is in place BEFORE the handshake, and connects.
+  const { app, error } = useApp({
+    appInfo: { name: 'Plitzi Widget', version: '1.0.0' },
+    capabilities: {},
+    onAppCreated: instance => {
+      instance.ontoolresult = setResult;
+      instance.ontoolcancelled = params => setCancelled(params.reason ?? 'The host cancelled the render.');
+      instance.onhostcontextchanged = params => setContext(previous => ({ ...previous, ...params }));
+      instance.onteardown = () => ({});
+    }
+  });
+
+  // The context the host sent in its initialize result predates any change notification.
+  useEffect(() => {
+    if (app) {
+      setContext(app.getHostContext());
+    }
+  }, [app]);
+
+  useHostStyles(app, context);
+
+  const failure = error?.message ?? cancelled;
+  if (failure) {
+    return <ErrorPanel title="Could not render the widget" details={failure} />;
+  }
+
+  // Still connecting, or connected and waiting for the result: the page's CSS placeholder covers both.
+  if (!result) {
+    return null;
+  }
+
+  // The payload rides in structuredContent, which the protocol types as unknown-valued; plitzi_render is the one
+  // guaranteeing the shape, and the SDK validates it again when it renders.
+  const offlineData = result.structuredContent?.offlineData as OfflineDataRaw | undefined;
+  if (!offlineData) {
+    // A failed render answers with its (already compact) reasons as the tool's JSON text summary.
+    const text = result.content.find(entry => entry.type === 'text');
+
+    return <ErrorPanel title="Render failed" details={text?.text ?? 'The tool returned no widget data.'} />;
+  }
+
+  const insets = context?.safeAreaInsets;
+
+  return (
+    <div
+      style={{
+        padding: `${insets?.top ?? 0}px ${insets?.right ?? 0}px ${insets?.bottom ?? 0}px ${insets?.left ?? 0}px`
+      }}
+    >
+      <RenderBoundary>
+        <PlitziSdk offlineData={offlineData} offlineMode environment="main" renderMode="raw" />
+      </RenderBoundary>
+    </div>
+  );
+};
+
+const root = document.getElementById('app');
+if (root) {
+  // The SDK styles its tree from this container class down.
+  root.className = 'plitzi-root-container';
+  createRoot(root).render(<RenderApp />);
+}

package/dist/modules/mcp/apps/shared/bundle.js

@@ -0,0 +1,22 @@
+import { require } from "./resolve.js";
+import { zodEnglishOnly } from "./zodEnglishOnly.js";
+import { build } from "esbuild";
+//#region src/modules/mcp/apps/shared/bundle.ts
+var bundle = async (entry) => {
+	return (await build({
+		entryPoints: [entry],
+		bundle: true,
+		write: false,
+		format: "iife",
+		platform: "browser",
+		target: "es2022",
+		jsx: "automatic",
+		minify: true,
+		alias: { "@plitzi/plitzi-sdk": require.resolve("@plitzi/plitzi-sdk") },
+		define: { "process.env.NODE_ENV": "\"production\"" },
+		plugins: [zodEnglishOnly],
+		logLevel: "silent"
+	})).outputFiles[0].text;
+};
+//#endregion
+export { bundle };

package/dist/modules/mcp/apps/shared/page.js

@@ -0,0 +1,23 @@
+import { bundle } from "./bundle.js";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { readFileSync } from "node:fs";
+import ejs from "ejs";
+//#region src/modules/mcp/apps/shared/page.ts
+var SHELL = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "shell.ejs");
+var template = () => ejs.compile(readFileSync(SHELL, "utf-8"), { filename: SHELL });
+var pages = /* @__PURE__ */ new Map();
+var page = (app) => {
+	let html = pages.get(app.uri);
+	if (!html) {
+		html = bundle(app.entry).then((script) => template()({
+			title: app.title,
+			app: script,
+			css: (app.styles?.() ?? []).map((file) => readFileSync(file, "utf-8")).join("\n")
+		}));
+		pages.set(app.uri, html);
+	}
+	return html;
+};
+//#endregion
+export { page };

package/dist/modules/mcp/apps/shared/registerApp.js

@@ -0,0 +1,27 @@
+import { page } from "./page.js";
+import { RESOURCE_MIME_TYPE, registerAppResource } from "@modelcontextprotocol/ext-apps/server";
+//#region src/modules/mcp/apps/shared/registerApp.ts
+var DEFAULT_CSP = {
+	resourceDomains: [
+		"*",
+		"data:",
+		"blob:"
+	],
+	connectDomains: ["*"]
+};
+/** Serves the app as a self-contained page: no import map, no asset mounts, no cross-origin fetches, so the
+*  strictest host sandbox runs it and no deployment has to serve anything extra. */
+var registerApp = (server, app) => {
+	const meta = { ui: { csp: app.csp ?? DEFAULT_CSP } };
+	registerAppResource(server, app.name, app.uri, {
+		description: app.description,
+		_meta: meta
+	}, async () => ({ contents: [{
+		uri: app.uri,
+		mimeType: RESOURCE_MIME_TYPE,
+		text: await page(app),
+		_meta: meta
+	}] }));
+};
+//#endregion
+export { registerApp };

package/dist/modules/mcp/apps/shared/resolve.js

@@ -0,0 +1,5 @@
+import { createRequire } from "node:module";
+//#region src/modules/mcp/apps/shared/resolve.ts
+var require = createRequire(import.meta.url);
+//#endregion
+export { require };

package/dist/modules/mcp/apps/shared/shell.ejs

@@ -0,0 +1,37 @@
+<%#
+  The page shell every MCP App shares. The host renders it in a sandboxed iframe on ITS OWN origin: the app and
+  its styles are inlined, so the page fetches NOTHING and runs under a deny-by-default sandbox CSP.
+-%>
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title><%= title %></title>
+
+    <style>
+      html,
+      body {
+        margin: 0;
+      }
+      /* The app renders nothing until the host pushes the tool result in. */
+      #app:empty::after {
+        content: 'Rendering…';
+        display: block;
+        padding: 16px;
+        font: 14px system-ui, sans-serif;
+        color: #64748b;
+      }
+    </style>
+    <style>
+<%- css %>
+    </style>
+  </head>
+  <body>
+    <div id="app"></div>
+
+    <script>
+<%- app %>
+    </script>
+  </body>
+</html>

package/dist/modules/mcp/apps/shared/zodEnglishOnly.js

@@ -0,0 +1,23 @@
+//#region src/modules/mcp/apps/shared/zodEnglishOnly.ts
+var NAMESPACE = "zod-locales-stub";
+var ZOD_PACKAGE = /node_modules[/\\]zod[/\\]/u;
+/** Drops zod's ~40 translations (194 KB): they are re-exported as a namespace, which no bundler can tree-shake.
+*  English survives because zod imports `locales/en.js` directly, not through this index. */
+var zodEnglishOnly = {
+	name: "zod-english-only",
+	setup(builder) {
+		builder.onResolve({ filter: /locales[/\\]index\.js$/ }, (args) => ZOD_PACKAGE.test(args.importer) ? {
+			path: args.path,
+			namespace: NAMESPACE
+		} : void 0);
+		builder.onLoad({
+			filter: /.*/,
+			namespace: NAMESPACE
+		}, () => ({
+			contents: "export {};",
+			loader: "js"
+		}));
+	}
+};
+//#endregion
+export { zodEnglishOnly };

package/dist/modules/mcp/handler.js

@@ -1,5 +1,5 @@
 import { createMcpServer } from "./server.js";
-import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 //#region src/modules/mcp/handler.ts
 var readMcpBody = (req) => new Promise((resolve, reject) => {
 	let raw = "";
@@ -15,6 +15,10 @@ var readMcpBody = (req) => new Promise((resolve, reject) => {
 	});
 	req.on("error", reject);
 });
+var operationOf = (body) => {
+	if (Array.isArray(body)) return `batch(${body.length})`;
+	if (typeof body === "object" && body !== null && "method" in body && typeof body.method === "string") return body.method;
+};
 var serveMcp = async (raw, res, server) => {
 	res.setHeader("Access-Control-Allow-Origin", "*");
 	res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
@@ -60,17 +64,15 @@ var serveMcp = async (raw, res, server) => {
 			return;
 		}
 		await transport.handleRequest(raw, res, body);
+		return operationOf(body);
 	} finally {
 		await transport.close();
 	}
 };
-var handleMcp = (raw, res, req, adapters, preview, screenshot, logger, renderApp) => serveMcp(raw, res, createMcpServer({
+var handleMcp = (raw, res, req, adapters, options = {}) => serveMcp(raw, res, createMcpServer({
 	adapters,
 	getSpaceId: () => adapters.getSpaceId?.(req) ?? Promise.resolve(void 0),
-	preview,
-	screenshot,
-	logger,
-	renderApp
+	...options
 }));
 //#endregion
 export { createMcpServer, handleMcp, readMcpBody, serveMcp };

package/dist/modules/mcp/helpers/log.js

@@ -1,7 +1,19 @@
+import { renderLogEvent } from "../../../helpers/serverLog.js";
 //#region src/modules/mcp/helpers/log.ts
 var MCP_DEBUG = process.env.MCP_DEBUG === "1";
-var summarize = (value, max = 300) => {
-	if (value === void 0) return;
+var MCP_LOG_ARGS = process.env.MCP_LOG_ARGS === "1";
+var shapeOf = (value, depth = 0) => {
+	if (value === null) return "null";
+	if (Array.isArray(value)) return `[${value.length}]`;
+	if (typeof value === "object") {
+		if (depth >= 2) return "{…}";
+		const entries = Object.entries(value);
+		const shown = entries.slice(0, 8).map(([key, item]) => `${key}:${shapeOf(item, depth + 1)}`);
+		return `{${[...shown, ...entries.length > shown.length ? ["…"] : []].join(",")}}`;
+	}
+	return typeof value;
+};
+var rawSummary = (value, max = 300) => {
 	let json;
 	try {
 		json = JSON.stringify(value);
@@ -10,25 +22,23 @@ var summarize = (value, max = 300) => {
 	}
 	return json.length > max ? `${json.slice(0, max)}…` : json;
 };
-var errorText = (error) => error instanceof Error ? error.message : String(error);
-var consoleRender = (event) => {
-	const kind = event.kind === "tool" ? "tools/call" : "resources/read";
-	const detail = event.argsSummary ? ` ${event.argsSummary}` : "";
-	const status = event.ok ? "ok" : `ERROR ${event.error ?? ""}`;
-	console.log(`[mcp] ${kind} ${event.name}${detail} ${Math.round(event.durationMs)}ms ${status}`);
+var summarize = (value) => {
+	if (value === void 0) return;
+	return MCP_LOG_ARGS ? rawSummary(value) : shapeOf(value);
 };
+var errorText = (error) => error instanceof Error ? error.message : String(error);
 var noop = () => void 0;
 var inertLog = {
 	toolCall: noop,
 	resourceRead: noop
 };
-/** Build the request-log sink for one MCP server. Dispatches structured events to the consumer's `logger` when
+/** Build the protocol-log sink for one MCP server. Dispatches structured events to the consumer's `logger` when
 *  provided; otherwise renders to the console when MCP_DEBUG=1; otherwise a no-op. */
 var createMcpLog = (logger) => {
 	if (!logger && !MCP_DEBUG) return inertLog;
 	const emit = (event) => {
 		if (logger) logger(event);
-		else consoleRender(event);
+		else console.log(renderLogEvent(event));
 	};
 	return {
 		toolCall: (name, args, ms, error) => emit({