pi-mcp-adapter 2.5.3 → 2.6.0

package/CHANGELOG.md

@@ -7,6 +7,30 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.6.0] - 2026-05-10
+
+### Added
+- Added a no-argument `/mcp-auth` OAuth picker and in-panel auth shortcut for OAuth-capable MCP servers.
+- Added compact collapsed rendering for MCP proxy and direct-tool result rows while keeping full tool results available when expanded.
+
+### Changed
+- Migrated Pi runtime dependencies and imports from deprecated `@mariozechner/*` packages to `@earendil-works/*` packages.
+
+### Fixed
+- Re-register dynamic OAuth clients during fresh auth when cached DCR client info exists without tokens, avoiding dead authorization URLs after server-side client invalidation.
+- Kept OAuth tokens, dynamic client info, PKCE verifiers, and OAuth state bound to the server URL so stale credentials cannot be reused after a server URL changes.
+- Kept the `/mcp-auth` OAuth picker search focused on OAuth server rows and prevented hidden panel shortcuts from unexpectedly launching auth.
+- Kept long MCP error results expanded in compact tool result rendering.
+
+## [2.5.4] - 2026-05-04
+
+### Changed
+- Ignored npm lockfiles and removed checked-in `package-lock.json` files.
+
+### Fixed
+- Resolved `${VAR}` and `$env:VAR` placeholders in HTTP bearer tokens.
+- Honored MCP sampling `modelPreferences.hints` before falling back to the current/default model.
+
 ## [2.5.3] - 2026-05-01
 
 ### Added

package/README.md

@@ -126,7 +126,7 @@ Pi-specific files are the write targets for imported or shared global servers wh
 | `headers` | HTTP headers; supports `${VAR}` and `$env:VAR` interpolation |
 | `auth` | `"bearer"` or `"oauth"` |
 | `oauth.grantType` | `"authorization_code"` (default) or `"client_credentials"` for non-interactive machine auth |
-| `bearerToken` / `bearerTokenEnv` | Token or env var name |
+| `bearerToken` / `bearerTokenEnv` | Token or env var name; `bearerToken` supports `${VAR}` and `$env:VAR` interpolation |
 | `lifecycle` | `"lazy"` (default), `"eager"`, or `"keep-alive"` |
 | `idleTimeout` | Minutes before idle disconnect (overrides global) |
 | `exposeResources` | Expose MCP resources as tools (default: true) |
@@ -159,7 +159,7 @@ Pi-specific files are the write targets for imported or shared global servers wh
 | `directTools` | Global default for all servers (default: false). Per-server overrides this. |
 | `disableProxyTool` | Hide the `mcp` proxy tool once configured direct tools are fully available from cache. |
 | `autoAuth` | Auto-run OAuth on `connect`/tool calls when a server needs auth, then retry once (default: false). |
-| `sampling` | Allow MCP servers to request LLM sampling through Pi's current/default model (default: true when UI approval is available). |
+| `sampling` | Allow MCP servers to sample through Pi models, honoring `modelPreferences.hints` before current/default fallback (default: true when UI approval is available). |
 | `samplingAutoApprove` | Skip sampling confirmation prompts. Required for sampling in non-UI sessions (default: false). |
 
 Per-server `idleTimeout` overrides the global setting.
@@ -236,7 +236,7 @@ Direct tools register from the metadata cache in the Pi agent dir (`~/.pi/agent/
 
 When you change direct-tool toggles in `/mcp` or write new config through `/mcp setup`, the extension triggers Pi's normal reload flow automatically. That refreshes extensions, prompts, skills, and MCP tool registration in one shot, so newly configured direct tools can appear without a manual restart.
 
-**Interactive configuration:** Run `/mcp` to open an interactive panel showing all servers with connection status, tools, and direct/proxy toggles. You can reconnect servers, initiate OAuth, and toggle tools between direct and proxy — all from one overlay.
+**Interactive configuration:** Run `/mcp` to open an interactive panel showing all servers with connection status, tools, and direct/proxy toggles. You can reconnect servers and toggle tools between direct and proxy from the same overlay. For OAuth, press Enter on a server that needs auth or `ctrl+a` on any OAuth server.
 
 **Guided first-run setup:** Run `/mcp setup` to inspect detected shared MCP files, adopt compatibility imports from other hosts, open discovered config paths, preview exact before/after file diffs for writes, scaffold a minimal project `.mcp.json`, or quick-add RepoPrompt into a standard/shared MCP file.
 
@@ -332,6 +332,8 @@ Prefer `.mcp.json` for project-local shared MCP config. Use `.pi/mcp.json` only
 | Connect | `mcp({ connect: "server-name" })` |
 | UI messages | `mcp({ action: "ui-messages" })` |
 
+MCP proxy and direct-tool results render compactly by default: long text shows the first three lines plus a `Ctrl+O to expand` hint, while the full result remains available when expanded and is still returned unchanged to the model.
+
 Search includes both MCP tools and Pi tools (from extensions). Pi tools appear first with `[pi tool]` prefix. Space-separated words are OR'd.
 
 Tool names are fuzzy-matched on hyphens and underscores — `context7_resolve_library_id` finds `context7_resolve-library-id`.
@@ -345,9 +347,12 @@ Tool names are fuzzy-matched on hyphens and underscores — `context7_resolve_li
 | `/mcp tools` | List all tools |
 | `/mcp reconnect` | Reconnect all servers |
 | `/mcp reconnect <server>` | Connect or reconnect a single server |
-| `/mcp-auth <server>` | OAuth setup |
+| `/mcp-auth` | Open an OAuth server picker in interactive UI sessions |
+| `/mcp-auth <server>` | OAuth setup for a specific server |
+
+If `settings.autoAuth` is `true`, `mcp({ connect: ... })`, `mcp({ tool: ... })`, and direct tool calls automatically run OAuth when needed and retry once.
 
-If `settings.autoAuth` is `true`, `mcp({ connect: ... })`, `mcp({ tool: ... })`, and direct tool calls will automatically run OAuth when needed and retry once. In non-interactive sessions, browser-based OAuth still requires running `/mcp-auth <server>` manually.
+In interactive sessions, you can also authenticate from `/mcp` with `ctrl+a` or Enter on a server that needs auth. In non-interactive sessions, browser-based OAuth still requires `/mcp-auth <server>`. `/mcp-auth` without a server only opens a picker in the interactive UI.
 
 ## How It Works
 
@@ -363,4 +368,5 @@ If `settings.autoAuth` is `true`, `mcp({ connect: ... })`, `mcp({ tool: ... })`,
 ## Limitations
 
 - Cross-session server sharing not yet implemented (each Pi session runs its own server processes)
+- Compact MCP result rendering summarizes text, but inline images are still controlled by Pi's image display settings and may render below the compact text summary.
 - MCP sampling support is text-only; context inclusion, tools, stop sequences, audio, and image content are rejected with explicit errors.

package/commands.ts

@@ -1,6 +1,6 @@
-import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
-import type { McpExtensionState } from "./state.js";
-import type { McpConfig, ServerEntry, McpPanelCallbacks, McpPanelResult, ImportKind } from "./types.js";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { McpExtensionState } from "./state.ts";
+import type { McpAuthResult, McpConfig, ServerEntry, McpPanelCallbacks, McpPanelResult, ImportKind } from "./types.ts";
 import {
   ensureCompatibilityImports,
   getMcpDiscoverySummary,
@@ -11,14 +11,14 @@ import {
   writeDirectToolsConfig,
   writeSharedServerEntry,
   writeStarterProjectConfig,
-} from "./config.js";
-import { lazyConnect, updateMetadataCache, updateStatusBar, getFailureAgeSeconds } from "./init.js";
-import { loadMetadataCache } from "./metadata-cache.js";
-import { buildToolMetadata } from "./tool-metadata.js";
-import { supportsOAuth, authenticate } from "./mcp-auth-flow.js";
-import { hasStoredTokens } from "./mcp-auth.js";
-import { loadOnboardingState, markSetupCompleted as persistSetupCompleted, markSharedConfigHintShown } from "./onboarding-state.js";
-import { openPath } from "./utils.js";
+} from "./config.ts";
+import { lazyConnect, updateMetadataCache, updateStatusBar, getFailureAgeSeconds } from "./init.ts";
+import { loadMetadataCache } from "./metadata-cache.ts";
+import { buildToolMetadata } from "./tool-metadata.ts";
+import { supportsOAuth, authenticate } from "./mcp-auth-flow.ts";
+import { getAuthForUrl } from "./mcp-auth.ts";
+import { loadOnboardingState, markSetupCompleted as persistSetupCompleted, markSharedConfigHintShown } from "./onboarding-state.ts";
+import { openPath } from "./utils.ts";
 
 export async function showStatus(state: McpExtensionState, ctx: ExtensionContext): Promise<void> {
   if (!ctx.hasUI) return;
@@ -140,30 +140,30 @@ export async function authenticateServer(
   serverName: string,
   config: McpConfig,
   ctx: ExtensionContext
-): Promise<void> {
-  if (!ctx.hasUI) return;
+): Promise<McpAuthResult> {
+  if (!ctx.hasUI) return { ok: false, message: "OAuth authentication requires an interactive session." };
 
   const definition = config.mcpServers[serverName];
   if (!definition) {
-    ctx.ui.notify(`Server "${serverName}" not found in config`, "error");
-    return;
+    const message = `Server "${serverName}" not found in config`;
+    ctx.ui.notify(message, "error");
+    return { ok: false, message };
   }
 
   if (!supportsOAuth(definition)) {
+    const message = `Server "${serverName}" does not use OAuth authentication. Set "auth": "oauth" or omit auth for auto-detection.`;
     ctx.ui.notify(
       `Server "${serverName}" does not use OAuth authentication.\n` +
       `Set "auth": "oauth" or omit auth for auto-detection.`,
       "error"
     );
-    return;
+    return { ok: false, message };
   }
 
   if (!definition.url) {
-    ctx.ui.notify(
-      `Server "${serverName}" has no URL configured (OAuth requires HTTP transport)`,
-      "error"
-    );
-    return;
+    const message = `Server "${serverName}" has no URL configured (OAuth requires HTTP transport)`;
+    ctx.ui.notify(message, "error");
+    return { ok: false, message };
   }
 
   try {
@@ -171,20 +171,22 @@ export async function authenticateServer(
     const status = await authenticate(serverName, definition.url, definition);
 
     if (status === "authenticated") {
+      const message = `OAuth authentication successful for "${serverName}"! Run /mcp reconnect ${serverName} to connect with the new token.`;
       ctx.ui.notify(
         `OAuth authentication successful for "${serverName}"!\n` +
         `Run /mcp reconnect ${serverName} to connect with the new token.`,
-        "success"
-      );
-    } else {
-      ctx.ui.notify(
-        `OAuth authentication failed for "${serverName}".`,
-        "error"
+        "info"
       );
+      return { ok: true, message };
     }
+
+    const message = `OAuth authentication failed for "${serverName}".`;
+    ctx.ui.notify(message, "error");
+    return { ok: false, message };
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     ctx.ui.notify(`Failed to authenticate "${serverName}": ${message}`, "error");
+    return { ok: false, message };
   } finally {
     ctx.ui.setStatus("mcp-auth", undefined);
   }
@@ -194,8 +196,8 @@ export interface PanelFlowResult {
   configChanged: boolean;
 }
 
-function buildSharedConfigNoticeLines(configOverridePath?: string): { lines: string[]; fingerprint: string | null } {
-  const discovery = getMcpDiscoverySummary(configOverridePath);
+function buildSharedConfigNoticeLines(configOverridePath: string | undefined, cwd: string): { lines: string[]; fingerprint: string | null } {
+  const discovery = getMcpDiscoverySummary(configOverridePath, cwd);
   const onboardingState = loadOnboardingState();
   if (!discovery.hasSharedServers || onboardingState.sharedConfigHintShown) {
     return { lines: [], fingerprint: null };
@@ -221,16 +223,16 @@ export async function openMcpSetup(
 ): Promise<PanelFlowResult> {
   if (!ctx.hasUI) return { configChanged: false };
 
-  const discovery = getMcpDiscoverySummary(configOverridePath);
+  const discovery = getMcpDiscoverySummary(configOverridePath, ctx.cwd);
   const onboardingState = loadOnboardingState();
-  const { createMcpSetupPanel } = await import("./mcp-setup-panel.js");
+  const { createMcpSetupPanel } = await import("./mcp-setup-panel.ts");
   let configChanged = false;
 
   const callbacks = {
     previewImports: (imports: ImportKind[]) => previewCompatibilityImports(imports, configOverridePath),
-    previewStarterProject: () => previewStarterProjectConfig(),
+    previewStarterProject: () => previewStarterProjectConfig(ctx.cwd),
     previewRepoPrompt: () => {
-      const repoPrompt = getMcpDiscoverySummary(configOverridePath).repoPrompt;
+      const repoPrompt = getMcpDiscoverySummary(configOverridePath, ctx.cwd).repoPrompt;
       if (!repoPrompt.entry || !repoPrompt.targetPath || !repoPrompt.serverName) return null;
       return previewSharedServerEntry(repoPrompt.targetPath, repoPrompt.serverName, repoPrompt.entry);
     },
@@ -240,12 +242,12 @@ export async function openMcpSetup(
       return result;
     },
     scaffoldProjectConfig: async () => {
-      const path = writeStarterProjectConfig();
+      const path = writeStarterProjectConfig(ctx.cwd);
       configChanged = true;
       return { path };
     },
     addRepoPrompt: async () => {
-      const repoPrompt = getMcpDiscoverySummary(configOverridePath).repoPrompt;
+      const repoPrompt = getMcpDiscoverySummary(configOverridePath, ctx.cwd).repoPrompt;
       if (!repoPrompt.entry || !repoPrompt.targetPath || !repoPrompt.serverName) {
         throw new Error("RepoPrompt is not available to add from this setup screen.");
       }
@@ -265,7 +267,7 @@ export async function openMcpSetup(
     ctx.ui.custom(
       (tui, _theme, _keybindings, done) => {
         return createMcpSetupPanel(discovery, callbacks, { mode, onboardingState }, tui, () => {
-          done();
+          done(undefined);
           resolve({ configChanged });
         });
       },
@@ -274,25 +276,18 @@ export async function openMcpSetup(
   });
 }
 
-export async function openMcpPanel(
+function buildMcpPanelCallbacks(
   state: McpExtensionState,
-  pi: ExtensionAPI,
+  config: McpConfig,
   ctx: ExtensionContext,
-  configOverridePath?: string,
-): Promise<PanelFlowResult> {
-  if (Object.keys(state.config.mcpServers).length === 0) {
-    return openMcpSetup(state, pi, ctx, configOverridePath, "empty");
-  }
-
-  const config = state.config;
-  const cache = loadMetadataCache();
-  const provenanceMap = getServerProvenance(pi.getFlag("mcp-config") as string | undefined ?? configOverridePath);
-  const { lines: noticeLines, fingerprint } = buildSharedConfigNoticeLines(pi.getFlag("mcp-config") as string | undefined ?? configOverridePath);
-
-  const callbacks: McpPanelCallbacks = {
-    reconnect: async (serverName: string) => {
-      return lazyConnect(state, serverName);
+): McpPanelCallbacks {
+  return {
+    reconnect: (serverName: string) => lazyConnect(state, serverName),
+    canAuthenticate: (serverName: string) => {
+      const definition = config.mcpServers[serverName];
+      return definition ? supportsOAuth(definition) : false;
     },
+    authenticate: (serverName: string) => authenticateServer(serverName, config, ctx),
     getConnectionStatus: (serverName: string) => {
       const definition = config.mcpServers[serverName];
       const connection = state.manager.getConnection(serverName);
@@ -301,9 +296,10 @@ export async function openMcpPanel(
       }
       if (
         definition?.auth === "oauth"
+        && definition.url
         && definition.oauth !== false
         && definition.oauth?.grantType !== "client_credentials"
-        && !hasStoredTokens(serverName)
+        && !getAuthForUrl(serverName, definition.url)?.tokens
       ) {
         return "needs-auth";
       }
@@ -316,8 +312,27 @@ export async function openMcpPanel(
       return freshCache?.servers?.[serverName] ?? null;
     },
   };
+}
+
+export async function openMcpPanel(
+  state: McpExtensionState,
+  pi: ExtensionAPI,
+  ctx: ExtensionContext,
+  configOverridePath?: string,
+): Promise<PanelFlowResult> {
+  if (Object.keys(state.config.mcpServers).length === 0) {
+    return openMcpSetup(state, pi, ctx, configOverridePath, "empty");
+  }
+
+  const config = state.config;
+  const cache = loadMetadataCache();
+  const configPath = pi.getFlag("mcp-config") as string | undefined ?? configOverridePath;
+  const provenanceMap = getServerProvenance(configPath, ctx.cwd);
+  const { lines: noticeLines, fingerprint } = buildSharedConfigNoticeLines(configPath, ctx.cwd);
+
+  const callbacks = buildMcpPanelCallbacks(state, config, ctx);
 
-  const { createMcpPanel } = await import("./mcp-panel.js");
+  const { createMcpPanel } = await import("./mcp-panel.ts");
   let configChanged = false;
 
   await new Promise<void>((resolve) => {
@@ -329,7 +344,7 @@ export async function openMcpPanel(
             configChanged = true;
             ctx.ui.notify("Direct tools updated. Pi will reload after this panel closes.", "info");
           }
-          done();
+          done(undefined);
           resolve();
         }, { noticeLines });
       },
@@ -343,3 +358,42 @@ export async function openMcpPanel(
 
   return { configChanged };
 }
+
+export async function openMcpAuthPanel(
+  state: McpExtensionState,
+  pi: ExtensionAPI,
+  ctx: ExtensionContext,
+  configOverridePath?: string,
+): Promise<PanelFlowResult> {
+  if (!ctx.hasUI) return { configChanged: false };
+
+  const config = state.config;
+  const oauthServers = Object.entries(config.mcpServers).filter(([, definition]) => supportsOAuth(definition));
+  if (oauthServers.length === 0) {
+    ctx.ui.notify("No OAuth-capable MCP servers are configured.", "warning");
+    return { configChanged: false };
+  }
+
+  const cache = loadMetadataCache();
+  const configPath = pi.getFlag("mcp-config") as string | undefined ?? configOverridePath;
+  const provenanceMap = getServerProvenance(configPath, ctx.cwd);
+  const callbacks = buildMcpPanelCallbacks(state, config, ctx);
+  const { createMcpPanel } = await import("./mcp-panel.ts");
+
+  await new Promise<void>((resolve) => {
+    ctx.ui.custom(
+      (tui, _theme, _keybindings, done) => {
+        return createMcpPanel(config, cache, provenanceMap, callbacks, tui, () => {
+          done(undefined);
+          resolve();
+        }, {
+          authOnly: true,
+          noticeLines: ["Select an OAuth MCP server and press Enter or ctrl+a to authenticate."],
+        });
+      },
+      { overlay: true, overlayOptions: { anchor: "center", width: 82 } },
+    );
+  });
+
+  return { configChanged: false };
+}

package/config.ts

@@ -2,8 +2,8 @@
 import { existsSync, readFileSync, writeFileSync, mkdirSync, renameSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
-import { getAgentPath } from "./agent-dir.js";
-import type { McpConfig, ServerEntry, McpSettings, ImportKind, ServerProvenance } from "./types.js";
+import { getAgentPath } from "./agent-dir.ts";
+import type { McpConfig, ServerEntry, McpSettings, ImportKind, ServerProvenance } from "./types.ts";
 
 const GENERIC_GLOBAL_CONFIG_PATH = join(homedir(), ".config", "mcp", "mcp.json");
 const PROJECT_CONFIG_NAME = ".mcp.json";
@@ -105,8 +105,8 @@ export function getProjectPiConfigPath(cwd = process.cwd()): string {
   return resolve(cwd, PROJECT_PI_CONFIG_NAME);
 }
 
-export function getConfigDiscoveryPaths(overridePath?: string): ConfigDiscoveryPath[] {
-  return getConfigSources(overridePath).map((source) => ({
+export function getConfigDiscoveryPaths(overridePath?: string, cwd = process.cwd()): ConfigDiscoveryPath[] {
+  return getConfigSources(overridePath, cwd).map((source) => ({
     label: source.label,
     path: source.readPath,
     exists: existsSync(source.readPath),
@@ -180,13 +180,13 @@ export function getMcpDiscoverySummary(overridePath?: string, cwd = process.cwd(
   };
 }
 
-export function loadMcpConfig(overridePath?: string): McpConfig {
+export function loadMcpConfig(overridePath?: string, cwd = process.cwd()): McpConfig {
   let config: McpConfig = { mcpServers: {} };
 
-  for (const source of getConfigSources(overridePath)) {
+  for (const source of getConfigSources(overridePath, cwd)) {
     const loaded = readValidatedConfig(source.readPath, `MCP config from ${source.readPath}`);
     if (!loaded) continue;
-    config = mergeConfigs(config, expandImports(loaded));
+    config = mergeConfigs(config, expandImports(loaded, cwd));
   }
 
   return config;
@@ -262,12 +262,12 @@ function mergeImports(left: ImportKind[] | undefined, right: ImportKind[] | unde
   return [...new Set(merged)];
 }
 
-function expandImports(config: McpConfig): McpConfig {
+function expandImports(config: McpConfig, cwd = process.cwd()): McpConfig {
   if (!config.imports?.length) return config;
 
   const importedServers: Record<string, ServerEntry> = {};
   for (const importKind of config.imports) {
-    const importPath = resolveImportPath(importKind);
+    const importPath = resolveImportPath(importKind, cwd);
     if (!importPath) continue;
 
     try {
@@ -591,17 +591,17 @@ export function writeSharedServerEntry(filePath: string, serverName: string, ent
   return filePath;
 }
 
-export function getServerProvenance(overridePath?: string): Map<string, ServerProvenance> {
+export function getServerProvenance(overridePath?: string, cwd = process.cwd()): Map<string, ServerProvenance> {
   const provenance = new Map<string, ServerProvenance>();
   const userPath = getPiGlobalConfigPath(overridePath);
 
-  for (const source of getConfigSources(overridePath)) {
+  for (const source of getConfigSources(overridePath, cwd)) {
     const loaded = readValidatedConfig(source.readPath, `MCP config from ${source.readPath}`);
     if (!loaded) continue;
 
     if (loaded.imports?.length) {
       for (const importKind of loaded.imports) {
-        const importPath = resolveImportPath(importKind);
+        const importPath = resolveImportPath(importKind, cwd);
         if (!importPath) continue;
 
         try {

package/consent-manager.ts

@@ -1,5 +1,5 @@
-import { ConsentError } from "./errors.js";
-import { logger } from "./logger.js";
+import { ConsentError } from "./errors.ts";
+import { logger } from "./logger.ts";
 
 export type ToolConsentMode = "never" | "once-per-server" | "always";
 

package/direct-tools.ts

@@ -1,16 +1,16 @@
-import type { ToolDefinition } from "@mariozechner/pi-coding-agent";
-import type { McpExtensionState } from "./state.js";
-import type { DirectToolSpec, McpConfig, McpContent } from "./types.js";
-import type { MetadataCache } from "./metadata-cache.js";
-import { lazyConnect, getFailureAgeSeconds } from "./init.js";
-import { isServerCacheValid } from "./metadata-cache.js";
-import { formatSchema } from "./tool-metadata.js";
-import { transformMcpContent } from "./tool-registrar.js";
-import { maybeStartUiSession, type UiSessionRuntime } from "./ui-session.js";
-import { formatToolName, isToolExcluded } from "./types.js";
-import { resourceNameToToolName } from "./resource-tools.js";
-import { authenticate, supportsOAuth } from "./mcp-auth-flow.js";
-import { formatAuthRequiredMessage } from "./utils.js";
+import type { AgentToolResult, AgentToolUpdateCallback, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { McpExtensionState } from "./state.ts";
+import type { DirectToolSpec, McpConfig, McpContent } from "./types.ts";
+import type { MetadataCache } from "./metadata-cache.ts";
+import { lazyConnect, getFailureAgeSeconds } from "./init.ts";
+import { isServerCacheValid } from "./metadata-cache.ts";
+import { formatSchema } from "./tool-metadata.ts";
+import { transformMcpContent } from "./tool-registrar.ts";
+import { maybeStartUiSession, type UiSessionRuntime } from "./ui-session.ts";
+import { formatToolName, isToolExcluded } from "./types.ts";
+import { resourceNameToToolName } from "./resource-tools.ts";
+import { authenticate, supportsOAuth } from "./mcp-auth-flow.ts";
+import { formatAuthRequiredMessage } from "./utils.ts";
 
 const BUILTIN_NAMES = new Set(["read", "bash", "edit", "write", "grep", "find", "ls", "mcp"]);
 
@@ -48,7 +48,7 @@ async function attemptDirectAutoAuth(
     return { status: "skipped" };
   }
 
-  const grantType = definition.oauth?.grantType ?? "authorization_code";
+  const grantType = definition.oauth ? definition.oauth.grantType ?? "authorization_code" : "authorization_code";
   if (!state.ui && grantType !== "client_credentials") {
     return {
       status: "failed",
@@ -260,7 +260,13 @@ export function buildProxyDescription(
   return desc;
 }
 
-type DirectToolExecute = ToolDefinition["execute"];
+type DirectToolExecute = (
+  toolCallId: string,
+  params: Record<string, unknown>,
+  signal: AbortSignal | undefined,
+  onUpdate: AgentToolUpdateCallback<Record<string, unknown>> | undefined,
+  ctx: ExtensionContext,
+) => Promise<AgentToolResult<Record<string, unknown>>>;
 
 export function createDirectToolExecutor(
   getState: () => McpExtensionState | null,

package/host-html-template.ts

@@ -1,4 +1,4 @@
-import type { UiHostContext, UiResourceContent, UiResourceCsp } from "./types.js";
+import type { UiHostContext, UiResourceContent, UiResourceCsp } from "./types.ts";
 
 // Use locally bundled AppBridge to avoid CDN Zod bundling issues
 const DEFAULT_APP_BRIDGE_MODULE_URL = "/app-bridge.bundle.js";

package/index.ts

@@ -1,14 +1,15 @@
-import type { ExtensionAPI, ToolInfo } from "@mariozechner/pi-coding-agent";
-import type { McpExtensionState } from "./state.js";
+import type { ExtensionAPI, ToolInfo } from "@earendil-works/pi-coding-agent";
+import type { McpExtensionState } from "./state.ts";
 import { Type } from "typebox";
-import { showStatus, showTools, reconnectServers, authenticateServer, openMcpPanel, openMcpSetup } from "./commands.js";
-import { loadMcpConfig } from "./config.js";
-import { buildProxyDescription, createDirectToolExecutor, getMissingConfiguredDirectToolServers, resolveDirectTools } from "./direct-tools.js";
-import { flushMetadataCache, initializeMcp, updateStatusBar } from "./init.js";
-import { loadMetadataCache } from "./metadata-cache.js";
-import { executeCall, executeConnect, executeDescribe, executeList, executeSearch, executeStatus, executeUiMessages } from "./proxy-modes.js";
-import { getConfigPathFromArgv, truncateAtWord } from "./utils.js";
-import { initializeOAuth, shutdownOAuth } from "./mcp-auth-flow.js";
+import { showStatus, showTools, reconnectServers, authenticateServer, openMcpAuthPanel, openMcpPanel, openMcpSetup } from "./commands.ts";
+import { loadMcpConfig } from "./config.ts";
+import { buildProxyDescription, createDirectToolExecutor, getMissingConfiguredDirectToolServers, resolveDirectTools } from "./direct-tools.ts";
+import { flushMetadataCache, initializeMcp, updateStatusBar } from "./init.ts";
+import { loadMetadataCache } from "./metadata-cache.ts";
+import { executeCall, executeConnect, executeDescribe, executeList, executeSearch, executeStatus, executeUiMessages } from "./proxy-modes.ts";
+import { getConfigPathFromArgv, truncateAtWord } from "./utils.ts";
+import { initializeOAuth, shutdownOAuth } from "./mcp-auth-flow.ts";
+import { renderMcpToolResult } from "./tool-result-renderer.ts";
 
 export default function mcpAdapter(pi: ExtensionAPI) {
   let state: McpExtensionState | null = null;
@@ -66,13 +67,14 @@ export default function mcpAdapter(pi: ExtensionAPI) {
     || missingConfiguredDirectToolServers.length > 0;
 
   for (const spec of directSpecs) {
-    pi.registerTool({
+    (pi.registerTool as (tool: unknown) => unknown)({
       name: spec.prefixedName,
       label: `MCP: ${spec.originalName}`,
       description: spec.description || "(no description)",
       promptSnippet: truncateAtWord(spec.description, 100) || `MCP tool from ${spec.serverName}`,
-      parameters: Type.Unsafe<Record<string, unknown>>(spec.inputSchema || { type: "object", properties: {} }),
+      parameters: Type.Unsafe((spec.inputSchema || { type: "object", properties: {} }) as never),
       execute: createDirectToolExecutor(() => state, () => initPromise, spec),
+      renderResult: renderMcpToolResult,
     });
   }
 
@@ -207,8 +209,7 @@ export default function mcpAdapter(pi: ExtensionAPI) {
     description: "Authenticate with an MCP server (OAuth)",
     handler: async (args, ctx) => {
       const serverName = args?.trim();
-      if (!serverName) {
-        if (ctx.hasUI) ctx.ui.notify("Usage: /mcp-auth <server-name>", "error");
+      if (!serverName && !ctx.hasUI) {
         return;
       }
 
@@ -226,12 +227,17 @@ export default function mcpAdapter(pi: ExtensionAPI) {
         return;
       }
 
+      if (!serverName) {
+        await openMcpAuthPanel(state, pi, ctx, earlyConfigPath);
+        return;
+      }
+
       await authenticateServer(serverName, state.config, ctx);
     },
   });
 
   if (shouldRegisterProxyTool) {
-    pi.registerTool({
+    (pi.registerTool as (tool: unknown) => unknown)({
       name: "mcp",
       label: "MCP",
       description: buildProxyDescription(earlyConfig, earlyCache, directSpecs),
@@ -247,6 +253,7 @@ export default function mcpAdapter(pi: ExtensionAPI) {
         server: Type.Optional(Type.String({ description: "Filter to specific server (also disambiguates tool calls)" })),
         action: Type.Optional(Type.String({ description: "Action: 'ui-messages' to retrieve prompts/intents from UI sessions" })),
       }),
+      renderResult: renderMcpToolResult,
       async execute(_toolCallId, params: {
         tool?: string;
         args?: string;

package/init.ts

@@ -1,10 +1,10 @@
-import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
-import type { McpExtensionState } from "./state.js";
-import type { ToolMetadata } from "./types.js";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { McpExtensionState } from "./state.ts";
+import type { ToolMetadata } from "./types.ts";
 import { existsSync } from "node:fs";
-import { loadMcpConfig } from "./config.js";
-import { ConsentManager } from "./consent-manager.js";
-import { McpLifecycleManager } from "./lifecycle.js";
+import { loadMcpConfig } from "./config.ts";
+import { ConsentManager } from "./consent-manager.ts";
+import { McpLifecycleManager } from "./lifecycle.ts";
 import {
   computeServerHash,
   getMetadataCachePath,
@@ -15,13 +15,13 @@ import {
   serializeResources,
   serializeTools,
   type ServerCacheEntry,
-} from "./metadata-cache.js";
-import { McpServerManager } from "./server-manager.js";
-import { buildToolMetadata, totalToolCount } from "./tool-metadata.js";
-import { UiResourceHandler } from "./ui-resource-handler.js";
-import { openUrl, parallelLimit } from "./utils.js";
-import { logger } from "./logger.js";
-import { getMissingConfiguredDirectToolServers } from "./direct-tools.js";
+} from "./metadata-cache.ts";
+import { McpServerManager } from "./server-manager.ts";
+import { buildToolMetadata, totalToolCount } from "./tool-metadata.ts";
+import { UiResourceHandler } from "./ui-resource-handler.ts";
+import { openUrl, parallelLimit } from "./utils.ts";
+import { logger } from "./logger.ts";
+import { getMissingConfiguredDirectToolServers } from "./direct-tools.ts";
 
 const FAILURE_BACKOFF_MS = 60 * 1000;
 
@@ -30,7 +30,7 @@ export async function initializeMcp(
   ctx: ExtensionContext
 ): Promise<McpExtensionState> {
   const configPath = pi.getFlag("mcp-config") as string | undefined;
-  const config = loadMcpConfig(configPath);
+  const config = loadMcpConfig(configPath, ctx.cwd);
 
   const manager = new McpServerManager();
   const samplingAutoApprove = config.settings?.samplingAutoApprove === true;
@@ -61,7 +61,7 @@ export async function initializeMcp(
     completedUiSessions: [],
     openBrowser: (url: string) => openUrl(pi, url, process.env.BROWSER),
     ui,
-    sendMessage: (message, options) => pi.sendMessage(message, options),
+    sendMessage: (message, options) => pi.sendMessage(message as unknown as Parameters<typeof pi.sendMessage>[0], options),
   };
 
   const serverEntries = Object.entries(config.mcpServers);