@fitchmultz/pi-mcp-adapter 8.0.6 → 8.0.8

package/dist/tool-result-renderer.js

@@ -34,9 +34,7 @@ class CollapsibleText {
         const safeWidth = Math.max(1, Math.floor(width));
         const charBudget = safeWidth * (this.maxCollapsedLines + 1) * COLLAPSED_RENDER_CHAR_SLACK;
         if (!this.collapsedText || this.collapsedText.charBudget !== charBudget) {
-            const prefix = this.text.length > charBudget
-                ? this.text.slice(0, charBudget)
-                : this.text;
+            const prefix = this.text.length > charBudget ? this.text.slice(0, charBudget) : this.text;
             this.collapsedText = {
                 charBudget,
                 fullyIncluded: prefix === this.text,
@@ -44,18 +42,19 @@ class CollapsibleText {
             };
         }
         const lines = this.collapsedText.text.render(width);
-        if (!this.preTruncated && this.collapsedText.fullyIncluded && lines.length <= this.maxCollapsedLines)
+        if (!this.preTruncated &&
+            this.collapsedText.fullyIncluded &&
+            lines.length <= this.maxCollapsedLines) {
             return lines;
-        return [
-            ...lines.slice(0, this.maxCollapsedLines),
-            ...this.footerText.render(width),
-        ];
+        }
+        return [...lines.slice(0, this.maxCollapsedLines), ...this.footerText.render(width)];
     }
     invalidate() { }
 }
 function truncateText(value, maxChars) {
-    if (value.length <= maxChars)
+    if (value.length <= maxChars) {
         return value;
+    }
     return `${value.slice(0, Math.max(0, maxChars - 1))}…`;
 }
 function formatJsonish(value, maxChars) {
@@ -75,51 +74,65 @@ function formatJsonish(value, maxChars) {
     }
 }
 function hasUsefulObjectContent(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value) && Object.keys(value).length > 0;
+    return (typeof value === "object" &&
+        value !== null &&
+        !Array.isArray(value) &&
+        Object.keys(value).length > 0);
 }
 export function formatMcpProxyToolCallLines(args, maxInputChars = DEFAULT_MAX_CALL_INPUT_CHARS) {
-    if (args.action === "ui-messages" || args.action === "status")
+    if (args.action === "ui-messages" || args.action === "status") {
         return [`mcp ${args.action}`];
+    }
     if (args.action) {
         const target = args.tool ?? args.query ?? args.uri ?? args.ref;
         let line = `mcp ${args.action}${target ? ` ${target}` : ""}${args.server ? `${target ? " @" : ""} ${args.server}` : ""}`;
-        if (args.action === "search" && args.includeSchemas === false)
+        if (args.action === "search" && args.includeSchemas === false) {
             line += " (schemas hidden)";
-        return args.action === "call" && args.args ? [line, formatJsonish(args.args, maxInputChars)] : [line];
+        }
+        return args.action === "call" && args.args
+            ? [line, formatJsonish(args.args, maxInputChars)]
+            : [line];
     }
     if (args.tool) {
         const target = args.server ? `${args.tool} @ ${args.server}` : args.tool;
         const lines = [`mcp call ${target}`];
-        if (args.args)
+        if (args.args) {
             lines.push(formatJsonish(args.args, maxInputChars));
+        }
         return lines;
     }
-    if (args.connect)
+    if (args.connect) {
         return [`mcp connect ${args.connect}`];
-    if (args.describe)
+    }
+    if (args.describe) {
         return [`mcp describe ${args.describe}`];
+    }
     if (args.search) {
         let line = `mcp search ${args.search}`;
-        if (args.server)
+        if (args.server) {
             line += ` @ ${args.server}`;
-        if (args.includeSchemas === false)
+        }
+        if (args.includeSchemas === false) {
             line += " (schemas hidden)";
+        }
         return [line];
     }
-    if (args.server)
+    if (args.server) {
         return [`mcp list ${args.server}`];
+    }
     return ["mcp status"];
 }
 export function formatMcpDirectToolCallLines(displayName, args, maxInputChars = DEFAULT_MAX_CALL_INPUT_CHARS) {
-    if (!hasUsefulObjectContent(args))
+    if (!hasUsefulObjectContent(args)) {
         return [displayName];
+    }
     return [displayName, formatJsonish(args, maxInputChars)];
 }
 function renderToolCallLines(lines, theme) {
     const activeTheme = theme ?? plainTheme;
     const [title = "mcp", ...rest] = lines;
     const styledTitle = activeTheme.fg("toolTitle", activeTheme.bold(title));
-    const styledRest = rest.map(line => activeTheme.fg("muted", line));
+    const styledRest = rest.map((line) => activeTheme.fg("muted", line));
     return new Text([styledTitle, ...styledRest].join("\n"), 0, 0);
 }
 export function renderMcpProxyToolCall(args, theme) {
@@ -137,8 +150,9 @@ function blockToLines(block) {
     return [`[image: ${block.mimeType}]`];
 }
 function collectCollapsedResultLines(content, maxLines, maxChars) {
-    if (content.length === 0)
+    if (content.length === 0) {
         return { lines: ["(empty result)"], truncated: false };
+    }
     const lines = [];
     let remainingChars = maxChars;
     let truncated = false;
@@ -159,45 +173,56 @@ function collectCollapsedResultLines(content, maxLines, maxChars) {
     };
     for (const block of content) {
         if (block.type !== "text") {
-            if (!appendLine(`[image: ${block.mimeType}]`))
+            if (!appendLine(`[image: ${block.mimeType}]`)) {
                 break;
+            }
             continue;
         }
         let start = 0;
         while (start <= block.text.length) {
             const newline = block.text.indexOf("\n", start);
             const line = newline === -1 ? block.text.slice(start) : block.text.slice(start, newline);
-            if (!appendLine(line))
+            if (!appendLine(line)) {
                 break;
-            if (newline === -1)
+            }
+            if (newline === -1) {
                 break;
+            }
             start = newline + 1;
         }
-        if (truncated)
+        if (truncated) {
             break;
+        }
     }
-    if (lines.length === 0)
+    if (lines.length === 0) {
         lines.push("");
-    if (truncated && lines.length >= maxLines)
+    }
+    if (truncated && lines.length >= maxLines) {
         lines.push("…");
+    }
     return { lines, truncated };
 }
 export function formatMcpToolResultIdentity(details) {
-    if (details?.mode !== "call")
+    if (details?.mode !== "call") {
         return null;
+    }
     const server = typeof details.server === "string"
         ? details.server
         : typeof details.hintServer === "string"
             ? details.hintServer
             : null;
-    if (!server)
+    if (!server) {
         return null;
-    if (typeof details.tool === "string")
+    }
+    if (typeof details.tool === "string") {
         return `MCP ${server}/${details.tool}`;
-    if (typeof details.resourceUri === "string")
+    }
+    if (typeof details.resourceUri === "string") {
         return `MCP ${server} resource ${details.resourceUri}`;
-    if (typeof details.requestedTool === "string")
+    }
+    if (typeof details.requestedTool === "string") {
         return `MCP ${server}/${details.requestedTool}`;
+    }
     return null;
 }
 export function formatMcpToolResultLines(result, expanded, maxCollapsedLines = 3, maxCollapsedChars = DEFAULT_MAX_COLLAPSED_CHARS) {

package/dist/types.d.ts

@@ -7,7 +7,7 @@ import type { UiToolVisibility } from "./ui-tool-visibility.ts";
 export type Transport = McpTransport;
 /** Versioned shared-event-bus channel for read-only MCP runtime snapshots. */
 export declare const MCP_STATUS_EVENT = "fitch-mcp-adapter/status/v1";
-export declare const MCP_STATUS_SNAPSHOT_VERSION: 1;
+export declare const MCP_STATUS_SNAPSHOT_VERSION = 1;
 export type McpServerRuntimeStatus = "connected" | "cached" | "failed" | "needs-auth" | "not-connected" | "disabled";
 export interface McpServerStatusSnapshot {
     readonly name: string;
@@ -209,7 +209,7 @@ export interface OAuthCrossAppAccessConfig {
     /** Optional IdP client_secret_post credential, also resolved lazily. */
     clientSecret?: string;
 }
-export declare function isNonInteractiveOAuth(config: OAuthConfig | false | undefined): boolean;
+export declare function isNonInteractiveOAuth(config: OAuthConfig | false | null | undefined): boolean;
 export interface OAuthConfig {
     /** Skip only authorization-server metadata issuer validation. Defaults to false. */
     skipIssuerMetadataValidation?: boolean;

package/dist/types.js

@@ -11,7 +11,9 @@ export function extractUiPromptText(params) {
     }
     if (params.role === "user" && Array.isArray(params.content)) {
         const text = params.content
-            .map((block) => (block && typeof block === "object" && "text" in block ? String(block.text ?? "") : ""))
+            .map((block) => block && typeof block === "object" && "text" in block
+            ? String(block.text ?? "")
+            : "")
             .filter(Boolean)
             .join("\n\n");
         return text || undefined;
@@ -51,8 +53,9 @@ export function parseUiPromptHandoff(prompt) {
 }
 export function createUiModelContextUpdate(params, maxChars = 12_000) {
     const payload = Object.fromEntries(Object.entries(params).filter(([, value]) => value !== undefined));
-    if (Object.keys(payload).length === 0)
+    if (Object.keys(payload).length === 0) {
         return undefined;
+    }
     const serialized = JSON.stringify(payload);
     if (serialized.length <= maxChars) {
         return { payload, summary: serialized, truncated: false };
@@ -63,18 +66,25 @@ export function createUiModelContextUpdate(params, maxChars = 12_000) {
     };
 }
 export function isNonInteractiveOAuth(config) {
-    return !!config && (config.grantType === "client_credentials" || config.crossAppAccess !== undefined);
+    return (config !== false &&
+        config !== null &&
+        config !== undefined &&
+        (config.grantType === "client_credentials" || config.crossAppAccess !== undefined));
 }
 /** Validate protocol options for both file and in-memory configurations. */
 export function validateServerProtocolConfig(definition) {
-    if (definition.protocolVersion !== undefined && definition.protocolVersion !== "auto" && definition.protocolVersion !== "legacy") {
+    if (definition.protocolVersion !== undefined &&
+        definition.protocolVersion !== "auto" &&
+        definition.protocolVersion !== "legacy") {
         throw new Error("protocolVersion must be auto or legacy");
     }
-    if (definition.retryOnTransportFailure !== undefined && typeof definition.retryOnTransportFailure !== "boolean") {
+    if (definition.retryOnTransportFailure !== undefined &&
+        typeof definition.retryOnTransportFailure !== "boolean") {
         throw new Error("retryOnTransportFailure must be a boolean");
     }
-    if (definition.oauth && definition.oauth.skipIssuerMetadataValidation !== undefined
-        && typeof definition.oauth.skipIssuerMetadataValidation !== "boolean") {
+    if (definition.oauth &&
+        definition.oauth.skipIssuerMetadataValidation !== undefined &&
+        typeof definition.oauth.skipIssuerMetadataValidation !== "boolean") {
         throw new Error("oauth.skipIssuerMetadataValidation must be a boolean");
     }
 }
@@ -86,16 +96,19 @@ export function isServerDisabled(definition) {
  * Get server prefix based on tool prefix mode.
  */
 export function getServerPrefix(serverName, mode) {
-    if (mode === "none")
+    if (mode === "none") {
         return "";
+    }
     if (mode === "short") {
         let short = serverName.replace(/-?mcp$/i, "").replace(/-/g, "_");
-        if (!short)
+        if (!short) {
             short = "mcp";
+        }
         return short;
     }
-    if (mode === "mcp")
+    if (mode === "mcp") {
         return `mcp__${serverName.replace(/-/g, "_")}`;
+    }
     return serverName.replace(/-/g, "_");
 }
 /**
@@ -111,8 +124,9 @@ export function resolveToolPrefix(definition, globalPrefix) {
 }
 export function sanitizePromptName(name) {
     const cleaned = name.replace(/[^A-Za-z0-9_-]+/g, "_").replace(/^[_-]+|[_-]+$/g, "");
-    if (!cleaned)
+    if (!cleaned) {
         return "prompt";
+    }
     return /^[0-9]/.test(cleaned) ? `_${cleaned}` : cleaned;
 }
 export function formatPromptCommandName(promptName, serverName, prefix) {
@@ -132,34 +146,41 @@ export function getToolNameCandidates(toolName, serverName, prefix) {
     ]);
 }
 function globToRegExp(pattern) {
-    const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
+    const escaped = pattern
+        .replace(/[.+^${}()|[\]\\]/g, "\\$&")
+        .replace(/\*/g, ".*")
+        .replace(/\?/g, ".");
     return new RegExp(`^${escaped}$`);
 }
 export function matchesToolPattern(candidates, patterns) {
-    if (!Array.isArray(patterns) || patterns.length === 0)
+    if (!Array.isArray(patterns) || patterns.length === 0) {
         return false;
+    }
     for (const pattern of patterns) {
-        if (typeof pattern !== "string")
+        if (typeof pattern !== "string") {
             continue;
+        }
         const normalized = normalizeToolName(pattern);
         if (!normalized.includes("*") && !normalized.includes("?") && candidates.has(normalized)) {
             return true;
         }
-        if ((normalized.includes("*") || normalized.includes("?")) && [...candidates].some(candidate => globToRegExp(normalized).test(candidate))) {
+        if ((normalized.includes("*") || normalized.includes("?")) &&
+            [...candidates].some((candidate) => globToRegExp(normalized).test(candidate))) {
             return true;
         }
     }
     return false;
 }
 export function isToolIncluded(toolName, serverName, prefix, includeTools) {
-    if (!Array.isArray(includeTools) || includeTools.length === 0)
+    if (!Array.isArray(includeTools) || includeTools.length === 0) {
         return true;
+    }
     return matchesToolPattern(getToolNameCandidates(toolName, serverName, prefix), includeTools);
 }
 export function isToolExcluded(toolName, serverName, prefix, excludeTools) {
     return matchesToolPattern(getToolNameCandidates(toolName, serverName, prefix), excludeTools);
 }
 export function isToolAllowed(toolName, serverName, prefix, includeTools, excludeTools) {
-    return isToolIncluded(toolName, serverName, prefix, includeTools)
-        && !isToolExcluded(toolName, serverName, prefix, excludeTools);
+    return (isToolIncluded(toolName, serverName, prefix, includeTools) &&
+        !isToolExcluded(toolName, serverName, prefix, excludeTools));
 }

package/dist/ui-message-history.js

@@ -12,12 +12,14 @@ export function createUiMessageHistory(outputDirectory) {
         messages,
         append(category, value) {
             try {
-                if (failed)
+                if (failed) {
                     throw new Error(messages.historyError);
+                }
                 if (!messages.historyRef) {
                     const root = outputDirectory === undefined ? tmpdir() : resolve(outputDirectory);
-                    if (outputDirectory !== undefined)
+                    if (outputDirectory !== undefined) {
                         mkdirSync(root, { recursive: true, mode: 0o700 });
+                    }
                     const dir = mkdtempSync(join(root, "pi-mcp-output-"));
                     const ref = join(dir, `output-${randomBytes(4).toString("hex")}.txt`);
                     writeFileSync(ref, "", { mode: 0o600 });
@@ -35,10 +37,12 @@ export function createUiMessageHistory(outputDirectory) {
             catch (error) {
                 failed = true;
                 messages.historyError = error instanceof Error ? error.message : String(error);
-                if (category === "intents")
+                if (category === "intents") {
                     messages.intents.push(value);
-                else
+                }
+                else {
                     messages[category].push(value);
+                }
                 return `UI history could not be saved; messages remain in memory for recovery: ${messages.historyError}. Unsaved messages will be lost on reload or process exit.`;
             }
         },
@@ -47,18 +51,25 @@ export function createUiMessageHistory(outputDirectory) {
 export async function* uiMessages(messages, category) {
     if (messages.historyRef && messages.historyBytes) {
         // A failed partial append is not an accepted event; the in-memory tail owns it instead.
-        const input = createReadStream(messages.historyRef, { encoding: "utf8", end: messages.historyBytes - 1 });
+        const input = createReadStream(messages.historyRef, {
+            encoding: "utf8",
+            end: messages.historyBytes - 1,
+        });
         let bytes = 0, count = 0;
-        input.on("data", chunk => { bytes += Buffer.byteLength(chunk); });
+        input.on("data", (chunk) => {
+            bytes += Buffer.byteLength(chunk);
+        });
         const lines = createInterface({ input, crlfDelay: Infinity });
         try {
             for await (const line of lines) {
                 const record = JSON.parse(line);
                 count++;
-                if (record.category === category)
+                if (record.category === category) {
                     yield record.value;
+                }
             }
-            if (bytes !== messages.historyBytes || (messages.historyCount !== undefined && count !== messages.historyCount)) {
+            if (bytes !== messages.historyBytes ||
+                (messages.historyCount !== undefined && count !== messages.historyCount)) {
                 throw new Error("UI history is incomplete; accepted messages remain pending recovery");
             }
         }
@@ -67,16 +78,25 @@ export async function* uiMessages(messages, category) {
             input.destroy();
         }
     }
-    for (const value of messages[category])
+    for (const value of messages[category]) {
         yield value;
+    }
 }
 export async function materializeUiMessages(messages) {
-    const result = { prompts: [], intents: [], notifications: [], contexts: messages.contexts };
-    for await (const value of uiMessages(messages, "prompts"))
+    const result = {
+        prompts: [],
+        intents: [],
+        notifications: [],
+        contexts: messages.contexts,
+    };
+    for await (const value of uiMessages(messages, "prompts")) {
         result.prompts.push(value);
-    for await (const value of uiMessages(messages, "intents"))
+    }
+    for await (const value of uiMessages(messages, "intents")) {
         result.intents.push(value);
-    for await (const value of uiMessages(messages, "notifications"))
+    }
+    for await (const value of uiMessages(messages, "notifications")) {
         result.notifications.push(value);
+    }
     return result;
 }

package/dist/ui-resource-handler.d.ts

@@ -8,9 +8,9 @@ interface ReadUiResourceOptions {
     onNeedsAuth?: SessionRecoveryDeps["onNeedsAuth"];
 }
 export declare class UiResourceHandler {
-    private log;
-    private manager;
-    private config;
+    private readonly log;
+    private readonly manager;
+    private readonly config;
     constructor(manager: McpServerManager, config?: McpConfig);
     readUiResource(serverName: string, uri: string, options?: ReadUiResourceOptions): Promise<UiResourceContent>;
     private getListResourceMeta;

package/dist/ui-resource-handler.js

@@ -1,5 +1,5 @@
 import { logger } from "./logger.js";
-import { isServerDisabled } from "./types.js";
+import { isServerDisabled, } from "./types.js";
 // MCP Apps resource media type; metadata reads must not import the app bridge.
 export const RESOURCE_MIME_TYPE = "text/html;profile=mcp-app";
 export class UiResourceHandler {
@@ -11,8 +11,10 @@ export class UiResourceHandler {
         this.config = config;
     }
     async readUiResource(serverName, uri, options = {}) {
-        const { UrlElicitationRequiredError } = await import("@modelcontextprotocol/client");
-        const { SessionRecoveryAuthRequiredError, withSessionRecovery } = await import("./session-recovery.js");
+        const [{ UrlElicitationRequiredError }, { SessionRecoveryAuthRequiredError, withSessionRecovery },] = await Promise.all([
+            import("@modelcontextprotocol/client"),
+            import("./session-recovery.js"),
+        ]);
         const log = this.log.child({ server: serverName, uri });
         if (!uri.startsWith("ui://")) {
             throw new Error(`Invalid UI resource "${uri}": URI must start with ui://`);
@@ -45,8 +47,10 @@ export class UiResourceHandler {
             }
         }
         catch (error) {
-            if (error instanceof UrlElicitationRequiredError || error instanceof SessionRecoveryAuthRequiredError)
+            if (error instanceof UrlElicitationRequiredError ||
+                error instanceof SessionRecoveryAuthRequiredError) {
                 throw error;
+            }
             const message = error instanceof Error ? error.message : String(error);
             log.error("Failed to read resource", error instanceof Error ? error : undefined);
             throw new Error(`Failed to fetch UI resource "${uri}": ${message}`, error instanceof Error ? { cause: error } : undefined);
@@ -66,18 +70,22 @@ export class UiResourceHandler {
         const listMeta = extractUiMeta(this.getListResourceMeta(serverName, uri));
         log.debug("Resource loaded successfully", {
             contentLength: html.length,
-            hasCsp: !!contentMeta.csp || !!listMeta.csp,
+            hasCsp: Boolean(contentMeta.csp) || Boolean(listMeta.csp),
         });
         return {
             uri: content.uri ?? uri,
             html,
             mimeType: mimeType ?? RESOURCE_MIME_TYPE,
             meta: {
-                ...((contentMeta.csp ?? listMeta.csp) !== undefined ? { csp: contentMeta.csp ?? listMeta.csp } : {}),
+                ...((contentMeta.csp ?? listMeta.csp) !== undefined
+                    ? { csp: contentMeta.csp ?? listMeta.csp }
+                    : {}),
                 ...((contentMeta.permissions ?? listMeta.permissions) !== undefined
                     ? { permissions: contentMeta.permissions ?? listMeta.permissions }
                     : {}),
-                ...((contentMeta.domain ?? listMeta.domain) !== undefined ? { domain: contentMeta.domain ?? listMeta.domain } : {}),
+                ...((contentMeta.domain ?? listMeta.domain) !== undefined
+                    ? { domain: contentMeta.domain ?? listMeta.domain }
+                    : {}),
                 ...((contentMeta.prefersBorder ?? listMeta.prefersBorder) !== undefined
                     ? { prefersBorder: contentMeta.prefersBorder ?? listMeta.prefersBorder }
                     : {}),
@@ -86,11 +94,13 @@ export class UiResourceHandler {
     }
     getListResourceMeta(serverName, uri) {
         const connection = this.manager.getConnection(serverName);
-        if (!connection?.resources?.length)
+        if (!connection?.resources?.length) {
             return undefined;
+        }
         const resource = connection.resources.find((entry) => entry.uri === uri);
-        if (!resource || !resource._meta || typeof resource._meta !== "object")
+        if (!resource || !resource._meta || typeof resource._meta !== "object") {
             return undefined;
+        }
         return resource._meta;
     }
 }
@@ -100,11 +110,13 @@ function selectContent(result, preferredUri) {
         throw new Error(`No contents returned for UI resource: ${preferredUri}`);
     }
     const byUri = contents.find((content) => content.uri === preferredUri);
-    if (byUri)
+    if (byUri) {
         return byUri;
+    }
     const byHtmlMime = contents.find((content) => content.mimeType && isHtmlMimeType(content.mimeType));
-    if (byHtmlMime)
+    if (byHtmlMime) {
         return byHtmlMime;
+    }
     const firstContent = contents[0];
     if (!firstContent) {
         throw new Error(`No contents returned for UI resource: ${preferredUri}`);
@@ -136,28 +148,28 @@ const UI_CSP_DOMAIN_FIELDS = [
     "baseUriDomains",
 ];
 function extractUiMeta(meta) {
-    if (!meta || typeof meta !== "object")
+    if (!meta || typeof meta !== "object") {
         return {};
+    }
     const ui = isRecord(meta.ui) ? meta.ui : undefined;
     const out = {};
     const openAiCsp = hasOwnProperty(meta, "openai/widgetCSP")
         ? normalizeOpenAiWidgetCsp(meta["openai/widgetCSP"])
         : undefined;
-    const hasStandardCsp = !!ui && hasOwnProperty(ui, "csp");
+    const hasStandardCsp = ui !== undefined && hasOwnProperty(ui, "csp");
     const standardCspValue = hasStandardCsp ? ui.csp : undefined;
     if (hasStandardCsp && !isRecord(standardCspValue)) {
         // A declared canonical container takes precedence even when malformed.
         out.csp = {};
     }
     else {
-        const standardCsp = hasStandardCsp
-            ? normalizeUiResourceCsp(standardCspValue)
-            : undefined;
+        const standardCsp = hasStandardCsp ? normalizeUiResourceCsp(standardCspValue) : undefined;
         if (openAiCsp || standardCsp) {
             out.csp = { ...openAiCsp, ...standardCsp };
             if (isRecord(standardCspValue)) {
                 for (const [, standardField] of OPENAI_CSP_FIELD_MAPPINGS) {
-                    if (hasOwnProperty(standardCspValue, standardField) && !copyStringArray(standardCspValue[standardField])) {
+                    if (hasOwnProperty(standardCspValue, standardField) &&
+                        !copyStringArray(standardCspValue[standardField])) {
                         delete out.csp[standardField];
                     }
                 }
@@ -176,24 +188,28 @@ function extractUiMeta(meta) {
     return out;
 }
 function normalizeUiResourceCsp(value) {
-    if (!isRecord(value))
+    if (!isRecord(value)) {
         return {};
+    }
     const csp = {};
     for (const field of UI_CSP_DOMAIN_FIELDS) {
         const domains = copyStringArray(value[field]);
-        if (domains)
+        if (domains) {
             csp[field] = domains;
+        }
     }
     return csp;
 }
 function normalizeOpenAiWidgetCsp(value) {
-    if (!isRecord(value))
+    if (!isRecord(value)) {
         return {};
+    }
     const csp = {};
     for (const [sourceField, targetField] of OPENAI_CSP_FIELD_MAPPINGS) {
         const domains = copyStringArray(value[sourceField]);
-        if (domains)
+        if (domains) {
             csp[targetField] = domains;
+        }
     }
     return csp;
 }