@stage-labs/metro 0.1.0-beta.304 → 0.1.0-beta.306

package/runtime/node_modules/@metro-labs/daemon/src/claude/plugin-cleanup.ts

@@ -0,0 +1,121 @@
+import { execFile } from 'node:child_process';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { isRecord } from '@metro-labs/core/is-record';
+import { errMsg, log } from '@metro-labs/core/log';
+import { existsSync } from '../agent-user/agent-fs.js';
+import { removeHome } from '../agent-user/home-fs.js';
+import { agentUser, asAgent, claudeBin } from '../agent-user/user.js';
+import { agentsDir } from '../agents/files.js';
+import { readSetupState, writeSetupState } from './setup-state.js';
+
+const PLUGIN = 'metro@metro';
+const MARKETPLACE = 'metro';
+const DONE = 'pluginRemoved';
+const STEP_MS = 60_000;
+const SAID_MAX = 300;
+
+export interface Answer {
+  status: number;
+  stdout: string;
+  stderr: string;
+}
+
+export type Run = (args: string[]) => Promise<Answer>;
+
+export interface CleanupDeps {
+  run?: Run | null;
+  agents?: string;
+  leftover?: string | null;
+}
+
+export type CleanupOutcome = 'done' | 'clean' | 'removed' | 'skipped' | 'failed';
+
+export const claudeAt =
+  (bin: string): Run =>
+  (args) =>
+    new Promise((resolve) => {
+      execFile(...asAgent(bin, args), { encoding: 'utf8', timeout: STEP_MS, maxBuffer: 4 * 1024 * 1024 }, (err, stdout, stderr) => {
+        const code = (err as { code?: unknown } | null)?.code;
+        resolve({ status: err === null ? 0 : typeof code === 'number' ? code : 1, stdout, stderr });
+      });
+    });
+
+async function findClaude(): Promise<Run | null> {
+  const candidates = agentUser() === null ? ['claude', join(homedir(), '.local', 'bin', 'claude')] : [claudeBin()];
+  for (const bin of candidates) {
+    const run = claudeAt(bin);
+    if ((await run(['--version'])).status === 0) return run;
+  }
+  return null;
+}
+
+function listOf(stdout: string): Record<string, unknown>[] {
+  try {
+    const parsed: unknown = JSON.parse(stdout);
+    return Array.isArray(parsed) ? parsed.filter(isRecord) : [];
+  } catch {
+    return [];
+  }
+}
+
+async function listed(run: Run, args: string[], key: string, wanted: string): Promise<boolean | null> {
+  const answer = await run(args);
+  if (answer.status !== 0) {
+    log.warn({ args, said: `${answer.stderr}${answer.stdout}`.trim().slice(0, SAID_MAX) }, 'claude-plugin: claude could not list');
+    return null;
+  }
+  return listOf(answer.stdout).some((entry) => entry[key] === wanted);
+}
+
+async function step(run: Run, args: string[]): Promise<boolean> {
+  const answer = await run(args);
+  if (answer.status === 0) {
+    log.info({ args }, 'claude-plugin: removed what the old metro plugin left');
+    return true;
+  }
+  log.warn({ args, said: `${answer.stderr}${answer.stdout}`.trim().slice(0, SAID_MAX) }, 'claude-plugin: claude refused');
+  return false;
+}
+
+async function removeIfListed(run: Run, list: string[], key: string, wanted: string, remove: string[]): Promise<'gone' | 'removed' | 'failed'> {
+  const present = await listed(run, list, key, wanted);
+  if (present === null) return 'failed';
+  if (!present) return 'gone';
+  return (await step(run, remove)) ? 'removed' : 'failed';
+}
+
+function leftoverDir(): string | null {
+  const user = agentUser();
+  return user === null ? null : join(user.home, '.metro', 'marketplace');
+}
+
+function removeLeftover(dir: string | null): boolean {
+  if (dir === null || !existsSync(dir)) return true;
+  try {
+    removeHome(dir, true);
+    log.info({ dir }, 'claude-plugin: removed the old plugin marketplace copy');
+    return true;
+  } catch (err) {
+    log.warn({ dir, err: errMsg(err) }, 'claude-plugin: could not remove the old plugin marketplace copy');
+    return false;
+  }
+}
+
+async function cleanUp(run: Run, leftover: string | null): Promise<'removed' | 'clean' | 'failed'> {
+  const plugin = await removeIfListed(run, ['plugin', 'list', '--json'], 'id', PLUGIN, ['plugin', 'uninstall', PLUGIN]);
+  const market = await removeIfListed(run, ['plugin', 'marketplace', 'list', '--json'], 'name', MARKETPLACE, ['plugin', 'marketplace', 'remove', MARKETPLACE]);
+  const folder = removeLeftover(leftover);
+  if (plugin === 'failed' || market === 'failed' || !folder) return 'failed';
+  return plugin === 'removed' || market === 'removed' ? 'removed' : 'clean';
+}
+
+export async function removeMetroPlugin(deps: CleanupDeps = {}): Promise<CleanupOutcome> {
+  const agents = deps.agents ?? agentsDir();
+  if (readSetupState(agents)[DONE] === true) return 'done';
+  const run = deps.run === undefined ? await findClaude() : deps.run;
+  if (run === null) return 'skipped';
+  const outcome = await cleanUp(run, deps.leftover === undefined ? leftoverDir() : deps.leftover);
+  if (outcome !== 'failed') writeSetupState(agents, { [DONE]: true });
+  return outcome;
+}

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

@@ -49,7 +49,6 @@ export interface SessionDeps {
   now?: () => number;
   version?: string;
   prepare?: (runner: HarnessRunner) => Promise<void>;
-  connectorsReady?: () => boolean;
 }
 
 export interface SessionStatus {
@@ -317,10 +316,9 @@ function strike(now: number): boolean {
   return true;
 }
 
-export type Ensured = 'started' | 'restarted' | 'running' | 'blocked' | 'off' | 'paused' | 'waiting';
+export type Ensured = 'started' | 'restarted' | 'running' | 'blocked' | 'off' | 'paused';
 
 function holdsBack(deps: SessionDeps, now: number): Ensured | null {
-  if (deps.connectorsReady?.() === false) return 'waiting';
   if (now < memory.pausedUntil) return 'paused';
   if (sessionBlocked(deps) !== null) return 'blocked';
   return strike(now) ? 'paused' : null;
@@ -354,7 +352,7 @@ export function ensureSession(deps: SessionDeps = {}): Ensured {
   const held = holdsBack(deps, r.now);
   if (held !== null) return held;
   if (found === 'stale') {
-    log.info({ was: startedVersion(r.agents), now: r.version }, 'claude-session: restarting the session an older metro started, so the new plugin and flags load');
+    log.info({ was: startedVersion(r.agents), now: r.version }, 'claude-session: restarting the session an older metro started, so the new hooks and flags load');
     stopSession(deps);
   }
   startSession(deps);

package/runtime/node_modules/@metro-labs/daemon/src/claude/setup.ts

@@ -2,7 +2,6 @@ import { createHash } from 'node:crypto';
 import { rmSync } from 'node:fs';
 import { existsSync, readFileSync, statSync } from '../agent-user/agent-fs.js';
 import { join } from 'node:path';
-import { fileURLToPath } from 'node:url';
 import { errMsg, log } from '@metro-labs/core/log';
 import { isRecord } from '@metro-labs/core/is-record';
 import { writeAtomic } from '@metro-labs/core/secure-fs';
@@ -10,7 +9,8 @@ import { agentsDir } from '../agents/files.js';
 import { moveHome, removeHome, writeHomeText } from '../agent-user/home-fs.js';
 import { claudeDir } from './files.js';
 import { memoryJobStatus, type MemoryJob } from './memory-routine.js';
-import { stagedMarketplaceDir } from './plugin-install.js';
+import { cliPackageDir, hooksDir, skillsDir } from './cli-files.js';
+import { hasMetroGuard, withMetroHooks } from './hooks.js';
 import { readModelConfig, routedConnection, type ModelConfig } from '../gateway/model-config.js';
 import { harnessRunner, runnerModel, sdkAllowed, sdkOnLogin, type HarnessRunner } from './runner.js';
 import { readSetupState, writeSetupState } from './setup-state.js';
@@ -49,7 +49,7 @@ Your final message is a report to the orchestrator, not a message to a human. It
 export interface SetupDeps {
   dir?: string;
   agents?: string;
-  plugin?: string;
+  cli?: string;
   env?: NodeJS.ProcessEnv;
 }
 
@@ -58,7 +58,7 @@ export type SettingsOutcome = 'written' | 'unchanged' | 'unreadable';
 
 export interface SetupReport {
   privacy: boolean;
-  guard: 'plugin';
+  guard: boolean;
   worker: Placed;
   skill: Placed;
   stage: Placed;
@@ -76,7 +76,7 @@ export interface SetupStatus {
   liveEvents: boolean;
   memoryRoutine: boolean;
   memoryJob: MemoryJob;
-  guard: 'plugin';
+  guard: boolean;
   worker: boolean;
   skill: boolean;
   stage: boolean;
@@ -134,15 +134,6 @@ export function setSystemPrompt(text: string, agents = agentsDir()): void {
   writeAtomic(promptPath(agents), `${trimmed}\n`, 0o600);
 }
 
-function pluginDir(env: NodeJS.ProcessEnv = process.env): string {
-  const staged = stagedMarketplaceDir(env);
-  if (staged !== null) {
-    const dir = join(staged, 'plugin');
-    if (existsSync(join(dir, RULES_FILE))) return dir;
-  }
-  return fileURLToPath(new URL('../../../../plugin', import.meta.url));
-}
-
 const PRIOR_WORKER: ReadonlySet<string> = new Set(['08a0cd8710df285d6512245246bb8b658b7cfc7f3e89490514ee5376779eb2ef']);
 const PRIOR_METRO: ReadonlySet<string> = new Set([
   '0b3d122ed95beff09d579cf912cd4238e1db524c41fce4b314de57d6ff5908ad',
@@ -152,6 +143,9 @@ const PRIOR_METRO: ReadonlySet<string> = new Set([
   '5ce3f76d610aae91adc922d0edc6c8be1f27aa2fec4a5e3a6d6231a04fb9310b',
   'b910597d24f31fa479b130a2545f94dd23684d802d99e36b637fc57c818a33be',
   'd3f7ed0f5175b9a7a77f06f6204ae0020369d0c8f6e2724196bb3c5822d4d8ba',
+  '587a1334f91a8b61541573cef16eaf44fbe63049a8d8b461fa9f5cc55bacbcb8',
+  '256c711a6175266c216e32c88b7190d0f98f5e6b702abe03220b422aba426574',
+  '9e164a956437d60d30ea1984115a17d303940d191f5efed04954f244fc89d48f',
 ]);
 const PRIOR_STAGE: ReadonlySet<string> = new Set([
   'dd7d30474765de3865ddc87c1cf3220161ded09502027cdff18597e5df0aab43',
@@ -219,15 +213,29 @@ function mergeSettings(dir: string, change: (settings: Record<string, unknown>)
   return 'written';
 }
 
-function applyPrivacy(dir: string, enabled: boolean): SettingsOutcome {
-  return mergeSettings(dir, (current) => withPrivacy(current, enabled));
+interface SettingsApplied {
+  settings: SettingsOutcome;
+  guard: boolean;
+}
+
+function applySettings(dir: string, privacy: boolean, hooks: string | null): SettingsApplied {
+  let guard = false;
+  const settings = mergeSettings(dir, (current) => {
+    const next = withPrivacy(current, privacy);
+    const hooked = hooks === null ? null : withMetroHooks(next, hooks);
+    if (hooks !== null && hooked === null)
+      log.warn({ path: join(dir, 'settings.json') }, 'claude-setup: the hooks in settings.json are not in the shape Claude Code reads, so metro did not add its own');
+    guard = hasMetroGuard(hooked ?? next);
+    return hooked ?? next;
+  });
+  return { settings, guard };
 }
 
 const skillPath = (dir: string, name: string): string => join(dir, 'skills', name, 'SKILL.md');
 const workerPath = (dir: string): string => join(dir, 'agents', 'worker.md');
 
-function placeSkill(dir: string, plugin: string, skill: ShippedSkill): Placed {
-  const source = join(plugin, skill.file);
+function placeSkill(dir: string, skills: string, skill: ShippedSkill): Placed {
+  const source = join(skills, skill.file);
   if (!existsSync(source)) return 'missing';
   return placeFile(skillPath(dir, skill.name), readFileSync(source, 'utf8'), skill.prior);
 }
@@ -264,21 +272,21 @@ export function ensureClaudeSetup(deps: SetupDeps = {}): SetupReport {
   const dir = deps.dir ?? claudeDir();
   const agents = deps.agents ?? agentsDir();
   const privacy = privacyEnabled(agents);
-  const plugin = deps.plugin ?? pluginDir(deps.env);
+  const cli = deps.cli ?? cliPackageDir(deps.env);
+  const hooks = hooksDir(cli);
   tryMoveRenamedSkill(dir);
-  const report: SetupReport = {
-    privacy,
-    guard: 'plugin',
-    worker: placeFile(workerPath(dir), WORKER_AGENT, PRIOR_WORKER),
-    skill: placeSkill(dir, plugin, METRO_SKILL),
-    stage: placeSkill(dir, plugin, STAGE_SKILL),
-    memory: placeSkill(dir, plugin, MEMORY_SKILL),
-    settings: applyPrivacy(dir, privacy),
-  };
+  const worker = placeFile(workerPath(dir), WORKER_AGENT, PRIOR_WORKER);
+  const skills = skillsDir(cli);
+  const skill = placeSkill(dir, skills, METRO_SKILL);
+  const stage = placeSkill(dir, skills, STAGE_SKILL);
+  const memory = placeSkill(dir, skills, MEMORY_SKILL);
+  const applied = applySettings(dir, privacy, hooks);
+  const report: SetupReport = { privacy, guard: applied.guard, worker, skill, stage, memory, settings: applied.settings };
   syncAvailableModelsQuietly({ ...deps, dir, agents });
   if ([report.worker, report.skill, report.stage, report.memory].some(written) || report.settings === 'written')
     log.info(report, 'claude-setup: applied the Claude Code setup for a metro box');
-  if (report.settings === 'unreadable') log.warn({ path: join(dir, 'settings.json') }, 'claude-setup: settings.json is not valid JSON, so the privacy settings were not written');
+  if (report.settings === 'unreadable') log.warn({ path: join(dir, 'settings.json') }, 'claude-setup: settings.json is not valid JSON, so the privacy settings and metro hooks were not written');
+  if (hooks === null) log.warn({ cli }, 'claude-setup: metro hooks were not found next to the CLI, so the guard and the standing rules are not in settings.json');
   return report;
 }
 
@@ -298,7 +306,7 @@ export function claudeSetupStatus(deps: SetupDeps = {}): SetupStatus {
     liveEvents: liveEvents(agents),
     memoryRoutine: memoryRoutine(agents),
     memoryJob: memoryJobStatus(),
-    guard: 'plugin',
+    guard: hasMetroGuard(settings),
     worker: existsSync(workerPath(dir)),
     skill: existsSync(skillPath(dir, METRO_SKILL.name)),
     stage: existsSync(skillPath(dir, STAGE_SKILL.name)),

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

@@ -18,7 +18,6 @@ export interface EnrollApiDeps {
   owner: () => string | null;
   dir?: () => string;
   api?: MetroApi;
-  invalidate?: () => void;
 }
 
 export interface Enrolled {
@@ -89,7 +88,6 @@ async function enroll(req: IncomingMessage, session: ApiSession, deps: EnrollApi
   if (enrolling.has(dir)) throw new ApiError('This agent is already enrolling. Wait for it to finish before trying again.', 409);
   enrolling.add(dir);
   try {
-    deps.invalidate?.();
     return await exchange(ticket, owner, dir, deps);
   } finally {
     enrolling.delete(dir);

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

@@ -21,6 +21,7 @@ import { SessionSlot } from './session-slot.js';
 import { connectCallBridge } from './call-bridge.js';
 import { connectServerApprovals } from './server-approvals.js';
 import { handleIncomingDiagnostic } from './diagnostics.js';
+import { onConnectorToolsChanged } from '../mcp-server/connector-tools.js';
 
 const isInitialize = (b: unknown): boolean =>
   !!b &&
@@ -99,6 +100,7 @@ async function serveGet(
 const isVoicePath = (req: IncomingMessage): boolean => (req.url ?? '').split('?')[0] === VOICE_MCP_PATH;
 
 let activeSlots: SessionSlot[] = [];
+let stopToolNotices: (() => void) | undefined;
 
 const MODEL_NOTICE = 'notifications/metro/model';
 
@@ -120,6 +122,10 @@ export async function createMetroMcp(options: { liveEvents?: boolean } = {}): Pr
   const slot = new SessionSlot(options.liveEvents);
   const voiceSlot = new SessionSlot(false, 'voice');
   activeSlots = [slot, voiceSlot];
+  stopToolNotices?.();
+  stopToolNotices = onConnectorToolsChanged(() => {
+    for (const each of [slot, voiceSlot]) each.current?.toolsChanged();
+  });
   connectCallBridge(() => slot.current);
   connectServerApprovals(() => slot.current);
 

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

@@ -16,7 +16,9 @@ export const MCP_INSTRUCTIONS =
   'it need approval (`list_accounts` shows each `policy`). A blocked call errors. A call ' +
   'needing approval must run in a background worker: on the main thread it is refused, so ' +
   'delegate that exact call and keep answering; the worker waits for the owner. Approval ' +
-  'prompts are relayed to the chat; the owner answers "yes <id>"/"no <id>".';
+  'prompts are relayed to the chat; the owner answers "yes <id>"/"no <id>". Connectors ' +
+  '(third-party tools like Notion, n8n, Gmail) are reached only through `tool_search` then ' +
+  '`tool_call`, from a worker.';
 
 export const VOICE_MCP_INSTRUCTIONS =
   "Metro's chat tools, opened for a live voice call. The caller hears what you say, so do not " +
@@ -27,4 +29,4 @@ export const VOICE_MCP_INSTRUCTIONS =
   '(`list_accounts` shows each `policy`). A blocked call errors. A call needing approval must ' +
   'run in a background worker: on the main thread it is refused, so delegate that exact call ' +
   'and keep talking; the worker waits while the owner is asked in the chat of the call, where ' +
-  'they answer "yes <id>"/"no <id>".';
+  'they answer "yes <id>"/"no <id>". Connectors are reached through `tool_search` then `tool_call`.';

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

@@ -1,6 +1,5 @@
 import { str } from '@metro-labs/core/str';
 import { readPreview, shownValue } from '../approvals/preview.js';
-import { connectorGates, connectorToolOf } from '../connectors/gates.js';
 import { stationByName } from '../stations/registry.js';
 import { stationOfAccount } from './read-tool.js';
 
@@ -83,21 +82,11 @@ function argLines(input: Record<string, unknown> | undefined): string[] {
   return args.length > ARGS_MAX ? [...args.slice(0, ARGS_MAX), `(${String(args.length - ARGS_MAX)} more)`] : args;
 }
 
-function connectorLines(name: string, tool: string, input: Record<string, unknown> | undefined): string[] {
-  return [`Approval needed: ${tool}`, `Connector: ${name}`, ...argLines(input)];
-}
-
 function bodyLines(params: PermissionParams): string[] {
   const metro = METRO_TOOL.exec(params.tool_name)?.[1];
   const { input } = readPreview(params.input_preview);
   const raw = params.input_preview.trim() === '' ? [] : [shorten(params.input_preview, RAW_MAX)];
   if (metro !== undefined) return input === undefined ? [`Approval needed: ${metro}`, ...raw] : metroLines(metro, input);
-  const connector = connectorToolOf(params.tool_name);
-  if (connector !== undefined) {
-    const { gate, tool } = connector;
-    const duplicate = connectorGates().some((entry) => entry.id !== gate.id && entry.name === gate.name);
-    return connectorLines(duplicate ? `${gate.name} (${gate.id})` : gate.name, tool, input);
-  }
   return [`Claude wants to run ${params.tool_name}: ${shorten(params.description)}`, '', ...raw];
 }
 
@@ -115,7 +104,6 @@ export function promptBody(params: PermissionParams): string {
 export interface ServerPrompt {
   requestId: string;
   tool: string;
-  connector: string | undefined;
   preview: string;
 }
 
@@ -123,5 +111,5 @@ export function serverPromptBody(prompt: ServerPrompt): string {
   const { input } = readPreview(prompt.preview);
   const raw = prompt.preview.trim() === '' ? [] : [shorten(prompt.preview, RAW_MAX)];
   const args = input === undefined ? raw : argLines(input);
-  return withAnswer(prompt.requestId, [`Approval needed: ${prompt.tool}`, ...(prompt.connector === undefined ? [] : [`Connector: ${prompt.connector}`]), ...args]);
+  return withAnswer(prompt.requestId, [`Approval needed: ${prompt.tool}`, ...args]);
 }

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

@@ -7,10 +7,11 @@ import { NEEDS_APPROVAL, takeGrant } from '../approvals/pending.js';
 import { profileScopeLine } from './profile-lookup.js';
 import { stationOfAccount } from './read-tool.js';
 import { stationForTool, toolGroupOf } from './tool-catalog.js';
+import { CONNECTOR_TOOLS } from '../mcp-server/connector-tools.js';
 
 type ChannelTarget = Extract<PolicyTarget, { kind: 'channel' }>;
 
-export const UNGATED = new Set<string>(['list_accounts', 'create_upload']);
+export const UNGATED = new Set<string>(['list_accounts', 'create_upload', ...CONNECTOR_TOOLS]);
 
 function fromLine(line: string, override = ''): ChannelTarget[] {
   const acct = accountFromLine(line);

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

@@ -7,7 +7,6 @@ import { agentsDir } from '../agents/files.js';
 import { knownAccounts } from '../agents/map.js';
 import { onPoliciesChanged, storedPolicies, type ToolPolicy } from '../policy/policy.js';
 import { UNGATED } from './policy-gate.js';
-import { connectorGates } from '../connectors/gates.js';
 import { stationToolOwners, TOOL_DEFS, toolGroupOf } from './tool-catalog.js';
 
 interface PolicySnapshot {
@@ -17,14 +16,6 @@ interface PolicySnapshot {
   ungated: string[];
   accounts: Record<string, ToolPolicy>;
   stations: Record<string, string[]>;
-  connectors: Record<string, SnapshotConnector>;
-}
-
-interface SnapshotConnector {
-  id: string;
-  name: string;
-  policy: ToolPolicy;
-  tools: Record<string, ToolGroup>;
 }
 
 const FILE = 'policy.json';
@@ -44,11 +35,6 @@ function policySnapshot(): PolicySnapshot {
     ungated: [...UNGATED],
     accounts,
     stations,
-    connectors: Object.fromEntries(
-      connectorGates()
-        .filter((gate) => gate.server !== '')
-        .map((gate) => [gate.server, { id: gate.id, name: gate.name, policy: gate.policy, tools: gate.tools }]),
-    ),
   };
 }
 
@@ -65,9 +51,9 @@ function writePolicySnapshot(path = policySnapshotPath()): void {
   if (current(path) === text) return;
   try {
     writeSecure(path, text);
-    log.info({ path }, 'policy: snapshot for the plugin hook written');
+    log.info({ path }, 'policy: snapshot for the guard hook written');
   } catch (err) {
-    log.warn({ path, err: errMsg(err) }, 'policy: the snapshot for the plugin hook could not be written');
+    log.warn({ path, err: errMsg(err) }, 'policy: the snapshot for the guard hook could not be written');
   }
 }
 

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

@@ -4,8 +4,7 @@ import type { McpApproval, McpDecision } from '@metro-labs/http/mcp-server-proto
 import { holdPrompt, isPromptHeld, type Behavior } from '../approvals/pending.js';
 import { ownerLine } from '../approvals/owner-line.js';
 import { metroNotice } from '../channels/notice.js';
-import { connectorGates } from '../connectors/gates.js';
-import { serverKey } from '../connectors/plugin-sync.js';
+import { announcedLine, noteAnnounced } from '../mcp-server/announced.js';
 import type { AnswerOutcome } from '../mcp-server/link.js';
 import { serverPromptBody } from './permission-prompt.js';
 import { metroSend, relayLine } from './permission-relay.js';
@@ -42,13 +41,8 @@ function remember(id: string, now = Date.now()): void {
 
 const answeredRecently = (id: string, now = Date.now()): boolean => now - (recent.get(id) ?? -Infinity) < RECENT_MS;
 
-function connectorName(key: string): string | undefined {
-  const names = new Set(connectorGates().filter((gate) => gate.server === key || serverKey(gate.name) === key).map((gate) => gate.name));
-  return names.size === 1 ? [...names][0] : undefined;
-}
-
 const noticeText = (tool: string, id: string, behavior: Behavior): string =>
-  behavior === 'allow' ? `Approved: ${tool} (${id}). Call call_tool again with the same arguments and approval: "${id}".` : `Denied: ${tool} (${id}).`;
+  behavior === 'allow' ? `Approved: ${tool} (${id}). Call tool_call again with the same arguments and approval: "${id}".` : `Denied: ${tool} (${id}).`;
 
 const requestedAt = (at: number, now = Date.now()): number => (Number.isFinite(at) && at > 0 ? Math.min(at, now) : now);
 
@@ -84,23 +78,28 @@ function sender(held: Held): (behavior: Behavior) => Promise<void> {
   };
 }
 
+function announce(id: string, line: string, text: string): void {
+  metroSend(line, text).then(() => {
+    noteAnnounced(id, line);
+  }).catch((err: unknown) => {
+    log.warn({ id, err: errMsg(err) }, 'mcp-server: the approval prompt could not be posted');
+  });
+}
+
 export function holdServerApproval(approval: McpApproval, answer: Held['answer'], publish: Held['publish']): boolean {
   if (isPromptHeld(approval.id) || answeredRecently(approval.id)) return false;
   const tool = `${approval.connector}.${approval.tool}`;
-  const name = connectorName(approval.connector);
-  const line = promptLineFor(approval.id);
+  const announced = announcedLine(approval.id);
+  const line = announced ?? promptLineFor(approval.id);
   const held: Held = { id: approval.id, tool, line, answer, publish };
   holdPrompt(
-    { requestId: approval.id, tool, description: name ?? approval.connector, preview: approval.preview, line, at: requestedAt(approval.requestedAt), origin: 'mcp-server' },
+    { 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 }, 'mcp-server: an approval is waiting for the owner');
-  if (line !== undefined)
-    metroSend(line, serverPromptBody({ requestId: approval.id, tool, connector: name, preview: approval.preview })).catch((err: unknown) => {
-      log.warn({ id: approval.id, err: errMsg(err) }, 'mcp-server: the approval prompt could not be posted');
-    });
+  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 }));
   return true;
 }
 

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

@@ -227,6 +227,10 @@ export class McpSession {
     return this.issuedSchema !== toolSchemaSignature();
   }
 
+  toolsChanged(): void {
+    this.announceToolSchema();
+  }
+
   private announceToolSchema(): void {
     if (!this.streamAttached) return;
     this.deliverSchemaNotice(

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

@@ -1,4 +1,6 @@
 import type { GroupOp, Station, StationTool, ToolGroup } from '@metro-labs/core/stations/types';
+import { TOOL_CALL, TOOL_SEARCH } from '@metro-labs/http/mcp-server-protocol';
+import { connectorTools } from '../mcp-server/connector-tools.js';
 import { STATIONS } from '../stations/registry.js';
 import { COMMON_TOOLS, LIST_ACCOUNTS_TOOL } from './tool-schemas.js';
 import { SET_PROFILE_TOOL } from './profile-tool.js';
@@ -14,7 +16,7 @@ const defOf = (tool: StationTool): ToolDef => ({
   ...(tool.destructive === true ? { destructive: true } : {}),
 });
 
-export const TOOL_DEFS: ToolDef[] = [
+const LOCAL_DEFS: ToolDef[] = [
   ...COMMON_TOOLS,
   ...STATIONS.flatMap((s) => s.tools.map(defOf)),
   LIST_ACCOUNTS_TOOL,
@@ -23,19 +25,27 @@ export const TOOL_DEFS: ToolDef[] = [
   GET_PROFILE_TOOL,
 ];
 
+const CONNECTOR_GROUPS: Record<string, Pick<ToolDef, 'group' | 'destructive'>> = {
+  [TOOL_SEARCH]: { group: 'read' },
+  [TOOL_CALL]: { group: 'write', destructive: true },
+};
+
+export const TOOL_DEFS: ToolDef[] = [
+  ...LOCAL_DEFS,
+  ...connectorTools().map((tool) => ({ name: tool.name, description: tool.description, inputSchema: tool.inputSchema, ...CONNECTOR_GROUPS[tool.name] })),
+];
+
 const BY_NAME = new Map(TOOL_DEFS.map((d) => [d.name, d] as const));
 
 export const declaredGroup = (name: string): ToolGroup | undefined => BY_NAME.get(name)?.group;
 
 export const toolGroupOf = (name: string): ToolGroup => declaredGroup(name) ?? 'write';
 
-export interface ToolAnnotations {
-  readOnlyHint: boolean;
-  destructiveHint?: boolean;
-}
+export type ToolAnnotations = Record<string, unknown>;
 
 export interface PublishedTool {
   name: string;
+  title?: string;
   description: string;
   inputSchema: Record<string, unknown>;
   annotations: ToolAnnotations;
@@ -50,14 +60,16 @@ const annotationsOf = (def: ToolDef): ToolAnnotations =>
     ? { readOnlyHint: true }
     : { readOnlyHint: false, destructiveHint: def.destructive === true };
 
-export const listedTools = (): PublishedTool[] =>
-  TOOL_DEFS.map((def) => ({
+export const listedTools = (): PublishedTool[] => [
+  ...LOCAL_DEFS.map((def) => ({
     name: def.name,
     description: def.description,
     inputSchema: def.inputSchema,
     annotations: annotationsOf(def),
     ...(ALWAYS_LOADED.has(def.name) ? { _meta: ALWAYS_LOAD } : {}),
-  }));
+  })),
+  ...connectorTools().map((tool) => ({ ...tool, _meta: ALWAYS_LOAD })),
+];
 
 const STATION_OF_TOOL = new Map(STATIONS.flatMap((s) => s.tools.map((t) => [t.name, s.name] as const)));
 

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

@@ -38,6 +38,7 @@ import {
 import { str } from '@metro-labs/core/str';
 import { linelessRead, stationOfAccount } from './read-tool.js';
 import { channelArgsError, channelScopeDenied, dispatchListChannels } from './channel-tool.js';
+import { callConnectorTool, CONNECTOR_TOOLS, connectorToolsVersion, type ConnectorResult } from '../mcp-server/connector-tools.js';
 
 const STATION_TOOLS = new Map<
   string,
@@ -63,14 +64,13 @@ const CORE_DISPATCH: Record<
 
 export const toolList = (): { tools: PublishedTool[] } => ({ tools: listedTools() });
 
-let schemaSignature: string | undefined;
+let schemaSignature: { version: number; value: string } | undefined;
 
 export const toolSchemaSignature = (): string => {
-  schemaSignature ??= createHash('sha256')
-    .update(JSON.stringify(toolList()))
-    .digest('hex')
-    .slice(0, 16);
-  return schemaSignature;
+  const version = connectorToolsVersion();
+  if (schemaSignature?.version !== version)
+    schemaSignature = { version, value: createHash('sha256').update(JSON.stringify(toolList())).digest('hex').slice(0, 16) };
+  return schemaSignature.value;
 };
 
 async function handleListAccounts(
@@ -197,6 +197,12 @@ export async function callToolHandler(
   return result;
 }
 
+function connectorToolHandler(req: { params: { name: string; arguments?: Record<string, unknown> } }): Promise<ConnectorResult> {
+  const args = req.params.arguments ?? {};
+  settlePromptsFor(req.params.name, args);
+  return callConnectorTool(req.params.name, args);
+}
+
 const TOOL_LIST_CHANGED = 'notifications/tools/list_changed';
 
 export interface SchemaNotice {
@@ -222,11 +228,11 @@ export function registerToolHandlers(
     ((
       req: { params: { name: string; arguments?: Record<string, unknown> } },
       extra: NotifyingExtra,
-    ): Promise<ToolResult> => {
+    ): Promise<ToolResult | ConnectorResult> => {
       notice?.deliver(() =>
         extra.sendNotification({ method: TOOL_LIST_CHANGED }),
       );
-      return callToolHandler(req, hooks);
+      return CONNECTOR_TOOLS.has(req.params.name) ? connectorToolHandler(req) : callToolHandler(req, hooks);
     }) as Parameters<typeof server.setRequestHandler>[1],
   );
 }