@herbertgao/pi-extensions 2026.8.2 → 2026.8.3

package/node_modules/pi-mcp-adapter/proxy-modes.ts

@@ -10,7 +10,7 @@ import { combineAbortSignals, isAbortError } from "./runtime-owner.ts";
 import { buildToolMetadata, getToolNames, findToolByName, formatSchema } from "./tool-metadata.ts";
 import { renderTsShape } from "./ts-shape.ts";
 import { reconstructPromptMetadata } from "./metadata-cache.ts";
-import { resolveMcpResultContent, transformMcpContent } from "./tool-registrar.ts";
+import { resolveMcpResultContent, transformMcpContent, transformMcpResourceContents } from "./tool-registrar.ts";
 import { guardMcpOutput, guardedMcpDetails, resolveMcpOutputGuardOptions } from "./mcp-output-guard.ts";
 import { maybeStartUiSession, summarizeUiSessionResult, type UiSessionRuntime } from "./ui-session.ts";
 import { formatAuthRequiredMessage, formatMcpStatus, resolveServerUrl, truncateAtWord } from "./utils.ts";
@@ -21,6 +21,7 @@ import { ensureToolCallApproved, isToolCallApprovalRequired } from "./tool-appro
 
 type ProxyToolResult = AgentToolResult<Record<string, unknown>>;
 type ClientCallToolResult = Awaited<ReturnType<Client["callTool"]>>;
+type ClientReadResourceResult = Awaited<ReturnType<Client["readResource"]>>;
 
 const require = createRequire(import.meta.url);
 const MAX_REGEX_SEARCH_QUERY_LENGTH = 256;
@@ -1112,7 +1113,7 @@ export async function executeCall(
     state.manager.incrementInFlight(serverName);
 
     if (toolMeta.resourceUri) {
-      const result = await withSessionRecovery(
+      const result = await withSessionRecovery<ClientReadResourceResult>(
         {
           manager: state.manager,
           config: state.config,
@@ -1122,10 +1123,7 @@ export async function executeCall(
         serverName,
         (conn) => conn.client.readResource({ uri: toolMeta.resourceUri! }, requestOptions),
       );
-      const content = (result.contents ?? []).map(c => ({
-        type: "text" as const,
-        text: "text" in c ? c.text : ("blob" in c ? `[Binary data: ${(c as { mimeType?: string }).mimeType ?? "unknown"}]` : JSON.stringify(c)),
-      }));
+      const content = transformMcpResourceContents(result.contents ?? [], state.owner?.signal);
       const guarded = await guardMcpOutput(content.length > 0 ? content : [{ type: "text" as const, text: "(empty resource)" }], outputGuardOptions);
       return {
         content: guarded.content,
@@ -1165,7 +1163,7 @@ export async function executeCall(
 
       if (result.isError) {
         const mcpContent = (result.content ?? []) as McpContent[];
-        const content = transformMcpContent(mcpContent);
+        const content = transformMcpContent(mcpContent, state.owner?.signal);
         const outputContent = content.length > 0 ? content : [{ type: "text" as const, text: "(empty result)" }];
         const schemaText = toolMeta.inputSchema ? `\n\nExpected parameters:\n${formatSchema(toolMeta.inputSchema)}` : "";
         const guarded = await guardMcpOutput(outputContent, { ...outputGuardOptions, prefix: "Error: ", suffix: schemaText, emptyTextFallback: "Tool execution failed", rawMcpResult: result });
@@ -1175,7 +1173,7 @@ export async function executeCall(
         };
       }
 
-      const content = resolveMcpResultContent(result as Record<string, unknown>);
+      const content = resolveMcpResultContent(result as Record<string, unknown>, state.owner?.signal);
       const outputContent = content.length > 0 ? content : [{ type: "text" as const, text: "(empty result)" }];
       const uiSummary = summarizeUiSessionResult(uiSession);
       const guarded = await guardMcpOutput(outputContent, { ...outputGuardOptions, suffix: `\n\n${uiSummary.message}`, rawMcpResult: result });
@@ -1194,7 +1192,7 @@ export async function executeCall(
 
     if (result.isError) {
       const mcpContent = (result.content ?? []) as McpContent[];
-      const content = transformMcpContent(mcpContent);
+      const content = transformMcpContent(mcpContent, state.owner?.signal);
       const outputContent = content.length > 0 ? content : [{ type: "text" as const, text: "(empty result)" }];
       const schemaText = toolMeta.inputSchema ? `\n\nExpected parameters:\n${formatSchema(toolMeta.inputSchema)}` : "";
       const guarded = await guardMcpOutput(outputContent, { ...outputGuardOptions, prefix: "Error: ", suffix: schemaText, emptyTextFallback: "Tool execution failed", rawMcpResult: result });
@@ -1204,7 +1202,7 @@ export async function executeCall(
       };
     }
 
-    const content = resolveMcpResultContent(result as Record<string, unknown>);
+    const content = resolveMcpResultContent(result as Record<string, unknown>, state.owner?.signal);
     const outputContent = content.length > 0 ? content : [{ type: "text" as const, text: "(empty result)" }];
     const guarded = await guardMcpOutput(outputContent, { ...outputGuardOptions, rawMcpResult: result });
     return {

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

@@ -2,12 +2,189 @@
 // NOTE: Tools are NOT registered with Pi - only the unified `mcp` proxy tool is registered.
 // This keeps the LLM context small (1 tool instead of 100s).
 
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import type { McpContent, ContentBlock } from "./types.ts";
 
+const MAX_BINARY_RESOURCE_BYTES = 10 * 1024 * 1024;
+const MAX_SESSION_RESOURCE_BYTES = 100 * 1024 * 1024;
+const MAX_SESSION_RESOURCE_FILES = 10_000; // Bounds metadata from empty or tiny resources.
+const CLEANUP_RETRY_DELAY_MS = 30_000;
+const MAX_CLEANUP_RETRY_ATTEMPTS = 3;
+type MaterializedResourceSession = {
+  directory: string | undefined;
+  bytes: number;
+  files: number;
+  sequence: number;
+};
+
+function createMaterializedResourceSession(): MaterializedResourceSession {
+  return {
+    directory: undefined,
+    bytes: 0,
+    files: 0,
+    sequence: 0,
+  };
+}
+
+const defaultMaterializedResourceSession = createMaterializedResourceSession();
+const scopedMaterializedResourceSessions = new WeakMap<object, MaterializedResourceSession>();
+const pendingCleanupDirectories = new Set<string>();
+const cleanupRetryAttempts = new Map<string, number>();
+let pendingCleanupRetry: ReturnType<typeof setTimeout> | undefined;
+
+function isAbortedScope(scope: object | undefined): boolean {
+  return !!scope && "aborted" in scope && (scope as { aborted?: unknown }).aborted === true;
+}
+
+function getMaterializedResourceSession(scope?: object): MaterializedResourceSession | undefined {
+  if (isAbortedScope(scope)) return undefined;
+  if (!scope) return defaultMaterializedResourceSession;
+  let session = scopedMaterializedResourceSessions.get(scope);
+  if (!session) {
+    session = createMaterializedResourceSession();
+    scopedMaterializedResourceSessions.set(scope, session);
+  }
+  return session;
+}
+
+type BinaryResource = { uri?: string | undefined; text?: string | undefined; mimeType?: string | undefined; blob: string };
+type McpResourceContent = {
+  uri: string;
+  text?: string | undefined;
+  blob?: string | undefined;
+  mimeType?: string | undefined;
+  [key: string]: unknown;
+};
+
+function hasRetryableCleanupDirectory(): boolean {
+  for (const directory of pendingCleanupDirectories) {
+    if ((cleanupRetryAttempts.get(directory) ?? 0) < MAX_CLEANUP_RETRY_ATTEMPTS) return true;
+  }
+  return false;
+}
+
+function schedulePendingCleanupRetry(): void {
+  if (pendingCleanupRetry || !hasRetryableCleanupDirectory()) return;
+  for (const directory of pendingCleanupDirectories) {
+    const attempts = cleanupRetryAttempts.get(directory) ?? 0;
+    if (attempts < MAX_CLEANUP_RETRY_ATTEMPTS) cleanupRetryAttempts.set(directory, attempts + 1);
+  }
+  pendingCleanupRetry = setTimeout(() => {
+    pendingCleanupRetry = undefined;
+    try {
+      drainPendingCleanupDirectories();
+    } catch {
+      // drainPendingCleanupDirectories already retained the paths and rescheduled another retry.
+    }
+  }, CLEANUP_RETRY_DELAY_MS);
+}
+
+function drainPendingCleanupDirectories(): void {
+  const failures: unknown[] = [];
+  for (const directory of Array.from(pendingCleanupDirectories)) {
+    try {
+      rmSync(directory, { recursive: true, force: true });
+      pendingCleanupDirectories.delete(directory);
+      cleanupRetryAttempts.delete(directory);
+    } catch (error) {
+      failures.push(error);
+    }
+  }
+  if (pendingCleanupDirectories.size === 0 && pendingCleanupRetry) {
+    clearTimeout(pendingCleanupRetry);
+    pendingCleanupRetry = undefined;
+  }
+  if (failures.length > 0) {
+    schedulePendingCleanupRetry();
+    throw new AggregateError(failures, "Failed to clean materialized MCP resources");
+  }
+}
+
+export function cleanupMaterializedBinaryResources(scope?: object): void {
+  const session = scope ? scopedMaterializedResourceSessions.get(scope) : defaultMaterializedResourceSession;
+  if (session?.directory) pendingCleanupDirectories.add(session.directory);
+  if (session) {
+    session.directory = undefined;
+    session.bytes = 0;
+    session.files = 0;
+    session.sequence = 0;
+    if (scope) scopedMaterializedResourceSessions.delete(scope);
+  }
+
+  drainPendingCleanupDirectories();
+}
+
+function replaceBlob(resource: BinaryResource, text: string): string {
+  delete (resource as Partial<BinaryResource>).blob;
+  resource.text = text;
+  return text;
+}
+
+function omitBinaryResource(resource: BinaryResource, reason: string): string {
+  return replaceBlob(resource, [
+    `[Resource: ${resource.uri ?? "(no URI)"}]`,
+    `Binary content omitted: ${reason}`,
+    `MIME type: ${resource.mimeType ?? "application/octet-stream"}`,
+  ].join("\n"));
+}
+
+function materializeBinaryResource(resource: BinaryResource, scope?: object): string {
+  const session = getMaterializedResourceSession(scope);
+  if (!session) return omitBinaryResource(resource, "runtime stopped");
+  const decodedBytes = Buffer.byteLength(resource.blob, "base64");
+  if (decodedBytes > MAX_BINARY_RESOURCE_BYTES) {
+    return omitBinaryResource(resource, "decoded size exceeds 10 MiB");
+  }
+  if (
+    session.bytes + decodedBytes > MAX_SESSION_RESOURCE_BYTES ||
+    session.files >= MAX_SESSION_RESOURCE_FILES
+  ) {
+    return omitBinaryResource(resource, "session resource limit reached");
+  }
+
+  try {
+    session.directory ??= mkdtempSync(join(tmpdir(), "pi-mcp-resource-"));
+  } catch {
+    return omitBinaryResource(resource, "could not be saved");
+  }
+
+  const filePath = join(session.directory, `resource-${++session.sequence}.bin`);
+  session.bytes += decodedBytes;
+  session.files += 1;
+  try {
+    writeFileSync(filePath, Buffer.from(resource.blob, "base64"), { flag: "wx", mode: 0o600 });
+  } catch {
+    try {
+      rmSync(filePath, { force: true });
+      session.bytes -= decodedBytes;
+      session.files -= 1;
+    } catch {
+      // Keep the reservation when a partial file cannot be removed.
+    }
+    return omitBinaryResource(resource, "could not be saved");
+  }
+
+  return replaceBlob(resource, [
+    `[Resource: ${resource.uri ?? "(no URI)"}]`,
+    `Binary content saved to ${filePath}`,
+    `MIME type: ${resource.mimeType ?? "application/octet-stream"}`,
+  ].join("\n"));
+}
+
 /**
  * Transform MCP content types to Pi content blocks.
  */
-export function transformMcpContent(content: McpContent[]): ContentBlock[] {
+export function transformMcpResourceContents(contents: McpResourceContent[], scope?: object): ContentBlock[] {
+  return contents.map(resource => {
+    if (typeof resource.text === "string") return { type: "text" as const, text: resource.text };
+    if (typeof resource.blob === "string") return { type: "text" as const, text: materializeBinaryResource(resource as BinaryResource, scope) };
+    return { type: "text" as const, text: JSON.stringify(resource) };
+  });
+}
+
+export function transformMcpContent(content: McpContent[], scope?: object): ContentBlock[] {
   return content.map(c => {
     if (c.type === "text") {
       return { type: "text" as const, text: c.text ?? "" };
@@ -21,6 +198,13 @@ export function transformMcpContent(content: McpContent[]): ContentBlock[] {
     }
     if (c.type === "resource") {
       const resourceUri = c.resource?.uri ?? "(no URI)";
+      if (c.resource && "blob" in c.resource && typeof c.resource.blob === "string") {
+        const binaryResource = c.resource as typeof c.resource & { mimeType?: string; blob: string };
+        return {
+          type: "text" as const,
+          text: materializeBinaryResource(binaryResource, scope),
+        };
+      }
       const resourceContent = c.resource?.text ?? (c.resource ? JSON.stringify(c.resource) : "(no content)");
       return {
         type: "text" as const,
@@ -49,8 +233,8 @@ export function transformMcpContent(content: McpContent[]): ContentBlock[] {
  * Resolve a tool result's content blocks, falling back to structuredContent
  * when content is empty.
  */
-export function resolveMcpResultContent(result: Record<string, unknown>): ContentBlock[] {
-  const blocks = transformMcpContent((Array.isArray(result.content) ? result.content : []) as McpContent[]);
+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) {

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

@@ -350,6 +350,8 @@ export interface OAuthConfig {
   clientName?: string;
   /** Client homepage URI for dynamic registration */
   clientUri?: string;
+  /** Client logo URL for dynamic registration; shown on consent screens */
+  logoUri?: string;
   /** Security-weakening escape hatch for known-misconfigured authorization servers. */
   skipIssuerMetadataValidation?: boolean;
 }

package/node_modules/pi-web-access/CHANGELOG.md

@@ -4,6 +4,51 @@ All notable changes to this project will be documented in this file.
 
 ## [Unreleased]
 
+## [0.22.0] - 2026-08-11
+
+### Added
+- Added Bocha web search provider support. Thanks @jingyulong for PR #243.
+- Added `maxInlineContentChars` to configure the direct content and stored-content slice limit, with a 200,000-character maximum. Thanks @be4zad for issue #244.
+
+### Fixed
+- Hardened the fetched-content cache against symlink traversal and unsafe permissions, and bounded it to 128 entries and 128 MiB with oldest-entry eviction. Thanks `@HerbertGao` for issue #240 and PR #241.
+
+## [0.21.0] - 2026-08-10
+
+### Added
+- Added per-tool and per-command registration gates plus image and PDF extraction gates. Thanks @jaudiger for issue #234.
+- Added `summaryGenerationDeadlineMs` to configure the summary model deadline for curator and auto-summary workflows. Thanks @cataldoc for issue #237.
+
+### Fixed
+- Store full fetched content in an external cache instead of embedding it in session JSONL entries, preventing large search-heavy sessions from ballooning on restore. Thanks Igor Samokhovets (`@samohovets`) for issue #236.
+- Document `get_search_content` parameter constraints in the tool schema. Thanks `@iwangjie` for PR #233.
+
+## [0.20.0] - 2026-08-10
+
+### Added
+- Added keyless DuckDuckGo HTML search as an explicit and routing provider. Thanks @lmilojevicc for issue #228.
+- Added Datalab hosted PDF-to-Markdown extraction as an optional PDF provider. Thanks José Antonio Galiano Sandoval (`@jagaliano`) for PR #226.
+
+### Changed
+- Tightened Datalab JSON response validation and Gemini Web fetch initialization internals.
+
+### Fixed
+- Fix Gemini Web "fetch failed" (`UND_ERR_HEADERS_OVERFLOW`) when running inside a host agent whose global undici dispatcher uses HTTP/1.1 with the default 16 KiB `maxHeaderSize`: Google's `/app` page exceeds that budget. Gemini Web requests now use a dedicated undici agent with a 4 MiB header budget. Thanks José Antonio Galiano Sandoval (`@jagaliano`) for PR #230.
+- Preserve collapsed `web_search` result background padding. Thanks `@SheffeyG` for PR #224.
+
+## [0.19.0] - 2026-08-08
+
+### Added
+- Added Jina Search as a normal configured `web_search` provider with `jinaApiKey` / `JINA_API_KEY`, explicit/auto/routing/all-provider support, domain and recency constraints, optional inline page content, and Curator integration. Thanks Orbio Agent (`@Gabrielgvl`) for PR #214.
+
+### Fixed
+- Added a tracked npm lockfile for reproducible contributor installs, and updated model-registry auth header typing for current Pi peer packages. Thanks `@dougEfresh` for PR #218.
+- Keep manual `/websearch` curator pages in sync if the live SSE stream disconnects or misses events while searches are still running. Thanks `@Whisperfall` for issue #215.
+- Updated Kagi Search and Extract requests for the current v1 API contracts. Thanks `@mattgaff` for PR #217.
+- Recognize `:max` thinking suffixes when matching scoped summary models. Thanks `@justin8ty` for PR #219.
+- Route local video Gemini upload, polling, and deletion requests through configured `geminiBaseUrl` / `GOOGLE_GEMINI_BASE_URL` relays. Thanks Mr. (`@Liemo99`) for PR #213.
+- Classify xAI `403` spending-limit and quota-exhaustion responses as quota errors so configured search routing can fall back, while preserving ordinary `403` responses as authentication errors. Thanks `@0xmarcinz` for PR #212.
+
 ## [0.18.0] - 2026-08-03
 
 ### Added