@stage-labs/metro 0.1.0-beta.316 → 0.1.0-beta.318

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.316",
+  "version": "0.1.0-beta.318",
   "description": "The metro command line: run your agent on this machine, relaying its chat channels and connectors to Claude Code.",
   "license": "MIT",
   "repository": {

package/runtime/node_modules/@metro-labs/core/package.json

@@ -26,6 +26,7 @@
     "./lines": "./src/lines.ts",
     "./endpoints": "./src/endpoints.ts",
     "./stations/types": "./src/stations/types.ts",
+    "./stations/account-status": "./src/stations/account-status.ts",
     "./stations/channel-directory": "./src/stations/channel-directory.ts",
     "./stations/channel-pages": "./src/stations/channel-pages.ts",
     "./stations/account-files": "./src/stations/account-files.ts",

package/runtime/node_modules/@metro-labs/core/src/stations/account-status.ts

@@ -0,0 +1,26 @@
+import { isRecord } from '../is-record.js';
+
+export const ACCOUNT_STATES = ['connected', 'connecting', 'logged_out', 'disconnected'] as const;
+
+export type AccountState = (typeof ACCOUNT_STATES)[number];
+
+export interface AccountStatus {
+  state: AccountState;
+  reason?: string;
+  since: number;
+}
+
+const REASON_MAX = 300;
+
+export function accountStatus(state: AccountState, reason?: string, since = Date.now()): AccountStatus {
+  const text = reason?.trim().slice(0, REASON_MAX) ?? '';
+  return text === '' ? { state, since } : { state, reason: text, since };
+}
+
+export function accountStatusOf(raw: unknown): AccountStatus | null {
+  if (!isRecord(raw)) return null;
+  const state = ACCOUNT_STATES.find((s) => s === raw.state);
+  const since = raw.since;
+  if (state === undefined || typeof since !== 'number' || !Number.isFinite(since)) return null;
+  return accountStatus(state, typeof raw.reason === 'string' ? raw.reason : undefined, since);
+}

package/runtime/node_modules/@metro-labs/core/src/stations/types.ts

@@ -114,6 +114,8 @@ export interface Station {
   readFilters?: ReadonlySet<ReadFilter>;
   approvals?: boolean;
   sendsFrames?: boolean;
+  reportsStatus?: boolean;
+  pairAgain?: { identity: string };
   attachmentMode: AttachmentMode;
   forget?: (accountId: string) => void;
   forgetExcept?: (keptAccountIds: readonly string[]) => void;

package/runtime/node_modules/@metro-labs/daemon/src/agents/account-routes.ts

@@ -13,6 +13,7 @@ export type AccountRoute =
   | { kind: 'enabled'; station: StationName; accountId: string }
   | { kind: 'policy'; station: StationName; accountId: string }
   | { kind: 'profiles'; station: StationName; accountId: string }
+  | { kind: 'repair'; station: StationName; accountId: string }
   | { kind: 'name'; station: StationName; accountId: string };
 
 const ROUTE_METHODS: Record<AccountRoute['kind'], string[]> = {
@@ -26,10 +27,11 @@ const ROUTE_METHODS: Record<AccountRoute['kind'], string[]> = {
   enabled: ['PUT'],
   policy: ['PUT'],
   profiles: ['GET'],
+  repair: ['POST'],
   name: ['GET', 'POST'],
 };
 
-const SUB_ROUTES = ['allowlist', 'senders', 'resolve', 'enabled', 'name', 'policy', 'profiles'] as const;
+const SUB_ROUTES = ['allowlist', 'senders', 'resolve', 'enabled', 'name', 'policy', 'profiles', 'repair'] as const;
 
 type SubRoute = (typeof SUB_ROUTES)[number];
 

package/runtime/node_modules/@metro-labs/daemon/src/agents/accounts-api.ts

@@ -37,6 +37,7 @@ interface AttachSessionApi {
     owner: AttachOwner,
     station: InteractiveStation,
     input: Record<string, unknown>,
+    repair?: string,
   ) => Promise<AttachView>;
   view: (owner: AttachOwner, attachId: string) => AttachView;
   submit: (
@@ -315,16 +316,36 @@ async function handleStep(
   sendJson(req, res, 200, view);
 }
 
+async function handleRepair(
+  req: IncomingMessage,
+  res: ServerResponse,
+  deps: AccountApiDeps,
+  owner: AttachOwner,
+  target: { station: StationName; accountId: string },
+): Promise<void> {
+  const { station, accountId } = target;
+  if (!isInteractiveStation(station) || stationByName(station)?.pairAgain === undefined)
+    throw new ApiError(`${station} cannot pair again`, 400);
+  const view = await deps.attachSessions.start(owner, station, asInput(await readJsonBody(req)), accountId);
+  sendJson(req, res, 201, view);
+}
+
+type AttachRoute = Extract<AccountRoute, { kind: 'start' | 'session' | 'step' | 'repair' }>;
+
+const isAttachRoute = (route: AccountRoute): route is AttachRoute =>
+  route.kind === 'start' || route.kind === 'session' || route.kind === 'step' || route.kind === 'repair';
+
 async function dispatchAttach(
   req: IncomingMessage,
   res: ServerResponse,
   deps: AccountApiDeps,
   agentId: string,
-  route: Extract<AccountRoute, { kind: 'start' | 'session' | 'step' }>,
+  route: AttachRoute,
   session?: ApiSession,
 ): Promise<void> {
   const owner: AttachOwner = { agentId, organization: session?.subject, userId: session?.userId, sessionId: session?.sessionId, authorization: req.headers.authorization };
   if (route.kind === 'start') return handleStart(req, res, deps, agentId, owner);
+  if (route.kind === 'repair') return handleRepair(req, res, deps, owner, route);
   if (route.kind === 'session') return handleSession(req, res, deps, owner, route.attachId);
   return handleStep(req, res, deps, owner, route.attachId);
 }
@@ -337,7 +358,7 @@ async function dispatchRoute(
   route: AccountRoute,
   session?: ApiSession,
 ): Promise<void> {
-  if (route.kind === 'start' || route.kind === 'session' || route.kind === 'step') return dispatchAttach(req, res, deps, agentId, route, session);
+  if (isAttachRoute(route)) return dispatchAttach(req, res, deps, agentId, route, session);
   if (route.kind === 'allowlist') return handleAllowlist(req, res, deps, agentId, route);
   if (route.kind === 'enabled') return handleEnabled(req, res, deps, agentId, route);
   if (route.kind === 'policy') return handlePolicy(req, res, deps, agentId, route);

package/runtime/node_modules/@metro-labs/daemon/src/agents/api.ts

@@ -13,6 +13,7 @@ import {
   type AccountRoute,
 } from './account-routes.js';
 import type { AgentSummary } from './admin.js';
+import { pairAgainStations, statusStations } from '../stations/registry.js';
 
 const PREFIX = '/api/agents';
 
@@ -70,6 +71,8 @@ async function handleList(
     capabilities: deps.capabilities(),
     features: deps.features ?? [],
     attachable: deps.attachable ?? ATTACHABLE,
+    reportsStatus: statusStations(),
+    pairAgain: pairAgainStations(),
     ...(deps.toolGroups === undefined ? {} : { tools: deps.toolGroups() }),
   };
   if (!wantsAccounts(req)) {

package/runtime/node_modules/@metro-labs/daemon/src/agents/file-admin.ts

@@ -210,6 +210,23 @@ export function localRenewGmail(agentId: string, accountId: string, previous: st
   return { agentId, station: 'gmail', accountId };
 }
 
+const sameIdentity = (a: unknown, b: unknown): boolean =>
+  typeof a === 'string' && typeof b === 'string' && a.replace(/[\s()+-]/g, '').toLowerCase() === b.replace(/[\s()+-]/g, '').toLowerCase();
+
+const shownIdentity = (value: unknown): string => (typeof value === 'string' && value !== '' ? value : 'unknown');
+
+export function localPairAgain(agentId: string, station: StationName, accountId: string, identity: string, config: Record<string, unknown>, dir = agentsDir()): AccountRef {
+  const stored = agentOrThrow(agentId, dir);
+  const account = stored.file.stations.find((s) => s.station === station && s.id === accountId);
+  if (account === undefined) throw new AgentAdminError('This channel is gone. Nothing was changed.', 404);
+  const before = account.config[identity];
+  const after = config[identity];
+  if (!sameIdentity(before, after)) throw new AgentAdminError(`This channel is ${shownIdentity(before)}, not ${shownIdentity(after)}. Nothing was changed.`, 400);
+  account.config = { ...account.config, ...config };
+  save(stored);
+  return { agentId, station, accountId };
+}
+
 export function readLocalAgentFile(agentId: string, dir = agentsDir()): AgentFile {
   const found = storedAgents(dir).find((s) => s.file.id === agentId);
   if (found === undefined) throw missing();

package/runtime/node_modules/@metro-labs/daemon/src/mcp/accounts.ts

@@ -6,6 +6,7 @@ import {
 } from '../stations/registry.js';
 import { listEndpoints } from '../stations/webhook-endpoints.js';
 import { hookUrl, threemaCallbackUrl } from '../stations/attach.js';
+import { accountStatusOf } from '@metro-labs/core/stations/account-status';
 import { accountEnabled, agentIdForAccount, allowlistForAccount, approversForAccount, knownAccounts, type KnownAccount } from '../agents/map.js';
 
 const accountId = (acc: unknown): string | undefined => {
@@ -85,8 +86,33 @@ function withCallbackUrl(acc: unknown): unknown {
   return { ...rest, callback: threemaCallbackUrl(callbackId, callbackToken) };
 }
 
-const decorate = (station: string, rows: unknown[]): unknown[] =>
-  station === 'threema' ? rows.map(withCallbackUrl) : rows;
+function withStatus(reports: boolean, acc: unknown): unknown {
+  const rec = asRecord(acc);
+  if (rec === undefined || !('status' in rec)) return acc;
+  const { status, ...rest } = rec;
+  const live = reports ? accountStatusOf(status) : null;
+  return live === null ? rest : { ...rest, status: live };
+}
+
+function decorate(station: string, rows: unknown[]): unknown[] {
+  const reports = stationByName(station)?.reportsStatus === true;
+  const live = rows.map((row) => withStatus(reports, row));
+  return station === 'threema' ? live.map(withCallbackUrl) : live;
+}
+
+const STATUS_WAIT_MS = 5_000;
+
+function answerIn<T>(call: Promise<T>, ms: number): Promise<T> {
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  const late = new Promise<never>((_resolve, reject) => {
+    timer = setTimeout(() => {
+      reject(new Error(`no answer within ${String(ms)} ms`));
+    }, ms);
+  });
+  return Promise.race([call, late]).finally(() => {
+    clearTimeout(timer);
+  });
+}
 
 export interface ScopedAccounts {
   accounts: Record<string, unknown[]>;
@@ -99,7 +125,8 @@ async function liveAccounts(
   if (!hasTrain(station))
     return { rows: inCoreAccounts(station), reachable: true };
   try {
-    const resp = await forwardTrainCall(station, 'accounts', {});
+    const call = forwardTrainCall(station, 'accounts', {});
+    const resp = await (stationByName(station)?.reportsStatus === true ? answerIn(call, STATUS_WAIT_MS) : call);
     const list = (resp.result as { accounts?: unknown[] } | undefined)?.accounts;
     return { rows: decorate(station, Array.isArray(list) ? list : []), reachable: true };
   } catch {

package/runtime/node_modules/@metro-labs/daemon/src/mcp/server-approvals.ts

@@ -46,10 +46,16 @@ const noticeText = (tool: string, id: string, behavior: Behavior): string =>
 
 const requestedAt = (at: number, now = Date.now()): number => (Number.isFinite(at) && at > 0 ? Math.min(at, now) : now);
 
+const askedBy = (approval: McpApproval): string => {
+  if (approval.origin !== 'key') return '';
+  return approval.keyLabel === undefined ? ' (from an access key)' : ` (from an access key: ${approval.keyLabel})`;
+};
+
 interface Held {
   id: string;
   tool: string;
   line: string | undefined;
+  tellAgent: boolean;
   answer: (decision: McpDecision) => Promise<AnswerOutcome>;
   publish: (event: MetroEvent) => void;
 }
@@ -60,6 +66,10 @@ async function deliver(held: Held, behavior: Behavior): Promise<void> {
     log.info({ id: held.id, outcome }, 'mcp-server: the answer was not taken, so the agent is not told');
     return;
   }
+  if (!held.tellAgent) {
+    log.info({ id: held.id }, 'mcp-server: the call came with an access key, not from this agent\'s session, so the agent is not told');
+    return;
+  }
   const line = noticeLineFor(held.line);
   if (line === undefined) {
     log.warn({ id: held.id }, 'mcp-server: no chat is known to tell the agent the answer');
@@ -91,15 +101,15 @@ export function holdServerApproval(approval: McpApproval, answer: Held['answer']
   const tool = `${approval.connector}.${approval.tool}`;
   const announced = announcedLine(approval.id);
   const line = announced ?? promptLineFor(approval.id);
-  const held: Held = { id: approval.id, tool, line, answer, publish };
+  const held: Held = { id: approval.id, tool, line, tellAgent: approval.origin !== 'key', answer, publish };
   holdPrompt(
     { requestId: approval.id, tool, description: approval.connector, preview: approval.preview, line, at: requestedAt(approval.requestedAt), origin: 'mcp-server' },
     owner,
     sender(held),
     line === undefined ? undefined : async (text) => metroSend(line, text),
   );
-  log.info({ id: approval.id, tool, inChat: line !== undefined, announced: announced !== undefined }, 'mcp-server: an approval is waiting for the owner');
-  if (line !== undefined && announced === undefined) announce(approval.id, line, serverPromptBody({ requestId: approval.id, tool, preview: approval.preview }));
+  log.info({ id: approval.id, tool, origin: approval.origin ?? null, inChat: line !== undefined, announced: announced !== undefined }, 'mcp-server: an approval is waiting for the owner');
+  if (line !== undefined && announced === undefined) announce(approval.id, line, serverPromptBody({ requestId: approval.id, tool: `${tool}${askedBy(approval)}`, preview: approval.preview }));
   return true;
 }
 

package/runtime/node_modules/@metro-labs/daemon/src/routes/local-mode.ts

@@ -4,6 +4,7 @@ import { AttachSessions } from '../stations/attach-session.js';
 import { startInteractiveAttach } from '../stations/attach-interactive.js';
 import { assertAttachOwner, finishGmailUpgrade, startGmailAttach } from './gmail-attach.js';
 import { detachWithGmailRevocation } from './gmail-detach.js';
+import { finishPairAgain, pairAgainInput } from './pair-again.js';
 import { recentSenders } from '../agents/senders.js';
 import { forwardTrainCall } from '../stations/train-call.js';
 import type { AgentApiDeps } from '../agents/api.js';
@@ -44,11 +45,16 @@ function attachSessions(deps: LocalModeDeps): AttachSessions {
       assertAttachOwner(owner);
       return Promise.resolve();
     },
-    start: (station, input, hooks, owner) => station === 'gmail' ? startGmailAttach(station, input, hooks, owner) : startInteractiveAttach(station, input, hooks),
-    complete: async (owner, station, config, active) => {
+    start: (station, input, hooks, owner, repair) => {
+      if (repair !== undefined) return startInteractiveAttach(station, pairAgainInput(owner, station, repair, input), hooks);
+      return station === 'gmail' ? startGmailAttach(station, input, hooks, owner) : startInteractiveAttach(station, input, hooks);
+    },
+    complete: async (owner, station, config, active, repair) => {
       assertAttachOwner(owner);
       if (!active()) throw new ApiError('This sign-in was cancelled or expired.', 409);
-      const ref = (station === 'gmail' ? finishGmailUpgrade(owner, config) : null) ?? await localAttachAccount(owner.agentId, station, config);
+      const ref = repair !== undefined
+        ? finishPairAgain(owner, station, repair, config)
+        : (station === 'gmail' ? finishGmailUpgrade(owner, config) : null) ?? await localAttachAccount(owner.agentId, station, config);
       const activated = await deps.syncStations(station).then(
         () => true,
         (err: unknown) => {

package/runtime/node_modules/@metro-labs/daemon/src/routes/pair-again.ts

@@ -0,0 +1,23 @@
+import { ApiError } from '@metro-labs/http/api-error';
+import type { StationName } from '@metro-labs/core/station-names';
+import { localPairAgain, readLocalAgentFile } from '../agents/file-admin.js';
+import type { AccountRef } from '../agents/account-attach.js';
+import { stationByName } from '../stations/registry.js';
+import type { AttachOwner } from '../stations/attach-session.js';
+
+function identityOf(station: string): string {
+  const identity = stationByName(station)?.pairAgain?.identity;
+  if (identity === undefined) throw new ApiError(`${station} cannot pair again`, 400);
+  return identity;
+}
+
+export function pairAgainInput(owner: AttachOwner, station: string, accountId: string, input: Record<string, unknown>): Record<string, unknown> {
+  const identity = identityOf(station);
+  const account = readLocalAgentFile(owner.agentId).stations.find((s) => s.station === station && s.id === accountId);
+  if (account === undefined) throw new ApiError('No such channel on this agent.', 404);
+  return { ...input, expect: account.config[identity] };
+}
+
+export function finishPairAgain(owner: AttachOwner, station: StationName, accountId: string, config: Record<string, unknown>): AccountRef {
+  return localPairAgain(owner.agentId, station, accountId, identityOf(station), config);
+}

package/runtime/node_modules/@metro-labs/daemon/src/stations/attach-interactive.ts

@@ -97,7 +97,7 @@ async function startWhatsapp(
       },
       onPaired: hooks.done,
       onFailed: hooks.fail,
-    });
+    }, normalizePhone(input.expect));
     await login.start();
   } catch (err) {
     await login?.cancel();

package/runtime/node_modules/@metro-labs/daemon/src/stations/attach-session.ts

@@ -19,6 +19,7 @@ export type StartAttach = (
   input: Record<string, unknown>,
   hooks: DriverHooks,
   owner: AttachOwner,
+  repair?: string,
 ) => Promise<StartedAttach>;
 
 export const ATTACH_ID_RE = /^as_[A-Za-z0-9_-]{22}$/;
@@ -60,6 +61,7 @@ type CompleteAttach = (
   station: StationName,
   config: Record<string, unknown>,
   active: () => boolean,
+  repair?: string,
 ) => Promise<{ accountId: string; activated: boolean }>;
 
 type AuthorizeAttach = (owner: AttachOwner) => Promise<void>;
@@ -72,6 +74,7 @@ export interface AttachSessionDeps {
 
 interface Session {
   owner: AttachOwner;
+  repair?: string;
   driver: AttachDriver | null;
   view: AttachView;
   finishing?: boolean;
@@ -177,6 +180,7 @@ export class AttachSessions {
           session.committing = true;
           return true;
         },
+        session.repair,
       );
       this.settle(session, {
         status: 'done',
@@ -187,12 +191,12 @@ export class AttachSessions {
       });
       log.info(
         { agentId: session.owner.agentId, station, account: landed.accountId },
-        'attach-session: signed in and attached a station account',
+        session.repair === undefined ? 'attach-session: signed in and attached a station account' : 'attach-session: paired a station account again',
       );
     } catch (err) {
       const reason =
         err instanceof ApiError ? err.message : 'could not store the account';
-      log.warn({ station, err: errMsg(err) }, 'attach-session: store failed');
+      log.warn({ station, ...(err instanceof ApiError ? { status: err.status } : { err: errMsg(err).replace(/\d{6,}/g, '<number>') }) }, 'attach-session: store failed');
       this.settle(session, { status: 'failed', prompt: '', error: reason });
     }
   }
@@ -230,6 +234,7 @@ export class AttachSessions {
     owner: AttachOwner,
     station: InteractiveStation,
     input: Record<string, unknown>,
+    repair?: string,
   ): Promise<AttachView> {
     await this.deps.authorize(owner);
     this.admit(owner);
@@ -237,6 +242,7 @@ export class AttachSessions {
     const attachId = newAttachId();
     const session: Session = {
       owner,
+      ...(repair === undefined ? {} : { repair }),
       driver: null,
       view: blankView(attachId, station),
     };
@@ -248,6 +254,7 @@ export class AttachSessions {
         input,
         this.hooksFor(attachId, station),
         owner,
+        repair,
       );
       if (this.sessions.get(attachId) !== session || session.view.expiresAt <= Date.now()) {
         await started.driver.cancel();

package/runtime/node_modules/@metro-labs/daemon/src/stations/registry.ts

@@ -41,6 +41,12 @@ export const accountStationCapabilities = (): Record<string, string[]> => {
   return out;
 };
 
+export const statusStations = (): string[] =>
+  STATIONS.filter((s) => s.reportsStatus === true).map((s) => s.name);
+
+export const pairAgainStations = (): string[] =>
+  STATIONS.filter((s) => s.pairAgain !== undefined).map((s) => s.name);
+
 export function forgetOrphans(known: readonly { station: string; id: string }[]): void {
   for (const s of STATIONS) {
     if (s.forgetExcept === undefined) continue;

package/runtime/node_modules/@metro-labs/http/src/connector-oauth.ts

@@ -11,6 +11,8 @@ const CLIENT_NAME = 'Metro';
 
 export class OAuthInvalidGrant extends ConnectorVerifyError {}
 
+const SIGN_IN_AGAIN = new Set(['invalid_grant', 'invalid_client', 'unauthorized_client']);
+
 export interface OAuthClient {
   clientId: string;
   clientSecret?: string;
@@ -143,10 +145,17 @@ async function postToken(
   } catch (err) {
     throw refused(`Metro could not reach that server to finish signing in: ${whyUnreachable(err)}`);
   }
-  const body: unknown = await res.json().catch(() => null);
-  if (form.grant_type === 'refresh_token' && res.status === 400 && isRecord(body) && body.error === 'invalid_grant') throw new OAuthInvalidGrant('That server requires a new sign-in.', 400);
-  if (!res.ok || !isRecord(body))
-    throw refused('That server refused to complete the sign-in.');
+  return tokenAnswer(form.grant_type === 'refresh_token', res.status, res.ok, await res.json().catch(() => null));
+}
+
+const errorCode = (body: unknown): string | null => (isRecord(body) && typeof body.error === 'string' && /^[a-z_]{1,64}$/.test(body.error) ? body.error : null);
+
+const grantGone = (refreshing: boolean, status: number, code: string | null): boolean => refreshing && (status === 400 || status === 401) && code !== null && SIGN_IN_AGAIN.has(code);
+
+function tokenAnswer(refreshing: boolean, status: number, ok: boolean, body: unknown): OAuthTokens {
+  const code = errorCode(body);
+  if (grantGone(refreshing, status, code)) throw new OAuthInvalidGrant('That server requires a new sign-in.', 400);
+  if (!ok || !isRecord(body)) throw refused(`That server refused to complete the sign-in (${String(status)}${code === null ? '' : ` ${code}`}).`);
   return tokensFrom(body);
 }
 

package/runtime/node_modules/@metro-labs/http/src/mcp-server-protocol.ts

@@ -27,12 +27,18 @@ export interface McpCall {
   approval?: string;
 }
 
+type McpApprovalOrigin = 'box' | 'key';
+
+const KEY_LABEL_MAX = 64;
+
 export interface McpApproval {
   id: string;
   connector: string;
   tool: string;
   preview: string;
   requestedAt: number;
+  origin?: McpApprovalOrigin;
+  keyLabel?: string;
 }
 
 export type McpDecision = 'allow' | 'deny';
@@ -70,9 +76,16 @@ export function mcpTokenHashOf(raw: unknown): string {
   return raw.tokenHash;
 }
 
+function originOf(raw: Record<string, unknown>): Pick<McpApproval, 'origin' | 'keyLabel'> {
+  if (raw.origin === 'box') return { origin: 'box' };
+  if (raw.origin !== 'key') return {};
+  const label = typeof raw.keyLabel === 'string' ? raw.keyLabel.replace(/\p{Cc}/gu, '').trim() : '';
+  return label === '' || label.length > KEY_LABEL_MAX ? { origin: 'key' } : { origin: 'key', keyLabel: label };
+}
+
 function approvalOf(raw: unknown): McpApproval | null {
   if (!isRecord(raw) || typeof raw.id !== 'string' || !MCP_APPROVAL_ID_RE.test(raw.id) || typeof raw.connector !== 'string' || typeof raw.tool !== 'string' || typeof raw.preview !== 'string' || typeof raw.requestedAt !== 'number') return null;
-  return { id: raw.id, connector: raw.connector, tool: raw.tool, preview: raw.preview, requestedAt: raw.requestedAt };
+  return { id: raw.id, connector: raw.connector, tool: raw.tool, preview: raw.preview, requestedAt: raw.requestedAt, ...originOf(raw) };
 }
 
 export function mcpApprovalsOf(raw: unknown): McpApproval[] {

package/runtime/node_modules/@metro-labs/http/src/mcp-server-tools.ts

@@ -61,19 +61,30 @@ export const toolSearchDescription = (keys: string[] | null): string =>
     'Results are full definitions (name, description and the JSON schema of the arguments) in a <functions> block. Each name is <connector>.<tool>: pass it exactly as "tool" to tool_call. Tools the owner blocked are never returned.',
   ].join('\n');
 
-export const TOOL_CALL_DESCRIPTION = [
-  'Run connector tools that tool_search found. Always find a tool with tool_search first: its exact name and argument schema come from there.',
-  `Shape: ${TOOL_CALL_EXAMPLE}`,
-  `Up to ${String(MCP_CALLS_MAX)} independent calls run in parallel in one tool_call and are answered in order. Each result starts with "[n] <connector>.<tool>", then the tool's own content, or one line saying why it did not run:`,
-  '- not_found: no such connector or tool here. Run tool_search, then use a name it returned.',
-  '- needs_approval: the owner was asked in chat and on metro.box. Tell the person what is waiting, wait for the channel message "Approved: <tool> (<id>)", then call again with the same tool and arguments plus "approval": "<id>". An approval works once.',
-  '- denied or blocked: the owner refused or blocked this call. Do not retry it.',
-  '- signin: the connector must be signed in again. Tell the owner to do it on the organization\'s Connectors page on metro.box.',
-  '- unavailable: the connector or Metro could not be reached. Try again later.',
-  '- vendor_error: the connector answered with its own error, shown as it came.',
-].join('\n');
+export type ApprovalPlace = 'session' | 'page' | 'owner';
 
-export function mcpServerTools(keys: string[] | null): McpServerTool[] {
+const NEEDS_APPROVAL: Record<ApprovalPlace, string> = {
+  session: '- needs_approval: the owner was asked in chat and on metro.box. Tell the person what is waiting, wait for the channel message "Approved: <tool> (<id>)", then call again with the same tool and arguments plus "approval": "<id>". An approval works once.',
+  page: '- needs_approval: the owner must approve it on this agent\'s page on metro.box. Tell the person what is waiting and ask them to approve it there, then call again with the same tool and arguments plus "approval": "<id>". An approval works once, within 10 minutes of the answer.',
+  owner: '- needs_approval: the agent\'s owner was asked in chat and on its page on metro.box. Tell the person what is waiting; once it is approved, call again with the same tool and arguments plus "approval": "<id>". An approval works once, within 10 minutes of the answer.',
+};
+
+const toolCallDescription = (place: ApprovalPlace): string =>
+  [
+    'Run connector tools that tool_search found. Always find a tool with tool_search first: its exact name and argument schema come from there.',
+    `Shape: ${TOOL_CALL_EXAMPLE}`,
+    `Up to ${String(MCP_CALLS_MAX)} independent calls run in parallel in one tool_call and are answered in order. Each result starts with "[n] <connector>.<tool>", then the tool's own content, or one line saying why it did not run:`,
+    '- not_found: no such connector or tool here. Run tool_search, then use a name it returned.',
+    NEEDS_APPROVAL[place],
+    '- denied or blocked: the owner refused or blocked this call. Do not retry it.',
+    '- signin: the connector must be signed in again. Tell the owner to do it on the organization\'s Connectors page on metro.box.',
+    '- unavailable: the connector or Metro could not be reached. Try again later.',
+    '- vendor_error: the connector answered with its own error, shown as it came.',
+  ].join('\n');
+
+export const TOOL_CALL_DESCRIPTION = toolCallDescription('session');
+
+export function mcpServerTools(keys: string[] | null, place: ApprovalPlace = 'session'): McpServerTool[] {
   return [
     {
       name: TOOL_SEARCH,
@@ -85,7 +96,7 @@ export function mcpServerTools(keys: string[] | null): McpServerTool[] {
     {
       name: TOOL_CALL,
       title: 'Call connector tools',
-      description: TOOL_CALL_DESCRIPTION,
+      description: toolCallDescription(place),
       inputSchema: callSchema,
       annotations: { title: 'Call connector tools', readOnlyHint: false, destructiveHint: true, openWorldHint: true },
     },

package/runtime/node_modules/@metro-labs/whatsapp/src/actions.ts

@@ -196,12 +196,13 @@ function makeDelete(clientFor: ClientFor): StationHandler {
 function makeAccounts(clientFor: ClientFor): StationHandler {
   return (id) => {
     const list = [...accounts.values()].map((a) => {
-      const phone = clientFor(a.id).self();
+      const client = clientFor(a.id);
+      const phone = client.self();
       return {
         id: a.id,
         handle: phone === null ? null : `+${phone}`,
         url: phone === null ? null : `https://wa.me/${phone}`,
-        connected: phone !== null,
+        status: client.status(),
       };
     });
     respond(id, { result: { accounts: list } });

package/runtime/node_modules/@metro-labs/whatsapp/src/client-types.ts

@@ -4,6 +4,7 @@ import type { MemberList } from '@metro-labs/core/stations/types';
 import type { ChannelList } from '@metro-labs/core/stations/channel-directory';
 import type { ProfileChange } from '@metro-labs/core/stations/profile';
 import type { SenderProfile } from '@metro-labs/core/stations/sender-profile';
+import type { AccountStatus } from '@metro-labs/core/stations/account-status';
 import type { WhatsAppAccount } from './types.js';
 import type { InboundMessage, ReactionInput } from './format.js';
 import type { SenderFound } from './resolve.js';
@@ -25,6 +26,7 @@ export interface WAMedia {
 export interface WAClient {
   account: WhatsAppAccount;
   self(): string | null;
+  status(): AccountStatus;
   start(handlers: InboundHandlers): Promise<void>;
   read(jid: string, options?: HistoryOptions): Promise<HistoryPage>;
   listMembers(jid: string, limit?: number): Promise<MemberList>;