@herbertgao/pi-extensions 2026.8.4 → 2026.8.5

package/node_modules/pi-mcp-adapter/tool-metadata.ts

@@ -1,7 +1,7 @@
 import { getToolUiResourceUri } from "./ui-app-bridge-helpers.ts";
 import type { McpExtensionState } from "./state.ts";
 import type { ToolMetadata, McpTool, McpResource, ServerEntry, ToolPrefix } from "./types.ts";
-import { formatToolName, isToolAllowed, resolveToolPrefix } from "./types.ts";
+import { formatToolName, getToolNameCandidates, isToolAllowed, resolveToolPrefix } from "./types.ts";
 import { resourceNameToToolName } from "./resource-tools.ts";
 import { extractToolUiStreamMode } from "./utils.ts";
 import { extractUiToolVisibility, isUiToolVisibleToModel } from "./ui-tool-visibility.ts";
@@ -11,19 +11,57 @@ export function buildToolMetadata(
   resources: McpResource[],
   definition: ServerEntry,
   serverName: string,
-  prefix: ToolPrefix
+  prefix: ToolPrefix,
+  configuredServers?: Record<string, ServerEntry>,
+  knownMetadata?: Map<string, ToolMetadata[]>,
+  includeMissingConfiguredCandidates = false,
 ): { metadata: ToolMetadata[]; failedTools: string[] } {
   const metadata: ToolMetadata[] = [];
   const failedTools: string[] = [];
   const seenNames = new Set<string>();
   const effectivePrefix = resolveToolPrefix(definition, prefix);
+  const getOtherCurrentCandidates = (toolName: string): Set<string> | undefined => {
+    if (!configuredServers) return undefined;
+    const candidates = new Set<string>();
+    const addCandidates = (originalName: string, candidateServerName: string, candidatePrefix: ToolPrefix) => {
+      for (const candidate of getToolNameCandidates(originalName, candidateServerName, candidatePrefix, false)) candidates.add(candidate);
+    };
+
+    for (const tool of tools) {
+      if (tool?.name) addCandidates(tool.name, serverName, effectivePrefix);
+    }
+    if (definition.exposeResources !== false) {
+      for (const resource of resources) {
+        if (resource?.name && resource?.uri) addCandidates(`read_${resourceNameToToolName(resource.name)}`, serverName, effectivePrefix);
+      }
+    }
+    for (const [otherServerName, otherDefinition] of Object.entries(configuredServers)) {
+      if (otherServerName === serverName) continue;
+      const knownTools = knownMetadata?.get(otherServerName);
+      if (knownTools) {
+        const otherPrefix = resolveToolPrefix(otherDefinition, prefix);
+        for (const tool of knownTools) {
+          candidates.add(tool.name);
+          addCandidates(tool.originalName, otherServerName, otherPrefix);
+        }
+      } else if (!knownMetadata || includeMissingConfiguredCandidates) {
+        const otherPrefix = resolveToolPrefix(otherDefinition, prefix);
+        addCandidates(toolName, otherServerName, otherPrefix);
+        if (includeMissingConfiguredCandidates) {
+          for (const candidate of getToolNameCandidates(toolName, otherServerName, otherPrefix, false)) candidates.add(candidate.replace(/-/g, "_"));
+        }
+      }
+    }
+    for (const candidate of getToolNameCandidates(toolName, serverName, effectivePrefix, false)) candidates.delete(candidate);
+    return candidates;
+  };
 
   for (const tool of tools) {
     if (!tool?.name) {
       failedTools.push("(unnamed)");
       continue;
     }
-    if (!isToolAllowed(tool.name, serverName, effectivePrefix, definition.includeTools, definition.excludeTools)) {
+    if (!isToolAllowed(tool.name, serverName, effectivePrefix, definition.includeTools, definition.excludeTools, getOtherCurrentCandidates(tool.name))) {
       continue;
     }
 
@@ -59,7 +97,7 @@ export function buildToolMetadata(
   if (definition.exposeResources !== false) {
     for (const resource of resources) {
       const baseName = `read_${resourceNameToToolName(resource.name)}`;
-      if (!isToolAllowed(baseName, serverName, effectivePrefix, definition.includeTools, definition.excludeTools)) {
+      if (!isToolAllowed(baseName, serverName, effectivePrefix, definition.includeTools, definition.excludeTools, getOtherCurrentCandidates(baseName))) {
         continue;
       }
 

package/node_modules/pi-mcp-adapter/tool-result-renderer.ts

@@ -1,5 +1,5 @@
 import type { AgentToolResult, ToolRenderResultOptions } from "@earendil-works/pi-coding-agent";
-import { type Component, Text } from "@earendil-works/pi-tui";
+import { type Component, Text, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 
 type McpToolResultDetails = Record<string, unknown> & { error?: unknown };
 type McpToolContentBlock = AgentToolResult<McpToolResultDetails>["content"][number];
@@ -23,8 +23,27 @@ export interface McpProxyToolCallInput {
   action?: string;
 }
 
+interface McpToolRenderState {
+  compactTitle?: string;
+}
+
 interface McpToolRenderContext {
   isError: boolean;
+  isPartial?: boolean;
+  expanded?: boolean;
+  state?: McpToolRenderState;
+}
+
+export type McpToolResultRendering = "compact" | "boxed";
+
+export interface McpToolRenderOptions {
+  resultRendering: McpToolResultRendering;
+  collapsedResultLines: 1 | 2 | 3;
+}
+
+export interface McpToolRenderSettings {
+  toolResultRendering?: unknown;
+  collapsedResultLines?: unknown;
 }
 
 export interface McpToolResultDisplay {
@@ -33,10 +52,62 @@ export interface McpToolResultDisplay {
 }
 
 const DEFAULT_MAX_CALL_INPUT_CHARS = 1500;
-const DEFAULT_MAX_COLLAPSED_LINES = 3;
+const DEFAULT_BOXED_COLLAPSED_LINES = 3;
+const DEFAULT_COMPACT_COLLAPSED_LINES = 1;
 const DEFAULT_MAX_COLLAPSED_CHARS = 8000;
 const COLLAPSED_RENDER_CHAR_SLACK = 8;
 
+class EmptyComponent implements Component {
+  render(): string[] {
+    return [];
+  }
+
+  invalidate(): void {}
+}
+
+class CompactMcpToolResult implements Component {
+  private rendered: { width: number; lines: string[] } | null = null;
+
+  constructor(
+    private readonly title: string,
+    private readonly display: McpToolResultDisplay,
+    private readonly theme: RenderTheme,
+  ) {}
+
+  render(width: number): string[] {
+    const safeWidth = Math.max(1, Math.floor(width));
+    if (this.rendered?.width === safeWidth) return this.rendered.lines;
+
+    const resultLines = this.display.lines.filter((line, index, lines) => {
+      return !(this.display.truncated && index === lines.length - 1 && line === "…");
+    });
+    const lines = resultLines.length > 0 ? resultLines : [""];
+    const bodies = lines.map((line, index) => {
+      const prefix = index === 0 && this.title ? `${this.theme.fg("toolTitle", this.title)} → ` : "";
+      return `${prefix}${this.theme.fg("toolOutput", line)}`;
+    });
+    const hiddenText = this.display.truncated || bodies.some((body) => visibleWidth(body) > safeWidth);
+    const rendered = bodies.map((body, index) => {
+      const suffix = hiddenText && index === bodies.length - 1 ? " … (Ctrl+O to expand)" : "";
+      if (!suffix) return truncateToWidth(body, safeWidth, "…");
+      if (safeWidth >= suffix.length + 20) {
+        return `${truncateToWidth(body, safeWidth - suffix.length, "…")}${this.theme.fg("muted", suffix)}`;
+      }
+      const shortSuffix = " (Ctrl+O)";
+      if (safeWidth >= shortSuffix.length + 5) {
+        return `${truncateToWidth(body, safeWidth - shortSuffix.length, "…")}${this.theme.fg("muted", shortSuffix)}`;
+      }
+      return truncateToWidth(this.theme.fg("muted", shortSuffix.trim()), safeWidth, "…");
+    });
+    this.rendered = { width: safeWidth, lines: rendered };
+    return rendered;
+  }
+
+  invalidate(): void {
+    this.rendered = null;
+  }
+}
+
 class CollapsibleText implements Component {
   private readonly fullText: Text;
   private readonly footerText: Text;
@@ -47,8 +118,8 @@ class CollapsibleText implements Component {
     private readonly text: string,
     private readonly expanded: boolean,
     private readonly maxCollapsedLines: number,
-    private readonly ellipsis: string,
-    private readonly expandHint: string,
+    ellipsis: string,
+    expandHint: string,
     private readonly preTruncated = false,
   ) {
     this.fullText = new Text(text, 0, 0);
@@ -168,13 +239,52 @@ function renderToolCallLines(lines: string[], theme?: RenderTheme) {
   return new Text([styledTitle, ...styledRest].join("\n"), 0, 0);
 }
 
-export function renderMcpProxyToolCall(args: McpProxyToolCallInput, theme?: RenderTheme) {
-  return renderToolCallLines(formatMcpProxyToolCallLines(args), theme);
+export function resolveMcpToolRenderOptions(settings?: McpToolRenderSettings): McpToolRenderOptions {
+  const resultRendering = settings?.toolResultRendering === "boxed" ? "boxed" : "compact";
+  const collapsedLines = settings?.collapsedResultLines;
+  const defaultLines = resultRendering === "boxed" ? DEFAULT_BOXED_COLLAPSED_LINES : DEFAULT_COMPACT_COLLAPSED_LINES;
+  return {
+    resultRendering,
+    collapsedResultLines: collapsedLines === 1 || collapsedLines === 2 || collapsedLines === 3 ? collapsedLines : defaultLines,
+  };
+}
+
+function shouldUseCompactFinalRender(options: McpToolRenderOptions, context?: McpToolRenderContext): boolean {
+  return options.resultRendering === "compact"
+    && context !== undefined
+    && context.isPartial === false
+    && context.expanded !== true
+    && context.isError !== true;
 }
 
-export function createMcpDirectToolCallRenderer(displayName: string) {
-  return (args: Record<string, unknown>, theme?: RenderTheme) => {
-    return renderToolCallLines(formatMcpDirectToolCallLines(displayName, args), theme);
+function renderToolCall(
+  lines: string[],
+  theme: RenderTheme | undefined,
+  context: McpToolRenderContext | undefined,
+  options: McpToolRenderOptions,
+) {
+  if (context?.state) context.state.compactTitle = lines[0] ?? "mcp";
+  if (shouldUseCompactFinalRender(options, context)) return new EmptyComponent();
+  return renderToolCallLines(lines, theme);
+}
+
+export function renderMcpProxyToolCall(
+  args: McpProxyToolCallInput,
+  theme?: RenderTheme,
+  context?: McpToolRenderContext,
+) {
+  return renderToolCall(formatMcpProxyToolCallLines(args), theme, context, resolveMcpToolRenderOptions());
+}
+
+export function createMcpProxyToolCallRenderer(options: McpToolRenderOptions) {
+  return (args: McpProxyToolCallInput, theme?: RenderTheme, context?: McpToolRenderContext) => {
+    return renderToolCall(formatMcpProxyToolCallLines(args), theme, context, options);
+  };
+}
+
+export function createMcpDirectToolCallRenderer(displayName: string, options = resolveMcpToolRenderOptions()) {
+  return (args: Record<string, unknown>, theme?: RenderTheme, context?: McpToolRenderContext) => {
+    return renderToolCall(formatMcpDirectToolCallLines(displayName, args), theme, context, options);
   };
 }
 
@@ -254,7 +364,7 @@ export function formatMcpToolResultIdentity(details: McpToolResultDetails | unde
 export function formatMcpToolResultLines(
   result: Pick<AgentToolResult<McpToolResultDetails>, "content">,
   expanded: boolean,
-  maxCollapsedLines = 3,
+  maxCollapsedLines = DEFAULT_BOXED_COLLAPSED_LINES,
   maxCollapsedChars = DEFAULT_MAX_COLLAPSED_CHARS,
 ): McpToolResultDisplay {
   if (!expanded) {
@@ -271,6 +381,7 @@ export function renderMcpToolResult(
   options: ToolRenderResultOptions,
   theme?: RenderTheme,
   context?: McpToolRenderContext,
+  renderOptions = resolveMcpToolRenderOptions(),
 ) {
   const activeTheme = theme ?? plainTheme;
   if (options.isPartial) {
@@ -279,7 +390,13 @@ export function renderMcpToolResult(
 
   const hasErrorDetails = Boolean(result.details.error);
   const expanded = options.expanded || context?.isError === true || hasErrorDetails;
-  const display = formatMcpToolResultLines(result, expanded);
+  if (!expanded && renderOptions.resultRendering === "compact") {
+    const display = formatMcpToolResultLines(result, false, renderOptions.collapsedResultLines);
+    const title = context?.state?.compactTitle ?? formatMcpToolResultIdentity(result.details) ?? "";
+    return new CompactMcpToolResult(title, display, activeTheme);
+  }
+
+  const display = formatMcpToolResultLines(result, expanded, renderOptions.collapsedResultLines);
   const identity = formatMcpToolResultIdentity(result.details);
   const output = [
     ...(identity ? [activeTheme.fg("muted", identity)] : []),
@@ -289,9 +406,18 @@ export function renderMcpToolResult(
   return new CollapsibleText(
     output,
     expanded,
-    DEFAULT_MAX_COLLAPSED_LINES + (identity ? 1 : 0),
+    renderOptions.collapsedResultLines + (identity ? 1 : 0),
     activeTheme.fg("muted", "…"),
     activeTheme.fg("muted", "(Ctrl+O to expand)"),
     display.truncated,
   );
 }
+
+export function createMcpToolResultRenderer(renderOptions: McpToolRenderOptions) {
+  return (
+    result: AgentToolResult<McpToolResultDetails>,
+    options: ToolRenderResultOptions,
+    theme?: RenderTheme,
+    context?: McpToolRenderContext,
+  ) => renderMcpToolResult(result, options, theme, context, renderOptions);
+}

package/node_modules/pi-mcp-adapter/types.ts

@@ -395,6 +395,13 @@ export interface ServerEntry {
   // Include/exclude specific MCP tools/resources by original or prefixed name
   includeTools?: string[];
   excludeTools?: string[];
+  /**
+   * Extra search keywords per tool, keyed by original name, prefixed name, or
+   * glob (same matching rules as includeTools/excludeTools). Keywords boost
+   * mcp({ search }) ranking only — they never appear in tool schemas,
+   * describe output, or the metadata cache.
+   */
+  searchKeywords?: Record<string, string[]>;
   // Require interactive approval before calling matching MCP tools/resources.
   approveTools?: boolean | string[];
   // Debug
@@ -473,6 +480,8 @@ export interface McpSettings {
   showStatusIcon?: boolean;
   /** Footer status verbosity: full details, compact connected/enabled count, or no footer status. Defaults to full. */
   mcpFooterStatus?: McpFooterStatus;
+  /** Show successful startup connection notifications. Defaults to true. */
+  notifyOnStartupConnect?: boolean;
   /** Discover detected host-specific MCP configs only when explicitly enabled. */
   hostConfigDiscovery?: HostConfigDiscovery;
   /** Agent Plugin package directories to load MCP servers from. */
@@ -482,6 +491,10 @@ export interface McpSettings {
   directTools?: boolean;
   /** Register the trusted MCP-only JavaScript scripting tool. Defaults to true; set false to hide it. */
   scriptMode?: boolean;
+  /** Render MCP tool results as compact self-rendered rows by default, or as the legacy boxed row. */
+  toolResultRendering?: "compact" | "boxed";
+  /** Number of result text lines to show before expansion. Supports 1, 2, or 3. Defaults to 1 in compact mode and 3 in boxed mode. */
+  collapsedResultLines?: 1 | 2 | 3;
   /** Default approval gate for matching tools/resources; per-server settings override it. */
   approveTools?: boolean | string[];
   disableProxyTool?: boolean;
@@ -635,18 +648,25 @@ export interface McpPanelResult {
 /**
  * Get server prefix based on tool prefix mode.
  */
+function sanitizeServerPrefix(serverName: string, preserveProviderValid = true): string {
+  const validCharacters = preserveProviderValid ? /^[A-Za-z0-9_-]$/ : /^[A-Za-z0-9]$/;
+  return Array.from(serverName, char =>
+    validCharacters.test(char) ? char : `_${char.codePointAt(0)!.toString(16)}_`,
+  ).join("");
+}
+
 export function getServerPrefix(
   serverName: string,
   mode: ToolPrefix
 ): string {
   if (mode === "none") return "";
   if (mode === "short") {
-    let short = serverName.replace(/-?mcp$/i, "").replace(/-/g, "_");
+    let short = sanitizeServerPrefix(serverName.replace(/-?mcp$/i, ""));
     if (!short) short = "mcp";
     return short;
   }
-  if (mode === "mcp") return `mcp__${serverName.replace(/-/g, "_")}`;
-  return serverName.replace(/-/g, "_");
+  if (mode === "mcp") return `mcp__${sanitizeServerPrefix(serverName)}`;
+  return sanitizeServerPrefix(serverName);
 }
 
 /**
@@ -700,11 +720,9 @@ export function resolveServerFromToolName(
   if (candidates.length === 0) return undefined;
   candidates.sort((a, b) => b.prefix.length - a.prefix.length);
   const best = candidates[0];
-  // Fail safe: two distinct server names can normalize to the same prefix
-  // (e.g. my-server and my_server both -> my_server under "server" mode).
-  // When that happens the owning server is ambiguous; return undefined so a
-  // downstream permission gate falls back to its existing wildcard path rather
-  // than enforcing a rule against the wrong server.
+  // Fail safe: short mode can intentionally map names such as foo and foo-mcp
+  // to the same prefix. Return undefined so a downstream permission gate uses
+  // its existing wildcard path rather than enforcing a rule against the wrong server.
   if (candidates.some((c) => c.prefix === best!.prefix && c.name !== best!.name)) {
     return undefined;
   }
@@ -722,22 +740,48 @@ export function formatPromptCommandName(
   serverName: string,
   prefix: ToolPrefix,
 ): string {
-  const serverPart = getServerPrefix(serverName, prefix) || serverName.replace(/-/g, "_") || "server";
+  const serverPart = getServerPrefix(serverName, prefix) || sanitizeServerPrefix(serverName) || "server";
   return `mcp__${serverPart}__${sanitizePromptName(promptName)}`;
 }
 
-function normalizeToolName(value: string): string {
-  return value.replace(/-/g, "_");
+function getLegacyServerPrefix(serverName: string, mode: ToolPrefix): string {
+  if (mode === "none") return "";
+  if (mode === "short") return sanitizeServerPrefix(serverName.replace(/-?mcp$/i, ""), false) || "mcp";
+  if (mode === "mcp") return `mcp__${sanitizeServerPrefix(serverName, false)}`;
+  return sanitizeServerPrefix(serverName, false);
 }
 
-export function getToolNameCandidates(toolName: string, serverName: string, prefix: ToolPrefix): Set<string> {
-  return new Set<string>([
-    normalizeToolName(toolName),
-    normalizeToolName(formatToolName(toolName, serverName, prefix)),
-    normalizeToolName(formatToolName(toolName, serverName, "server")),
-    normalizeToolName(formatToolName(toolName, serverName, "short")),
-    normalizeToolName(formatToolName(toolName, serverName, "mcp")),
+function formatLegacyToolName(toolName: string, serverName: string, prefix: ToolPrefix): string {
+  const serverPrefix = getLegacyServerPrefix(serverName, prefix);
+  const sanitizedToolName = toolName.replace(/[.-]/g, "_");
+  return serverPrefix ? `${serverPrefix}_${sanitizedToolName}` : sanitizedToolName;
+}
+
+export function getToolNameCandidates(toolName: string, serverName: string, prefix: ToolPrefix, includeLegacy = true): Set<string> {
+  const candidates = new Set<string>([
+    toolName,
+    formatToolName(toolName, serverName, prefix),
+    formatToolName(toolName, serverName, "server"),
+    formatToolName(toolName, serverName, "short"),
+    formatToolName(toolName, serverName, "mcp"),
   ]);
+  if (includeLegacy) {
+    const legacyToolName = toolName.replace(/-/g, "_");
+    candidates.add(legacyToolName);
+    candidates.add(formatToolName(legacyToolName, serverName, prefix));
+    candidates.add(formatToolName(legacyToolName, serverName, "server"));
+    candidates.add(formatToolName(legacyToolName, serverName, "short"));
+    candidates.add(formatToolName(legacyToolName, serverName, "mcp"));
+    candidates.add(formatLegacyToolName(toolName, serverName, prefix));
+    candidates.add(formatLegacyToolName(toolName, serverName, "server"));
+    candidates.add(formatLegacyToolName(toolName, serverName, "short"));
+    candidates.add(formatLegacyToolName(toolName, serverName, "mcp"));
+    candidates.add(formatToolName(toolName, serverName, prefix).replace(/-/g, "_"));
+    candidates.add(formatToolName(toolName, serverName, "server").replace(/-/g, "_"));
+    candidates.add(formatToolName(toolName, serverName, "short").replace(/-/g, "_"));
+    candidates.add(formatToolName(toolName, serverName, "mcp").replace(/-/g, "_"));
+  }
+  return candidates;
 }
 
 function globToRegExp(pattern: string): RegExp {
@@ -750,11 +794,10 @@ export function matchesToolPattern(candidates: Set<string>, patterns?: unknown):
 
   for (const pattern of patterns) {
     if (typeof pattern !== "string") continue;
-    const normalized = normalizeToolName(pattern);
-    if (!normalized.includes("*") && !normalized.includes("?") && candidates.has(normalized)) {
+    if (!pattern.includes("*") && !pattern.includes("?") && candidates.has(pattern)) {
       return true;
     }
-    if ((normalized.includes("*") || normalized.includes("?")) && [...candidates].some(candidate => globToRegExp(normalized).test(candidate))) {
+    if ((pattern.includes("*") || pattern.includes("?")) && [...candidates].some(candidate => globToRegExp(pattern).test(candidate))) {
       return true;
     }
   }
@@ -762,23 +805,45 @@ export function matchesToolPattern(candidates: Set<string>, patterns?: unknown):
   return false;
 }
 
+function matchesToolSelector(
+  toolName: string,
+  serverName: string,
+  prefix: ToolPrefix,
+  patterns: unknown,
+  otherCurrentCandidates?: Set<string>,
+): boolean {
+  const currentCandidates = getToolNameCandidates(toolName, serverName, prefix, false);
+  if (matchesToolPattern(currentCandidates, patterns)) return true;
+  if (!otherCurrentCandidates) return matchesToolPattern(getToolNameCandidates(toolName, serverName, prefix), patterns);
+  const legacyCandidates = getToolNameCandidates(toolName, serverName, prefix);
+  for (const candidate of currentCandidates) legacyCandidates.delete(candidate);
+  if (!Array.isArray(patterns)) return false;
+  return patterns.some(pattern =>
+    typeof pattern === "string"
+    && !matchesToolPattern(otherCurrentCandidates, [pattern])
+    && matchesToolPattern(legacyCandidates, [pattern]),
+  );
+}
+
 export function isToolIncluded(
   toolName: string,
   serverName: string,
   prefix: ToolPrefix,
-  includeTools?: unknown
+  includeTools?: unknown,
+  otherCurrentCandidates?: Set<string>,
 ): boolean {
   if (!Array.isArray(includeTools) || includeTools.length === 0) return true;
-  return matchesToolPattern(getToolNameCandidates(toolName, serverName, prefix), includeTools);
+  return matchesToolSelector(toolName, serverName, prefix, includeTools, otherCurrentCandidates);
 }
 
 export function isToolExcluded(
   toolName: string,
   serverName: string,
   prefix: ToolPrefix,
-  excludeTools?: unknown
+  excludeTools?: unknown,
+  otherCurrentCandidates?: Set<string>,
 ): boolean {
-  return matchesToolPattern(getToolNameCandidates(toolName, serverName, prefix), excludeTools);
+  return matchesToolSelector(toolName, serverName, prefix, excludeTools, otherCurrentCandidates);
 }
 
 export function isToolAllowed(
@@ -787,7 +852,8 @@ export function isToolAllowed(
   prefix: ToolPrefix,
   includeTools?: unknown,
   excludeTools?: unknown,
+  otherCurrentCandidates?: Set<string>,
 ): boolean {
-  return isToolIncluded(toolName, serverName, prefix, includeTools)
-    && !isToolExcluded(toolName, serverName, prefix, excludeTools);
+  return isToolIncluded(toolName, serverName, prefix, includeTools, otherCurrentCandidates)
+    && !isToolExcluded(toolName, serverName, prefix, excludeTools, otherCurrentCandidates);
 }

package/node_modules/pi-mcp-adapter/ui-server.ts

@@ -18,6 +18,7 @@ import type { McpExtensionState } from "./state.ts";
 import { SessionRecoveryAuthRequiredError, withSessionRecovery, type SessionRecoveryDeps } from "./session-recovery.ts";
 import { ensureToolCallApproved, isToolCallApprovalRequired } from "./tool-approval.ts";
 import { extractUiToolVisibility, isUiToolCallableByApp, isUiToolVisibleToModel } from "./ui-tool-visibility.ts";
+import { resourceNameToToolName } from "./resource-tools.ts";
 import {
   createUiModelContextUpdate,
   extractUiPromptText,
@@ -451,6 +452,23 @@ export async function startUiServer(options: UiServerOptions): Promise<UiServerH
           ...(toolDefinition?.inputSchema !== undefined ? { inputSchema: toolDefinition.inputSchema } : {}),
           ...(uiVisibility !== undefined ? { uiVisibility } : {}),
         };
+        const approvalMetadata = new Map(options.state?.toolMetadata);
+        const definition = options.config?.mcpServers[options.serverName] ?? options.state?.config.mcpServers[options.serverName];
+        approvalMetadata.set(options.serverName, [
+          ...connection.tools.map(tool => ({
+            name: tool.name,
+            originalName: tool.name,
+            description: tool.description ?? "",
+          })),
+          ...(definition?.exposeResources !== false ? (connection.resources ?? []).map(resource => {
+            const originalName = `read_${resourceNameToToolName(resource.name)}`;
+            return {
+              name: originalName,
+              originalName,
+              description: resource.description ?? `Read resource: ${resource.uri}`,
+            };
+          }) : []),
+        ]);
         const approval = options.state
           ? await ensureToolCallApproved(
               options.state,
@@ -459,8 +477,9 @@ export async function startUiServer(options: UiServerOptions): Promise<UiServerH
               callArgs.arguments,
               options.state.owner?.signal,
               "iframe",
+              approvalMetadata,
             )
-          : options.config && isToolCallApprovalRequired(options.config, options.serverName, toolMeta)
+          : options.config && isToolCallApprovalRequired(options.config, options.serverName, toolMeta, approvalMetadata)
             ? { ok: false as const, reason: "approval_required_headless" as const }
             : { ok: true as const };
         if (approval.ok === false) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@herbertgao/pi-extensions",
-  "version": "2026.8.4",
+  "version": "2026.8.5",
   "description": "Aggregate installer for HerbertGao-maintained Pi extensions.",
   "keywords": [
     "extensions",
@@ -42,7 +42,7 @@
     "@earendil-works/pi-tui": "^0.84.1",
     "@effect/platform-node": "4.0.0-beta.103",
     "@effect/platform-node-shared": "4.0.0-beta.103",
-    "@herbertgao/pi-cc-extensions": "0.8.53",
+    "@herbertgao/pi-cc-extensions": "0.8.54",
     "@herbertgao/pi-copy-response": "0.2.6",
     "@herbertgao/pi-handoff": "1.1.2",
     "@herbertgao/pi-inline-skills": "1.0.5",
@@ -51,18 +51,18 @@
     "@herbertgao/pi-recap": "0.4.4",
     "@herbertgao/pi-rename": "0.4.2",
     "@herbertgao/pi-stash": "0.1.1",
-    "@herbertgao/pi-subagents": "0.15.3",
+    "@herbertgao/pi-subagents": "0.15.4",
     "@herbertgao/pi-titlebar-spinner": "0.1.3",
-    "@juicesharp/rpiv-ask-user-question": "2.4.0",
-    "@juicesharp/rpiv-config": "^2.4.0",
+    "@juicesharp/rpiv-ask-user-question": "2.5.2",
+    "@juicesharp/rpiv-config": "^2.5.2",
     "@modelcontextprotocol/client": "2.0.0",
     "@modelcontextprotocol/core": "2.0.0",
     "@modelcontextprotocol/ext-apps": "^1.2.2",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "@mozilla/readability": "^0.6.0",
     "@napi-rs/keyring": "^1.3.0",
-    "@narumitw/pi-btw": "0.50.0",
-    "@narumitw/pi-tui-kit": "^0.49.1",
+    "@narumitw/pi-btw": "0.51.0",
+    "@narumitw/pi-tui-kit": "^0.54.0",
     "@noble/ed25519": "^3.1.0",
     "@pi-plugins/fast-mode": "0.1.9",
     "@shikijs/cli": "^4.0.2",
@@ -77,13 +77,13 @@
     "jiti": "^2.7.0",
     "js-yaml": "^5.2.2",
     "linkedom": "^0.16.0",
-    "minimatch": "^10.2.5",
+    "minimatch": "^10.2.6",
     "nanoid": "^5.0.0",
     "open": "^10.2.0",
     "p-limit": "^6.1.0",
     "pi-footer": "0.5.1",
-    "pi-lens": "3.8.74",
-    "pi-mcp-adapter": "2.23.0",
+    "pi-lens": "4.0.0",
+    "pi-mcp-adapter": "2.25.0",
     "pi-web-access": "0.22.0",
     "pidusage": "^4.0.1",
     "promise.try": "^2.0.1",
@@ -161,8 +161,7 @@
     "skills": [
       "./node_modules/@dietrichgebert/ponytail/skills",
       "./node_modules/pi-mcp-adapter/skills",
-      "./node_modules/pi-lens/skills",
-      "./node_modules/remote-pi/skills"
+      "./node_modules/pi-lens/skills"
     ]
   }
 }