@herbertgao/pi-extensions 2026.8.1 → 2026.8.2

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

@@ -1,4 +1,4 @@
-import { getToolUiResourceUri } from "@modelcontextprotocol/ext-apps/app-bridge";
+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";
@@ -44,14 +44,15 @@ export function buildToolMetadata(
     } catch {
       failedTools.push(tool.name);
     }
+    const uiStreamMode = extractToolUiStreamMode(tool._meta);
     metadata.push({
       name,
       originalName: tool.name,
       description: tool.description ?? "",
-      inputSchema: tool.inputSchema,
-      uiResourceUri,
-      uiVisibility,
-      uiStreamMode: extractToolUiStreamMode(tool._meta),
+      ...(tool.inputSchema !== undefined ? { inputSchema: tool.inputSchema } : {}),
+      ...(uiResourceUri !== undefined ? { uiResourceUri } : {}),
+      ...(uiVisibility !== undefined ? { uiVisibility } : {}),
+      ...(uiStreamMode !== undefined ? { uiStreamMode } : {}),
     });
   }
 

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

@@ -41,6 +41,7 @@ class CollapsibleText implements Component {
   private readonly fullText: Text;
   private readonly footerText: Text;
   private collapsedText: { charBudget: number; fullyIncluded: boolean; text: Text } | null = null;
+  private collapsedRender: { width: number; charBudget: number; lines: string[] } | null = null;
 
   constructor(
     private readonly text: string,
@@ -70,18 +71,29 @@ class CollapsibleText implements Component {
         fullyIncluded: prefix === this.text,
         text: new Text(prefix, 0, 0),
       };
+      this.collapsedRender = null;
     }
 
     const lines = this.collapsedText.text.render(width);
     if (!this.preTruncated && this.collapsedText.fullyIncluded && lines.length <= this.maxCollapsedLines) return lines;
+    if (this.collapsedRender?.width === width && this.collapsedRender.charBudget === charBudget) {
+      return this.collapsedRender.lines;
+    }
 
-    return [
+    const rendered = [
       ...lines.slice(0, this.maxCollapsedLines),
       ...this.footerText.render(width),
     ];
+    this.collapsedRender = { width, charBudget, lines: rendered };
+    return rendered;
   }
 
-  invalidate(): void {}
+  invalidate(): void {
+    this.fullText.invalidate();
+    this.footerText.invalidate();
+    this.collapsedText?.text.invalidate();
+    this.collapsedRender = null;
+  }
 }
 
 function truncateText(value: string, maxChars: number): string {

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

@@ -39,7 +39,10 @@ export function renderTsShape(inputSchema: unknown): string | null {
         if (typeof schema.$ref !== "string") return null;
         const match = schema.$ref.match(/^#\/(\$defs|definitions)\/([^/]+)$/);
         if (!match) return null;
-        const definitionKey = `${match[1]}/${decodePointerToken(match[2])}`;
+        const definitionGroup = match[1];
+        const definitionName = match[2];
+        if (definitionGroup === undefined || definitionName === undefined) return null;
+        const definitionKey = `${definitionGroup}/${decodePointerToken(definitionName)}`;
         if (!definitions.has(definitionKey)) return null;
         return aliasFor(definitionKey);
       }
@@ -108,7 +111,11 @@ function isSchema(value: unknown): value is Schema {
 }
 
 function hasUnsupportedKeyword(schema: Schema): boolean {
-  return UNSUPPORTED_KEYWORDS.some(keyword => Object.hasOwn(schema, keyword));
+  return UNSUPPORTED_KEYWORDS.some(keyword => {
+    if (!Object.hasOwn(schema, keyword)) return false;
+    // `additionalProperties: false` is a closed-object constraint, not a shape that this renderer needs to understand.
+    return keyword !== "additionalProperties" || schema.additionalProperties !== false;
+  });
 }
 
 function decodePointerToken(token: string): string {

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

@@ -1,6 +1,11 @@
 // types.ts - Core type definitions
-import type { Transport as McpTransport } from "@modelcontextprotocol/sdk/shared/transport.js";
-import type { ContentBlock as McpContentBlock } from "@modelcontextprotocol/sdk/types.js";
+import type {
+  ContentBlock as McpContentBlock,
+  ListPromptsResult,
+  ListResourcesResult,
+  ListToolsResult,
+  Transport as McpTransport,
+} from "@modelcontextprotocol/client";
 import type { TextContent, ImageContent } from "@earendil-works/pi-ai";
 import type { UiStreamMode } from "./ui-stream-types.ts";
 import type { UiToolVisibility } from "./ui-tool-visibility.ts";
@@ -48,36 +53,41 @@ export type ImportKind =
   | "windsurf" 
   | "vscode";
 
-// Tool definition from MCP server
+type SdkTool = ListToolsResult["tools"][number];
+type SdkResource = ListResourcesResult["resources"][number];
+type SdkPrompt = ListPromptsResult["prompts"][number];
+type SdkPromptArgument = NonNullable<SdkPrompt["arguments"]>[number];
+
+// MCP wire definitions derive their field types from the installed SDK while
+// retaining the adapter's deliberately smaller public surface.
 export interface McpTool {
-  name: string;
-  title?: string;
-  description?: string;
-  inputSchema?: unknown; // JSON Schema
-  _meta?: Record<string, unknown>;
+  name: SdkTool["name"];
+  title?: SdkTool["title"];
+  description?: SdkTool["description"];
+  inputSchema?: SdkTool["inputSchema"]; // JSON Schema
+  _meta?: SdkTool["_meta"];
 }
 
-// Resource definition from MCP server
 export interface McpResource {
-  uri: string;
-  name: string;
-  description?: string;
-  mimeType?: string;
-  _meta?: Record<string, unknown>;
+  uri: SdkResource["uri"];
+  name: SdkResource["name"];
+  description?: SdkResource["description"];
+  mimeType?: SdkResource["mimeType"];
+  _meta?: SdkResource["_meta"];
 }
 
 export interface McpPromptArgument {
-  name: string;
-  description?: string;
-  required?: boolean;
+  name: SdkPromptArgument["name"];
+  description?: SdkPromptArgument["description"];
+  required?: SdkPromptArgument["required"];
 }
 
 export interface McpPrompt {
-  name: string;
-  title?: string;
-  description?: string;
-  arguments?: McpPromptArgument[];
-  _meta?: Record<string, unknown>;
+  name: SdkPrompt["name"];
+  title?: SdkPrompt["title"];
+  description?: SdkPrompt["description"];
+  arguments?: SdkPrompt["arguments"];
+  _meta?: SdkPrompt["_meta"];
 }
 
 export interface UiResourceMeta {
@@ -340,6 +350,8 @@ export interface OAuthConfig {
   clientName?: string;
   /** Client homepage URI for dynamic registration */
   clientUri?: string;
+  /** Security-weakening escape hatch for known-misconfigured authorization servers. */
+  skipIssuerMetadataValidation?: boolean;
 }
 
 // Server configuration
@@ -387,6 +399,20 @@ export interface ServerEntry {
   debug?: boolean;  // Show server stderr (default: false)
   /** Enable metadata-only JSONL protocol tracing for this server. */
   trace?: boolean;
+  /** Force a specific HTTP MCP transport. Used by Agent Plugins, whose `type` declares the transport and forbids client fallback. */
+  httpTransport?: "streamable-http" | "sse";
+  /** Client-managed persistent data directory for Agent Plugin stdio servers. */
+  pluginDataDir?: string;
+  /** Treat env values as already resolved literals. Used for Agent Plugin env rules. */
+  literalEnv?: boolean;
+  /**
+   * MCP protocol era negotiation for this server. Defaults to `"legacy"`
+   * (byte-equivalent to pre-2026 behavior — no `versionNegotiation` is sent).
+   * `"auto"` offers the SDK's default 2026-07-28+ modern versions with
+   * legacy fallback; `"2026-07-28"` pins the connection to that revision
+   * with no fallback. `auto` and `2026-07-28` must be set explicitly.
+   */
+  protocolVersion?: "legacy" | "auto" | "2026-07-28";
   // Keep configuration visible without allowing connections or execution.
   disabled?: boolean;
 }
@@ -422,6 +448,23 @@ export interface McpTraceSettings {
   maxEvents?: number;
 }
 
+export const MCP_TOOL_APPROVAL_REQUEST_EVENT = "pi-mcp-adapter:tool-approval-request" as const;
+
+export type McpToolApprovalOrigin = "proxy" | "direct" | "script" | "resource" | "iframe";
+export type McpToolApprovalDecision = "allow_once" | "allow_for_session" | "deny" | "abstain";
+export type McpToolApprovalHandler = () => McpToolApprovalDecision | Promise<McpToolApprovalDecision>;
+
+export interface McpToolApprovalRequest {
+  requestId: string;
+  serverName: string;
+  originalToolName: string;
+  prefixedToolName: string;
+  args: Record<string, unknown>;
+  origin: McpToolApprovalOrigin;
+  signal?: AbortSignal;
+  claim(handler: McpToolApprovalHandler): boolean;
+}
+
 export interface McpSettings {
   toolPrefix?: ToolPrefix;
   /** Show the plug prefix in MCP status and connection text (default: true). Set to false to disable it. */
@@ -430,6 +473,8 @@ export interface McpSettings {
   mcpFooterStatus?: McpFooterStatus;
   /** Discover detected host-specific MCP configs only when explicitly enabled. */
   hostConfigDiscovery?: HostConfigDiscovery;
+  /** Agent Plugin package directories to load MCP servers from. */
+  agentPluginPaths?: string[];
   idleTimeout?: number; // minutes, default 10, 0 to disable
   requestTimeoutMs?: number; // milliseconds, overrides the SDK request timeout when > 0
   directTools?: boolean;
@@ -622,6 +667,48 @@ export function resolveToolPrefix(
   return definition?.toolPrefix ?? globalPrefix ?? "server";
 }
 
+
+/**
+ * Resolve a configured MCP server name from a prefixed tool name.
+ *
+ * When the proxy tool is addressed with a fully-qualified name such as
+ * `searxng_searxng_web_search`, downstream policy systems (for example a
+ * permission gate) need to recover the owning server so they can evaluate
+ * server-scoped rules against the bare server name. This performs the inverse
+ * of {@link getServerPrefix}: it finds the longest configured server prefix
+ * that the tool name starts with and returns that server's name.
+ *
+ * @param toolName - the tool name as passed to the proxy `mcp({ tool })` call.
+ * @param serverNames - the configured MCP server names (keys of `mcpServers`).
+ * @param prefix - the active tool-prefix mode.
+ * @returns the resolved server name, or `undefined` when no prefix matches or
+ *   the prefix mode is `"none"`.
+ */
+export function resolveServerFromToolName(
+  toolName: string,
+  serverNames: Iterable<string>,
+  prefix: ToolPrefix,
+): string | undefined {
+  if (prefix === "none") return undefined;
+  const candidates: { name: string; prefix: string }[] = [];
+  for (const name of serverNames) {
+    const p = getServerPrefix(name, prefix);
+    if (p && toolName.startsWith(p + "_")) candidates.push({ name, prefix: p });
+  }
+  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.
+  if (candidates.some((c) => c.prefix === best!.prefix && c.name !== best!.name)) {
+    return undefined;
+  }
+  return best?.name;
+}
+
 export function sanitizePromptName(name: string): string {
   const cleaned = name.replace(/[^A-Za-z0-9_-]+/g, "_").replace(/^[_-]+|[_-]+$/g, "");
   if (!cleaned) return "prompt";

package/node_modules/pi-mcp-adapter/ui-app-bridge-helpers.ts

@@ -0,0 +1,40 @@
+import type { UiResourcePermissions } from "./types.ts";
+
+export const RESOURCE_MIME_TYPE = "text/html;profile=mcp-app";
+
+const RESOURCE_URI_META_KEY = "ui/resourceUri";
+
+export function getToolUiResourceUri(tool: { _meta?: Record<string, unknown> | undefined }): string | undefined {
+  const meta = tool._meta;
+  let resourceUri = getNestedResourceUri(meta);
+  if (resourceUri === undefined) {
+    resourceUri = meta?.[RESOURCE_URI_META_KEY];
+  }
+
+  if (typeof resourceUri === "string" && resourceUri.startsWith("ui://")) {
+    return resourceUri;
+  }
+
+  if (resourceUri !== undefined) {
+    throw new Error(`Invalid UI resource URI: ${JSON.stringify(resourceUri)}`);
+  }
+
+  return undefined;
+}
+
+export function buildAllowAttribute(permissions: UiResourcePermissions | undefined): string {
+  if (!permissions) return "";
+
+  const allowed: string[] = [];
+  if (permissions.camera) allowed.push("camera");
+  if (permissions.microphone) allowed.push("microphone");
+  if (permissions.geolocation) allowed.push("geolocation");
+  if (permissions.clipboardWrite) allowed.push("clipboard-write");
+  return allowed.join("; ");
+}
+
+function getNestedResourceUri(meta: Record<string, unknown> | undefined): unknown {
+  const ui = meta?.ui;
+  if (!ui || typeof ui !== "object") return undefined;
+  return (ui as Record<string, unknown>).resourceUri;
+}

package/node_modules/pi-mcp-adapter/ui-resource-handler.ts

@@ -1,10 +1,10 @@
-import { RESOURCE_MIME_TYPE } from "@modelcontextprotocol/ext-apps/app-bridge";
-import { UrlElicitationRequiredError, type ReadResourceResult } from "@modelcontextprotocol/sdk/types.js";
+import { RESOURCE_MIME_TYPE } from "./ui-app-bridge-helpers.ts";
+import { UrlElicitationRequiredError, type ReadResourceResult } from "@modelcontextprotocol/client";
 import { ResourceFetchError, ResourceParseError } from "./errors.ts";
 import { logger } from "./logger.ts";
 import { SessionRecoveryAuthRequiredError, withSessionRecovery, type SessionRecoveryDeps } from "./session-recovery.ts";
 import type { McpServerManager } from "./server-manager.ts";
-import { isServerDisabled, type McpConfig, type UiResourceContent, type UiResourceCsp, type UiResourceMeta } from "./types.ts";
+import { isServerDisabled, type McpConfig, type UiResourceContent, type UiResourceCsp, type UiResourceMeta, type UiResourcePermissions } from "./types.ts";
 
 interface ResourceContentRecord {
   uri?: string;
@@ -23,7 +23,7 @@ interface ReadUiResourceOptions {
 export class UiResourceHandler {
   private log = logger.child({ component: "UiResourceHandler" });
 
-  constructor(private manager: McpServerManager, private config?: McpConfig) {}
+  constructor(private manager: McpServerManager, private config: McpConfig | undefined = undefined) {}
 
   async readUiResource(serverName: string, uri: string, options: ReadUiResourceOptions = {}): Promise<UiResourceContent> {
     const log = this.log.child({ server: serverName, uri });
@@ -45,7 +45,12 @@ export class UiResourceHandler {
         this.manager.incrementInFlight(serverName);
         try {
           result = await withSessionRecovery(
-            { manager: this.manager, config, signal: options.signal, onNeedsAuth: options.onNeedsAuth },
+            {
+              manager: this.manager,
+              config,
+              ...(options.signal ? { signal: options.signal } : {}),
+              ...(options.onNeedsAuth ? { onNeedsAuth: options.onNeedsAuth } : {}),
+            },
             serverName,
             (connection) => connection.client.readResource({ uri }, this.manager.getRequestOptions(serverName, options.signal)),
           );
@@ -62,7 +67,7 @@ export class UiResourceHandler {
       log.error("Failed to read resource", error instanceof Error ? error : undefined);
       throw new ResourceFetchError(uri, message, {
         server: serverName,
-        cause: error instanceof Error ? error : undefined,
+        ...(error instanceof Error ? { cause: error } : {}),
       });
     }
 
@@ -97,10 +102,14 @@ export class UiResourceHandler {
       html,
       mimeType: mimeType ?? RESOURCE_MIME_TYPE,
       meta: {
-        csp: contentMeta.csp ?? listMeta.csp,
-        permissions: contentMeta.permissions ?? listMeta.permissions,
-        domain: contentMeta.domain ?? listMeta.domain,
-        prefersBorder: contentMeta.prefersBorder ?? listMeta.prefersBorder,
+        ...((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.prefersBorder ?? listMeta.prefersBorder) !== undefined
+          ? { prefersBorder: contentMeta.prefersBorder ?? listMeta.prefersBorder }
+          : {}),
       },
     };
   }
@@ -128,7 +137,11 @@ function selectContent(result: ReadResourceResult, preferredUri: string): Resour
   );
   if (byHtmlMime) return byHtmlMime;
 
-  return contents[0];
+  const firstContent = contents[0];
+  if (!firstContent) {
+    throw new Error(`No contents returned for UI resource: ${preferredUri}`);
+  }
+  return firstContent;
 }
 
 function isHtmlMimeType(mimeType: string): boolean {
@@ -166,10 +179,10 @@ function extractUiMeta(meta: Record<string, unknown> | undefined): UiResourceMet
 
   const ui = isRecord(meta.ui) ? meta.ui : undefined;
   const out: UiResourceMeta = {};
-  const openAiCsp = hasOwnProperty(meta, "openai/widgetCSP")
+  const openAiCsp = Object.hasOwn(meta, "openai/widgetCSP")
     ? normalizeOpenAiWidgetCsp(meta["openai/widgetCSP"])
     : undefined;
-  const hasStandardCsp = !!ui && hasOwnProperty(ui, "csp");
+  const hasStandardCsp = !!ui && Object.hasOwn(ui, "csp");
   const standardCspValue = hasStandardCsp ? ui.csp : undefined;
 
   if (hasStandardCsp && !isRecord(standardCspValue)) {
@@ -183,7 +196,7 @@ function extractUiMeta(meta: Record<string, unknown> | undefined): UiResourceMet
       out.csp = { ...openAiCsp, ...standardCsp };
       if (isRecord(standardCspValue)) {
         for (const [, standardField] of OPENAI_CSP_FIELD_MAPPINGS) {
-          if (hasOwnProperty(standardCspValue, standardField) && !copyStringArray(standardCspValue[standardField])) {
+          if (Object.hasOwn(standardCspValue, standardField) && !copyStringArray(standardCspValue[standardField])) {
             delete out.csp[standardField];
           }
         }
@@ -192,7 +205,7 @@ function extractUiMeta(meta: Record<string, unknown> | undefined): UiResourceMet
   }
 
   if (ui && isRecord(ui.permissions)) {
-    out.permissions = ui.permissions as UiResourceMeta["permissions"];
+    out.permissions = ui.permissions as UiResourcePermissions;
   }
   if (ui && typeof ui.domain === "string") {
     out.domain = ui.domain;
@@ -232,10 +245,6 @@ function copyStringArray(value: unknown): string[] | undefined {
     : undefined;
 }
 
-function hasOwnProperty(record: Record<string, unknown>, property: string): boolean {
-  return Object.prototype.hasOwnProperty.call(record, property);
-}
-
 function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }