antechamber 1.0.30 → 1.0.31

package/CHANGELOG.md

@@ -7,6 +7,18 @@ and this project uses [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [1.0.31] - 2026-10-29
+
+### Fixed
+
+- Show the MCP servers and their count before a session runs. A directory with no running agent used to report no servers,
+  so the sidebar's "MCP servers" count sat at 0 in a new chat, on a dormant project and after the idle reaper stopped the
+  last agent. The servers are now read by a short-lived agent started for that read alone.
+- Keep that list current: antechamber announces `mcp.status.changed` when an agent starts, stops or reports new MCP state,
+  so OpenChamber re-reads instead of keeping a stale count (it treats an answer as fresh for a minute).
+- Stop a sign-in from failing with "pi process disposed" when OmO answers `auth-start` only while `auth-complete` is
+  already running. The agent started for the sign-in was stopped mid-command; the completion now owns it until it ends.
+
 ## [1.0.30] - 2026-10-28
 
 - update

package/dist/mcp.d.ts

@@ -72,6 +72,11 @@ export declare function v2McpStatus(server: OmoMcpServer): V2McpStatus;
  * all connected within about a second, each change announced by `loaded_surfaces_changed`.
  */
 export declare function waitForMcpServers(pi: PiRpcClient, budgetMs: number, signal?: AbortSignal): Promise<void>;
+/**
+ * An agent started, stopped or reported new MCP state. Every directory a client read is told to read
+ * again: with the cross-directory fallback, one agent can change the answer for all of them.
+ */
+export declare function mcpSurfacesChanged(broadcast: RouteServices["broadcast"]): void;
 /** The URL OmO prints on its own line after naming the server (`auth` and `auth-start` both do). */
 export declare function authorizationUrl(text: string, name: string): string | undefined;
 /**
@@ -80,7 +85,7 @@ export declare function authorizationUrl(text: string, name: string): string | u
  * authorization request's own `redirect_uri` and `state`.
  */
 export declare function redirectInput(authorization: string, input: string): string | undefined;
-/** Stops the agents spawned for sign-ins; live sessions are stopped by their own manager. */
+/** Stops the agents spawned for sign-ins and inventories; live sessions are stopped by their own manager. */
 export declare function disposeMcpAgents(): Promise<void>;
 export declare function mcpRoute(services: RouteServices, method: string, path: string, directory: string, body: () => Promise<unknown>): Promise<RouteResult | undefined>;
 export declare function mcpRouteV2(services: RouteServices, method: string, path: string, directory: string, body: () => Promise<unknown>): Promise<RouteResult | undefined>;

package/dist/mcp.js

@@ -39,8 +39,18 @@ const SERVER_NAME = /^[^\s"'\\]+$/;
 const INTEGRATION_PREFIX = "mcp_";
 const OAUTH_METHOD_ID = "oauth";
 const BUILTIN_MCP_PATH = "<builtin:mcp>";
+/** How long an inventory read without a running agent is reused. */
+const MCP_INVENTORY_TTL_MS = 30_000;
+/** A fresh agent answers `get_state` once its extensions loaded, about 1.3 s on a typical install. */
+const MCP_INVENTORY_START_MS = 15_000;
+/** OmO reports each server settling separately at startup; one announcement covers the burst. */
+const MCP_CHANGE_DEBOUNCE_MS = 250;
 const flows = new Map();
 const admissions = new Map();
+const watchedDirectories = new Set();
+const inventories = new Map();
+const inventoryAgents = new Set();
+let changeTimer;
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -141,11 +151,58 @@ export async function waitForMcpServers(pi, budgetMs, signal) {
     }
 }
 async function directoryServers(sessions, directory) {
-    // A directory whose sessions are all dormant would list nothing. Its servers are mostly
-    // the user's global and built-in ones, so any running session gives a better answer.
-    const fallback = sessions.liveSessions()[0]?.pi;
-    const live = liveSession(sessions, directory) ?? (fallback === undefined ? undefined : { pi: fallback });
-    return live === undefined ? [] : loadedServers(live.pi).catch(() => []);
+    watchedDirectories.add(directory);
+    // A directory whose sessions are all dormant reads a running session elsewhere: its servers are
+    // mostly the user's global and built-in ones. An agent that just exited is skipped.
+    const agents = new Set([liveSession(sessions, directory)?.pi, ...sessions.liveSessions().map((s) => s.pi)]);
+    for (const pi of agents) {
+        if (pi === undefined)
+            continue;
+        try {
+            return await loadedServers(pi);
+        }
+        catch { }
+    }
+    return inventory(directory);
+}
+/** With no running agent, a short-lived `--no-session` agent reads the inventory, shared for a while. */
+function inventory(directory) {
+    const cached = inventories.get(directory);
+    if (cached !== undefined && Date.now() - cached.at < MCP_INVENTORY_TTL_MS)
+        return cached.servers;
+    const servers = readInventory(directory).catch((error) => {
+        if (inventories.get(directory)?.servers === servers)
+            inventories.delete(directory);
+        console.error(`[mcp] listing servers for ${directory} failed: ${errorMessage(error)}`);
+        return [];
+    });
+    inventories.set(directory, { at: Date.now(), servers });
+    return servers;
+}
+async function readInventory(directory) {
+    const pi = new PiRpcClient({ cwd: directory, args: ["--no-session"] });
+    inventoryAgents.add(pi);
+    try {
+        await pi.command({ type: "get_state" }, MCP_INVENTORY_START_MS);
+        return await loadedServers(pi);
+    }
+    finally {
+        inventoryAgents.delete(pi);
+        await pi.dispose();
+    }
+}
+/**
+ * An agent started, stopped or reported new MCP state. Every directory a client read is told to read
+ * again: with the cross-directory fallback, one agent can change the answer for all of them.
+ */
+export function mcpSurfacesChanged(broadcast) {
+    inventories.clear();
+    clearTimeout(changeTimer);
+    changeTimer = setTimeout(() => {
+        for (const directory of watchedDirectories)
+            broadcast(directory, { type: "mcp.tools.changed", properties: { server: "" } });
+    }, MCP_CHANGE_DEBOUNCE_MS);
+    changeTimer.unref();
 }
 /** The builtin MCP command's name in this agent; builds without `sourceInfo` only know it as `mcp`. */
 async function mcpCommandName(pi) {
@@ -279,14 +336,16 @@ function release(flow) {
         .dispose()
         .catch((error) => console.error(`[mcp] stopping an auth agent failed: ${errorMessage(error)}`));
 }
-/** Stops the agents spawned for sign-ins; live sessions are stopped by their own manager. */
+/** Stops the agents spawned for sign-ins and inventories; live sessions are stopped by their own manager. */
 export async function disposeMcpAgents() {
+    clearTimeout(changeTimer);
+    inventories.clear();
     const dedicated = [...flows.values()].filter((flow) => flow.s === undefined && !flow.released);
     for (const flow of dedicated) {
         flow.released = true;
         clearTimeout(flow.expiry);
     }
-    await Promise.all(dedicated.map((flow) => flow.pi.dispose()));
+    await Promise.all([...dedicated.map((flow) => flow.pi.dispose()), ...[...inventoryAgents].map((pi) => pi.dispose())]);
 }
 async function flowStatus(flow, name) {
     if (flow.server !== undefined || !agentCurrent(flow))
@@ -359,6 +418,7 @@ async function startFlow(services, directory, name, command) {
         done: Promise.resolve(),
         running: true,
         authorized: false,
+        completing: false,
         released: false,
     };
     if (live === undefined) {
@@ -380,7 +440,8 @@ async function startFlow(services, directory, name, command) {
         .then(async () => {
         if (!flow.authorized)
             return;
-        if (live === undefined) {
+        // A completion in flight set `authorized` and owns the agent: stopping it now would kill its command.
+        if (live === undefined && !flow.completing) {
             const server = await currentStatus(pi, name).catch(() => undefined);
             if (server !== undefined)
                 flow.server = server;
@@ -448,6 +509,7 @@ async function completeFlow(services, directory, name, input) {
     // OmO consumes the pending state on any answer, so a dedicated agent has nothing left to wait for.
     let attempted = false;
     let server;
+    flow.completing = true;
     try {
         if (flow.running && flow.command === "auth") {
             const target = new URL(redirect);
@@ -483,6 +545,7 @@ async function completeFlow(services, directory, name, input) {
         return fail(400, "McpAuthError", flow.error);
     }
     finally {
+        flow.completing = false;
         if (attempted)
             release(flow);
     }

package/dist/server.js

@@ -1,7 +1,7 @@
 /** HTTP/SSE composition root for the OpenCode API backed by pi. */
 import { createHash, randomBytes } from "node:crypto";
 import { createServer } from "node:http";
-import { disposeMcpAgents } from "./mcp.js";
+import { disposeMcpAgents, mcpSurfacesChanged } from "./mcp.js";
 import { debugLog } from "./misc-routes.js";
 import { SessionManager } from "./sessions.js";
 import { loadCatalog } from "./catalog.js";
@@ -30,6 +30,7 @@ export class AdapterServer {
         this.options = options;
         this.sse = new SSE(options, this.sseClients, (id) => this.sessions.monitors.owns(id));
         this.sessions = new SessionManager((directory, event) => this.broadcast(directory, event), undefined, options.defaultDirectory);
+        this.sessions.onMcpSurfacesChanged = () => mcpSurfacesChanged((directory, event) => this.broadcast(directory, event));
         this.server = createServer((req, res) => void this.route(req, res));
         this.server.on("upgrade", (req, socket, head) => this.handleUpgrade(req, socket, head));
     }

package/dist/sessions.d.ts

@@ -116,6 +116,8 @@ export declare class SessionManager {
     private scanCache;
     /** freshness of the all-directories scan (see listAll). */
     private scanAllCache;
+    /** Called when an agent starts, stops or reports a change to its MCP servers. */
+    onMcpSurfacesChanged: (() => void) | undefined;
     constructor(emit: EventSink, store?: SessionStore, defaultDirectory?: string | undefined, lifecycleOptions?: LifecycleOptions);
     create(directory: string, title?: string, parentID?: string, options?: {
         id?: string;

package/dist/sessions.js

@@ -75,6 +75,8 @@ export class SessionManager {
     scanCache = new Map();
     /** freshness of the all-directories scan (see listAll). */
     scanAllCache;
+    /** Called when an agent starts, stops or reports a change to its MCP servers. */
+    onMcpSurfacesChanged;
     constructor(emit, store, defaultDirectory, lifecycleOptions = {}) {
         this.emit = emit;
         this.defaultDirectory = defaultDirectory;
@@ -258,6 +260,8 @@ export class SessionManager {
         const onEvent = (payload) => {
             if (s.pi !== pi)
                 return;
+            if (payload.type === "loaded_surfaces_changed")
+                this.onMcpSurfacesChanged?.();
             this.lifecycle.touch(s);
             s.approvals?.observeQuestion(payload);
             try {
@@ -278,6 +282,7 @@ export class SessionManager {
         const onExit = (code, signal) => {
             if (s.pi !== pi)
                 return;
+            this.onMcpSurfacesChanged?.();
             // An agent that stopped on its own (timeout, broken pipe, crash) must say why: a notice card in the
             // transcript, the same error on the reply it interrupted, and a replay after an adapter restart.
             // Pending commands reject with the same PiStoppedError; prompt admission leaves it to this handler.
@@ -315,6 +320,7 @@ export class SessionManager {
         pi.onEvent(onEvent);
         pi.onExtensionUI(onExtensionUI);
         pi.onExit(onExit);
+        this.onMcpSurfacesChanged?.();
         s.unwirePi = () => {
             pi.off("event", onEvent);
             pi.off("extension_ui_request", onExtensionUI);

package/extensions/omo-compat/package.json

@@ -1,6 +1,6 @@
 {
   "name": "antechamber-omo-compat",
-  "version": "1.0.30",
+  "version": "1.0.31",
   "description": "OpenChamber extension: displays OmO tool calls the way OmO means them when OpenChamber runs on antechamber",
   "private": true,
   "type": "module",

package/extensions/omo-dag/package.json

@@ -1,6 +1,6 @@
 {
   "name": "antechamber-omo-graph",
-  "version": "1.0.30",
+  "version": "1.0.31",
   "description": "OpenChamber extension: live, interactive graph of the OmO sub-agents behind the current session",
   "private": true,
   "type": "module",

package/extensions/omo-work/package.json

@@ -1,6 +1,6 @@
 {
   "name": "antechamber-omo-work",
-  "version": "1.0.30",
+  "version": "1.0.31",
   "description": "OpenChamber 2.x Work Status section: OmO todo phases, monitors, eval cells and background work of the current session",
   "private": true,
   "type": "module",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "antechamber",
-  "version": "1.0.30",
+  "version": "1.0.31",
   "description": "OpenCode-compatible HTTP/SSE server that lets OpenChamber drive the pi coding agent (and OmO) over RPC",
   "type": "module",
   "license": "MIT",