@bastani/atomic 0.9.25-alpha.2 → 0.9.25-alpha.4

package/dist/builtin/mcp/README.md

@@ -1,388 +1,101 @@
-<p>
-  <img src="banner.png" alt="pi-mcp-adapter" width="1100">
-</p>
+# Atomic MCP
 
-# Pi MCP Adapter
+Atomic's bundled [Model Context Protocol](https://modelcontextprotocol.io) support connects to servers over stdio and streamable HTTP. It provides a server manager, shell commands, OAuth, codemode and deferred tool discovery, direct tools, and standard resource tools. No separate installation is needed with Atomic.
 
-Use MCP servers with [Pi](https://github.com/badlogic/pi-mono/) without burning your context window.
+See the [MCP servers guide](../coding-agent/docs/mcp-servers.md) for configuration and [OAuth](OAUTH.md) for authentication.
 
-https://github.com/user-attachments/assets/4b7c66ff-e27e-4639-b195-22c3db406a5a
+## Quick setup
 
-## Why This Exists
-
-Mario wrote about [why you might not need MCP](https://mariozechner.at/posts/2025-11-02-what-if-you-dont-need-mcp/). The problem: tool definitions are verbose. A single MCP server can burn 10k+ tokens, and you're paying that cost whether you use those tools or not. Connect a few servers and you've burned half your context window before the conversation starts.
-
-His take: skip MCP entirely, write simple CLI tools instead.
-
-But the MCP ecosystem has useful stuff - databases, browsers, APIs. This adapter gives you access without the bloat. One proxy tool (~200 tokens) instead of hundreds. The agent discovers what it needs on-demand. Servers only start when you actually use them.
-
-## Install
-
-```bash
-pi install npm:pi-mcp-adapter
+```sh
+atomic mcp add filesystem -- npx -y @modelcontextprotocol/server-filesystem .
+atomic mcp add docs --url https://example.com/mcp
+atomic mcp list
+atomic
 ```
 
-Restart Pi after installation.
-
-## What happens on first run
-
-The adapter reads standard MCP files automatically. No extra setup needed if you already have them.
-
-| You already have... | What happens |
-|---------------------|--------------|
-| `.mcp.json` or `~/.config/mcp/mcp.json` | Pi uses it immediately. The first time you open `/mcp`, you'll see a short heads-up explaining which file Pi detected and that Pi only writes adapter-specific overrides to its own files. |
-| Host-specific configs (Claude Code, Codex, etc.) but no standard MCP files | Run `/mcp setup` to adopt those host configs into Pi. The setup flow shows exactly what it found, lets you pick which ones to import, and previews the exact file changes before writing. |
-| Nothing configured yet | Run `/mcp setup` to scaffold a minimal `.mcp.json`, quick-add RepoPrompt, or inspect what the adapter discovered on your machine. |
+Commands write `~/.atomic/agent/mcp.json` by default. Add `--local` (`-l`) to use `.atomic/mcp.json` in the current project. Project servers are read only after project trust is granted; a project entry replaces a user-level entry of the same name.
 
-If you prefer the terminal, you can also run `pi-mcp-adapter init` after install to scan for host-specific configs and add missing compatibility imports to the Pi agent dir (`~/.pi/agent/mcp.json` by default, or `$PI_CODING_AGENT_DIR/mcp.json` when set).
-
-## Quick Start
-
-Preferred project config: `.mcp.json`
+Both files use this shape:
 
 ```json
 {
   "mcpServers": {
-    "chrome-devtools": {
+    "filesystem": {
       "command": "npx",
-      "args": ["-y", "chrome-devtools-mcp@latest"]
-    }
-  }
-}
-```
-
-Preferred user-global shared config: `~/.config/mcp/mcp.json`
-
-Pi also reads Pi-owned override files for settings and host-specific compatibility:
-
-- `<Pi agent dir>/mcp.json` — Pi global override (`~/.pi/agent/mcp.json` by default)
-- `.pi/mcp.json` — Pi project override
-
-Precedence is:
-
-1. `~/.config/mcp/mcp.json`
-2. `<Pi agent dir>/mcp.json`
-3. `.mcp.json`
-4. `.pi/mcp.json`
-
-Servers are **lazy by default** — they won't connect until you actually call one of their tools. The adapter caches tool metadata so search and describe work without live connections when a valid cache exists; on a cold cache, explicit proxy search/describe/server-list requests may connect lazy server(s) once to hydrate metadata on demand. `describe` narrows cold-cache hydration to an explicitly requested server or the server identified by the configured tool-name prefix before falling back to broader discovery. Unscoped `search` intentionally hydrates every configured lazy server that lacks cached metadata so the search can see all available tools.
-
-MCP startup and first-use calls share one initialization attempt per session. If background initialization fails, the next proxy, direct-tool, `/mcp`, or `/mcp-auth` use retries it; concurrent callers join that retry rather than starting duplicates, and a stale attempt cannot publish after session shutdown or context disposal. Replacement sessions normally wait for retired initialization, state, and OAuth cleanup; teardown uses a finite deadline so a non-abortable SDK producer cannot permanently block later sessions, while late settlement stays observed and fenced from publication. Shared lazy server connections and auto-authentication flows use the same caller-local cancellation rule: a pre-cancelled call starts nothing, while cancelling one waiter promptly rejects that call with its exact host reason without cancelling the producer needed by surviving callers. Session restart/shutdown deterministically rejects retired OAuth callers with retry guidance and clears old ownership before replacement authentication begins. Direct tools, proxy modes, metadata hydration, and readiness-critical commands revalidate the exact session lease after lifecycle-spanning waits and before SDK calls or state mutation; a UI runtime produced after caller cancellation is closed rather than orphaned. Direct and proxy resource/tool requests still forward the call's abort signal to the MCP SDK; protocol-level remote cancellation remains advisory.
-
-Await SDK session disposal even when MCP initialization is still pending. If an unpublished candidate fails cleanup, disposal rejects with `ShutdownFailed` and retains that cause; cancellation is not treated as successful resource release. Other owned cleanup, including OAuth cleanup, is still attempted.
-
-For MCP Apps tools, host cancellation sends one terminal `tool-cancelled` event after tool input and before session teardown, then rejects with the exact host abort reason even when the SDK wraps cancellation or the browser notification fails. A successful `tool-result` is mutually exclusive with that cancellation event. Non-UI tools and resource reads do not participate in the Apps lifecycle.
-
-```
-mcp({ search: "screenshot" })
-```
-```
-chrome_devtools_take_screenshot
-  Take a screenshot of the page or element.
-
-  Parameters:
-    format (enum: "png", "jpeg", "webp") [default: "png"]
-    fullPage (boolean) - Full page instead of viewport
-```
-```
-mcp({ tool: "chrome_devtools_take_screenshot", args: '{"format": "png"}' })
-```
-
-Note: `args` is a JSON string, not an object.
-
-Two calls instead of 26 tools cluttering the context.
-
-## Config
-
-### File Layout
-
-Use the shared MCP files when you want one setup to work across hosts, and Pi-owned files when you need Pi-specific overrides or settings.
-
-| File | Purpose |
-|------|---------|
-| `~/.config/mcp/mcp.json` | User-global shared MCP config |
-| `.mcp.json` | Project-local shared MCP config |
-| `<Pi agent dir>/mcp.json` | Pi global override and compatibility imports (`~/.pi/agent/mcp.json` by default) |
-| `.pi/mcp.json` | Pi project override |
-
-Pi-specific files are the write targets for imported or shared global servers when Pi needs to persist adapter-only settings such as `directTools`.
-
-### Server Options
-
-```json
-{
-  "mcpServers": {
-    "my-server": {
-      "command": "npx",
-      "args": ["-y", "some-mcp-server"],
-      "lifecycle": "lazy",
-      "idleTimeout": 10,
-      "timeoutMs": 30000
-    }
-  }
-}
-```
-
-| Field | Description |
-|-------|-------------|
-| `command` | Executable for stdio transport |
-| `args` | Command arguments |
-| `env` | Environment variables; supports `${VAR}` and `$env:VAR` interpolation |
-| `cwd` | Working directory; supports `${VAR}`, `$env:VAR`, and `~` expansion |
-| `url` | HTTP(S) endpoint (StreamableHTTP with SSE fallback); supports `${VAR}` and `$env:VAR` interpolation. Unset variables become empty strings; an empty or invalid resolved endpoint is rejected before connecting. |
-| `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` supports `${VAR}` and `$env:VAR` interpolation |
-| `lifecycle` | `"lazy"` (default), `"eager"`, or `"keep-alive"` |
-| `idleTimeout` | Minutes before idle disconnect (overrides global) |
-| `timeoutMs` | Per-tool-call inactivity timeout in milliseconds for local or remote servers; omit to use the MCP SDK default |
-| `exposeResources` | Expose MCP resources as tools (default: true) |
-| `directTools` | `true`, `string[]`, or `false` — register tools individually instead of through proxy |
-| `excludeTools` | `string[]` of tool names to hide (matches original names like `get_screenshot` and prefixed names like `figma_get_screenshot`) |
-| `debug` | Show server stderr (default: false) |
-| `disabled` | `true` removes the server from the effective config; `{ "disabled": true }` alone turns off a server contributed by a package or extension |
-
-`timeoutMs` is an **inactivity timeout**, not a total wall-clock limit. Each MCP progress notification resets the timer, so a tool that continues reporting progress can run indefinitely. The value must be a finite number greater than zero; invalid values produce a configuration error when the MCP config loads.
-
-### Lifecycle Modes
-
-- **`lazy`** (default) — Don't connect at startup. Connect on first tool call or explicit cold-cache proxy metadata request (`search`, `describe`, or `server` list). Disconnect after idle timeout. Cached metadata keeps search/list working without connections.
-- **`eager`** — Connect at startup but don't auto-reconnect if the connection drops. No idle timeout by default (set `idleTimeout` explicitly to enable).
-- **`keep-alive`** — Connect at startup. Auto-reconnect via health checks. No idle timeout. Use for servers you always need available.
-
-### Settings
-
-```json
-{
-  "settings": {
-    "toolPrefix": "server",
-    "idleTimeout": 10
-  },
-  "mcpServers": { }
-}
-```
-
-| Setting | Description |
-|---------|-------------|
-| `toolPrefix` | `"server"` (default), `"short"` (strips `-mcp` suffix), or `"none"` |
-| `idleTimeout` | Global idle timeout in minutes (default: 10, 0 to disable) |
-| `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 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.
-
-### Direct Tools
-
-By default, all MCP tools are accessed through the single `mcp` proxy tool. This keeps context small but means the LLM has to discover MCP tools via proxy search. If you want specific tools to show up directly in the agent's tool list — alongside `read`, `bash`, `edit`, etc. — add `directTools` to your config.
-
-Per-server:
-
-```json
-{
-  "mcpServers": {
-    "chrome-devtools": {
-      "command": "npx",
-      "args": ["-y", "chrome-devtools-mcp@latest"],
-      "directTools": true
+      "args": ["-y", "@modelcontextprotocol/server-filesystem", "."]
     },
-    "github": {
-      "command": "npx",
-      "args": ["-y", "@modelcontextprotocol/server-github"],
-      "directTools": ["search_repositories", "get_file_contents"]
-    },
-    "huge-server": {
-      "command": "npx",
-      "args": ["-y", "mega-mcp@latest"]
-    }
-  }
-}
-```
-
-| Value | Behavior |
-|-------|----------|
-| `true` | Register all tools from this server as individual Pi tools |
-| `["tool_a", "tool_b"]` | Register only these tools (use original MCP names) |
-| Omitted or `false` | Proxy only (default) |
-
-To set a global default for all servers:
-
-```json
-{
-  "settings": {
-    "directTools": true
-  },
-  "mcpServers": {
-    "huge-server": {
-      "directTools": false
-    }
-  }
-}
-```
-
-Per-server `directTools` overrides the global setting. The example above registers direct tools for every server except `huge-server`.
-
-To exclude specific tools while still using `directTools: true`, add `excludeTools` on the server:
-
-```json
-{
-  "mcpServers": {
-    "figma": {
-      "url": "http://localhost:3845/mcp",
-      "directTools": true,
-      "excludeTools": ["get_figjam", "figma_get_code_connect_map"]
+    "docs": {
+      "url": "https://example.com/mcp",
+      "description": "Search and read the product documentation"
     }
   }
 }
 ```
 
-`excludeTools` filters direct tools, proxy search/list/describe, and the `/mcp` panel view.
-
-Each direct tool costs ~150-300 tokens in the system prompt (name + description + schema). Good for targeted sets of 5-20 tools. For servers with 75+ tools, stick with the proxy or pick specific tools with a `string[]`.
-
-Direct tools register from the metadata cache in the Pi agent dir (`~/.pi/agent/mcp-cache.json` by default, or `$PI_CODING_AGENT_DIR/mcp-cache.json` when set), so no server connections are needed at startup when the cache is warm. On the first session after adding `directTools` to a new server, or when a child/subagent selects tools, the cache may not exist yet — tools fall back to proxy-only while the selected/configured direct-tool servers populate in the background, then the extension refreshes tool registration so the warmed direct tools become available in the current session. To force it immediately: `/mcp reconnect <server>`.
-
-In-process subagents receive direct-tool selection through the typed admission policy rather than an environment bridge. An omitted `mcpDirectTools` field preserves the session's MCP configuration defaults, a list selects exactly those server/tool names, and an empty list explicitly disables direct tools. The legacy environment override is removed; parent sessions should use MCP configuration instead.
-
-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 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.
-
-**Subagent integration:** If you use the subagent extension, agents can request direct MCP tools in their frontmatter with `mcp:server-name` syntax. See the subagent README for details.
-
-### MCP UI Integration
-
-MCP servers can ship interactive UIs via the [MCP UI](https://github.com/MCP-UI-Org/mcp-ui) standard. When you call a tool that has a UI resource, the adapter opens it in a native macOS window via [Glimpse](https://github.com/hazat/glimpse) if available, otherwise falls back to the browser.
-
-**How it works:**
-
-1. Agent calls a tool like `launch_dashboard`
-2. The tool's metadata includes `_meta.ui.resourceUri` pointing to a UI resource
-3. pi-mcp-adapter fetches the UI HTML and opens it in an iframe
-4. The UI can call MCP tools and send messages back to the agent
-
-**Native rendering:** On macOS, if [Glimpse](https://github.com/hazat/glimpse) is installed (`pi install npm:glimpseui`), UIs open in a native WKWebView window instead of a browser tab. Set `MCP_UI_VIEWER=browser` to force the browser, or `MCP_UI_VIEWER=glimpse` to require native rendering.
-
-**Bidirectional communication:** The UI talks back. When it sends a prompt or intent, the message is stored and `triggerTurn()` wakes the agent. The agent retrieves messages via `mcp({ action: "ui-messages" })` and responds, enabling conversational UIs where the app and agent collaborate in real-time.
+## Commands
 
-**Session reuse:** When the agent calls the same tool again while its UI is already open, the adapter pushes the new result to the existing window instead of replacing it. This enables live updates — the agent can refine a chart, add data, or respond to user input without losing the current view. Different tools still replace the session as before.
+Run `/mcp` to inspect connection state, tools, exposure, source, and errors. Select a server to sign in or out, reconnect, change exposure, or enable and disable it. File-backed changes are saved to the defining file; extension-server changes apply only to the session. Run `/reload` or restart Atomic after editing configuration outside the session.
 
-**Message types from UI:**
+| Session command | Action |
+| --- | --- |
+| `/mcp` | Open the manager, or show status outside the TUI. |
+| `/mcp login [server]` | Sign in with OAuth. |
+| `/mcp logout [server]` | Remove stored OAuth credentials. |
+| `/mcp reconnect [server]` | Reconnect one server and refresh tools. |
 
-| Type | Purpose |
-|------|---------|
-| `prompt` | User message that triggers an agent response |
-| `intent` | Structured action with name + params |
-| `notify` | Fire-and-forget notification |
-| `message` | Generic message payload |
-| (custom) | Any other type forwarded as intent |
+Completion suggests actions and eligible server names. Omitting the name selects an eligible server when unambiguous, otherwise opens a picker. Session login requires an interactive UI. If the browser is on another machine, paste its complete redirected URL into the waiting sign-in prompt.
 
-**Retrieving UI messages:**
+Shell commands work without a session and do not load extensions:
 
+```sh
+atomic mcp add <server> [options] -- <command> [args...]
+atomic mcp add <server> [options] --url <url>
+atomic mcp remove <server> [-l]
+atomic mcp list [--json]
+atomic mcp login <server> [--timeout <seconds>]
+atomic mcp logout <server>
 ```
-mcp({ action: "ui-messages" })
-```
-
-Returns accumulated messages from UI sessions. Each message includes `type`, `sessionId`, `serverName`, `toolName`, and `timestamp`. Prompt messages include `prompt`, intent messages include `intent` and `params`.
-
-**Browser controls:**
-
-- **CMD/CTRL+Enter** — Complete and close
-- **Escape** — Cancel and close
-- **Done/Cancel buttons** — Same as keyboard shortcuts
-
-**Technical notes:**
 
-- Tool consent gates whether UIs can call MCP tools (never/once-per-server/always)
-- Works with both stdio and HTTP MCP servers
-- Uses a local 408KB AppBridge bundle (MCP SDK + Zod) for browser↔server communication
+`list` connects to enabled servers and exits with status 1 for invalid entries or an enabled server that is not connected. Shell login opens the browser and waits up to 300 seconds by default. Run `atomic mcp --help` for all options.
 
-### Local Example: Interactive Visualizer
+## Configuration
 
-A minimal MCP UI example at `examples/interactive-visualizer` demonstrating charts, bidirectional messaging, and streaming. From that directory:
+Stdio uses `command`, `args`, `env`, and `cwd`. HTTP uses `url`, `headers`, and `oauth`. URLs support `${NAME}` and `$env:NAME` environment references, resolved in memory before validation without rewriting files. `env`, `headers`, and `oauth.clientSecret` support `${NAME}` references and whole-value `!command` expressions. Only use commands from configuration you trust.
 
-```bash
-npm install
-npm run build
-npm run install-local
-```
+| Setting | Meaning |
+| --- | --- |
+| `description` | Short summary used in discovery and the system prompt. |
+| `timeout` | Inactivity timeout in seconds, default 60. Progress resets it. |
+| `enabled: false` | Keep the server listed without connecting. |
+| `exposure` | `codemode`, `deferred`, `direct`, or `hidden`. |
+| `toolExposure` | Per-tool overrides, with exact names or `*` patterns. |
 
-Restart pi, then ask the agent to show a chart — it calls `show_chart` and opens the UI in Glimpse (macOS) or the browser. Use `npm run uninstall-local` to remove the MCP entry.
+Package and extension contributions use the same server shape and sit below file-configured servers. `ATOMIC_CODING_AGENT_DIR` relocates the Atomic agent directory.
 
-### Import Existing Configs
+## Tools and resources
 
-Shared MCP files are loaded automatically. Use `imports` only for host-specific config formats that are not already covered by `.mcp.json` or `~/.config/mcp/mcp.json`.
+Tools use names such as `mcp__github__search_code`. Collisions after identifier normalization receive deterministic hash suffixes. Call names returned by discovery instead of constructing them.
 
-```json
-{
-  "imports": ["claude-code", "claude-desktop"],
-  "mcpServers": { }
-}
-```
-
-Supported compatibility imports: `claude-code`, `claude-desktop`, `vscode`, `windsurf`, `codex`
+The default exposure is `codemode`: scripts discover tools through `searchTools()`, `describeTool()`, and `ALL_TOOLS`, then call them. `deferred` tools become declared after `tool_search` loads a match. `direct` tools are declared immediately; `hidden` tools are unreachable. `toolExposure` overrides the server's default. Exact names win over patterns; among patterns, the first match wins.
 
-`pi-mcp-adapter init` detects these host-specific configs and adds missing imports to the Pi agent dir config for you.
+Atomic activates codemode for codemode servers and tool search for deferred servers. Set `"autoEnableCodemode": false` beside `mcpServers` to prevent automatic codemode activation. A project value overrides the user-level value. Scripts read server instructions with `describeNamespace("mcp__github")`.
 
-### Project Config
+Enabled servers connect in the background. The first prompt waits up to 10 seconds for direct-tool servers. Discovery and calls wait for the servers they need. Dropped connections reconnect on the next call, and tool-list notifications update registrations.
 
-Prefer `.mcp.json` for project-local shared MCP config. Use `.pi/mcp.json` only when you need a Pi-specific project override. Project files override both user-global shared MCP config and Pi global overrides.
+The resource tools are `list_mcp_resources`, `list_mcp_resource_templates`, and `read_mcp_resource`. They reach enabled, non-hidden resource servers. Text and image resources are returned directly; other binary content is saved to temporary files. MCP Apps UI resources are omitted because Atomic does not render them.
 
-## Usage
+MCP calls pass through Atomic's permission pipeline, including nested calls from codemode. Scripts receive the full MCP result. Model-facing text over 20 KB is shortened, with its full text saved to a temporary file named in the result.
 
-| Mode | Example |
-|------|---------|
-| Status | `mcp({ })` |
-| List server | `mcp({ server: "name" })` |
-| Search | `mcp({ search: "screenshot navigate" })` |
-| Describe | `mcp({ describe: "tool_name" })` |
-| Call | `mcp({ tool: "...", args: '{"key": "value"}' })` |
-| Connect | `mcp({ connect: "server-name" })` |
-| UI messages | `mcp({ action: "ui-messages" })` |
+## Authentication
 
-MCP call headers show the server name while pending, without waiting for a result. Direct tools use their registered server; gateway calls use an explicit target or an unambiguous match in available metadata or configured prefixes. Unknown or ambiguous targets keep the operation/tool name without guessing a server. Rendering never connects to a server.
+Run `/mcp login <server>`, choose **Sign in** in the manager, or run `atomic mcp login <server>`. HTTP servers without an `Authorization` header or provider-token configuration use OAuth when challenged. Atomic registers as `atomic` and stores credentials in `~/.atomic/agent/mcp-auth.json`.
 
-MCP proxy and direct-tool results render compactly by default: long text shows the first three lines plus a `ctrl+o Expand` hint, while the full result remains available when expanded and is still returned unchanged to the model.
+OAuth options include `clientId`, `clientSecret`, `scope`, `clientName`, `callbackPort`, `callbackUrl`, and `authServerMetadataUrl`. See [OAuth](OAUTH.md) for examples and troubleshooting.
 
-Search includes both MCP tools and Pi tools (from extensions). Pi tools appear first with `[pi tool]` prefix. Space-separated words are OR'd.
+An HTTP server may instead set `"auth": { "provider": "radius" }` to use the current `/login radius` token. This is allowed only in global configuration and extension registrations, not project files or package manifests. HTTPS is required except on loopback hosts, and credentials are sent only to the configured origin.
 
-Tool names are fuzzy-matched on hyphens and underscores — `context7_resolve_library_id` finds `context7_resolve-library-id`.
+## Native configuration only
 
-## Commands
+The old adapter has been replaced by the native client. Only `~/.atomic/agent/mcp.json` and trusted `.atomic/mcp.json` files are read. Shared configuration files, client imports, old-field translations, and imports of old OAuth credential files are not supported. Sign in through the native client.
 
-| Command | What it does |
-|---------|--------------|
-| `/mcp` | Interactive panel and first-run onboarding surface |
-| `/mcp setup` | Guided setup for imports, a minimal `.mcp.json`, RepoPrompt quick-add, and config-path inspection |
-| `/mcp tools` | List all tools |
-| `/mcp reconnect` | Reconnect all servers |
-| `/mcp reconnect <server>` | Connect or reconnect a single server |
-| `/mcp logout <server>` | Clear stored OAuth credentials for a server and disconnect it |
-| `/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.
-
-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
-
-- One `mcp` tool in context (~200 tokens) instead of hundreds
-- Servers are lazy by default — they connect on first tool call or explicit cold-cache proxy metadata request, not at startup
-- Tool metadata is cached to disk so search/list/describe work without live connections when the cache is valid; cold-cache explicit search/describe/server-list requests hydrate metadata on demand
-- Idle servers disconnect after 10 minutes (configurable), reconnect automatically on next use
-- npx-based servers resolve to direct binary paths, skipping the ~143 MB npm parent process
-- MCP server validates arguments, not the adapter
-- Keep-alive servers get health checks and auto-reconnect
-- Specific tools can be promoted from the proxy to first-class Pi tools via `directTools` config, so the LLM sees them directly instead of having to search
-
-## 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.
+The old gateway tool, configurable prefixes, lazy/idle lifecycle settings, metadata cache, SSE transport, MCP Apps rendering, and setup command are no longer available. Use the native configuration, tools, and commands documented above.