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

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/connectors/agent-key.ts

@@ -21,19 +21,17 @@ export interface Enrollment {
 export interface AgentKey {
   keyId: string;
   signingKey: string;
-  sealingKey: string;
   signing: KeyObject;
-  sealing: KeyObject;
   enrollment: Enrollment | null;
 }
 
 const pathOf = (dir: string): string => join(dir, FILE);
 
-function privateKeyOf(raw: unknown, type: 'ed25519' | 'x25519'): KeyObject | null {
+function privateSigningKey(raw: unknown): KeyObject | null {
   if (typeof raw !== 'string' || raw === '') return null;
   try {
     const key = createPrivateKey({ key: Buffer.from(raw, 'base64'), format: 'der', type: 'pkcs8' });
-    return key.asymmetricKeyType === type ? key : null;
+    return key.asymmetricKeyType === 'ed25519' ? key : null;
   } catch {
     return null;
   }
@@ -45,9 +43,9 @@ function enrollmentOf(raw: unknown): Enrollment | null {
   return server !== null && isOrganizationId(raw.organization) ? { server, organization: raw.organization, at: raw.at } : null;
 }
 
-function agentKeyOf(signing: KeyObject, sealing: KeyObject, enrollment: Enrollment | null): AgentKey {
+function agentKeyOf(signing: KeyObject, enrollment: Enrollment | null): AgentKey {
   const signingKey = rawPublicKey(createPublicKey(signing));
-  return { keyId: agentKeyId(signingKey), signingKey, sealingKey: rawPublicKey(createPublicKey(sealing)), signing, sealing, enrollment };
+  return { keyId: agentKeyId(signingKey), signingKey, signing, enrollment };
 }
 
 const unreadable = (): null => {
@@ -67,10 +65,9 @@ function storedOf(path: string): Record<string, unknown> | null {
 
 function keyOf(stored: Record<string, unknown> | null): AgentKey | null {
   if (stored === null) return null;
-  const signing = privateKeyOf(stored.signing, 'ed25519');
-  const sealing = privateKeyOf(stored.sealing, 'x25519');
-  if (stored.version !== 1 || signing === null || sealing === null) return unreadable();
-  return agentKeyOf(signing, sealing, enrollmentOf(stored.enrollment));
+  const signing = privateSigningKey(stored.signing);
+  if (stored.version !== 1 || signing === null) return unreadable();
+  return agentKeyOf(signing, enrollmentOf(stored.enrollment));
 }
 
 export function readAgentKey(dir = agentsDir()): AgentKey | null {
@@ -132,12 +129,12 @@ export function clearPendingAgentKey(dir: string): void {
 }
 
 export function newAgentKey(): AgentKey {
-  return agentKeyOf(generateKeyPairSync('ed25519').privateKey, generateKeyPairSync('x25519').privateKey, null);
+  return agentKeyOf(generateKeyPairSync('ed25519').privateKey, null);
 }
 
 const exported = (key: KeyObject): string => key.export({ format: 'der', type: 'pkcs8' }).toString('base64');
 
-const privateKeys = (key: AgentKey): Record<string, unknown> => ({ version: 1, signing: exported(key.signing), sealing: exported(key.sealing) });
+const privateKeys = (key: AgentKey): Record<string, unknown> => ({ version: 1, signing: exported(key.signing) });
 
 export function savePendingAgentKey(key: AgentKey, owner: string, ticketHash: string, dir: string, expectedServer?: string): void {
   writeKey(pendingPath(dir), { ...privateKeys(key), owner, ticketHash, ...(expectedServer === undefined ? {} : { expectedServer }) });

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

@@ -66,7 +66,7 @@ async function exchange(ticket: string, owner: string, dir: string, deps: Enroll
   if (finished !== null) return finished;
   const key = pending?.ticketHash === ticketHash ? pending : newAgentKey();
   if (key !== pending) savePendingAgentKey(key, owner, ticketHash, dir);
-  const enrolled = enrolledOf(await agentCall(api, key, '/api/agents/enroll', { ticket, organization: owner, signingKey: key.signingKey, sealingKey: key.sealingKey }), key, owner);
+  const enrolled = enrolledOf(await agentCall(api, key, '/api/agents/enroll', { ticket, organization: owner, signingKey: key.signingKey }), key, owner);
   sameOwner(deps, owner);
   savePendingAgentKey(key, owner, ticketHash, dir, enrolled.server);
   const confirmed = enrolledOf(await agentCall(api, key, '/api/agents/session'), key, owner);

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

@@ -0,0 +1,59 @@
+import { lstatSync, readdirSync, unlinkSync } from 'node:fs';
+import { join } from 'node:path';
+import { errMsg, log } from '@metro-labs/core/log';
+import { agentsDir } from '../agents/files.js';
+
+const WRITTEN = new Set([
+  'connectors.json',
+  'connector-migrations.json',
+  'connector-migrations.initialized',
+  'connector-server-keys.json',
+  'connector-server-keys.initialized',
+  'org-connector-sync.json',
+]);
+
+const OPERATIONS = 'connector-migration-operations-[A-Za-z0-9][A-Za-z0-9_-]{10}\\.json';
+
+const PATTERNS = [
+  new RegExp(`^${OPERATIONS}(?:\\.initialized)?$`),
+  new RegExp(`^(?:connectors\\.json|connector-server-keys\\.json|connector-server-keys\\.initialized|org-connector-sync\\.json|${OPERATIONS})\\.tmp-[0-9]+$`),
+  /^connector-migrations\.json\.[0-9a-f]{24}\.tmp$/,
+];
+
+const isConnectorLeftover =(name: string): boolean => WRITTEN.has(name) || PATTERNS.some((pattern) => pattern.test(name));
+
+const codeOf = (err: unknown): unknown => (err instanceof Error && 'code' in err ? err.code : undefined);
+
+function namesIn(dir: string): string[] {
+  try {
+    return readdirSync(dir).filter(isConnectorLeftover);
+  } catch (err) {
+    if (codeOf(err) !== 'ENOENT') log.warn({ err: errMsg(err), dir }, 'connectors: could not list the old connector files');
+    return [];
+  }
+}
+
+function removeOne(path: string): boolean {
+  try {
+    if (!lstatSync(path).isFile()) {
+      log.warn({ path }, 'connectors: left an old connector file alone, it is not a regular file');
+      return false;
+    }
+    unlinkSync(path);
+    return true;
+  } catch (err) {
+    if (codeOf(err) !== 'ENOENT') log.warn({ err: errMsg(err), path }, 'connectors: could not remove an old connector file');
+    return false;
+  }
+}
+
+export function removeConnectorLeftovers(dir = agentsDir()): number {
+  try {
+    const removed = namesIn(dir).filter((name) => removeOne(join(dir, name))).length;
+    log.info({ removed }, 'connectors: removed the files of the old connector path');
+    return removed;
+  } catch (err) {
+    log.warn({ err: errMsg(err) }, 'connectors: could not remove the files of the old connector path');
+    return 0;
+  }
+}

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));
+}