@bastani/atomic 0.9.24 → 0.9.25-alpha.2

package/CHANGELOG.md

@@ -2,6 +2,48 @@
 
 ## [Unreleased]
 
+## [0.9.25-alpha.2] - 2026-09-30
+
+### Fixed
+
+- OpenAI's **Sign in with ChatGPT** login now shows a redirect-URL paste input, allowing authentication from remote machines without a reachable local browser callback.
+- SDK-created sessions now discover package-provided workflows from their resource loader, including after workflow reload, while preserving project trust and custom loaders without workflow resources ([#3372](https://github.com/bastani-inc/atomic/issues/3372)).
+- SDK-created sessions now retain package-contributed MCP servers when adding the shipped MCP extension to a custom resource loader ([#3372](https://github.com/bastani-inc/atomic/issues/3372)).
+- Structured decisions and schema-backed workflow results now accept strict-provider null placeholders for omitted optional fields instead of exhausting output repairs. Explicitly nullable fields keep their null values, and required fields still enforce the original schema.
+
+## [0.9.25-alpha.1] - 2026-09-29
+
+### Added
+
+- Added GPT-6.1 Sol and its first-party Fast variants for OpenAI API keys and ChatGPT Codex subscriptions.
+- Added **Sign in with ChatGPT** for the OpenAI provider, independently of Codex backend login.
+- Added Jev decision models on Vercel AI Gateway and OpenCode Zen.
+- Added configurable fullscreen mouse-wheel scrolling with terminal-aware automatic behavior or a fixed line count.
+- Extension tools can declare exposure, namespaces, annotations and output schemas, and invoke permitted nested tools through the ordinary validation and permission hooks.
+- Added a selectable system theme based on the terminal's palette and contrast, and OKHSL colors for custom themes.
+- Added opt-in `codemode` scripts for composing permitted tools, filtering output, branch-local JSON storage, and classifier calls, plus `tool_search` for activating deferred tools. Interactive and orchestration tools remain unavailable from scripts.
+- Added `builtin:llama.cpp`, `builtin:codemode`, and `builtin:tool-search` extension resources for explicit loading and settings-based enable/disable controls, with diagnostics when an extension replaces codemode or tool search.
+- Added Ultrafast for GPT-6 Astra as `openai/gpt-6-astra-ultrafast` and `openai-codex/gpt-6-astra-ultrafast`, priced at OpenAI's published Ultrafast rates. GPT-6 Astra is the only model with an Ultrafast choice. If the provider rejects an Ultrafast choice you selected, the request fails.
+
+### Changed
+
+- `defaultTools` now accepts `+name` and `-name` modifiers. Project modifier-only lists adjust the global selection instead of replacing it.
+- Automatic model routing now includes GPT-6.1 Sol results from Artificial Analysis, FrontierCode, and OpenAI's published external benchmarks, preserving measured efforts and independent reporters. Metadata-backed Fast variants use base-model evidence without inventing separate Fast scores; independently registered Fast IDs require their own evidence.
+- Completed `bash` commands now return bounded structured output for programmatic callers, including nonzero exits, without increasing model-facing output limits.
+- Codex's automatic provider default is now GPT-6.1 Sol. Explicit saved model selections remain unchanged.
+- Reduced transcript/footer and shell-preview rendering work in long sessions.
+- Tool previews without custom renderers now show their arguments in collapsed and expanded views.
+- `-fast` and `-ultrafast` choices for OpenAI and Codex models now follow the tiers each model advertises in Codex's catalog and on OpenAI's pricing page. Models without Fast, such as `gpt-5.3-codex-spark`, `openai/gpt-5-nano`, `openai/gpt-5-pro`, and `openai/o1`, no longer list a `-fast` choice. A tier the model doesn't advertise is left out of the request, which runs at standard processing.
+- OpenAI and Codex Fast usage is priced at each model's published Fast rates instead of a flat 2x, for example 1.7x for GPT-4o. A Fast request that OpenAI serves at Standard is priced at Standard.
+
+### Fixed
+
+- Theme-colored notices now refresh after theme changes and late terminal color replies.
+- llama.cpp unloaded autoload presets now retain their cached effective context size instead of falling back to the model's training limit.
+- Native extension providers with stored credentials become available immediately after registration without exposing unrelated unauthenticated models.
+- Cancelled tools no longer start queued native or nested sequential calls after cancellation.
+- The interactive footer's context percentage, token, cost and cache-hit (`CH`) segments update after every message again, instead of only when a run ends. A new session no longer shows `0.0%` with no token or cost segments for its whole first run, and steered or long runs keep the footer current. The footer totals now include cache-warming requests, which `/session` already counts, and RPC `get_session_stats` responses report the newest reply's usage as `latestAssistantUsage` ([#3328](https://github.com/bastani-inc/atomic/issues/3328); [#3364](https://github.com/bastani-inc/atomic/pull/3364) by [@dairefagan](https://github.com/dairefagan)).
+
 ## [0.9.24] - 2026-09-29
 
 ### Added

package/dist/builtin/intercom/index.bundle.mjs

@@ -2577,6 +2577,7 @@ function registerContactSupervisorTool(pi, deps) {
   if (childOrchestratorMetadata !== null) {
     pi.registerTool({
       name: "contact_supervisor",
+      exposure: "model-only",
       label: "Contact Supervisor",
       description: "Subagent-only tool for contacting the supervisor agent that delegated this task. In a live foreground child, need_decision and interview_request end the child and return a fresh-subagent handoff to the supervisor; fallback Intercom delivery waits for a reply when no foreground owner claims the request. One blocking supervisor request is allowed per child and may coexist with ordinary intercom asks. progress_update is fire-and-forget. Do not use for routine completion handoffs.",
       promptSnippet: "Subagent-only: yield decisions or structured interviews to the supervisor for a fresh-child follow-up, or send meaningful plan-changing progress updates.",
@@ -3301,6 +3302,7 @@ function registerIntercomTool(pi, deps) {
   const activeReplyTracker = () => typeof deps.replyTracker === "function" ? deps.replyTracker() : deps.replyTracker;
   pi.registerTool({
     name: "intercom",
+    exposure: "model-only",
     label: "Intercom",
     description: `Send a message to another local agent session running on this machine.
 Use this to communicate findings, request help, or coordinate work with other sessions.
@@ -7883,6 +7885,7 @@ function intercom(pi, options = {}) {
       typedContactSupervisorRegistered = true;
       pi.registerTool({
         name: "contact_supervisor",
+        exposure: "model-only",
         label: "Contact Supervisor",
         description: "Subagent-only tool for contacting the supervisor agent that delegated this task.",
         promptSnippet: "Subagent-only: contact the supervisor for decisions, interviews, or meaningful updates.",
@@ -8120,6 +8123,7 @@ function intercom(pi, options = {}) {
   });
   pi.registerTool({
     name: "intercom",
+    exposure: "model-only",
     label: "Intercom",
     description: `Send a message to another local agent session running on this machine.
 Use this to communicate findings, request help, or coordinate work with other sessions.
@@ -8169,6 +8173,7 @@ Usage:
   if (hasSubagentIntercomEnv()) {
     pi.registerTool({
       name: "contact_supervisor",
+      exposure: "model-only",
       label: "Contact Supervisor",
       description: "Subagent-only tool for contacting the supervisor agent that delegated this task. Use need_decision when blocked, uncertain, needing approval, or facing a product/API/scope decision before continuing; this waits for the supervisor's reply. Use interview_request when multiple structured questions need supervisor answers; this also waits for a reply. Use progress_update only for meaningful progress or unexpected discoveries that change the plan; this does not wait for a reply. Do not use for routine completion handoffs.",
       promptSnippet: "Subagent-only: contact the supervisor for decisions, structured interviews, or meaningful plan-changing updates. Do not use for routine completion handoffs.",

package/dist/builtin/intercom/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/intercom",
-  "version": "0.9.24",
+  "version": "0.9.25-alpha.2",
   "private": true,
   "description": "Atomic extension providing a private coordination channel between parent and child agent sessions. Fork of: https://github.com/nicobailon/pi-intercom",
   "contributors": [
@@ -44,7 +44,7 @@
   },
   "peerDependencies": {
     "@bastani/atomic": "*",
-    "@earendil-works/pi-tui": "^0.87.1",
+    "@earendil-works/pi-tui": "^0.99.1",
     "typebox": "*"
   },
   "peerDependenciesMeta": {

package/dist/builtin/mcp/CHANGELOG.md

@@ -7,6 +7,17 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.9.25-alpha.1] - 2026-09-29
+
+### Changed
+
+- MCP tool previews now show arguments in collapsed and expanded views while redacting sensitive argument fields.
+
+### Fixed
+
+- Concurrent Atomic processes now coordinate rotating OAuth refresh tokens, reusing the refreshed credential rather than independently rotating the same token.
+- Stalled OAuth refresh requests now time out after 15 seconds, including response-body reads, so connection shutdown can finish and release the refresh lock.
+
 ## [0.9.24] - 2026-09-29
 
 ### Added

package/dist/builtin/mcp/index.bundle.mjs

@@ -13473,13 +13473,14 @@ var require_fast_uri = __commonJS(function(exports, module) {
       if (!malformedIPLiteral) {
         malformedHost = canonicalizeHost(parsed, options, schemeHandler, isIP);
       }
-      if (!schemeHandler || schemeHandler && !schemeHandler.skipNormalize) {
-        if (uri.indexOf("%") !== -1) {
-          if (parsed.host !== undefined && !malformedIPLiteral) {
-            const host = isIP ? parsed.host : normalizePercentEncoding(parsed.host, true);
-            parsed.host = reescapeHostDelimiters(host, isIP);
-          }
+      if (uri.indexOf("%") !== -1 && parsed.host !== undefined && !malformedIPLiteral) {
+        let host = isIP ? parsed.host : normalizePercentEncoding(parsed.host, true);
+        if (!isIP) {
+          host = normalizePercentEncoding(host.toLowerCase());
         }
+        parsed.host = reescapeHostDelimiters(host, isIP);
+      }
+      if (!schemeHandler || schemeHandler && !schemeHandler.skipNormalize) {
         if (parsed.path) {
           parsed.path = normalizePathEncoding(parsed.path);
         }
@@ -19860,6 +19861,7 @@ var init_npx_resolver = __esm(() => {
 // dist/builtin/mcp/mcp-auth.ts
 import { mkdirSync as mkdirSync4, readFileSync as readFileSync5, writeFileSync as writeFileSync4, existsSync as existsSync5, rmSync } from "fs";
 import { join as join5 } from "path";
+import lockfile from "proper-lockfile";
 function getOwnedOAuthTransients() {
   const owner = getMcpOwner();
   if (!owner)
@@ -19898,6 +19900,14 @@ function ensureServerDir(serverName) {
     mkdirSync4(dir, { recursive: true, mode: 448 });
   }
 }
+async function acquireTokenRefreshLock(serverName) {
+  ensureServerDir(serverName);
+  return lockfile.lock(getServerDir(serverName), {
+    realpath: false,
+    retries: { retries: 120, minTimeout: 100, maxTimeout: 1000 },
+    stale: 60000
+  });
+}
 function readAuthEntry(serverName) {
   try {
     const filePath = getTokensFilePath(serverName);
@@ -20058,6 +20068,58 @@ var init_mcp_auth = __esm(() => {
 });
 
 // dist/builtin/mcp/mcp-oauth-provider.ts
+async function fetchRefreshResponse(url, init) {
+  const controller = new AbortController;
+  const signal = init.signal ? AbortSignal.any([init.signal, controller.signal]) : controller.signal;
+  const timer = setTimeout(() => controller.abort(new DOMException("MCP token refresh timed out", "TimeoutError")), REFRESH_REQUEST_TIMEOUT_MS);
+  let reader;
+  let onAbort;
+  const aborted = new Promise((_resolve, reject) => {
+    onAbort = () => {
+      reader?.cancel(signal.reason).catch(() => {});
+      reject(signal.reason);
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    if (signal.aborted)
+      onAbort();
+  });
+  const request = (async () => {
+    signal.throwIfAborted();
+    const response = await fetch(url, { ...init, signal });
+    if (signal.aborted) {
+      response.body?.cancel(signal.reason).catch(() => {});
+      signal.throwIfAborted();
+    }
+    reader = response.body?.getReader();
+    const decoder = new TextDecoder;
+    let text = "";
+    if (reader) {
+      try {
+        for (;; ) {
+          const chunk = await reader.read();
+          signal.throwIfAborted();
+          if (chunk.done)
+            break;
+          text += decoder.decode(chunk.value, { stream: true });
+        }
+        text += decoder.decode();
+      } finally {
+        reader.releaseLock();
+      }
+    }
+    return new Response(response.body ? text : null, {
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    });
+  })();
+  try {
+    return await Promise.race([request, aborted]);
+  } finally {
+    clearTimeout(timer);
+    signal.removeEventListener("abort", onAbort);
+  }
+}
 function getConfiguredOAuthCallbackPort() {
   return configuredOAuthCallbackPort;
 }
@@ -20074,6 +20136,66 @@ class McpOAuthProvider {
   config;
   callbacks;
   transients = getOwnedOAuthTransients();
+  refreshRelease;
+  refreshes = new Set;
+  fetch = async (url, init) => {
+    if (!(init?.body instanceof URLSearchParams) || init.body.get("grant_type") !== "refresh_token") {
+      return fetch(url, init);
+    }
+    let finish;
+    const pending = new Promise((resolve) => {
+      finish = resolve;
+    });
+    this.refreshes.add(pending);
+    const release = await acquireTokenRefreshLock(this.serverName).catch((error) => {
+      this.refreshes.delete(pending);
+      finish();
+      throw error;
+    });
+    this.refreshRelease = async () => {
+      this.refreshRelease = undefined;
+      try {
+        await release();
+      } finally {
+        this.refreshes.delete(pending);
+        finish();
+      }
+    };
+    try {
+      init.signal?.throwIfAborted();
+      const current = getAuthForUrl(this.serverName, this.serverUrl)?.tokens;
+      if (!current?.refreshToken)
+        throw new UnauthorizedError("MCP refresh credentials are no longer available");
+      if (current.refreshToken !== init.body.get("refresh_token") && (!current.expiresAt || current.expiresAt > Date.now() / 1000)) {
+        return Response.json({
+          access_token: current.accessToken,
+          refresh_token: current.refreshToken,
+          token_type: "Bearer",
+          ...current.expiresAt ? { expires_in: Math.max(0, current.expiresAt - Date.now() / 1000) } : {},
+          ...current.scope ? { scope: current.scope } : {}
+        });
+      }
+      const body = new URLSearchParams(init.body);
+      body.set("refresh_token", current.refreshToken);
+      const response = await fetchRefreshResponse(url, { ...init, body });
+      if (!response.ok) {
+        await this.refreshRelease();
+        return response;
+      }
+      const parsed = OAuthTokensSchema.safeParse(await response.clone().json());
+      if (!parsed.success) {
+        await this.refreshRelease();
+        return response;
+      }
+      return Response.json({ refresh_token: current.refreshToken, ...parsed.data });
+    } catch (error) {
+      await this.refreshRelease?.();
+      throw error;
+    }
+  };
+  async waitForRefresh() {
+    await Promise.all(this.refreshes);
+  }
   transientEntry() {
     if (!this.transients)
       return getAuthForUrl(this.serverName, this.serverUrl);
@@ -20165,14 +20287,19 @@ class McpOAuthProvider {
     };
   }
   async saveTokens(tokens) {
-    this.ensureActive();
-    const storedTokens = {
-      accessToken: tokens.access_token,
-      refreshToken: tokens.refresh_token,
-      expiresAt: tokens.expires_in ? Date.now() / 1000 + tokens.expires_in : undefined,
-      scope: tokens.scope
-    };
-    updateTokens(this.serverName, storedTokens, this.serverUrl);
+    try {
+      if (!this.refreshRelease)
+        this.ensureActive();
+      const storedTokens = {
+        accessToken: tokens.access_token,
+        refreshToken: tokens.refresh_token,
+        expiresAt: tokens.expires_in ? Date.now() / 1000 + tokens.expires_in : undefined,
+        scope: tokens.scope
+      };
+      updateTokens(this.serverName, storedTokens, this.serverUrl);
+    } finally {
+      await this.refreshRelease?.();
+    }
   }
   async redirectToAuthorization(authorizationUrl) {
     this.ensureActive();
@@ -20255,9 +20382,10 @@ class McpOAuthProvider {
     return params;
   }
 }
-var DEFAULT_OAUTH_CALLBACK_PORT = 19876, OAUTH_CALLBACK_PATH = "/callback", configuredOAuthCallbackPort, oauthCallbackPort;
+var DEFAULT_OAUTH_CALLBACK_PORT = 19876, OAUTH_CALLBACK_PATH = "/callback", REFRESH_REQUEST_TIMEOUT_MS = 15000, configuredOAuthCallbackPort, oauthCallbackPort;
 var init_mcp_oauth_provider = __esm(() => {
   init_auth2();
+  init_auth();
   init_mcp_auth();
   configuredOAuthCallbackPort = DEFAULT_OAUTH_CALLBACK_PORT;
   if (process.env.MCP_OAUTH_CALLBACK_PORT) {
@@ -20954,6 +21082,7 @@ var init_open = __esm(() => {
 
 // dist/builtin/mcp/mcp-callback-server.ts
 import { createServer } from "http";
+import { oauthErrorHtml, oauthSuccessHtml } from "@bastani/pi-ai/utils/oauth-page";
 function handleRequest(req, res) {
   const url = new URL(req.url || "/", `http://${req.headers.host}`);
   if (url.pathname !== OAUTH_CALLBACK_PATH) {
@@ -21123,48 +21252,12 @@ function stopCallbackServer(error = new Error("OAuth callback server stopped"))
     setOAuthCallbackPort(getConfiguredOAuthCallbackPort());
   });
 }
-var HTML_SUCCESS = `<!DOCTYPE html>
-<html>
-<head>
-  <title>Pi - Authorization Successful</title>
-  <style>
-    body { font-family: system-ui, -apple-system, sans-serif; display: flex; justify-content: center; align-items: center; height: 100vh; margin: 0; background: #1a1a2e; color: #eee; }
-    .container { text-align: center; padding: 2rem; }
-    h1 { color: #4ade80; margin-bottom: 1rem; }
-    p { color: #aaa; }
-  </style>
-</head>
-<body>
-  <div class="container">
-    <h1>Authorization Successful</h1>
-    <p>You can close this window and return to Pi.</p>
-  </div>
-  <script>setTimeout(() => window.close(), 2000);</script>
-</body>
-</html>`, renderCallbackErrorHtml = () => `<!DOCTYPE html>
-<html>
-<head>
-  <title>Pi - Authorization Failed</title>
-  <style>
-    body { font-family: system-ui, -apple-system, sans-serif; display: flex; justify-content: center; align-items: center; height: 100vh; margin: 0; background: #1a1a2e; color: #eee; }
-    .container { text-align: center; padding: 2rem; }
-    h1 { color: #f87171; margin-bottom: 1rem; }
-    p { color: #aaa; }
-    .error { color: #fca5a5; font-family: monospace; margin-top: 1rem; padding: 1rem; background: rgba(248,113,113,0.1); border-radius: 0.5rem; }
-  </style>
-</head>
-<body>
-  <div class="container">
-    <h1>Authorization Failed</h1>
-    <p>An error occurred during authorization.</p>
-    <div class="error">Return to Atomic and try again.</div>
-  </div>
-</body>
-</html>`, server, serverTransition, pendingAuths, standaloneOwner, serverOwners, callbackOwner = () => getMcpOwner() ?? standaloneOwner, CALLBACK_TIMEOUT_MS, MAX_PORT_SCAN_ATTEMPTS = 25;
+var HTML_SUCCESS, renderCallbackErrorHtml = () => oauthErrorHtml("Return to Atomic and try again."), server, serverTransition, pendingAuths, standaloneOwner, serverOwners, callbackOwner = () => getMcpOwner() ?? standaloneOwner, CALLBACK_TIMEOUT_MS, MAX_PORT_SCAN_ATTEMPTS = 25;
 var init_mcp_callback_server = __esm(() => {
   init_mcp_oauth_provider();
   init_logger();
   init_diagnostics();
+  HTML_SUCCESS = oauthSuccessHtml("You can close this window and return to Atomic.");
   serverTransition = Promise.resolve();
   pendingAuths = new Map;
   standaloneOwner = {};
@@ -21371,7 +21464,7 @@ async function startAuthAttempt(serverName, serverUrl, definition, owner) {
   };
   if (config.grantType === "client_credentials") {
     const authProvider = new McpOAuthProvider(serverName, serverUrl, config, providerCallbacks);
-    const result = await auth(authProvider, { serverUrl }).catch((error) => {
+    const result = await auth(authProvider, { serverUrl, fetchFn: authProvider.fetch }).catch((error) => {
       throw sanitizeRemoteError(error, serverUrl);
     });
     assertActive(owner);
@@ -21393,7 +21486,7 @@ async function startAuthAttempt(serverName, serverUrl, definition, owner) {
     assertActive: () => assertActive(owner)
   });
   try {
-    const result = await auth(authProvider, { serverUrl }).catch((error) => {
+    const result = await auth(authProvider, { serverUrl, fetchFn: authProvider.fetch }).catch((error) => {
       throw sanitizeRemoteError(error, serverUrl);
     });
     assertActive(owner);
@@ -21406,7 +21499,7 @@ async function startAuthAttempt(serverName, serverUrl, definition, owner) {
     const pendingTransport = {
       serverName,
       serverUrl,
-      transport: new StreamableHTTPClientTransport(new URL(serverUrl), { authProvider }),
+      transport: new StreamableHTTPClientTransport(new URL(serverUrl), { authProvider, fetch: authProvider.fetch }),
       oauthState
     };
     pendingTransports.set(serverName, pendingTransport);
@@ -21908,22 +22001,33 @@ class McpServerManager {
         onRedirect: async (_authUrl) => {}
       });
     }
-    const streamableTransport = protectRemoteTransport(new StreamableHTTPClientTransport(url, {
+    const protect = (transport) => {
+      if (authProvider) {
+        const close = transport.close.bind(transport);
+        transport.close = async () => {
+          await authProvider.waitForRefresh();
+          await close();
+        };
+      }
+      return protectRemoteTransport(transport, resolvedUrl);
+    };
+    const streamableTransport = protect(new StreamableHTTPClientTransport(url, {
       requestInit,
-      authProvider
-    }), resolvedUrl);
+      authProvider,
+      fetch: authProvider?.fetch
+    }));
     try {
       const testClient = new Client({ name: "pi-mcp-probe", version: "2.1.2" });
       await testClient.connect(streamableTransport);
       await testClient.close().catch(() => {});
       await streamableTransport.close().catch(() => {});
-      return protectRemoteTransport(new StreamableHTTPClientTransport(url, { requestInit, authProvider }), resolvedUrl);
+      return protect(new StreamableHTTPClientTransport(url, { requestInit, authProvider, fetch: authProvider?.fetch }));
     } catch (error) {
       await streamableTransport.close().catch(() => {});
       if (error instanceof UnauthorizedError) {
         throw error;
       }
-      return protectRemoteTransport(new SSEClientTransport(url, { requestInit, authProvider }), resolvedUrl);
+      return protect(new SSEClientTransport(url, { requestInit, authProvider, fetch: authProvider?.fetch }));
     }
   }
   async fetchAllTools(client) {
@@ -25625,7 +25729,7 @@ function stateChangedResult() {
 function createDirectToolExecutor(ensureInitialized, isActiveStateOwner, spec, options = {}) {
   const startUiSession = options.startUiSession ?? maybeStartUiSession;
   const startAutoAuth = options.startAutoAuth ?? attemptDirectAutoAuth;
-  return async function execute(_toolCallId, params, signal) {
+  const execute = async function execute(_toolCallId, params, signal) {
     signal?.throwIfAborted();
     let state;
     try {
@@ -25761,6 +25865,7 @@ Expected parameters:
 ${formatSchema(spec.inputSchema)}`;
         return {
           content: [{ type: "text", text: `Error: ${errorText}` }],
+          structuredContent: result,
           details: { error: "tool_error", server: spec.serverName }
         };
       }
@@ -25772,11 +25877,13 @@ ${formatSchema(spec.inputSchema)}`;
           content: [{ type: "text", text: `${resultText}
 
 ${uiMessage}` }],
+          structuredContent: result,
           details: { server: spec.serverName, tool: spec.originalName, uiOpen: true }
         };
       }
       return {
         content: content.length > 0 ? content : [{ type: "text", text: "(empty result)" }],
+        structuredContent: result,
         details: { server: spec.serverName, tool: spec.originalName }
       };
     } catch (error) {
@@ -25806,6 +25913,18 @@ ${formatSchema(spec.inputSchema)}`;
       }
     }
   };
+  return async (...args) => {
+    const result = await execute(...args);
+    if (spec.resourceUri || result.structuredContent !== undefined)
+      return result;
+    return {
+      ...result,
+      structuredContent: {
+        content: result.content.map((block) => block.type === "text" ? { type: "text", text: block.text } : { type: "image", data: block.data, mimeType: block.mimeType }),
+        isError: !!result.details.error
+      }
+    };
+  };
 }
 var init_direct_tool_executor = __esm(() => {
   init_init();
@@ -27086,7 +27205,7 @@ function blockToLines(block) {
   }
   return [`[image: ${block.mimeType}]`];
 }
-function formatMcpToolResultLines(result, expanded, maxCollapsedLines = 3) {
+function formatMcpToolResultLines(result, expanded, maxCollapsedLines = 5) {
   const allLines = result.content.flatMap(blockToLines);
   const lines = allLines.length > 0 ? allLines : ["(empty result)"];
   if (expanded || lines.length <= maxCollapsedLines) {
@@ -27114,6 +27233,7 @@ ${theme.fg("muted", `(${expandKey} Expand)`)}` : "";
 // dist/builtin/mcp/tool-call-renderer.ts
 init_tool_metadata();
 init_types2();
+import { formatToolCallWithArgs } from "@bastani/atomic";
 import { stripTerminalSequences, Text as Text2 } from "@earendil-works/pi-tui";
 function textArg(value) {
   return typeof value === "string" && value.length > 0 ? value : undefined;
@@ -27129,14 +27249,31 @@ function inferServer(tool, source) {
   });
   return candidates.length === 1 ? candidates[0] : undefined;
 }
-function header(theme, server, operation) {
+function redactArguments(value) {
+  if (Array.isArray(value))
+    return value.map(redactArguments);
+  if (value !== null && typeof value === "object")
+    return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, /token|secret|password|authorization|api.?key/i.test(key) ? "[redacted]" : redactArguments(entry)]));
+  return value;
+}
+function header(theme, server, operation, args, expanded = false) {
   const clean = (value) => stripTerminalSequences(value).replace(/[\r\n\t]/g, " ");
+  if (server && args && Object.keys(args).length > 0)
+    return new Text2(formatToolCallWithArgs(`MCP${server ? ` ${clean(server)}` : ""} · ${clean(operation)}`, redactArguments(args), { fg: (name, text) => theme.fg(name, text), bold: (text) => theme.bold?.(text) ?? text }, expanded), 0, 0);
   return new Text2(theme.fg("toolTitle", `MCP${server ? ` ${clean(server)}` : ""}`) + theme.fg("muted", ` · ${clean(operation)}`), 0, 0);
 }
-function renderMcpDirectToolCall(server, tool, theme) {
-  return header(theme, server, tool);
+function renderMcpDirectToolCall(server, tool, theme, args, expanded = false) {
+  return header(theme, server, tool, args, expanded);
 }
-function renderMcpToolCall(args, theme, source = {}) {
+function renderMcpToolCall(args, theme, source = {}, expanded = false) {
+  let callArgs = args.args;
+  if (typeof callArgs === "string") {
+    try {
+      callArgs = JSON.parse(callArgs);
+    } catch {
+      callArgs = { args: callArgs };
+    }
+  }
   const action = textArg(args?.action);
   const tool = textArg(args?.tool);
   const connect = textArg(args?.connect);
@@ -27144,8 +27281,11 @@ function renderMcpToolCall(args, theme, source = {}) {
   const server = textArg(args?.server);
   if (action === "ui-messages")
     return header(theme, undefined, action);
-  if (tool)
-    return header(theme, server ?? inferServer(tool, source), tool);
+  if (tool) {
+    const target = server ?? inferServer(tool, source);
+    const knownTarget = target !== undefined && (Object.hasOwn(source.config?.mcpServers ?? {}, target) || source.toolMetadata?.has(target));
+    return header(theme, target, tool, knownTarget && typeof callArgs === "object" && callArgs !== null && !Array.isArray(callArgs) ? callArgs : undefined, expanded);
+  }
   if (connect)
     return header(theme, connect, "connect");
   if (describe)
@@ -27225,8 +27365,16 @@ function mcpAdapter(pi) {
         description: spec.description || "(no description)",
         promptSnippet: truncateAtWord(spec.description, 100) || `MCP tool from ${spec.serverName}`,
         parameters: Type.Unsafe(spec.inputSchema || { type: "object", properties: {} }),
+        exposure: "direct",
+        namespace: { name: `mcp:${spec.serverName}` },
+        ...!spec.resourceUri ? { outputSchema: Type.Object({
+          content: Type.Array(Type.Object({ type: Type.String() }, { additionalProperties: true })),
+          isError: Type.Optional(Type.Boolean()),
+          structuredContent: Type.Optional(Type.Object({}, { additionalProperties: true })),
+          _meta: Type.Optional(Type.Object({}, { additionalProperties: true }))
+        }, { additionalProperties: true }) } : {},
         execute: createDirectToolExecutor(() => ensureMcpInitialized(), (candidate) => isOwnedState(candidate), spec),
-        renderCall: (_args, theme) => renderMcpDirectToolCall(spec.serverName, spec.originalName, theme),
+        renderCall: (args, theme, context) => renderMcpDirectToolCall(spec.serverName, spec.originalName, theme, args, context.expanded),
         renderResult: renderMcpToolResult
       });
     }
@@ -27555,7 +27703,7 @@ function mcpAdapter(pi) {
         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" }))
       }),
-      renderCall: (args, theme) => renderMcpToolCall(args, theme, { config: state?.config ?? renderConfig, toolMetadata: state?.toolMetadata }),
+      renderCall: (args, theme, context) => renderMcpToolCall(args, theme, { config: state?.config ?? renderConfig, toolMetadata: state?.toolMetadata }, context.expanded),
       renderResult: renderMcpToolResult,
       async execute(_toolCallId, params, signal, _onUpdate, _ctx) {
         signal?.throwIfAborted();

package/dist/builtin/mcp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/mcp",
-  "version": "0.9.24",
+  "version": "0.9.25-alpha.2",
   "private": true,
   "description": "Atomic extension that adapts MCP (Model Context Protocol) servers into the coding agent. Fork of: https://github.com/nicobailon/pi-mcp-adapter",
   "contributors": [
@@ -33,7 +33,7 @@
   "peerDependencies": {
     "@bastani/atomic": "*",
     "@bastani/pi-ai": "*",
-    "@earendil-works/pi-tui": "^0.87.1",
+    "@earendil-works/pi-tui": "^0.99.1",
     "zod": "^3.25.0 || ^4.0.0",
     "typebox": "*"
   },
@@ -52,6 +52,10 @@
     "@modelcontextprotocol/ext-apps": "^1.7.5",
     "@modelcontextprotocol/sdk": "^1.30.0",
     "open": "^11.0.1",
+    "proper-lockfile": "4.1.2",
     "zod": "^3.25.0 || ^4.0.0"
+  },
+  "devDependencies": {
+    "@types/proper-lockfile": "4.1.4"
   }
 }

package/dist/builtin/subagents/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/subagents",
-  "version": "0.9.24",
+  "version": "0.9.25-alpha.2",
   "private": true,
   "description": "Atomic extension for delegating tasks to subagents with parallel execution. Fork of: https://github.com/nicobailon/pi-subagents",
   "contributors": [
@@ -35,8 +35,8 @@
   "peerDependencies": {
     "@bastani/atomic": "*",
     "@bastani/pi-ai": "*",
-    "@earendil-works/pi-agent-core": "^0.87.1",
-    "@earendil-works/pi-tui": "^0.87.1",
+    "@earendil-works/pi-agent-core": "^0.99.1",
+    "@earendil-works/pi-tui": "^0.99.1",
     "typebox": "*"
   },
   "peerDependenciesMeta": {

package/dist/builtin/subagents/src/extension/index.bundle.mjs

@@ -18260,6 +18260,7 @@ function registerSubagentExtension(pi) {
     });
     const tool = {
       name: "subagent",
+      exposure: "model-only",
       label: "Subagent",
       description: SUBAGENT_TOOL_DESCRIPTION,
       parameters: SubagentParams,