@fitchmultz/pi-mcp-adapter 8.0.6 → 8.0.8

package/dist/ui-server.js

@@ -7,7 +7,7 @@ import { ContentBlockSchema } from "@modelcontextprotocol/core";
 import { formatAuthRequiredMessage } from "./utils.js";
 import { buildHostHtmlTemplate, buildCspMetaContent } from "./host-html-template.js";
 import { logger } from "./logger.js";
-import { SessionRecoveryAuthRequiredError, withSessionRecovery } from "./session-recovery.js";
+import { SessionRecoveryAuthRequiredError, withSessionRecovery, } from "./session-recovery.js";
 import { ensureToolCallApproved, isToolCallApprovalRequired } from "./tool-approval.js";
 import { extractUiToolVisibility, isUiToolCallableByApp } from "./ui-tool-visibility.js";
 import { createUiMessageHistory } from "./ui-message-history.js";
@@ -68,8 +68,9 @@ export async function startUiServer(options) {
     };
     const updateStreamSummary = (payload) => {
         const envelope = getVisualizationStreamEnvelope(payload?.structuredContent);
-        if (!envelope)
+        if (!envelope) {
             return;
+        }
         if (!streamSummary) {
             streamSummary = {
                 streamId: envelope.streamId,
@@ -83,10 +84,12 @@ export async function startUiServer(options) {
             streamSummary.phases.push(envelope.phase);
         }
         streamSummary.finalStatus = envelope.status;
-        if (envelope.message !== undefined)
+        if (envelope.message !== undefined) {
             streamSummary.lastMessage = envelope.message;
-        else
+        }
+        else {
             delete streamSummary.lastMessage;
+        }
     };
     const serializeEvent = (eventId, name, payload) => {
         return `id: ${eventId}\nevent: ${name}\ndata: ${JSON.stringify(payload)}\n\n`;
@@ -94,8 +97,9 @@ export async function startUiServer(options) {
     const getLatestCheckpointIndex = () => {
         for (let index = eventLog.length - 1; index >= 0; index -= 1) {
             const entry = eventLog[index];
-            if (!entry)
+            if (!entry) {
                 continue;
+            }
             const envelope = getVisualizationStreamEnvelope(entry.payload?.structuredContent);
             if (envelope?.frameType === "checkpoint" || envelope?.frameType === "final") {
                 return index;
@@ -104,8 +108,9 @@ export async function startUiServer(options) {
         return -1;
     };
     const pruneEventLog = () => {
-        if (eventLog.length <= MAX_EVENT_LOG)
+        if (eventLog.length <= MAX_EVENT_LOG) {
             return;
+        }
         const latestCheckpointIndex = getLatestCheckpointIndex();
         if (latestCheckpointIndex > 0) {
             eventLog.splice(0, latestCheckpointIndex);
@@ -115,8 +120,9 @@ export async function startUiServer(options) {
         }
     };
     const pushEvent = (name, payload) => {
-        if (completed)
+        if (completed) {
             return;
+        }
         const eventId = nextEventId++;
         eventLog.push({ id: eventId, name, payload });
         updateStreamSummary(payload);
@@ -159,14 +165,16 @@ export async function startUiServer(options) {
         sseClients.clear();
     };
     const stopWatchdog = () => {
-        if (!watchdog)
+        if (!watchdog) {
             return;
+        }
         clearInterval(watchdog);
         watchdog = null;
     };
     const markCompleted = (reason) => {
-        if (completed)
+        if (completed) {
             return;
+        }
         log.debug("Session completed", { reason });
         pushEvent("session-complete", { reason });
         completed = true;
@@ -189,13 +197,17 @@ export async function startUiServer(options) {
             }
             if (method === "GET" && url.pathname === "/") {
                 if (!url.searchParams.has("session")) {
-                    res.writeHead(200, { "Content-Type": "text/html; charset=utf-8", "Cache-Control": "no-store" });
-                    res.end("<!doctype html><html><head><meta charset=\"utf-8\"><title>MCP UI</title></head>" +
+                    res.writeHead(200, {
+                        "Content-Type": "text/html; charset=utf-8",
+                        "Cache-Control": "no-store",
+                    });
+                    res.end('<!doctype html><html><head><meta charset="utf-8"><title>MCP UI</title></head>' +
                         "<body><p>Open the authenticated MCP UI URL shown by Pi.</p></body></html>");
                     return;
                 }
-                if (!validateTokenQuery(url, sessionToken, res))
+                if (!validateTokenQuery(url, sessionToken, res)) {
                     return;
+                }
                 touchHeartbeat();
                 const html = buildHostHtmlTemplate({
                     sessionToken,
@@ -216,8 +228,9 @@ export async function startUiServer(options) {
                 return;
             }
             if (method === "GET" && url.pathname === "/events") {
-                if (!validateTokenQuery(url, sessionToken, res))
+                if (!validateTokenQuery(url, sessionToken, res)) {
                     return;
+                }
                 touchHeartbeat();
                 log.debug("SSE client connected", { clientCount: sseClients.size + 1 });
                 res.writeHead(200, {
@@ -235,14 +248,16 @@ export async function startUiServer(options) {
                 return;
             }
             if (method === "GET" && url.pathname === "/health") {
-                if (!validateTokenQuery(url, sessionToken, res))
+                if (!validateTokenQuery(url, sessionToken, res)) {
                     return;
+                }
                 sendJson(res, 200, { ok: true, result: { healthy: true } });
                 return;
             }
             if (method === "GET" && url.pathname === "/ui-app") {
-                if (!validateTokenQuery(url, uiResourceToken, res, "resource"))
+                if (!validateTokenQuery(url, uiResourceToken, res, "resource")) {
                     return;
+                }
                 touchHeartbeat();
                 // Enforce host metadata independently of where app HTML places its document head.
                 const cspContent = buildCspMetaContent(options.resource.meta.csp);
@@ -275,13 +290,19 @@ export async function startUiServer(options) {
                 return;
             }
             const body = await parseBody(req, res);
-            if (!body)
+            if (!body) {
                 return;
-            if (!validateTokenBody(body, sessionToken, res))
+            }
+            if (!validateTokenBody(body, sessionToken, res)) {
                 return;
+            }
             // A partial upload is not accepted until its authenticated body is complete.
-            if (completed && (url.pathname === "/proxy/ui/message" || url.pathname === "/proxy/ui/context")) {
-                sendJson(res, 409, { ok: false, error: "UI session is complete; message was not accepted" });
+            if (completed &&
+                (url.pathname === "/proxy/ui/message" || url.pathname === "/proxy/ui/context")) {
+                sendJson(res, 409, {
+                    ok: false,
+                    error: "UI session is complete; message was not accepted",
+                });
                 return;
             }
             const params = body.params ?? {};
@@ -295,28 +316,41 @@ export async function startUiServer(options) {
                 }
                 const connection = options.manager.getConnection(options.serverName);
                 if (!connection || connection.status !== "connected") {
-                    sendJson(res, 503, { ok: false, error: `Server "${options.serverName}" is not connected` });
+                    sendJson(res, 503, {
+                        ok: false,
+                        error: `Server "${options.serverName}" is not connected`,
+                    });
                     return;
                 }
-                if (isServerDisabled(options.config?.mcpServers[options.serverName]) || isServerDisabled(connection.definition)) {
+                if (isServerDisabled(options.config?.mcpServers[options.serverName]) ||
+                    isServerDisabled(connection.definition)) {
                     sendJson(res, 503, { ok: false, error: `Server "${options.serverName}" is disabled` });
                     return;
                 }
                 const definition = options.config?.mcpServers[options.serverName] ?? connection.definition;
                 const toolDefinitions = Array.isArray(connection.tools) ? connection.tools : [];
                 const toolDefinition = toolDefinitions.find((tool) => tool.name === callParams.name);
-                if (!toolDefinition || !isToolAllowed(callParams.name, options.serverName, resolveToolPrefix(definition, options.config?.settings?.toolPrefix), definition?.includeTools, definition?.excludeTools)) {
-                    sendJson(res, 403, { ok: false, error: `MCP tool "${callParams.name}" is not callable by apps` });
+                if (!toolDefinition ||
+                    !isToolAllowed(callParams.name, options.serverName, resolveToolPrefix(definition, options.config?.settings?.toolPrefix), definition?.includeTools, definition?.excludeTools)) {
+                    sendJson(res, 403, {
+                        ok: false,
+                        error: `MCP tool "${callParams.name}" is not callable by apps`,
+                    });
                     return;
                 }
                 const uiVisibility = extractUiToolVisibility(toolDefinition._meta);
                 if (!isUiToolCallableByApp(uiVisibility)) {
-                    sendJson(res, 403, { ok: false, error: `MCP tool "${callParams.name}" is not callable by apps` });
+                    sendJson(res, 403, {
+                        ok: false,
+                        error: `MCP tool "${callParams.name}" is not callable by apps`,
+                    });
                     return;
                 }
                 const callArgs = {
                     name: callParams.name,
-                    arguments: callParams.arguments && typeof callParams.arguments === "object" && !Array.isArray(callParams.arguments)
+                    arguments: callParams.arguments &&
+                        typeof callParams.arguments === "object" &&
+                        !Array.isArray(callParams.arguments)
                         ? callParams.arguments
                         : {},
                 };
@@ -324,15 +358,18 @@ export async function startUiServer(options) {
                     name: callParams.name,
                     originalName: callParams.name,
                     description: toolDefinition?.description ?? "",
-                    ...(toolDefinition?.inputSchema !== undefined ? { inputSchema: toolDefinition.inputSchema } : {}),
+                    ...(toolDefinition?.inputSchema !== undefined
+                        ? { inputSchema: toolDefinition.inputSchema }
+                        : {}),
                     ...(uiVisibility !== undefined ? { uiVisibility } : {}),
                 };
                 const approval = options.state
                     ? await ensureToolCallApproved(options.state, options.serverName, toolMeta, callArgs.arguments, options.state.owner?.signal)
-                    : options.config && isToolCallApprovalRequired(options.config, options.serverName, toolMeta)
+                    : options.config &&
+                        isToolCallApprovalRequired(options.config, options.serverName, toolMeta)
                         ? { ok: false, reason: "approval_required_headless" }
                         : { ok: true };
-                if (approval.ok === false) {
+                if (!approval.ok) {
                     const denied = approval.reason === "denied";
                     const message = denied
                         ? `The user declined approval to run MCP tool "${callParams.name}" on server "${options.serverName}".`
@@ -369,7 +406,7 @@ export async function startUiServer(options) {
                 return;
             }
             if (url.pathname === "/proxy/ui/consent") {
-                const approved = !!params.approved;
+                const approved = Boolean(params.approved);
                 options.consentManager.registerDecision(options.serverName, approved);
                 sendJson(res, 200, { ok: true, result: { approved } });
                 return;
@@ -412,14 +449,23 @@ export async function startUiServer(options) {
             if (url.pathname === "/proxy/ui/context") {
                 const content = params.content;
                 const structuredContent = params.structuredContent;
-                if ((content !== undefined && (!Array.isArray(content) || content.some((block) => !ContentBlockSchema.safeParse(block).success))) ||
-                    (structuredContent !== undefined && (!structuredContent || typeof structuredContent !== "object" || Array.isArray(structuredContent)))) {
+                if ((content !== undefined &&
+                    (!Array.isArray(content) ||
+                        content.some((block) => !ContentBlockSchema.safeParse(block).success))) ||
+                    (structuredContent !== undefined &&
+                        (!structuredContent ||
+                            typeof structuredContent !== "object" ||
+                            Array.isArray(structuredContent)))) {
                     sendJson(res, 400, { ok: false, error: "Invalid update-model-context params" });
                     return;
                 }
                 const ctxParams = {
-                    ...(content !== undefined ? { content: content } : {}),
-                    ...(structuredContent !== undefined ? { structuredContent: structuredContent } : {}),
+                    ...(content !== undefined
+                        ? { content: content }
+                        : {}),
+                    ...(structuredContent !== undefined
+                        ? { structuredContent: structuredContent }
+                        : {}),
                 };
                 const update = createUiModelContextUpdate(ctxParams);
                 if (update) {
@@ -428,7 +474,10 @@ export async function startUiServer(options) {
                         sessionMessages.contexts.shift();
                     }
                 }
-                log.debug("UI context update", { hasContent: !!ctxParams.content, hasUpdate: !!update });
+                log.debug("UI context update", {
+                    hasContent: Boolean(ctxParams.content),
+                    hasUpdate: Boolean(update),
+                });
                 await options.onContextUpdate?.(ctxParams);
                 sendJson(res, 200, { ok: true, result: {} });
                 return;
@@ -490,9 +539,10 @@ export async function startUiServer(options) {
         catch (error) {
             if (error instanceof SessionRecoveryAuthRequiredError) {
                 const fallback = `Server "${options.serverName}" requires OAuth authentication. If mcp is inactive, first mcp_search({ enable: ["gateway"] }). Run mcp({ action: "auth-start", server: "${options.serverName}" }) to get a browser URL, or /mcp-auth ${options.serverName} in an interactive local session.`;
-                const message = error.authMessage ?? (options.config
-                    ? formatAuthRequiredMessage(options.config, options.serverName, fallback)
-                    : fallback);
+                const message = error.authMessage ??
+                    (options.config
+                        ? formatAuthRequiredMessage(options.config, options.serverName, fallback)
+                        : fallback);
                 sendJson(res, 401, { ok: false, error: message });
                 return;
             }
@@ -511,10 +561,12 @@ export async function startUiServer(options) {
         });
     }
     watchdog = setInterval(() => {
-        if (completed)
+        if (completed) {
             return;
-        if (Date.now() - lastHeartbeatAt <= ABANDONED_GRACE_MS)
+        }
+        if (Date.now() - lastHeartbeatAt <= ABANDONED_GRACE_MS) {
             return;
+        }
         markCompleted("stale");
         try {
             server.close();
@@ -599,7 +651,10 @@ async function parseBody(req, res) {
         return body;
     }
     catch (error) {
-        sendJson(res, 400, { ok: false, error: error instanceof Error ? error.message : "Invalid body" });
+        sendJson(res, 400, {
+            ok: false,
+            error: error instanceof Error ? error.message : "Invalid body",
+        });
         return null;
     }
 }
@@ -628,20 +683,23 @@ function readBody(req) {
     });
 }
 function resolvePortCandidates(port) {
-    if (port !== undefined)
+    if (port !== undefined) {
         return [port];
+    }
     const candidates = [];
     const count = MOSHI_DISCOVERY_PORT_END - MOSHI_DISCOVERY_PORT_START + 1;
     for (let offset = 0; offset < count; offset += 1) {
-        const candidate = MOSHI_DISCOVERY_PORT_START + ((nextMoshiDiscoveryPort - MOSHI_DISCOVERY_PORT_START + offset) % count);
+        const candidate = MOSHI_DISCOVERY_PORT_START +
+            ((nextMoshiDiscoveryPort - MOSHI_DISCOVERY_PORT_START + offset) % count);
         candidates.push(candidate);
     }
     candidates.push(0);
     return candidates;
 }
 function rememberMoshiDiscoveryPort(port) {
-    if (port < MOSHI_DISCOVERY_PORT_START || port > MOSHI_DISCOVERY_PORT_END)
+    if (port < MOSHI_DISCOVERY_PORT_START || port > MOSHI_DISCOVERY_PORT_END) {
         return;
+    }
     nextMoshiDiscoveryPort = port >= MOSHI_DISCOVERY_PORT_END ? MOSHI_DISCOVERY_PORT_START : port + 1;
 }
 function isAllowedHost(hostname) {

package/dist/ui-session.js

@@ -3,7 +3,7 @@ import { randomUUID } from "node:crypto";
 import net from "node:net";
 import { UrlElicitationRequiredError } from "@modelcontextprotocol/client";
 import { createUiModelContextUpdate, extractUiPromptText, } from "./types.js";
-import { UI_STREAM_HOST_CONTEXT_KEY, UI_STREAM_REQUEST_META_KEY, UI_STREAM_STRUCTURED_CONTENT_KEY } from "./ui-stream-types.js";
+import { UI_STREAM_HOST_CONTEXT_KEY, UI_STREAM_REQUEST_META_KEY, UI_STREAM_STRUCTURED_CONTENT_KEY, } from "./ui-stream-types.js";
 import { logger } from "./logger.js";
 import { startUiServer } from "./ui-server.js";
 import { isGlimpseAvailable, openGlimpseWindow } from "./glimpse-ui.js";
@@ -18,7 +18,9 @@ export function summarizeUiSessionResult(uiSession) {
         };
     }
     if (!uiSession.windowOpen) {
-        const action = uiSession.reused ? "Updated the suppressed MCP UI session." : "MCP UI window was suppressed.";
+        const action = uiSession.reused
+            ? "Updated the suppressed MCP UI session."
+            : "MCP UI window was suppressed.";
         return {
             message: `${action} Open manually: ${uiSession.url}`,
             uiOpen: false,
@@ -40,7 +42,9 @@ function withStreamEnvelope(result, streamId, sequence) {
     if (!streamId) {
         return result;
     }
-    const structuredContent = result.structuredContent && typeof result.structuredContent === "object" && !Array.isArray(result.structuredContent)
+    const structuredContent = result.structuredContent &&
+        typeof result.structuredContent === "object" &&
+        !Array.isArray(result.structuredContent)
         ? { ...result.structuredContent }
         : {};
     const rawEnvelope = structuredContent[UI_STREAM_STRUCTURED_CONTENT_KEY];
@@ -69,11 +73,13 @@ async function openInBrowser(state, url, signal) {
         return null;
     }
     catch (error) {
-        if (isAbortError(error, signal))
+        if (isAbortError(error, signal)) {
             throw error;
+        }
         const message = error instanceof Error ? error.message : String(error);
-        if (state.owner?.isActive() === false)
+        if (state.owner?.isActive() === false) {
             return null;
+        }
         state.ui?.notify(`MCP UI browser open failed: ${message}`, "warning");
         return message;
     }
@@ -149,10 +155,12 @@ export async function maybeStartUiSession(state, request) {
             existingHandle.sendToolInput(request.toolArgs);
             if (streamToken) {
                 state.manager.registerUiStreamListener(streamToken, (serverName, notification) => {
-                    if (!active || state.uiServer !== existingHandle)
+                    if (!active || state.uiServer !== existingHandle) {
                         return;
-                    if (serverName !== request.serverName)
+                    }
+                    if (serverName !== request.serverName) {
                         return;
+                    }
                     nextStreamSequence += 1;
                     existingHandle.sendResultPatch(withStreamEnvelope(notification.result, streamId, nextStreamSequence));
                 });
@@ -170,20 +178,23 @@ export async function maybeStartUiSession(state, request) {
                 windowOpen: existingHandle.windowOpen ?? true,
                 isActive: () => active && state.uiServer === existingHandle,
                 sendToolResult: (result) => {
-                    if (!active || state.uiServer !== existingHandle)
+                    if (!active || state.uiServer !== existingHandle) {
                         return;
+                    }
                     nextStreamSequence += 1;
                     existingHandle.sendToolResult(withStreamEnvelope(result, streamId, nextStreamSequence));
                 },
                 sendResultPatch: (result) => {
-                    if (!active || state.uiServer !== existingHandle)
+                    if (!active || state.uiServer !== existingHandle) {
                         return;
+                    }
                     nextStreamSequence += 1;
                     existingHandle.sendResultPatch(withStreamEnvelope(result, streamId, nextStreamSequence));
                 },
                 sendToolCancelled: (reason) => {
-                    if (!active || state.uiServer !== existingHandle)
+                    if (!active || state.uiServer !== existingHandle) {
                         return;
+                    }
                     nextStreamSequence += 1;
                     existingHandle.sendToolResult(withStreamEnvelope({
                         isError: true,
@@ -248,7 +259,12 @@ export async function maybeStartUiSession(state, request) {
                     if (state.sendMessage) {
                         state.sendMessage({
                             customType: "mcp-ui-prompt",
-                            content: [{ type: "text", text: `User sent prompt from ${request.serverName} UI: "${prompt}"` }],
+                            content: [
+                                {
+                                    type: "text",
+                                    text: `User sent prompt from ${request.serverName} UI: "${prompt}"`,
+                                },
+                            ],
                             display: `💬 UI Prompt: ${prompt}`,
                             details: { server: request.serverName, tool: request.toolName, prompt },
                         }, { triggerTurn: true });
@@ -262,9 +278,19 @@ export async function maybeStartUiSession(state, request) {
                         const paramsStr = intentParams ? ` ${JSON.stringify(intentParams)}` : "";
                         state.sendMessage({
                             customType: "mcp-ui-intent",
-                            content: [{ type: "text", text: `User triggered intent from ${request.serverName} UI: ${intent}${paramsStr}` }],
+                            content: [
+                                {
+                                    type: "text",
+                                    text: `User triggered intent from ${request.serverName} UI: ${intent}${paramsStr}`,
+                                },
+                            ],
                             display: `🎯 UI Intent: ${intent}`,
-                            details: { server: request.serverName, tool: request.toolName, intent, params: intentParams },
+                            details: {
+                                server: request.serverName,
+                                tool: request.toolName,
+                                intent,
+                                params: intentParams,
+                            },
                         }, { triggerTurn: true });
                         log.debug("Triggered agent turn for UI intent", { intent });
                     }
@@ -279,14 +305,19 @@ export async function maybeStartUiSession(state, request) {
             onContextUpdate: (params) => {
                 const update = createUiModelContextUpdate(params);
                 log.debug("Model context update from UI", {
-                    hasContent: !!params.content,
-                    hasStructured: !!params.structuredContent,
-                    hasUpdate: !!update,
+                    hasContent: Boolean(params.content),
+                    hasStructured: Boolean(params.structuredContent),
+                    hasUpdate: Boolean(update),
                 });
                 if (update && state.sendMessage) {
                     state.sendMessage({
                         customType: "mcp-ui-context",
-                        content: [{ type: "text", text: `User submitted model context from ${request.serverName} UI:\n${update.summary}` }],
+                        content: [
+                            {
+                                type: "text",
+                                text: `User submitted model context from ${request.serverName} UI:\n${update.summary}`,
+                            },
+                        ],
                         display: "UI Context submitted",
                         details: { server: request.serverName, tool: request.toolName, context: update },
                     }, { triggerTurn: true });
@@ -298,12 +329,12 @@ export async function maybeStartUiSession(state, request) {
                 if (state.uiServer === handle) {
                     const messages = handle.getSessionMessages();
                     const stream = handle.getStreamSummary();
-                    const hasContent = !!messages.historyCount ||
+                    const hasContent = Boolean(messages.historyCount) ||
                         messages.prompts.length > 0 ||
                         messages.intents.length > 0 ||
                         messages.notifications.length > 0 ||
                         messages.contexts.length > 0 ||
-                        !!stream;
+                        Boolean(stream);
                     if (hasContent) {
                         state.completedUiSessions.push({
                             serverName: handle.serverName,
@@ -340,10 +371,12 @@ export async function maybeStartUiSession(state, request) {
         }
         if (streamToken) {
             state.manager.registerUiStreamListener(streamToken, (serverName, notification) => {
-                if (!active || state.uiServer !== handle)
+                if (!active || state.uiServer !== handle) {
                     return;
-                if (serverName !== request.serverName)
+                }
+                if (serverName !== request.serverName) {
                     return;
+                }
                 nextStreamSequence += 1;
                 handle.sendResultPatch(withStreamEnvelope(notification.result, streamId, nextStreamSequence));
             });
@@ -361,7 +394,7 @@ export async function maybeStartUiSession(state, request) {
             log.info("Suppressing MCP UI window (MCP_UI_VIEWER=" + viewerPref + ")", { url: handle.url });
         }
         else {
-            const remoteLikely = remoteByEnv || await hasActiveRemoteLogin();
+            const remoteLikely = remoteByEnv || (await hasActiveRemoteLogin());
             const emitRemoteHint = async (openError, openedOnHost = false) => {
                 state.ui?.notify(remoteAccessHint({
                     url: handle.url,
@@ -372,8 +405,7 @@ export async function maybeStartUiSession(state, request) {
                 }), openError === null ? "info" : "warning");
             };
             const glimpseDetected = !remoteByEnv && isGlimpseAvailable();
-            const useGlimpse = !remoteByEnv && (viewerPref === "glimpse" ||
-                (viewerPref !== "browser" && glimpseDetected));
+            const useGlimpse = !remoteByEnv && (viewerPref === "glimpse" || (viewerPref !== "browser" && glimpseDetected));
             if (useGlimpse) {
                 try {
                     const glimpseHtml = `<!DOCTYPE html><html><head><meta charset="utf-8"><style>body{margin:0;padding:0;width:100vw;height:100vh;overflow:hidden}iframe{width:100%;height:100%;border:none}</style></head><body><iframe src="${handle.url}"></iframe></body></html>`;
@@ -382,8 +414,9 @@ export async function maybeStartUiSession(state, request) {
                         width: 1000,
                         height: 800,
                         onClosed: () => {
-                            if (active)
+                            if (active) {
                                 handle.close("glimpse-closed");
+                            }
                         },
                     });
                     if (state.owner?.isActive() === false || runtimeSignal.aborted) {
@@ -431,20 +464,23 @@ export async function maybeStartUiSession(state, request) {
             windowOpen,
             isActive: () => active && state.uiServer === handle,
             sendToolResult: (result) => {
-                if (!active || state.uiServer !== handle)
+                if (!active || state.uiServer !== handle) {
                     return;
+                }
                 nextStreamSequence += 1;
                 handle.sendToolResult(withStreamEnvelope(result, streamId, nextStreamSequence));
             },
             sendResultPatch: (result) => {
-                if (!active || state.uiServer !== handle)
+                if (!active || state.uiServer !== handle) {
                     return;
+                }
                 nextStreamSequence += 1;
                 handle.sendResultPatch(withStreamEnvelope(result, streamId, nextStreamSequence));
             },
             sendToolCancelled: (reason) => {
-                if (!active || state.uiServer !== handle)
+                if (!active || state.uiServer !== handle) {
                     return;
+                }
                 handle.sendToolCancelled(reason);
             },
             close: (reason) => {
@@ -455,8 +491,9 @@ export async function maybeStartUiSession(state, request) {
         };
     }
     catch (error) {
-        if (error instanceof UrlElicitationRequiredError || isAbortError(error, runtimeSignal))
+        if (error instanceof UrlElicitationRequiredError || isAbortError(error, runtimeSignal)) {
             throw error;
+        }
         const message = error instanceof Error ? error.message : String(error);
         log.error("Failed to start UI session", error instanceof Error ? error : undefined);
         state.ui?.notify(`MCP UI unavailable for ${request.toolName} (${request.serverName}): ${message}`, "warning");

package/dist/ui-stream-types.js

@@ -5,7 +5,13 @@ export const UI_STREAM_RESULT_PATCH_METHOD = "notifications/pi-mcp-adapter/ui-re
 export const SERVER_STREAM_RESULT_PATCH_METHOD = "notifications/pi-mcp-adapter/result-patch";
 export const UI_STREAM_STRUCTURED_CONTENT_KEY = "pi-mcp-adapter/stream";
 export const uiStreamModeSchema = z.enum(["eager", "stream-first"]);
-export const visualizationStreamPhaseSchema = z.enum(["shell", "narrative", "structure", "detail", "settled"]);
+export const visualizationStreamPhaseSchema = z.enum([
+    "shell",
+    "narrative",
+    "structure",
+    "detail",
+    "settled",
+]);
 export const visualizationStreamFrameTypeSchema = z.enum(["patch", "checkpoint", "final"]);
 export const visualizationStreamStatusSchema = z.enum(["ok", "error"]);
 const looseRecordSchema = z.record(z.string(), z.unknown());
@@ -26,12 +32,14 @@ export const visualizationStreamEnvelopeSchema = z.object({
     spec: looseRecordSchema.optional(),
     checkpoint: looseRecordSchema.optional(),
 });
-export const uiStreamCallToolResultSchema = z.object({
+export const uiStreamCallToolResultSchema = z
+    .object({
     content: looseArraySchema.optional(),
     structuredContent: looseRecordSchema.optional(),
     isError: z.boolean().optional(),
     _meta: looseRecordSchema.optional(),
-}).passthrough();
+})
+    .passthrough();
 export const uiStreamResultPatchNotificationSchema = z.object({
     method: z.literal(UI_STREAM_RESULT_PATCH_METHOD),
     params: uiStreamCallToolResultSchema,
@@ -49,7 +57,9 @@ export function getUiStreamHostContext(hostContext) {
     return parsed.success ? parsed.data : undefined;
 }
 export function getVisualizationStreamEnvelope(structuredContent) {
-    if (!structuredContent || typeof structuredContent !== "object" || Array.isArray(structuredContent)) {
+    if (!structuredContent ||
+        typeof structuredContent !== "object" ||
+        Array.isArray(structuredContent)) {
         return undefined;
     }
     const candidate = structuredContent[UI_STREAM_STRUCTURED_CONTENT_KEY];

package/dist/ui-tool-visibility.js

@@ -1,20 +1,26 @@
 export function extractUiToolVisibility(meta) {
-    if (!meta || typeof meta !== "object")
+    if (!meta || typeof meta !== "object") {
         return undefined;
+    }
     const ui = meta.ui;
-    if (!ui || typeof ui !== "object" || Array.isArray(ui))
+    if (!ui || typeof ui !== "object" || Array.isArray(ui)) {
         return undefined;
+    }
     const visibility = ui.visibility;
-    if (visibility === undefined)
+    if (visibility === undefined) {
         return undefined;
-    if (!Array.isArray(visibility))
+    }
+    if (!Array.isArray(visibility)) {
         return [];
+    }
     const values = [];
     for (const entry of visibility) {
-        if (entry !== "model" && entry !== "app")
+        if (entry !== "model" && entry !== "app") {
             return [];
-        if (!values.includes(entry))
+        }
+        if (!values.includes(entry)) {
             values.push(entry);
+        }
     }
     return values;
 }