@herbertgao/pi-extensions 2026.9.10 → 2026.9.12

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 { createToolSelectorCandidateIndex, formatToolName, getToolNameCandidates, isToolAllowed, resolveToolPrefix } from "./types.ts";
+import { createToolSelectorCandidateIndex, formatToolName, getToolNameCandidates, isToolAllowed, resolveToolPrefix, resolveUniqueNameOwnership } from "./types.ts";
 import { resourceNameToToolName } from "./resource-tools.ts";
 import { extractToolUiStreamMode } from "./utils.ts";
 import { extractUiToolVisibility, isUiToolVisibleToModel } from "./ui-tool-visibility.ts";
@@ -18,7 +18,6 @@ export function buildToolMetadata(
 ): { metadata: ToolMetadata[]; failedTools: string[] } {
   const metadata: ToolMetadata[] = [];
   const failedTools: string[] = [];
-  const seenNames = new Set<string>();
   const effectivePrefix = resolveToolPrefix(definition, prefix);
   const hasToolFilters =
     (Array.isArray(definition.includeTools) && definition.includeTools.length > 0) ||
@@ -86,16 +85,10 @@ export function buildToolMetadata(
     }
 
     const name = formatToolName(tool.name, serverName, effectivePrefix);
-    if (seenNames.has(name)) {
-      continue;
-    }
-
     const uiVisibility = extractUiToolVisibility(tool._meta);
     if (!isUiToolVisibleToModel(uiVisibility)) {
       continue;
     }
-    seenNames.add(name);
-
     let uiResourceUri: string | undefined;
     try {
       uiResourceUri = getToolUiResourceUri({ _meta: tool._meta });
@@ -123,11 +116,6 @@ export function buildToolMetadata(
       }
 
       const name = formatToolName(baseName, serverName, effectivePrefix);
-      if (seenNames.has(name)) {
-        continue;
-      }
-      seenNames.add(name);
-
       metadata.push({
         name,
         originalName: baseName,
@@ -137,7 +125,11 @@ export function buildToolMetadata(
     }
   }
 
-  return { metadata, failedTools };
+  const ownership = resolveUniqueNameOwnership(metadata, (tool) => tool.name);
+  for (const colliding of ownership.collisions.values()) {
+    failedTools.push(...colliding.map((tool) => tool.originalName));
+  }
+  return { metadata: ownership.unique, failedTools };
 }
 
 export function getToolNames(state: McpExtensionState, serverName: string): string[] {

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

@@ -230,18 +230,20 @@ export function transformMcpContent(content: McpContent[], scope?: object): Cont
 }
 
 /**
- * Resolve a tool result's content blocks, falling back to structuredContent
- * when content is empty.
+ * Resolve a tool result's content blocks, appending structuredContent when it
+ * coexists with ordinary content and falling back to it when content is empty.
  */
 export function resolveMcpResultContent(result: Record<string, unknown>, scope?: object): ContentBlock[] {
   const blocks = transformMcpContent((Array.isArray(result.content) ? result.content : []) as McpContent[], scope);
-  if (blocks.length > 0) return blocks;
-
   if (result.structuredContent !== undefined && result.structuredContent !== null) {
-    return [{ type: "text" as const, text: stringifyStructuredContent(result.structuredContent) }];
+    const structured = stringifyStructuredContent(result.structuredContent);
+    if (blocks.length > 0) {
+      return [...blocks, { type: "text" as const, text: `structuredContent:\n${structured}` }];
+    }
+    return [{ type: "text" as const, text: structured }];
   }
 
-  return [];
+  return blocks;
 }
 
 function stringifyStructuredContent(value: unknown): string {

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

@@ -225,7 +225,10 @@ export function formatMcpProxyToolCallLines(
   }
 
   if (args.connect) return [`mcp connect ${args.connect}`];
-  if (args.describe) return [`mcp describe ${args.describe}`];
+  if (args.describe) {
+    const target = args.server ? `${args.describe} @ ${args.server}` : args.describe;
+    return [`mcp describe ${target}`];
+  }
 
   if (args.search) {
     let line = `mcp search ${args.search}`;

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

@@ -498,6 +498,15 @@ export interface ServerEntry {
    * with no fallback. `auto` and `2026-07-28` must be set explicitly.
    */
   protocolVersion?: "legacy" | "auto" | "2026-07-28";
+  /**
+   * MCP Tasks extension (io.modelcontextprotocol/tasks, SEP-2663) support.
+   * On 2026-07-28 connections where the server advertises the extension, tool
+   * calls that return a task handle are transparently polled to completion,
+   * task-time elicitation is routed through the normal elicitation UI, and
+   * aborting a call cancels the remote task. Enabled by default; set to
+   * false to keep the plain synchronous call path.
+   */
+  tasks?: boolean;
   // Keep configuration visible without allowing connections or execution.
   disabled?: boolean;
 }
@@ -576,6 +585,8 @@ export interface McpToolApprovalRequest {
   claim(handler: McpToolApprovalHandler): boolean;
 }
 
+export type { JevAnswer, JevErrorCode, JevEvaluateInput, JevEvaluationData, JevEvaluationEnvelope, JevJson, JevQuestion } from "./jev-contracts.ts";
+
 export interface McpSettings {
   toolPrefix?: ToolPrefix;
   /** Show the plug prefix in MCP status and connection text (default: true). Set to false to disable it. */
@@ -593,6 +604,8 @@ export interface McpSettings {
   idleTimeout?: number; // minutes, default 10, 0 to disable
   requestTimeoutMs?: number; // milliseconds, overrides the SDK request timeout when > 0
   directTools?: boolean | "search";
+  /** Register per-server mcp__<server> namespace proxies. Defaults to true. */
+  namespaceProxyTools?: boolean;
   /**
    * Validate direct-tool inputs against the advertised schema after recovering
    * one JSON string layer for object and array properties. Defaults to false.
@@ -607,6 +620,25 @@ export interface McpSettings {
   warnOnLargeDirectTools?: boolean;
   /** Register the trusted MCP-only JavaScript scripting tool. Defaults to true; set false to hide it. */
   scriptMode?: boolean;
+  /** Optional TypeSafe Jev integrations. A valid key enables semantic search; script evaluation remains disabled by default. */
+  jev?: false | {
+    semanticSearch?: boolean;
+    scriptEvaluation?: boolean;
+    /** Restrict semantic-search metadata and allow script-evaluation sources. Semantic search defaults to every enabled server. */
+    allowedServers?: string[];
+    model?: string;
+    requestTimeoutMs?: number;
+    maxRetries?: number;
+    maxStateBytes?: number;
+    maxQuestionsPerRequest?: number;
+    maxEvaluationsPerScript?: number;
+    maxEvaluationBytesPerScript?: number;
+    /** Cumulative provider-reported input plus output tokens per script. Defaults to 32768. */
+    maxEvaluationTokensPerScript?: number;
+    /** Maximum semantic candidates per request. Defaults to 127; range 2..127. */
+    semanticCandidateLimit?: number;
+    semanticMinProbability?: number;
+  };
   /** 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. */
@@ -815,6 +847,9 @@ export function formatToolName(
 ): string {
   const p = getServerPrefix(serverName, prefix);
   const sanitized = toolName.replace(/\./g, "_");
+  if (p && sanitized.startsWith(`${p}_`) && sanitized.length > p.length + 1) {
+    return sanitized;
+  }
   return p ? `${p}_${sanitized}` : sanitized;
 }
 
@@ -825,6 +860,24 @@ export function resolveToolPrefix(
   return definition?.toolPrefix ?? globalPrefix ?? "server";
 }
 
+/** A canonical name has an owner only when exactly one eligible entry produces it. */
+export function resolveUniqueNameOwnership<T>(
+  entries: readonly T[],
+  getName: (entry: T) => string,
+): { unique: T[]; collisions: Map<string, T[]> } {
+  const owners = new Map<string, T[]>();
+  for (const entry of entries) {
+    const name = getName(entry);
+    const named = owners.get(name) ?? [];
+    named.push(entry);
+    owners.set(name, named);
+  }
+  const collisions = new Map([...owners].filter(([, named]) => named.length > 1));
+  return {
+    unique: entries.filter((entry) => !collisions.has(getName(entry))),
+    collisions,
+  };
+}
 
 /**
  * Resolve a configured MCP server name from a prefixed tool name.

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

@@ -19,10 +19,11 @@ import {
   SANDBOX_RESOURCE_PATH_PREFIX,
 } from "./sandbox-proxy-template.ts";
 import { logger } from "./logger.ts";
-import type { McpServerManager } from "./server-manager.ts";
+import type { McpServerManager, ServerConnection } from "./server-manager.ts";
 import type { McpExtensionState } from "./state.ts";
 import { SessionRecoveryAuthRequiredError, withSessionRecovery, type SessionRecoveryDeps } from "./session-recovery.ts";
 import { ensureToolCallApproved, isToolCallApprovalRequired } from "./tool-approval.ts";
+import { callToolViaTaskSession } from "./mcp-tasks.ts";
 import { extractUiToolVisibility, isUiToolCallableByApp, isUiToolVisibleToModel } from "./ui-tool-visibility.ts";
 import { resourceNameToToolName } from "./resource-tools.ts";
 import {
@@ -530,6 +531,19 @@ export async function startUiServer(options: UiServerOptions): Promise<UiServerH
         try {
           options.manager.touch(options.serverName);
           options.manager.incrementInFlight(options.serverName);
+          const callTool = async (conn: ServerConnection) => {
+            await options.manager.ensureListen?.(options.serverName, conn);
+            const requestOptions = options.manager.getRequestOptions?.(options.serverName);
+            if (conn.taskSession) {
+              return callToolViaTaskSession(conn.taskSession, {
+                name: callArgs.name,
+                args: callArgs.arguments,
+                requestTimeoutMs: requestOptions?.timeout,
+                signal: requestOptions?.signal,
+              });
+            }
+            return conn.client.callTool(callArgs, requestOptions);
+          };
           const result = options.config
             ? await withSessionRecovery(
                 {
@@ -538,15 +552,9 @@ export async function startUiServer(options: UiServerOptions): Promise<UiServerH
                   ...(options.onNeedsAuth ? { onNeedsAuth: options.onNeedsAuth } : {}),
                 },
                 options.serverName,
-                async (conn) => {
-                  await options.manager.ensureListen?.(options.serverName, conn);
-                  return conn.client.callTool(callArgs, options.manager.getRequestOptions?.(options.serverName));
-                },
+                callTool,
               )
-            : await (async () => {
-                await options.manager.ensureListen?.(options.serverName, connection);
-                return connection.client.callTool(callArgs, options.manager.getRequestOptions?.(options.serverName));
-              })();
+            : await callTool(connection);
           sendJson(res, 200, { ok: true, result });
         } finally {
           options.manager.decrementInFlight(options.serverName);

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

@@ -426,6 +426,22 @@ export function formatMcpStatus(config: Pick<McpConfig, "settings">, message: st
   return `${config.settings?.showStatusIcon === false ? "MCP: " : "🔌 MCP: "}${message}`;
 }
 
+export function formatMcpFooterStatus(
+  config: Pick<McpConfig, "settings">,
+  enabledCount: number,
+  disabledCount: number,
+  connectedCount: number,
+): string | undefined {
+  if (enabledCount + disabledCount === 0 || config.settings?.mcpFooterStatus === "off") return undefined;
+  const footerStatus = config.settings?.mcpFooterStatus ?? "full";
+  if (footerStatus === "compact") return `MCP ${connectedCount}/${enabledCount}`;
+
+  let status = `${enabledCount} ${enabledCount === 1 ? "server" : "servers"} enabled`;
+  if (connectedCount > 0) status += ` (${connectedCount} connected)`;
+  if (disabledCount > 0) status += ` (${disabledCount} disabled)`;
+  return formatMcpStatus(config, status);
+}
+
 /**
  * Extract the adapter-owned UI stream mode from tool metadata.
  */