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

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',
@@ -153,6 +144,8 @@ const PRIOR_METRO: ReadonlySet<string> = new Set([
   'b910597d24f31fa479b130a2545f94dd23684d802d99e36b637fc57c818a33be',
   'd3f7ed0f5175b9a7a77f06f6204ae0020369d0c8f6e2724196bb3c5822d4d8ba',
   '587a1334f91a8b61541573cef16eaf44fbe63049a8d8b461fa9f5cc55bacbcb8',
+  '256c711a6175266c216e32c88b7190d0f98f5e6b702abe03220b422aba426574',
+  '9e164a956437d60d30ea1984115a17d303940d191f5efed04954f244fc89d48f',
 ]);
 const PRIOR_STAGE: ReadonlySet<string> = new Set([
   'dd7d30474765de3865ddc87c1cf3220161ded09502027cdff18597e5df0aab43',
@@ -220,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);
 }
@@ -265,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;
 }
 
@@ -299,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/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/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

@@ -51,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

@@ -42,7 +42,7 @@ function remember(id: string, now = Date.now()): void {
 const answeredRecently = (id: string, now = Date.now()): boolean => now - (recent.get(id) ?? -Infinity) < RECENT_MS;
 
 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);
 

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],
   );
 }

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

@@ -1,7 +1,5 @@
 import { log } from '@metro-labs/core/log';
 
-export const MCP_SERVER_KEY = 'mcp';
-
 const DEFAULT_URL = 'https://mcp.metro.box';
 
 const LOOPBACK = new Set(['localhost', '127.0.0.1', '[::1]']);

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

@@ -0,0 +1,114 @@
+import { isRecord } from '@metro-labs/core/is-record';
+import { errMsg, log } from '@metro-labs/core/log';
+import { TOOL_CALL, TOOL_SEARCH } from '@metro-labs/http/mcp-server-protocol';
+import { mcpServerTools, type McpServerTool } from '@metro-labs/http/mcp-server-tools';
+import { askServer, type ServerAnswer, type ServerDeps } from './rpc.js';
+
+export const CONNECTOR_TOOLS: ReadonlySet<string> = new Set([TOOL_SEARCH, TOOL_CALL]);
+
+export const CALL_TIMEOUT_MS = 120_000;
+const LIST_TIMEOUT_MS = 15_000;
+const REFRESH_MS = 5 * 60_000;
+
+export const NOT_SET_UP = 'Connectors are not set up on this agent: enroll it in its organization on the Server page of metro.box, then try again.';
+export const UNAVAILABLE = 'mcp.metro.box is unavailable, try again.';
+
+export interface ConnectorResult {
+  [key: string]: unknown;
+  content: unknown[];
+  isError?: boolean;
+}
+
+const FALLBACK = mcpServerTools(null);
+let current: McpServerTool[] = FALLBACK;
+let version = 0;
+const listeners = new Set<() => void>();
+
+export const connectorTools = (): McpServerTool[] => current;
+
+export const connectorToolsVersion = (): number => version;
+
+export function onConnectorToolsChanged(listener: () => void): () => void {
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+}
+
+function toolOf(raw: unknown, fallback: McpServerTool): McpServerTool | null {
+  if (!isRecord(raw) || typeof raw.description !== 'string' || !isRecord(raw.inputSchema)) return null;
+  return {
+    name: fallback.name,
+    title: typeof raw.title === 'string' ? raw.title : fallback.title,
+    description: raw.description,
+    inputSchema: raw.inputSchema,
+    annotations: isRecord(raw.annotations) ? raw.annotations : fallback.annotations,
+  };
+}
+
+function servedTools(result: unknown): McpServerTool[] | null {
+  const tools: unknown[] = isRecord(result) && Array.isArray(result.tools) ? result.tools : [];
+  const picked = FALLBACK.map((fallback) => toolOf(tools.find((tool) => isRecord(tool) && tool.name === fallback.name), fallback));
+  return picked.every((tool): tool is McpServerTool => tool !== null) ? picked : null;
+}
+
+function changed(): void {
+  for (const listener of listeners)
+    try {
+      listener();
+    } catch (err) {
+      log.warn({ err: errMsg(err) }, 'mcp-server: a tool list listener failed');
+    }
+}
+
+export async function refreshConnectorTools(deps: ServerDeps = {}): Promise<boolean> {
+  const answer = await askServer('tools/list', {}, LIST_TIMEOUT_MS, deps);
+  const tools = answer.ok ? servedTools(answer.result) : null;
+  if (tools === null) {
+    if (!answer.ok && answer.reason !== 'unset') log.debug({ reason: answer.reason }, 'mcp-server: the connector tool list could not be read');
+    return false;
+  }
+  if (JSON.stringify(tools) === JSON.stringify(current)) return false;
+  current = tools;
+  version += 1;
+  log.info({ version }, 'mcp-server: the connector tools changed, the session is told');
+  changed();
+  return true;
+}
+
+let timer: ReturnType<typeof setInterval> | null = null;
+
+export function watchConnectorTools(everyMs = REFRESH_MS): () => void {
+  const tick = (): void => {
+    refreshConnectorTools().catch((err: unknown) => {
+      log.warn({ err: errMsg(err) }, 'mcp-server: the connector tool refresh failed');
+    });
+  };
+  if (timer === null) {
+    tick();
+    timer = setInterval(tick, everyMs);
+    timer.unref();
+  }
+  return () => {
+    if (timer !== null) clearInterval(timer);
+    timer = null;
+  };
+}
+
+const errorResult = (text: string): ConnectorResult => ({ content: [{ type: 'text', text }], isError: true });
+
+function resultOf(name: string, answer: ServerAnswer): ConnectorResult {
+  if (answer.ok) {
+    if (isRecord(answer.result) && Array.isArray(answer.result.content)) return answer.result as ConnectorResult;
+    log.warn({ tool: name }, 'mcp-server: mcp.metro.box answered a tool call without content');
+    return errorResult(UNAVAILABLE);
+  }
+  if (answer.reason === 'unset') return errorResult(NOT_SET_UP);
+  if (answer.reason === 'refused') return errorResult(`mcp.metro.box refused the call: ${answer.message}`);
+  log.warn({ tool: name, detail: answer.detail }, 'mcp-server: a connector tool call did not reach mcp.metro.box');
+  return errorResult(UNAVAILABLE);
+}
+
+export async function callConnectorTool(name: string, args: Record<string, unknown>, deps: ServerDeps = {}): Promise<ConnectorResult> {
+  return resultOf(name, await askServer('tools/call', { name, arguments: args }, CALL_TIMEOUT_MS, deps));
+}

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

@@ -24,6 +24,7 @@ export interface McpLinkDeps {
   key: () => AgentKey | null;
   dir: () => string;
   hold: HoldApproval;
+  registered?: () => void;
   fetch?: AgentFetch;
   timing?: Partial<McpTiming>;
 }
@@ -61,6 +62,10 @@ export class McpServerLink {
     await this.running;
   }
 
+  reregister(): void {
+    this.registered = null;
+  }
+
   async answer(id: string, decision: McpDecision): Promise<AnswerOutcome> {
     for (let attempt = 0; !this.stopped; attempt += 1) {
       if (attempt > 0) await this.pause(this.delay(attempt));
@@ -124,6 +129,7 @@ export class McpServerLink {
     await agentCall(this.api, key, MCP_PATHS.token, { tokenHash: token.hash }, { signal: this.abort.signal });
     this.registered = binding;
     log.info({ server: this.deps.url, keyId: key.keyId }, 'mcp-server: the MCP token is registered');
+    this.deps.registered?.();
   }
 
   private async poll(key: AgentKey): Promise<void> {
@@ -168,17 +174,22 @@ let active: McpServerLink | null = null;
 export interface McpServerWatch {
   owner: () => string | null;
   hold: HoldApproval;
+  registered?: () => void;
 }
 
 export function watchMcpServer(watch: McpServerWatch, env: NodeJS.ProcessEnv = process.env): boolean {
   const url = mcpServerUrl(env);
   if (url === null || active !== null) return false;
-  active = new McpServerLink({ url, owner: watch.owner, key: () => readAgentKey(), dir: agentsDir, hold: watch.hold });
+  active = new McpServerLink({ url, owner: watch.owner, key: () => readAgentKey(), dir: agentsDir, hold: watch.hold, ...(watch.registered === undefined ? {} : { registered: watch.registered }) });
   active.start();
   log.info({ server: url }, 'mcp-server: connector approvals relay from this server once the agent is enrolled');
   return true;
 }
 
+export function reregisterMcpToken(): void {
+  active?.reregister();
+}
+
 export async function stopMcpServer(): Promise<void> {
   const link = active;
   active = null;

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

@@ -0,0 +1,67 @@
+import { isRecord } from '@metro-labs/core/is-record';
+import { errMsg } from '@metro-labs/core/log';
+import { agentsDir } from '../agents/files.js';
+import { mcpServerUrl } from './config.js';
+import { reregisterMcpToken } from './link.js';
+import { readMcpToken } from './token.js';
+
+export interface ServerDeps {
+  url?: string | null;
+  token?: string | null;
+  fetch?: (url: string, init: RequestInit) => Promise<Response>;
+  reregister?: () => void;
+}
+
+export type ServerAnswer =
+  | { ok: true; result: unknown }
+  | { ok: false; reason: 'unset' }
+  | { ok: false; reason: 'unavailable'; detail: string }
+  | { ok: false; reason: 'refused'; message: string };
+
+let nextId = 1;
+
+const unavailable = (detail: string): ServerAnswer => ({ ok: false, reason: 'unavailable', detail });
+
+async function bodyOf(res: Response): Promise<ServerAnswer> {
+  let body: unknown;
+  try {
+    body = JSON.parse(await res.text());
+  } catch (err) {
+    return unavailable(`unreadable answer: ${errMsg(err)}`);
+  }
+  if (isRecord(body) && isRecord(body.error))
+    return { ok: false, reason: 'refused', message: typeof body.error.message === 'string' ? body.error.message.slice(0, 500) : 'refused' };
+  return isRecord(body) && Object.hasOwn(body, 'result') ? { ok: true, result: body.result } : unavailable('no JSON-RPC result');
+}
+
+interface Target {
+  url: string;
+  token: string;
+}
+
+function targetOf(deps: ServerDeps): Target | null {
+  const url = deps.url === undefined ? mcpServerUrl() : deps.url;
+  const token = deps.token === undefined ? readMcpToken(agentsDir()) : deps.token;
+  return url === null || token === null ? null : { url, token };
+}
+
+export async function askServer(method: string, params: Record<string, unknown>, timeoutMs: number, deps: ServerDeps = {}): Promise<ServerAnswer> {
+  const target = targetOf(deps);
+  if (target === null) return { ok: false, reason: 'unset' };
+  const { url, token } = target;
+  let res: Response;
+  try {
+    res = await (deps.fetch ?? fetch)(`${url}/`, {
+      method: 'POST',
+      headers: { authorization: `Bearer ${token}`, 'content-type': 'application/json', accept: 'application/json, text/event-stream' },
+      body: JSON.stringify({ jsonrpc: '2.0', id: nextId++, method, params }),
+      redirect: 'manual',
+      signal: AbortSignal.timeout(timeoutMs),
+    });
+  } catch (err) {
+    return unavailable(errMsg(err));
+  }
+  if (res.status === 401) (deps.reregister ?? reregisterMcpToken)();
+  if (!res.ok) return unavailable(`HTTP ${String(res.status)}`);
+  return bodyOf(res);
+}

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

@@ -24,7 +24,8 @@
     "./connector-input": "./src/connector-input.ts",
     "./connector-policy": "./src/connector-policy.ts",
     "./connector-grant": "./src/connector-grant.ts",
-    "./mcp-server-protocol": "./src/mcp-server-protocol.ts"
+    "./mcp-server-protocol": "./src/mcp-server-protocol.ts",
+    "./mcp-server-tools": "./src/mcp-server-tools.ts"
   },
   "scripts": {
     "build": "tsc",

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

@@ -7,6 +7,11 @@ export const MCP_CALLS_MAX = 10;
 export const MCP_QUERY_MAX = 500;
 export const MCP_APPROVAL_WAIT_MS = 25_000;
 export const MCP_APPROVAL_ID_RE = /^[a-km-z]{5}$/;
+export const TOOL_SEARCH = 'tool_search';
+export const TOOL_CALL = 'tool_call';
+export const TOOL_CALL_EXAMPLE = '{"calls":[{"tool":"notion.search","arguments":{"query":"roadmap"}}]}';
+
+const EXPECTED = ` Expected: ${TOOL_CALL_EXAMPLE}, with names as tool_search returns them.`;
 export const MCP_TOKEN_RE = /^mcp_[A-Za-z0-9_-]{43}$/;
 
 export type McpErrorCode = 'blocked' | 'needs_approval' | 'denied' | 'not_found' | 'signin' | 'unavailable' | 'vendor_error' | 'invalid';
@@ -40,23 +45,23 @@ export function splitMcpTool(name: string): { connector: string; tool: string }
 }
 
 export function mcpFindRequestOf(raw: unknown): McpFindRequest {
-  if (!isRecord(raw) || typeof raw.query !== 'string' || raw.query.trim() === '' || raw.query.length > MCP_QUERY_MAX) throw new Error('find_tools needs a query of 1 to 500 characters.');
+  if (!isRecord(raw) || typeof raw.query !== 'string' || raw.query.trim() === '' || raw.query.length > MCP_QUERY_MAX) throw new Error('tool_search needs a query of 1 to 500 characters.');
   const wanted = raw.max_results ?? MCP_FIND_DEFAULT;
   if (typeof wanted !== 'number' || !Number.isInteger(wanted) || wanted < 1) throw new Error('max_results must be a whole number from 1.');
   return { query: raw.query.trim(), max_results: Math.min(wanted, MCP_FIND_MAX) };
 }
 
 function callOf(raw: unknown): McpCall {
-  if (!isRecord(raw) || typeof raw.tool !== 'string' || splitMcpTool(raw.tool) === null) throw new Error('Each call needs a tool named <connector>.<tool>, as find_tools returns it.');
+  if (!isRecord(raw) || typeof raw.tool !== 'string' || splitMcpTool(raw.tool) === null) throw new Error(`Each call needs a tool named <connector>.<tool>, as tool_search returns it.${EXPECTED}`);
   const args = raw.arguments ?? {};
-  if (!isRecord(args)) throw new Error(`The arguments of ${raw.tool} must be an object.`);
+  if (!isRecord(args)) throw new Error(`The arguments of ${raw.tool} must be an object.${EXPECTED}`);
   if (raw.approval !== undefined && (typeof raw.approval !== 'string' || !MCP_APPROVAL_ID_RE.test(raw.approval))) throw new Error('approval must be the 5-letter id the approval request gave.');
   return { tool: raw.tool, arguments: args, ...(typeof raw.approval === 'string' ? { approval: raw.approval } : {}) };
 }
 
 export function mcpCallsOf(raw: unknown): McpCall[] {
   const calls = isRecord(raw) ? raw.calls : undefined;
-  if (!Array.isArray(calls) || calls.length === 0 || calls.length > MCP_CALLS_MAX) throw new Error(`call_tool needs 1 to ${String(MCP_CALLS_MAX)} calls.`);
+  if (!Array.isArray(calls) || calls.length === 0 || calls.length > MCP_CALLS_MAX) throw new Error(`tool_call needs 1 to ${String(MCP_CALLS_MAX)} calls in "calls".${EXPECTED}`);
   return calls.map(callOf);
 }