@ashx-j/lunr-dev 0.2.13-dev.8.1 → 0.2.16-dev.9.1

package/dist/node-runtime/chunk-F4VQFJI2.js

@@ -0,0 +1,1269 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  AZ,
+  ServerError,
+  logger,
+  wrapError
+} from "./chunk-MKKH27PH.js";
+import {
+  UrlElicitationRequiredError
+} from "./chunk-4TLO4PO2.js";
+import {
+  UI_STREAM_HOST_CONTEXT_KEY,
+  UI_STREAM_REQUEST_META_KEY,
+  UI_STREAM_STRUCTURED_CONTENT_KEY,
+  extractUiPromptText,
+  getVisualizationStreamEnvelope
+} from "./chunk-ARC4KOTI.js";
+
+// packages/coding-agent/dist/builtin-extensions/pi-mcp-adapter/tool-registrar.js
+function transformMcpContent(content) {
+  return content.map((c) => {
+    if (c.type === "text")
+      return { type: "text", text: c.text ?? "" };
+    if (c.type === "image")
+      return {
+        type: "image",
+        data: c.data ?? "",
+        mimeType: c.mimeType ?? "image/png"
+      };
+    if (c.type === "resource") {
+      let resourceUri = c.resource?.uri ?? "(no URI)", resourceContent = c.resource?.text ?? (c.resource ? JSON.stringify(c.resource) : "(no content)");
+      return {
+        type: "text",
+        text: `[Resource: ${resourceUri}]
+${resourceContent}`
+      };
+    }
+    if (c.type === "resource_link") {
+      let linkName = c.name ?? c.uri ?? "unknown", linkUri = c.uri ?? "(no URI)";
+      return {
+        type: "text",
+        text: `[Resource Link: ${linkName}]
+URI: ${linkUri}`
+      };
+    }
+    return c.type === "audio" ? {
+      type: "text",
+      text: `[Audio content: ${c.mimeType ?? "audio/*"}]`
+    } : { type: "text", text: JSON.stringify(c) };
+  });
+}
+function resolveMcpResultContent(result) {
+  let blocks = transformMcpContent(Array.isArray(result.content) ? result.content : []);
+  return blocks.length > 0 ? blocks : result.structuredContent !== void 0 && result.structuredContent !== null ? [{ type: "text", text: stringifyStructuredContent(result.structuredContent) }] : [];
+}
+function stringifyStructuredContent(value) {
+  try {
+    return JSON.stringify(value, null, 2) ?? String(value);
+  } catch {
+    return String(value);
+  }
+}
+
+// packages/coding-agent/dist/builtin-extensions/pi-mcp-adapter/mcp-output-guard.js
+import { randomBytes } from "node:crypto";
+import { mkdtemp, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+var DEFAULT_MCP_OUTPUT_MAX_BYTES = 50 * 1024, DEFAULT_MCP_OUTPUT_MAX_LINES = 2e3, DEFAULT_MCP_DETAILS_MAX_BYTES = 16 * 1024, CONTENT_SUMMARY_LIMIT = 20, KEY_PREVIEW_LIMIT = 20, KEY_MAX_CHARS = 120;
+function resolveMcpOutputGuardOptions(settings) {
+  let configured = settings?.outputGuard, tuning = typeof configured == "object" && configured !== null ? configured : void 0;
+  return {
+    enabled: envKillSwitch("MCP_OUTPUT_GUARD") ?? configured !== !1,
+    maxBytes: positiveInt(tuning?.maxBytes) ?? DEFAULT_MCP_OUTPUT_MAX_BYTES,
+    maxLines: positiveInt(tuning?.maxLines) ?? DEFAULT_MCP_OUTPUT_MAX_LINES,
+    detailsMaxBytes: positiveInt(tuning?.detailsMaxBytes) ?? DEFAULT_MCP_DETAILS_MAX_BYTES
+  };
+}
+function guardedMcpDetails(guarded) {
+  return {
+    ...guarded.mcpResult !== void 0 ? { mcpResult: guarded.mcpResult } : {},
+    ...guarded.outputGuard ? { outputGuard: guarded.outputGuard } : {}
+  };
+}
+async function guardMcpOutput(content, options = {}) {
+  let maxBytes = options.maxBytes ?? DEFAULT_MCP_OUTPUT_MAX_BYTES, maxLines = options.maxLines ?? DEFAULT_MCP_OUTPUT_MAX_LINES, detailsMaxBytes = options.detailsMaxBytes ?? DEFAULT_MCP_DETAILS_MAX_BYTES, prefix = options.prefix ?? "", suffix = options.suffix ?? "", normalizedContent = withEmptyTextFallback(content.length > 0 ? sanitizeContent(content) : [{ type: "text", text: options.emptyTextFallback ?? "(empty result)" }], options.emptyTextFallback);
+  if (options.enabled === !1)
+    return {
+      content: addAffixes(normalizedContent, prefix, suffix),
+      mcpResult: options.rawMcpResult
+    };
+  let imageBlocks = normalizedContent.filter((block) => block.type === "image"), textOutput = normalizedContent.filter((block) => block.type === "text").map((block) => block.text).join(`
+`), composedOutput = `${prefix}${textOutput}${suffix}`, stats = textStats(composedOutput), guardedContent = addAffixes(normalizedContent, prefix, suffix), outputGuard;
+  if (stats.bytes > maxBytes || stats.lines > maxLines) {
+    let { path: fullOutputPath, error: writeError } = await saveArtifact("output", composedOutput), notice = formatTruncationNotice(stats, fullOutputPath, writeError), previewBudget = reserveBudget(maxBytes, maxLines, notice), finalText = `${truncateHead(composedOutput, previewBudget.maxBytes, previewBudget.maxLines).content}
+
+${notice}`, finalStats = textStats(finalText);
+    guardedContent = [{ type: "text", text: finalText }, ...imageBlocks], outputGuard = {
+      truncated: !0,
+      originalBytes: stats.bytes,
+      returnedBytes: finalStats.bytes,
+      originalLines: stats.lines,
+      returnedLines: finalStats.lines,
+      ...imageBlocks.length > 0 ? { imageBlocksPassedThrough: imageBlocks.length } : {},
+      fullOutputPath,
+      writeError
+    };
+  }
+  let mcpResult = options.rawMcpResult === void 0 ? void 0 : await boundMcpResult(options.rawMcpResult, detailsMaxBytes);
+  return { content: guardedContent, outputGuard, mcpResult };
+}
+function sanitizeContent(content) {
+  return content.map((block) => {
+    if (block.type !== "image")
+      return block;
+    let mimeType = typeof block.mimeType == "string" && block.mimeType.trim() ? block.mimeType.trim().slice(0, 100) : "image/png";
+    return { ...block, mimeType };
+  });
+}
+function withEmptyTextFallback(content, fallback) {
+  return !fallback || content.filter((block) => block.type === "text").map((block) => block.text).join(`
+`) ? content : [{ type: "text", text: fallback }, ...content.filter((block) => block.type === "image")];
+}
+function addAffixes(content, prefix, suffix) {
+  if (!prefix && !suffix)
+    return content;
+  let next = [...content];
+  if (prefix) {
+    let index = next.findIndex((block2) => block2.type === "text"), block = next[index];
+    index >= 0 && block.type === "text" ? next[index] = { ...block, text: `${prefix}${block.text}` } : next.unshift({ type: "text", text: prefix });
+  }
+  if (suffix) {
+    let index = -1;
+    for (let i = next.length - 1; i >= 0; i--)
+      if (next[i].type === "text") {
+        index = i;
+        break;
+      }
+    let block = next[index];
+    index >= 0 && block.type === "text" ? next[index] = { ...block, text: `${block.text}${suffix}` } : next.push({ type: "text", text: suffix });
+  }
+  return next;
+}
+function reserveBudget(maxBytes, maxLines, notice) {
+  let noticeStats = textStats(`
+
+${notice}`);
+  return {
+    maxBytes: Math.max(0, maxBytes - noticeStats.bytes),
+    maxLines: Math.max(0, maxLines - noticeStats.lines)
+  };
+}
+function truncateHead(text, maxBytes, maxLines) {
+  let lines = text.split(`
+`), output = [], bytes = 0;
+  for (let line of lines) {
+    if (output.length >= maxLines)
+      break;
+    let separatorBytes = output.length > 0 ? 1 : 0, lineBytes = byteLength(line);
+    if (bytes + separatorBytes + lineBytes > maxBytes) {
+      let remaining = maxBytes - bytes - separatorBytes;
+      remaining > 0 && output.push(truncateStringToBytes(line, remaining));
+      break;
+    }
+    output.push(line), bytes += separatorBytes + lineBytes;
+  }
+  let content = output.join(`
+`), stats = textStats(content);
+  return { content, bytes: stats.bytes, lines: stats.lines };
+}
+function truncateStringToBytes(value, maxBytes) {
+  if (byteLength(value) <= maxBytes)
+    return value;
+  let buffer = Buffer.from(value, "utf8"), end = Math.max(0, maxBytes);
+  for (; end > 0 && (buffer[end] & 192) === 128; )
+    end--;
+  return buffer.subarray(0, end).toString("utf8");
+}
+function formatTruncationNotice(stats, fullOutputPath, writeError) {
+  let base = `[MCP text output truncated: original ${stats.lines.toLocaleString()} lines / ${formatSize(stats.bytes)}.`;
+  return fullOutputPath ? `${base} Full text saved to: ${fullOutputPath} \u2014 use read with offset/limit or grep to inspect.]` : `${base} Full output could not be saved: ${writeError ?? "unknown error"}]`;
+}
+async function boundMcpResult(result, detailsMaxBytes) {
+  let raw = safeStringify(result), rawBytes = byteLength(raw);
+  return rawBytes <= detailsMaxBytes ? result : summarizeMcpResult(result, raw, rawBytes);
+}
+async function summarizeMcpResult(result, raw, rawBytes) {
+  let { path: fullResultPath, error: resultWriteError } = await saveArtifact("mcp-result", raw), record = asRecord(result), content = Array.isArray(record?.content) ? record.content : [], summary = {
+    omitted: !0,
+    reason: "Raw MCP result exceeded the details size limit and was replaced with this summary to keep session context bounded.",
+    isError: record?.isError === !0,
+    contentBlocks: content.length,
+    contentSummary: summarizeContent(content),
+    rawResultBytes: rawBytes,
+    fullResultPath,
+    resultWriteError
+  };
+  if (record && "structuredContent" in record && (summary.structuredContent = summarizeValue(record.structuredContent)), record && "_meta" in record && (summary.meta = summarizeValue(record._meta)), record) {
+    let standard = /* @__PURE__ */ new Set(["content", "isError", "structuredContent", "_meta"]), extraFields = Object.keys(record).filter((key) => !standard.has(key)).slice(0, KEY_PREVIEW_LIMIT).map((key) => ({ key: truncateKey(key), type: typeof record[key], estimatedBytes: estimateValueBytes(record[key]), omitted: !0 }));
+    extraFields.length > 0 && (summary.extraFields = extraFields);
+  }
+  return summary;
+}
+function summarizeContent(content) {
+  let summaries = content.slice(0, CONTENT_SUMMARY_LIMIT).map((block) => {
+    let record = asRecord(block);
+    if (!record)
+      return { type: typeof block, omitted: !0 };
+    if (record.type === "text") {
+      let text = typeof record.text == "string" ? record.text : "";
+      return { type: "text", bytes: byteLength(text), lines: textStats(text).lines, textOmitted: !0 };
+    }
+    if (record.type === "image") {
+      let data = typeof record.data == "string" ? record.data : "";
+      return { type: "image", mimeType: typeof record.mimeType == "string" ? record.mimeType : void 0, dataBytes: byteLength(data), dataOmitted: !0 };
+    }
+    return { type: typeof record.type == "string" ? record.type : "unknown", estimatedBytes: estimateValueBytes(record), omitted: !0 };
+  });
+  return content.length > CONTENT_SUMMARY_LIMIT && summaries.push({ type: "omitted", count: content.length - CONTENT_SUMMARY_LIMIT }), summaries;
+}
+function summarizeValue(value) {
+  let record = asRecord(value);
+  if (!record)
+    return { type: value === null ? "null" : typeof value, estimatedBytes: estimateValueBytes(value), omitted: !0 };
+  let keys = Object.keys(record);
+  return {
+    type: Array.isArray(value) ? "array" : "object",
+    estimatedBytes: estimateValueBytes(value),
+    keyCount: keys.length,
+    keysPreview: keys.slice(0, KEY_PREVIEW_LIMIT).map(truncateKey),
+    omitted: !0
+  };
+}
+function estimateValueBytes(value, depth = 0) {
+  if (value == null)
+    return 0;
+  if (typeof value == "string")
+    return byteLength(value);
+  if (typeof value == "number" || typeof value == "boolean" || typeof value == "bigint")
+    return byteLength(String(value));
+  let record = asRecord(value);
+  return !record || depth >= 2 ? 0 : (Array.isArray(value) ? value.slice(0, KEY_PREVIEW_LIMIT) : Object.values(record).slice(0, KEY_PREVIEW_LIMIT)).reduce((total, item) => total + estimateValueBytes(item, depth + 1), 0);
+}
+function truncateKey(key) {
+  return key.length <= KEY_MAX_CHARS ? key : `${key.slice(0, KEY_MAX_CHARS - 1)}\u2026`;
+}
+async function saveArtifact(kind, text) {
+  try {
+    let dir = await mkdtemp(join(tmpdir(), "pi-mcp-output-")), path2 = join(dir, `${kind}-${randomBytes(4).toString("hex")}.txt`);
+    return await writeFile(path2, text, { encoding: "utf8", mode: 384 }), { path: path2 };
+  } catch (error) {
+    return { error: error instanceof Error ? error.message : String(error) };
+  }
+}
+function asRecord(value) {
+  return typeof value == "object" && value !== null ? value : void 0;
+}
+function safeStringify(value) {
+  try {
+    return JSON.stringify(value, null, 2);
+  } catch {
+    return String(value);
+  }
+}
+function textStats(text) {
+  return { bytes: byteLength(text), lines: text.length === 0 ? 0 : text.split(`
+`).length };
+}
+function byteLength(text) {
+  return Buffer.byteLength(text, "utf8");
+}
+function positiveInt(value) {
+  if (typeof value != "number" || !Number.isFinite(value))
+    return;
+  let integer = Math.floor(value);
+  return integer > 0 ? integer : void 0;
+}
+function envKillSwitch(name) {
+  let value = process.env[name]?.trim().toLowerCase();
+  if (value) {
+    if (["0", "false", "no", "off"].includes(value))
+      return !1;
+    if (["1", "true", "yes", "on"].includes(value))
+      return !0;
+  }
+}
+function formatSize(bytes) {
+  return bytes < 1024 ? `${bytes} B` : bytes < 1024 * 1024 ? `${(bytes / 1024).toFixed(1)} KiB` : `${(bytes / (1024 * 1024)).toFixed(1)} MiB`;
+}
+
+// packages/coding-agent/dist/builtin-extensions/pi-mcp-adapter/ui-session.js
+import { randomUUID as randomUUID2 } from "node:crypto";
+
+// packages/coding-agent/dist/builtin-extensions/pi-mcp-adapter/ui-server.js
+import http from "node:http";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+
+// packages/coding-agent/dist/builtin-extensions/pi-mcp-adapter/host-html-template.js
+var DEFAULT_APP_BRIDGE_MODULE_URL = "/app-bridge.bundle.js";
+function buildHostHtmlTemplate(input) {
+  let cspContent = buildCspMetaContent(input.resource.meta.csp), resourceHtml = applyCspMeta(input.resource.html, cspContent), hostContext = input.hostContext ?? {}, sessionToken = safeInlineJSON(input.sessionToken), toolArgs = safeInlineJSON(input.toolArgs), uiHtml = safeInlineJSON(resourceHtml), serverName = safeInlineJSON(input.serverName), toolName = safeInlineJSON(input.toolName), hostContextJson = safeInlineJSON(hostContext), allowAttribute = safeInlineJSON(input.allowAttribute), requireToolConsent = safeInlineJSON(input.requireToolConsent), cacheToolConsent = safeInlineJSON(input.cacheToolConsent), moduleUrl = safeInlineJSON(input.appBridgeModuleUrl ?? DEFAULT_APP_BRIDGE_MODULE_URL);
+  return `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>MCP UI - ${escapeHtml(input.serverName)} / ${escapeHtml(input.toolName)}</title>
+  <style>
+    :root {
+      color-scheme: light dark;
+      --bg: #0f1115;
+      --surface: #181c22;
+      --text: #ecf0f5;
+      --muted: #a9b2bf;
+      --accent: #43c0ff;
+      --border: rgba(255, 255, 255, 0.12);
+      --good: #34d399;
+      --warn: #fbbf24;
+      --bad: #f87171;
+    }
+    @media (prefers-color-scheme: light) {
+      :root {
+        --bg: #f6f7fb;
+        --surface: #ffffff;
+        --text: #1d2939;
+        --muted: #667085;
+        --accent: #0ea5e9;
+        --border: rgba(15, 23, 42, 0.14);
+        --good: #059669;
+        --warn: #b45309;
+        --bad: #b91c1c;
+      }
+    }
+    * { box-sizing: border-box; }
+    html, body { margin: 0; padding: 0; height: 100%; font-family: ui-sans-serif, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; background: var(--bg); color: var(--text); }
+    body { display: flex; flex-direction: column; min-height: 100vh; }
+    header { background: var(--surface); border-bottom: 1px solid var(--border); padding: 10px 14px; display: flex; align-items: center; justify-content: space-between; gap: 10px; }
+    .title { display: flex; gap: 8px; align-items: baseline; min-width: 0; }
+    .server { font-size: 12px; color: var(--muted); text-transform: uppercase; letter-spacing: 0.08em; white-space: nowrap; }
+    .tool { font-size: 14px; font-weight: 600; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+    .badge { border: 1px solid var(--border); border-radius: 999px; padding: 2px 8px; font-size: 11px; color: var(--muted); white-space: nowrap; }
+    .controls { display: flex; gap: 8px; align-items: center; }
+    .status { font-size: 12px; color: var(--muted); white-space: nowrap; }
+    button { border: 1px solid var(--border); background: transparent; color: var(--text); border-radius: 8px; padding: 6px 10px; cursor: pointer; font-size: 12px; }
+    button.primary { border-color: color-mix(in srgb, var(--good) 40%, var(--border) 60%); color: var(--good); }
+    button.danger { border-color: color-mix(in srgb, var(--bad) 40%, var(--border) 60%); color: var(--bad); }
+    button:hover { background: color-mix(in srgb, var(--surface) 75%, var(--accent) 25%); }
+    main { flex: 1; min-height: 0; padding: 10px; display: flex; }
+    iframe { width: 100%; height: 100%; border: 1px solid var(--border); border-radius: 10px; background: white; }
+    .overlay { position: fixed; inset: 0; background: color-mix(in srgb, var(--bg) 90%, black 10%); display: none; align-items: center; justify-content: center; z-index: 2; }
+    .overlay.visible { display: flex; }
+    .panel { width: min(680px, calc(100vw - 40px)); background: var(--surface); border: 1px solid var(--border); border-radius: 12px; padding: 18px; }
+    .panel h2 { margin: 0 0 8px; font-size: 16px; }
+    .panel p { margin: 0; color: var(--muted); line-height: 1.4; font-size: 14px; white-space: pre-wrap; }
+  </style>
+</head>
+<body>
+  <header>
+    <div class="title">
+      <span class="server">MCP \xB7 <span id="server-name"></span></span>
+      <span class="tool" id="tool-name"></span>
+      <span class="badge">Sandboxed</span>
+    </div>
+    <div class="controls">
+      <span class="status" id="status">Loading UI...</span>
+      <button class="primary" id="done-btn" title="Cmd/Ctrl+Enter">Done</button>
+      <button class="danger" id="cancel-btn" title="Escape">Cancel</button>
+    </div>
+  </header>
+  <main>
+    <iframe id="mcp-app" referrerpolicy="no-referrer"></iframe>
+  </main>
+  <div class="overlay" id="error-overlay">
+    <div class="panel">
+      <h2>UI Error</h2>
+      <p id="error-message"></p>
+    </div>
+  </div>
+  <script type="module">
+    import { AppBridge, PostMessageTransport } from ${moduleUrl};
+
+    const SESSION_TOKEN = ${sessionToken};
+    const SERVER_NAME = ${serverName};
+    const TOOL_NAME = ${toolName};
+    const TOOL_ARGS = ${toolArgs};
+    const HOST_CONTEXT = ${hostContextJson};
+    const ALLOW_ATTRIBUTE = ${allowAttribute};
+    const REQUIRE_TOOL_CONSENT = ${requireToolConsent};
+    const CACHE_TOOL_CONSENT = ${cacheToolConsent};
+    const STREAM_CONTEXT_KEY = "pi-mcp-adapter/stream";
+    const STREAM_PATCH_METHOD = "notifications/pi-mcp-adapter/ui-result-patch";
+
+    const iframe = document.getElementById("mcp-app");
+    const statusNode = document.getElementById("status");
+    const doneBtn = document.getElementById("done-btn");
+    const cancelBtn = document.getElementById("cancel-btn");
+    const errorOverlay = document.getElementById("error-overlay");
+    const errorMessage = document.getElementById("error-message");
+
+    document.getElementById("server-name").textContent = SERVER_NAME;
+    document.getElementById("tool-name").textContent = TOOL_NAME;
+
+    const setStatus = (text, isError = false) => {
+      statusNode.textContent = text;
+      statusNode.style.color = isError ? "var(--bad)" : "var(--muted)";
+    };
+
+    const showError = (message) => {
+      errorMessage.textContent = message;
+      errorOverlay.classList.add("visible");
+      setStatus("Error", true);
+    };
+
+    const post = async (endpoint, params) => {
+      const response = await fetch(endpoint, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ token: SESSION_TOKEN, params }),
+      });
+
+      const body = await response.json().catch(() => ({ ok: false, error: "Invalid JSON response" }));
+      if (!response.ok || !body.ok) {
+        const message = body.error || ("HTTP " + response.status);
+        throw new Error(message);
+      }
+      return body.result ?? {};
+    };
+
+    let consentGranted = !REQUIRE_TOOL_CONSENT;
+    const initialStreamContext = HOST_CONTEXT?.[STREAM_CONTEXT_KEY];
+    const streamMode = initialStreamContext?.mode === "stream-first" ? "stream-first" : "eager";
+
+    const bridge = new AppBridge(
+      null,
+      { name: "pi", version: "1.0.0" },
+      { serverTools: {}, openLinks: {}, logging: {}, updateModelContext: {}, message: {} },
+      { hostContext: HOST_CONTEXT }
+    );
+
+    bridge.oncalltool = async (params) => {
+      if (!consentGranted) {
+        const accepted = window.confirm("Allow this UI to call server tools for this session?");
+        if (!accepted) {
+          await post("/proxy/ui/consent", { approved: false }).catch(() => {});
+          return {
+            isError: true,
+            content: [{ type: "text", text: "Tool call denied by user." }],
+          };
+        }
+        await post("/proxy/ui/consent", { approved: true });
+        if (CACHE_TOOL_CONSENT) {
+          consentGranted = true;
+        }
+      }
+      const result = await post("/proxy/tools/call", params);
+      // Notify agent about the tool call
+      await post("/proxy/ui/message", {
+        type: "intent",
+        intent: "call_tool",
+        params: { tool: params.name, arguments: params.arguments, isError: result.isError }
+      }).catch(() => {});
+      return result;
+    };
+
+    bridge.onmessage = async (params) => post("/proxy/ui/message", params);
+    bridge.onupdatemodelcontext = async (params) => post("/proxy/ui/context", params);
+    
+    // Also listen for raw postMessage events with custom types (notify, prompt, intent, etc.)
+    // These bypass the AppBridge protocol but are used by some MCP UI implementations
+    window.addEventListener("message", async (event) => {
+      const data = event.data;
+      if (!data || typeof data !== "object") return;
+      
+      // Skip AppBridge protocol messages (handled by bridge)
+      if (data.jsonrpc || (typeof data.method === "string" && (data.method.startsWith("app/") || data.method.startsWith("host/")))) return;
+      
+      // Handle raw UI action messages
+      const msgType = data.type;
+      if (typeof msgType !== "string") return;
+      
+      if (msgType === "notify" || msgType === "prompt" || msgType === "intent" || msgType === "message") {
+        // Standard MCP-UI types - preserve their semantics
+        // Support both { type, payload: {...} } and { type, field: value } formats
+        const { type: _, payload, ...directFields } = data;
+        await post("/proxy/ui/message", { type: msgType, ...directFields, ...(payload || {}) }).catch(() => {});
+      } else if (!msgType.startsWith("ui-lifecycle-") && !msgType.startsWith("ui-message-")) {
+        // Any other custom type - forward as intent with type as intent name
+        // (Skip internal lifecycle/ack messages)
+        const payload = data.payload || {};
+        await post("/proxy/ui/message", {
+          type: "intent",
+          intent: msgType,
+          params: payload,
+        }).catch(() => {});
+      }
+    });
+    bridge.ondownloadfile = async (params) => post("/proxy/ui/download-file", params);
+    bridge.onrequestdisplaymode = async (params) => post("/proxy/ui/request-display-mode", params);
+    bridge.onopenlink = async (params) => {
+      const result = await post("/proxy/ui/open-link", params);
+      if (!result.isError) {
+        window.open(params.url, "_blank", "noopener,noreferrer");
+        // Notify agent about the link open
+        await post("/proxy/ui/message", {
+          type: "intent",
+          intent: "open_link",
+          params: { url: params.url }
+        }).catch(() => {});
+      }
+      return result;
+    };
+
+    bridge.oninitialized = () => {
+      if (streamMode !== "stream-first") {
+        bridge.sendToolInput({ arguments: TOOL_ARGS });
+      }
+      setStatus(streamMode === "stream-first" ? "Streaming\u2026" : "Connected");
+    };
+
+    bridge.onsizechange = ({ width, height }) => {
+      if (typeof width === "number" && width > 0) {
+        iframe.style.minWidth = Math.min(width, window.innerWidth - 24) + "px";
+      }
+      if (typeof height === "number" && height > 0) {
+        iframe.style.height = Math.max(height, 320) + "px";
+      }
+    };
+
+    if (ALLOW_ATTRIBUTE) {
+      iframe.setAttribute("allow", ALLOW_ATTRIBUTE);
+    }
+
+    // Connect bridge BEFORE loading iframe to ensure we're listening when the app sends ui/initialize
+    try {
+      const transport = new PostMessageTransport(iframe.contentWindow, null);
+      await bridge.connect(transport);
+    } catch (error) {
+      console.error("[host] Bridge connection failed:", error);
+      showError("Failed to initialize AppBridge: " + String(error));
+    }
+
+    const iframeLoaded = new Promise((resolve) => {
+      iframe.onload = resolve;
+    });
+    iframe.src = "/ui-app?session=" + encodeURIComponent(SESSION_TOKEN);
+    await iframeLoaded;
+
+    const eventSource = new EventSource("/events?session=" + encodeURIComponent(SESSION_TOKEN));
+    eventSource.addEventListener("tool-input", (event) => {
+      try {
+        bridge.sendToolInput(JSON.parse(event.data));
+      } catch (error) {
+        showError("Failed to forward tool input: " + String(error));
+      }
+    });
+    eventSource.addEventListener("tool-result", (event) => {
+      try {
+        bridge.sendToolResult(JSON.parse(event.data));
+      } catch (error) {
+        showError("Failed to forward tool result: " + String(error));
+      }
+    });
+    eventSource.addEventListener("tool-cancelled", (event) => {
+      try {
+        bridge.sendToolCancelled(JSON.parse(event.data));
+      } catch (error) {
+        showError("Failed to forward cancellation: " + String(error));
+      }
+    });
+    eventSource.addEventListener("result-patch", async (event) => {
+      try {
+        await bridge.notification({
+          method: STREAM_PATCH_METHOD,
+          params: JSON.parse(event.data),
+        });
+      } catch (error) {
+        showError("Failed to forward stream patch: " + String(error));
+      }
+    });
+    eventSource.addEventListener("host-context", (event) => {
+      try {
+        bridge.setHostContext(JSON.parse(event.data));
+      } catch {}
+    });
+    eventSource.addEventListener("session-complete", async () => {
+      await bridge.teardownResource({}).catch(() => {});
+      eventSource.close();
+      window.close();
+    });
+    eventSource.onerror = () => {
+      setStatus("Connection lost", true);
+    };
+
+    const heartbeat = setInterval(() => {
+      post("/proxy/ui/heartbeat", {}).catch(() => {});
+    }, 10000);
+
+    const complete = async (reason) => {
+      try {
+        await post("/proxy/ui/complete", { reason });
+      } catch {}
+      try {
+        await bridge.teardownResource({});
+      } catch {}
+      clearInterval(heartbeat);
+      eventSource.close();
+      window.close();
+    };
+
+    doneBtn.addEventListener("click", () => complete("done"));
+    cancelBtn.addEventListener("click", () => complete("cancel"));
+    window.addEventListener("keydown", (event) => {
+      if (event.key === "Escape") {
+        event.preventDefault();
+        complete("cancel");
+      } else if ((event.metaKey || event.ctrlKey) && event.key === "Enter") {
+        event.preventDefault();
+        complete("done");
+      }
+    });
+  </script>
+</body>
+</html>`;
+}
+function buildCspMetaContent(csp) {
+  if (!csp)
+    return;
+  let directives = [];
+  directives.push("default-src 'none'");
+  let scriptSrc = toDirective("script-src", csp.scriptDomains), styleSrc = toDirective("style-src", csp.styleDomains), fontSrc = toDirective("font-src", csp.fontDomains), imgSrc = toDirective("img-src", csp.imgDomains), mediaSrc = toDirective("media-src", csp.mediaDomains), connectSrc = toDirective("connect-src", csp.connectDomains), frameSrc = toDirective("frame-src", csp.frameDomains), workerSrc = toDirective("worker-src", csp.workerDomains), baseUri = toDirective("base-uri", csp.baseUriDomains);
+  return scriptSrc && directives.push(scriptSrc), styleSrc && directives.push(styleSrc), fontSrc && directives.push(fontSrc), imgSrc && directives.push(imgSrc), mediaSrc && directives.push(mediaSrc), connectSrc && directives.push(connectSrc), frameSrc && directives.push(frameSrc), workerSrc && directives.push(workerSrc), baseUri && directives.push(baseUri), directives.join("; ");
+}
+function toDirective(name, domains) {
+  return !domains || domains.length === 0 ? null : `${name} ${domains.join(" ")}`;
+}
+function applyCspMeta(html, cspContent) {
+  if (!cspContent || /http-equiv=["']Content-Security-Policy["']/i.test(html))
+    return html;
+  let metaTag = `<meta http-equiv="Content-Security-Policy" content="${escapeHtmlAttribute(cspContent)}">`;
+  return /<head[^>]*>/i.test(html) ? html.replace(/<head[^>]*>/i, (match) => `${match}
+${metaTag}`) : `${metaTag}
+${html}`;
+}
+function safeInlineJSON(value) {
+  return JSON.stringify(value).replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/&/g, "\\u0026").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+}
+function escapeHtml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function escapeHtmlAttribute(value) {
+  return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+
+// packages/coding-agent/dist/builtin-extensions/pi-mcp-adapter/ui-server.js
+var MAX_BODY_SIZE = 2 * 1024 * 1024, ABANDONED_GRACE_MS = 6e4, WATCHDOG_INTERVAL_MS = 5e3, MAX_EVENT_LOG = 128;
+async function startUiServer(options) {
+  let sessionToken = options.sessionToken ?? randomUUID(), log = logger.child({
+    component: "UiServer",
+    server: options.serverName,
+    tool: options.toolName,
+    session: sessionToken.slice(0, 8)
+  });
+  log.debug("Starting UI server");
+  let sseClients = /* @__PURE__ */ new Set(), completed = !1, lastHeartbeatAt = Date.now(), watchdog = null, currentDisplayMode = options.hostContext?.displayMode ?? "inline", nextEventId = 1, eventLog = [], streamSummary, sessionMessages = {
+    prompts: [],
+    notifications: [],
+    intents: []
+  }, hostContext = {
+    displayMode: currentDisplayMode,
+    availableDisplayModes: ["inline", "fullscreen", "pip"],
+    platform: "desktop",
+    ...options.hostContext
+    // Only include toolInfo if caller provides full tool definition with inputSchema
+    // The App validates toolInfo.tool.inputSchema as required object
+  }, initialStreamContext = hostContext["pi-mcp-adapter/stream"];
+  if (initialStreamContext && typeof initialStreamContext == "object") {
+    let streamId = initialStreamContext.streamId, mode = initialStreamContext.mode;
+    typeof streamId == "string" && (mode === "eager" || mode === "stream-first") && (streamSummary = {
+      streamId,
+      mode,
+      frames: 0,
+      phases: []
+    });
+  }
+  let touchHeartbeat = () => {
+    lastHeartbeatAt = Date.now();
+  }, updateStreamSummary = (payload) => {
+    let envelope = getVisualizationStreamEnvelope(payload?.structuredContent);
+    envelope && (streamSummary || (streamSummary = {
+      streamId: envelope.streamId,
+      mode: "eager",
+      frames: 0,
+      phases: []
+    }), streamSummary.frames += 1, streamSummary.phases.includes(envelope.phase) || streamSummary.phases.push(envelope.phase), streamSummary.finalStatus = envelope.status, streamSummary.lastMessage = envelope.message);
+  }, serializeEvent = (eventId, name, payload) => `id: ${eventId}
+event: ${name}
+data: ${JSON.stringify(payload)}
+
+`, getLatestCheckpointIndex = () => {
+    for (let index = eventLog.length - 1; index >= 0; index -= 1) {
+      let entry = eventLog[index], envelope = getVisualizationStreamEnvelope(entry.payload?.structuredContent);
+      if (envelope?.frameType === "checkpoint" || envelope?.frameType === "final")
+        return index;
+    }
+    return -1;
+  }, pruneEventLog = () => {
+    if (eventLog.length <= MAX_EVENT_LOG)
+      return;
+    let latestCheckpointIndex = getLatestCheckpointIndex();
+    latestCheckpointIndex > 0 && eventLog.splice(0, latestCheckpointIndex), eventLog.length > MAX_EVENT_LOG && eventLog.splice(0, eventLog.length - MAX_EVENT_LOG);
+  }, pushEvent = (name, payload) => {
+    if (completed)
+      return;
+    let eventId = nextEventId++;
+    eventLog.push({ id: eventId, name, payload }), updateStreamSummary(payload), pruneEventLog();
+    let chunk = serializeEvent(eventId, name, payload);
+    for (let client of sseClients)
+      try {
+        client.write(chunk);
+      } catch {
+        sseClients.delete(client);
+      }
+  }, replayEvents = (res, lastEventIdHeader) => {
+    let parsedLastId = lastEventIdHeader ? Number(lastEventIdHeader) : Number.NaN, eventsToReplay = Number.isFinite(parsedLastId) ? eventLog.filter((entry) => entry.id > parsedLastId) : (() => {
+      let latestCheckpointIndex = getLatestCheckpointIndex();
+      return latestCheckpointIndex >= 0 ? eventLog.slice(latestCheckpointIndex) : eventLog;
+    })();
+    for (let entry of eventsToReplay)
+      try {
+        res.write(serializeEvent(entry.id, entry.name, entry.payload));
+      } catch {
+        sseClients.delete(res);
+        return;
+      }
+  }, closeSse = () => {
+    for (let client of sseClients)
+      try {
+        client.end();
+      } catch {
+      }
+    sseClients.clear();
+  }, stopWatchdog = () => {
+    watchdog && (clearInterval(watchdog), watchdog = null);
+  }, markCompleted = (reason) => {
+    completed || (log.debug("Session completed", { reason }), pushEvent("session-complete", { reason }), completed = !0, stopWatchdog(), options.onComplete?.(reason));
+  }, server = http.createServer(async (req, res) => {
+    try {
+      let method = req.method || "GET", url = new URL(req.url || "/", `http://${req.headers.host || "127.0.0.1"}`);
+      if (method === "GET" && url.pathname === "/") {
+        if (!validateTokenQuery(url, sessionToken, res))
+          return;
+        touchHeartbeat();
+        let html = buildHostHtmlTemplate({
+          sessionToken,
+          serverName: options.serverName,
+          toolName: options.toolName,
+          toolArgs: options.toolArgs,
+          resource: options.resource,
+          allowAttribute: AZ(options.resource.meta.permissions),
+          requireToolConsent: options.consentManager.requiresPrompt(options.serverName),
+          cacheToolConsent: options.consentManager.shouldCacheConsent(),
+          hostContext
+        });
+        res.writeHead(200, {
+          "Content-Type": "text/html; charset=utf-8",
+          "Cache-Control": "no-store"
+        }), res.end(html);
+        return;
+      }
+      if (method === "GET" && url.pathname === "/events") {
+        if (!validateTokenQuery(url, sessionToken, res))
+          return;
+        touchHeartbeat(), log.debug("SSE client connected", { clientCount: sseClients.size + 1 }), res.writeHead(200, {
+          "Content-Type": "text/event-stream",
+          "Cache-Control": "no-cache, no-transform",
+          Connection: "keep-alive",
+          "X-Accel-Buffering": "no"
+        }), res.write(`: connected
+
+`), sseClients.add(res), replayEvents(res, req.headers["last-event-id"] ? String(req.headers["last-event-id"]) : null), req.on("close", () => {
+          sseClients.delete(res);
+        });
+        return;
+      }
+      if (method === "GET" && url.pathname === "/health") {
+        if (!validateTokenQuery(url, sessionToken, res))
+          return;
+        sendJson(res, 200, { ok: !0, result: { healthy: !0 } });
+        return;
+      }
+      if (method === "GET" && url.pathname === "/ui-app") {
+        if (!validateTokenQuery(url, sessionToken, res))
+          return;
+        touchHeartbeat();
+        let cspContent = buildCspMetaContent(options.resource.meta.csp), appHtml = applyCspMeta(options.resource.html, cspContent);
+        res.writeHead(200, {
+          "Content-Type": "text/html; charset=utf-8",
+          "Cache-Control": "no-store"
+        }), res.end(appHtml);
+        return;
+      }
+      if (method === "GET" && url.pathname === "/app-bridge.bundle.js") {
+        let bundlePath = path.join(import.meta.dirname, "app-bridge.bundle.js");
+        try {
+          let content = await fs.readFile(bundlePath, "utf-8");
+          res.writeHead(200, {
+            "Content-Type": "application/javascript",
+            "Cache-Control": "public, max-age=31536000"
+          }), res.end(content);
+        } catch {
+          sendJson(res, 500, { ok: !1, error: "Bundle not found" });
+        }
+        return;
+      }
+      if (method !== "POST") {
+        sendJson(res, 404, { ok: !1, error: "Not found" });
+        return;
+      }
+      let body = await parseBody(req, res);
+      if (!body || !validateTokenBody(body, sessionToken, res))
+        return;
+      let params = body.params ?? {};
+      if (touchHeartbeat(), url.pathname === "/proxy/tools/call") {
+        options.consentManager.ensureApproved(options.serverName);
+        let callParams = params;
+        if (!callParams || typeof callParams.name != "string" || !callParams.name.trim()) {
+          sendJson(res, 400, { ok: !1, error: "Invalid tools/call params" });
+          return;
+        }
+        let connection = options.manager.getConnection(options.serverName);
+        if (!connection || connection.status !== "connected") {
+          sendJson(res, 503, { ok: !1, error: `Server "${options.serverName}" is not connected` });
+          return;
+        }
+        try {
+          options.manager.touch(options.serverName), options.manager.incrementInFlight(options.serverName);
+          let result = await connection.client.callTool({
+            name: callParams.name,
+            arguments: callParams.arguments && typeof callParams.arguments == "object" && !Array.isArray(callParams.arguments) ? callParams.arguments : {}
+          }, void 0, options.manager.getRequestOptions?.(options.serverName));
+          sendJson(res, 200, { ok: !0, result });
+        } finally {
+          options.manager.decrementInFlight(options.serverName), options.manager.touch(options.serverName);
+        }
+        return;
+      }
+      if (url.pathname === "/proxy/ui/consent") {
+        let approved = !!params.approved;
+        options.consentManager.registerDecision(options.serverName, approved), sendJson(res, 200, { ok: !0, result: { approved } });
+        return;
+      }
+      if (url.pathname === "/proxy/ui/message") {
+        let msgParams = params, promptText = extractUiPromptText(msgParams);
+        if (promptText)
+          sessionMessages.prompts.push(promptText), log.debug("UI prompt received", { prompt: promptText.slice(0, 100) });
+        else if (msgParams.type === "intent" || msgParams.intent) {
+          let intentName = msgParams.intent ?? "";
+          intentName && (sessionMessages.intents.push({
+            intent: intentName,
+            params: msgParams.params
+          }), log.debug("UI intent received", { intent: intentName }));
+        } else if (msgParams.type === "notify" || msgParams.message) {
+          let notifyText = msgParams.message ?? "";
+          notifyText && (sessionMessages.notifications.push(notifyText), log.debug("UI notification", { message: notifyText.slice(0, 100) }));
+        }
+        await options.onMessage?.(msgParams), sendJson(res, 200, { ok: !0, result: {} });
+        return;
+      }
+      if (url.pathname === "/proxy/ui/context") {
+        let ctxParams = params;
+        log.debug("UI context update", { hasContent: !!ctxParams.content }), await options.onContextUpdate?.(ctxParams), sendJson(res, 200, { ok: !0, result: {} });
+        return;
+      }
+      if (url.pathname === "/proxy/ui/open-link") {
+        let openParams = params;
+        if (!openParams?.url || typeof openParams.url != "string") {
+          sendJson(res, 400, { ok: !1, error: "Invalid open-link params" });
+          return;
+        }
+        let result = {};
+        try {
+          new URL(openParams.url);
+        } catch {
+          result = { isError: !0 };
+        }
+        sendJson(res, 200, { ok: !0, result });
+        return;
+      }
+      if (url.pathname === "/proxy/ui/download-file") {
+        sendJson(res, 200, { ok: !0, result: { isError: !0 } });
+        return;
+      }
+      if (url.pathname === "/proxy/ui/request-display-mode") {
+        let requested = params?.mode, available = hostContext.availableDisplayModes ?? ["inline"];
+        requested && available.includes(requested) && (currentDisplayMode = requested), hostContext.displayMode = currentDisplayMode, pushEvent("host-context", { displayMode: currentDisplayMode }), sendJson(res, 200, { ok: !0, result: { mode: currentDisplayMode } });
+        return;
+      }
+      if (url.pathname === "/proxy/ui/heartbeat") {
+        sendJson(res, 200, { ok: !0, result: {} });
+        return;
+      }
+      if (url.pathname === "/proxy/ui/complete") {
+        let reason = typeof params.reason == "string" ? params.reason : "done";
+        markCompleted(reason), sendJson(res, 200, { ok: !0, result: {} }), setTimeout(() => {
+          try {
+            server.close();
+          } catch {
+          }
+          closeSse();
+        }, 20).unref();
+        return;
+      }
+      sendJson(res, 404, { ok: !1, error: "Not found" });
+    } catch (error) {
+      let wrapped = wrapError(error, { server: options.serverName, tool: options.toolName }), status = /approval required|denied/i.test(wrapped.message) ? 403 : 500;
+      status === 500 && log.error("Request handler error", error instanceof Error ? error : void 0), sendJson(res, status, { ok: !1, error: wrapped.message });
+    }
+  });
+  return options.initialResultPromise && options.initialResultPromise.then((result) => pushEvent("tool-result", result), (error) => {
+    let reason = error instanceof Error ? error.message : String(error);
+    pushEvent("tool-cancelled", { reason });
+  }), watchdog = setInterval(() => {
+    if (!completed && !(Date.now() - lastHeartbeatAt <= ABANDONED_GRACE_MS)) {
+      markCompleted("stale");
+      try {
+        server.close();
+      } catch {
+      }
+      closeSse();
+    }
+  }, WATCHDOG_INTERVAL_MS), watchdog.unref(), new Promise((resolve, reject) => {
+    let onError = (error) => {
+      log.error("Failed to start server", error), reject(new ServerError(error.message, { port: options.port, cause: error }));
+    };
+    server.once("error", onError), server.listen(options.port ?? 0, "127.0.0.1", () => {
+      server.off("error", onError);
+      let address = server.address();
+      if (!address || typeof address == "string") {
+        let err = new ServerError("invalid address");
+        log.error("Invalid server address", err), reject(err);
+        return;
+      }
+      log.debug("Server started", { port: address.port });
+      let handle = {
+        url: `http://localhost:${address.port}/?session=${sessionToken}`,
+        port: address.port,
+        sessionToken,
+        serverName: options.serverName,
+        toolName: options.toolName,
+        close: (reason) => {
+          markCompleted(reason ?? "closed");
+          try {
+            server.close();
+          } catch {
+          }
+          closeSse();
+        },
+        sendToolInput: (args) => {
+          pushEvent("tool-input", { arguments: args });
+        },
+        sendToolResult: (result) => {
+          pushEvent("tool-result", result);
+        },
+        sendResultPatch: (result) => {
+          pushEvent("result-patch", result);
+        },
+        sendToolCancelled: (reason) => {
+          pushEvent("tool-cancelled", { reason });
+        },
+        sendHostContext: (context) => {
+          Object.assign(hostContext, context), pushEvent("host-context", context);
+        },
+        getSessionMessages: () => ({ ...sessionMessages }),
+        getStreamSummary: () => streamSummary ? { ...streamSummary, phases: [...streamSummary.phases] } : void 0
+      };
+      resolve(handle);
+    });
+  });
+}
+async function parseBody(req, res) {
+  try {
+    let body = await readBody(req);
+    return !body || typeof body != "object" ? (sendJson(res, 400, { ok: !1, error: "Invalid request body" }), null) : body;
+  } catch (error) {
+    return sendJson(res, 400, { ok: !1, error: error instanceof Error ? error.message : "Invalid body" }), null;
+  }
+}
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    let size = 0, chunks = [];
+    req.on("data", (chunk) => {
+      if (size += chunk.length, size > MAX_BODY_SIZE) {
+        req.destroy(), reject(new Error("Request body too large"));
+        return;
+      }
+      chunks.push(chunk);
+    }), req.on("end", () => {
+      try {
+        resolve(JSON.parse(Buffer.concat(chunks).toString("utf-8")));
+      } catch (error) {
+        reject(error);
+      }
+    }), req.on("error", reject);
+  });
+}
+function validateTokenQuery(url, expected, res) {
+  return url.searchParams.get("session") !== expected ? (sendJson(res, 403, { ok: !1, error: "Invalid session" }), !1) : !0;
+}
+function validateTokenBody(body, expected, res) {
+  return body.token !== expected ? (sendJson(res, 403, { ok: !1, error: "Invalid session" }), !1) : !0;
+}
+function sendJson(res, status, payload) {
+  res.writeHead(status, {
+    "Content-Type": "application/json; charset=utf-8",
+    "Cache-Control": "no-store"
+  }), res.end(JSON.stringify(payload));
+}
+
+// packages/coding-agent/dist/builtin-extensions/pi-mcp-adapter/glimpse-ui.js
+import { existsSync } from "node:fs";
+import { execFileSync } from "node:child_process";
+import { join as join2, dirname } from "node:path";
+import { platform } from "node:os";
+import { createRequire } from "node:module";
+var __rewriteRelativeImportExtension = function(path2, preserveJsx) {
+  return typeof path2 == "string" && /^\.\.?\//.test(path2) ? path2.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function(m, tsx, d, ext, cm) {
+    return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : d + ext + "." + cm.toLowerCase() + "js";
+  }) : path2;
+}, glimpseAvailable = null, resolvedBinaryPath = null;
+function isGlimpseAvailable() {
+  return glimpseAvailable !== null ? glimpseAvailable : platform() !== "darwin" ? (glimpseAvailable = !1, !1) : (resolvedBinaryPath = getGlimpseBinaryPath(), glimpseAvailable = resolvedBinaryPath !== null, glimpseAvailable);
+}
+function getGlimpseBinaryPath() {
+  if (process.env.GLIMPSE_BINARY && existsSync(process.env.GLIMPSE_BINARY))
+    return process.env.GLIMPSE_BINARY;
+  try {
+    let glimpseuiPath = createRequire(new URL("../builtin-extensions/pi-mcp-adapter/glimpse-ui.js", import.meta.url).href).resolve("glimpseui"), binaryPath = join2(dirname(glimpseuiPath), "glimpse");
+    if (existsSync(binaryPath))
+      return binaryPath;
+  } catch {
+  }
+  try {
+    let globalRoot = execFileSync("npm", ["root", "-g"], { encoding: "utf-8" }).trim(), binaryPath = join2(globalRoot, "glimpseui", "src", "glimpse");
+    if (existsSync(binaryPath))
+      return binaryPath;
+  } catch {
+  }
+  return null;
+}
+async function openGlimpseWindow(html, options) {
+  let modulePath = resolvedBinaryPath ? join2(dirname(resolvedBinaryPath), "glimpse.mjs") : "glimpseui", glimpse = await import(__rewriteRelativeImportExtension(modulePath)), active = !0, win = glimpse.open(html, {
+    width: options.width ?? 900,
+    height: options.height ?? 700,
+    title: options.title
+  });
+  return win.on("closed", () => {
+    active && (active = !1, options.onClosed());
+  }), {
+    close: () => {
+      active && (active = !1, win.close());
+    }
+  };
+}
+
+// packages/coding-agent/dist/builtin-extensions/pi-mcp-adapter/ui-session.js
+var activeGlimpseWindow = null, MAX_COMPLETED_SESSIONS = 10;
+function withStreamEnvelope(result, streamId, sequence) {
+  if (!streamId)
+    return result;
+  let structuredContent = result.structuredContent && typeof result.structuredContent == "object" && !Array.isArray(result.structuredContent) ? { ...result.structuredContent } : {}, rawEnvelope = structuredContent[UI_STREAM_STRUCTURED_CONTENT_KEY], envelope = rawEnvelope && typeof rawEnvelope == "object" && !Array.isArray(rawEnvelope) ? { ...rawEnvelope } : {
+    frameType: "final",
+    phase: "settled",
+    status: result.isError ? "error" : "ok"
+  };
+  return structuredContent[UI_STREAM_STRUCTURED_CONTENT_KEY] = {
+    ...envelope,
+    streamId,
+    sequence
+  }, {
+    ...result,
+    structuredContent
+  };
+}
+async function openInBrowser(state, url) {
+  try {
+    await state.openBrowser(url);
+  } catch (error) {
+    let message = error instanceof Error ? error.message : String(error);
+    state.ui?.notify(`MCP UI browser open failed: ${message}`, "warning"), state.ui?.notify(`Open manually: ${url}`, "info");
+  }
+}
+async function maybeStartUiSession(state, request) {
+  let log = logger.child({
+    component: "UiSession",
+    server: request.serverName,
+    tool: request.toolName
+  });
+  try {
+    if (state.uiServer && state.uiServer.serverName === request.serverName && state.uiServer.toolName === request.toolName) {
+      let existingHandle = state.uiServer, streamMode2 = request.streamMode, streamId2 = streamMode2 ? randomUUID2() : void 0, streamToken2 = streamMode2 ? randomUUID2() : void 0, active2 = !0, nextStreamSequence2 = 0, cleanupStreamListener2 = () => {
+        streamToken2 && state.manager.removeUiStreamListener(streamToken2);
+      };
+      return existingHandle.sendToolInput(request.toolArgs), streamToken2 && state.manager.registerUiStreamListener(streamToken2, (serverName, notification) => {
+        !active2 || state.uiServer !== existingHandle || serverName === request.serverName && (nextStreamSequence2 += 1, existingHandle.sendResultPatch(withStreamEnvelope(notification.result, streamId2, nextStreamSequence2)));
+      }), {
+        serverName: request.serverName,
+        toolName: request.toolName,
+        reused: !0,
+        streamId: streamId2,
+        streamToken: streamToken2,
+        streamMode: streamMode2,
+        requestMeta: streamToken2 ? { [UI_STREAM_REQUEST_META_KEY]: streamToken2 } : void 0,
+        url: existingHandle.url,
+        isActive: () => active2 && state.uiServer === existingHandle,
+        sendToolResult: (result) => {
+          !active2 || state.uiServer !== existingHandle || (nextStreamSequence2 += 1, existingHandle.sendToolResult(withStreamEnvelope(result, streamId2, nextStreamSequence2)));
+        },
+        sendResultPatch: (result) => {
+          !active2 || state.uiServer !== existingHandle || (nextStreamSequence2 += 1, existingHandle.sendResultPatch(withStreamEnvelope(result, streamId2, nextStreamSequence2)));
+        },
+        sendToolCancelled: (reason) => {
+          !active2 || state.uiServer !== existingHandle || (nextStreamSequence2 += 1, existingHandle.sendToolResult(withStreamEnvelope({
+            isError: !0,
+            content: [{ type: "text", text: reason }]
+          }, streamId2, nextStreamSequence2)));
+        },
+        close: () => {
+          active2 = !1, cleanupStreamListener2();
+        }
+      };
+    }
+    let resource = await state.uiResourceHandler.readUiResource(request.serverName, request.uiResourceUri);
+    state.uiServer && (state.uiServer.close("replaced"), state.uiServer = null), activeGlimpseWindow && (activeGlimpseWindow.close(), activeGlimpseWindow = null);
+    let streamMode = request.streamMode, streamId = streamMode ? randomUUID2() : void 0, streamToken = streamMode ? randomUUID2() : void 0, hostContext = streamMode && streamId ? {
+      [UI_STREAM_HOST_CONTEXT_KEY]: {
+        mode: streamMode,
+        streamId,
+        intermediateResultPatches: streamMode === "stream-first",
+        partialInput: !1
+      }
+    } : void 0, active = !0, nextStreamSequence = 0, handle = null, cleanupStreamListener = () => {
+      streamToken && state.manager.removeUiStreamListener(streamToken);
+    };
+    handle = await startUiServer({
+      serverName: request.serverName,
+      toolName: request.toolName,
+      toolArgs: streamMode === "stream-first" ? {} : request.toolArgs,
+      resource,
+      manager: state.manager,
+      consentManager: state.consentManager,
+      hostContext,
+      onMessage: (params) => {
+        let prompt = extractUiPromptText(params);
+        if (prompt)
+          state.sendMessage && (state.sendMessage({
+            customType: "mcp-ui-prompt",
+            content: [{ type: "text", text: `User sent prompt from ${request.serverName} UI: "${prompt}"` }],
+            display: `\u{1F4AC} UI Prompt: ${prompt}`,
+            details: { server: request.serverName, tool: request.toolName, prompt }
+          }, { triggerTurn: !0 }), log.debug("Triggered agent turn for UI prompt", { prompt: prompt.slice(0, 50) }));
+        else if (params.type === "intent" || params.intent) {
+          let intent = params.intent ?? "", intentParams = params.params;
+          if (intent && state.sendMessage) {
+            let paramsStr = intentParams ? ` ${JSON.stringify(intentParams)}` : "";
+            state.sendMessage({
+              customType: "mcp-ui-intent",
+              content: [{ type: "text", text: `User triggered intent from ${request.serverName} UI: ${intent}${paramsStr}` }],
+              display: `\u{1F3AF} UI Intent: ${intent}`,
+              details: { server: request.serverName, tool: request.toolName, intent, params: intentParams }
+            }, { triggerTurn: !0 }), log.debug("Triggered agent turn for UI intent", { intent });
+          }
+        } else if (params.type === "notify" || params.message) {
+          let text = params.message ?? "";
+          text && state.ui && state.ui.notify(`[${request.serverName}] ${text}`, "info");
+        }
+      },
+      onContextUpdate: (params) => {
+        log.debug("Model context update from UI", {
+          hasContent: !!params.content,
+          hasStructured: !!params.structuredContent
+        });
+      },
+      onComplete: (reason) => {
+        if (active = !1, cleanupStreamListener(), state.uiServer === handle) {
+          let messages = handle.getSessionMessages(), stream = handle.getStreamSummary();
+          if (messages.prompts.length > 0 || messages.intents.length > 0 || messages.notifications.length > 0 || !!stream) {
+            for (state.completedUiSessions.push({
+              serverName: handle.serverName,
+              toolName: handle.toolName,
+              completedAt: /* @__PURE__ */ new Date(),
+              reason,
+              messages,
+              stream
+            }); state.completedUiSessions.length > MAX_COMPLETED_SESSIONS; )
+              state.completedUiSessions.shift();
+            log.debug("Session completed", {
+              reason,
+              prompts: messages.prompts.length,
+              intents: messages.intents.length,
+              notifications: messages.notifications.length,
+              streamFrames: stream?.frames ?? 0
+            });
+          }
+          state.uiServer = null, activeGlimpseWindow && (activeGlimpseWindow.close(), activeGlimpseWindow = null);
+        }
+      }
+    }), streamToken && state.manager.registerUiStreamListener(streamToken, (serverName, notification) => {
+      !active || state.uiServer !== handle || serverName === request.serverName && (nextStreamSequence += 1, handle.sendResultPatch(withStreamEnvelope(notification.result, streamId, nextStreamSequence)));
+    }), state.uiServer = handle;
+    let glimpseDetected = isGlimpseAvailable(), viewerPref = process.env.MCP_UI_VIEWER?.toLowerCase();
+    if (viewerPref === "glimpse" || viewerPref !== "browser" && glimpseDetected)
+      try {
+        let 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>`;
+        activeGlimpseWindow = await openGlimpseWindow(glimpseHtml, {
+          title: `MCP \xB7 ${request.serverName} \xB7 ${request.toolName}`,
+          width: 1e3,
+          height: 800,
+          onClosed: () => {
+            active && handle.close("glimpse-closed");
+          }
+        });
+      } catch (error) {
+        log.debug("Glimpse unavailable, using browser", {
+          error: error instanceof Error ? error.message : String(error)
+        }), await openInBrowser(state, handle.url);
+      }
+    else
+      await openInBrowser(state, handle.url);
+    return {
+      serverName: request.serverName,
+      toolName: request.toolName,
+      reused: !1,
+      streamId,
+      streamToken,
+      streamMode,
+      requestMeta: streamToken ? { [UI_STREAM_REQUEST_META_KEY]: streamToken } : void 0,
+      url: handle.url,
+      isActive: () => active && state.uiServer === handle,
+      sendToolResult: (result) => {
+        !active || state.uiServer !== handle || (nextStreamSequence += 1, handle.sendToolResult(withStreamEnvelope(result, streamId, nextStreamSequence)));
+      },
+      sendResultPatch: (result) => {
+        !active || state.uiServer !== handle || (nextStreamSequence += 1, handle.sendResultPatch(withStreamEnvelope(result, streamId, nextStreamSequence)));
+      },
+      sendToolCancelled: (reason) => {
+        !active || state.uiServer !== handle || handle.sendToolCancelled(reason);
+      },
+      close: (reason) => {
+        active = !1, cleanupStreamListener(), handle.close(reason);
+      }
+    };
+  } catch (error) {
+    if (error instanceof UrlElicitationRequiredError)
+      throw error;
+    let message = error instanceof Error ? error.message : String(error);
+    return log.error("Failed to start UI session", error instanceof Error ? error : void 0), state.ui?.notify(`MCP UI unavailable for ${request.toolName} (${request.serverName}): ${message}`, "warning"), null;
+  }
+}
+
+export {
+  transformMcpContent,
+  resolveMcpResultContent,
+  resolveMcpOutputGuardOptions,
+  guardedMcpDetails,
+  guardMcpOutput,
+  maybeStartUiSession
+};