@stage-labs/metro 0.1.0-beta.87 → 0.1.0-beta.88

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.87",
+  "version": "0.1.0-beta.88",
   "description": "The metro command line. Sign in once per machine, then hand your MCP connector list to Claude Code without the credentials touching disk, argv or shell history.",
   "license": "MIT",
   "repository": {

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

@@ -20,9 +20,8 @@ import {
 } from '../routes/http.js';
 import { localAgentKey } from '../stations/materialize.js';
 import { agentsDir, fileSource } from '../agents/files.js';
-import { ConnectorAggregate } from '../connectors/aggregate.js';
-import { setConnectorToolProvider } from '../mcp/connector-tools.js';
-import { invalidateToolSchema } from '../mcp/tool-dispatch.js';
+import { ConnectorWatch } from '../connectors/watch.js';
+import { syncPluginServers } from '../connectors/plugin-sync.js';
 import { applyLocalOwner } from './local-owner.js';
 import { localOwner } from '../agents/file-admin.js';
 import { ensureStationDeps } from '../stations/runtime-deps.js';
@@ -32,7 +31,6 @@ import {
   agentLiveness,
   closeAgentSession,
   createMetroMcp,
-  announceToolSchemaToAll,
 } from '../mcp/index.js';
 import { metroCall } from '../mcp/ctx.js';
 import { gatherAccountsForAgents } from '../mcp/accounts.js';
@@ -121,20 +119,14 @@ function sessionApis(): SessionApis {
     });
 }
 
-let connectors: ConnectorAggregate | null = null;
+let connectors: ConnectorWatch | null = null;
 
 function startConnectors(): void {
-  const aggregate = new ConnectorAggregate(agentsDir(), () => {
-    invalidateToolSchema();
-    announceToolSchemaToAll();
+  const watch = new ConnectorWatch(agentsDir(), () => {
+    syncPluginServers();
   });
-  connectors = aggregate;
-  setConnectorToolProvider({
-    list: () => aggregate.list(),
-    owns: (name) => aggregate.owns(name),
-    call: (name, args) => aggregate.call(name, args),
-  });
-  aggregate.start();
+  connectors = watch;
+  watch.start();
 }
 
 async function main(): Promise<void> {

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

@@ -0,0 +1,97 @@
+import { existsSync, readdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { errMsg, log } from '@metro-labs/core/log';
+import { claudeDir } from '../claude/files.js';
+import { webhookPort } from '../net/tunnel.js';
+import { readLocalConnectors, type LocalConnectorRow } from './store.js';
+
+const MARKER = join('bin', 'metro-plugin.mjs');
+const FILE = '.mcp.json';
+const HELPER = 'node "${CLAUDE_PLUGIN_ROOT}/bin/metro-plugin.mjs" headers';
+const SLUG_MAX = 40;
+
+export interface PluginServer {
+  type: 'http';
+  url: string;
+  headersHelper: string;
+}
+
+export function serverKey(name: string): string {
+  const slug = name
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, SLUG_MAX)
+    .replace(/-+$/, '');
+  return slug === '' ? 'connector' : slug;
+}
+
+export function pluginServers(rows: LocalConnectorRow[], base: string): Record<string, PluginServer> {
+  const taken = new Map<string, number>();
+  const out: Record<string, PluginServer> = {};
+  for (const row of rows) {
+    const wanted = serverKey(row.name);
+    const seen = taken.get(wanted) ?? 0;
+    taken.set(wanted, seen + 1);
+    const key = seen === 0 ? wanted : `${wanted}-${row.id.toLowerCase().replace(/[^a-z0-9]/g, '').slice(0, 4)}`;
+    out[key] = { type: 'http', url: `${base}/relay/${row.id}`, headersHelper: HELPER };
+  }
+  return out;
+}
+
+export function installedPluginFiles(dir = claudeDir()): string[] {
+  const root = join(dir, 'plugins', 'marketplaces');
+  if (!existsSync(root)) return [];
+  const out: string[] = [];
+  for (const entry of readdirSync(root, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    const plugin = join(root, entry.name, 'plugin');
+    if (existsSync(join(plugin, MARKER))) out.push(join(plugin, FILE));
+  }
+  return out;
+}
+
+const readOrNull = (path: string): string | null => {
+  try {
+    return readFileSync(path, 'utf8');
+  } catch {
+    return null;
+  }
+};
+
+function writeIfChanged(path: string, text: string): boolean {
+  if (readOrNull(path) === text) return false;
+  const tmp = `${path}.metro-${String(process.pid)}`;
+  writeFileSync(tmp, text, { mode: 0o644 });
+  renameSync(tmp, path);
+  return true;
+}
+
+export interface PluginSyncOptions {
+  dir?: string;
+  base?: string;
+  agents?: string;
+}
+
+export function syncPluginServers(opts: PluginSyncOptions = {}): number {
+  const files = installedPluginFiles(opts.dir ?? claudeDir());
+  if (files.length === 0) return 0;
+  const base = opts.base ?? `http://127.0.0.1:${String(webhookPort())}`;
+  const rows = opts.agents === undefined ? readLocalConnectors() : readLocalConnectors(opts.agents);
+  const servers = pluginServers(rows, base);
+  const text = `${JSON.stringify(servers, null, 2)}\n`;
+  let written = 0;
+  for (const file of files) {
+    try {
+      if (writeIfChanged(file, text)) written += 1;
+    } catch (err) {
+      log.warn({ file, err: errMsg(err) }, 'plugin: could not write the connector servers');
+    }
+  }
+  if (written > 0)
+    log.info(
+      { files: written, servers: Object.keys(servers).length },
+      'plugin: connector servers written; /reload-plugins picks them up in a running session',
+    );
+  return written;
+}

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

@@ -0,0 +1,54 @@
+import { watch, type FSWatcher } from 'node:fs';
+import { errMsg, log } from '@metro-labs/core/log';
+
+const DEBOUNCE_MS = 300;
+const FILE = 'connectors.json';
+
+export class ConnectorWatch {
+  private watcher: FSWatcher | null = null;
+  private timer: ReturnType<typeof setTimeout> | null = null;
+
+  constructor(
+    private readonly dir: string,
+    private readonly onChange: () => void,
+  ) {}
+
+  start(): void {
+    try {
+      this.watcher = watch(this.dir, (_event, file) => {
+        if (file === null || file === FILE) this.schedule();
+      });
+      this.watcher.on('error', (err: unknown) => {
+        log.warn({ err: errMsg(err) }, 'connectors: watcher failed; the plugin list refreshes at the next start');
+      });
+      this.watcher.unref();
+    } catch (err) {
+      log.warn({ err: errMsg(err) }, 'connectors: could not watch the agents dir');
+    }
+    this.fire();
+  }
+
+  stop(): void {
+    this.watcher?.close();
+    this.watcher = null;
+    if (this.timer !== null) clearTimeout(this.timer);
+    this.timer = null;
+  }
+
+  private schedule(): void {
+    if (this.timer !== null) clearTimeout(this.timer);
+    this.timer = setTimeout(() => {
+      this.timer = null;
+      this.fire();
+    }, DEBOUNCE_MS);
+    this.timer.unref();
+  }
+
+  private fire(): void {
+    try {
+      this.onChange();
+    } catch (err) {
+      log.warn({ err: errMsg(err) }, 'connectors: change handler failed');
+    }
+  }
+}

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

@@ -138,10 +138,6 @@ export function agentLiveness(): Map<string, AgentLiveness> {
   return activeRegistry?.liveness() ?? new Map<string, AgentLiveness>();
 }
 
-export function announceToolSchemaToAll(): void {
-  activeRegistry?.announceToolSchema();
-}
-
 export async function closeAgentSession(agentId: string): Promise<boolean> {
   const scopeKey = sessionScopeKey({ kind: 'agent', agentId });
   return (await activeRegistry?.closeScope(scopeKey)) ?? false;

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

@@ -61,10 +61,6 @@ export class SessionRegistry {
     return out;
   }
 
-  announceToolSchema(): void {
-    for (const session of this.byId.values()) session.announceToolSchema();
-  }
-
   forScope(scopeKey: string): McpSession | undefined {
     return this.byScope.get(scopeKey);
   }

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

@@ -165,7 +165,7 @@ export class McpSession {
     return this.issuedSchema !== toolSchemaSignature();
   }
 
-  announceToolSchema(): void {
+  private announceToolSchema(): void {
     if (!this.streamAttached) return;
     this.deliverSchemaNotice(
       () => this.server.sendToolListChanged(),

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

@@ -31,7 +31,6 @@ import {
   type RequestIdentity,
 } from './request-identity.js';
 import { str } from '@metro-labs/core/str';
-import { callConnectorTool, connectorToolList, isConnectorTool } from './connector-tools.js';
 
 const STATION_TOOLS = new Map<
   string,
@@ -63,16 +62,11 @@ const toolList = (): { tools: unknown[] } => ({
       })),
     ),
     LIST_ACCOUNTS_TOOL,
-    ...connectorToolList(),
   ],
 });
 
 let schemaSignature: string | undefined;
 
-export function invalidateToolSchema(): void {
-  schemaSignature = undefined;
-}
-
 export const toolSchemaSignature = (): string => {
   schemaSignature ??= createHash('sha256')
     .update(JSON.stringify(toolList()))
@@ -155,7 +149,6 @@ async function runTool(
   const name = req.params.name;
   const a = req.params.arguments ?? {};
 
-  if (isConnectorTool(name)) return callConnectorTool(name, a);
   const identity = currentIdentity();
   if (name !== 'list_accounts' && scopeDenied(identity, name, a))
     return errResult('metro: this account is outside your authorized scope');

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.87"
+  "version": "0.1.0-beta.88"
 }

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

@@ -1,199 +0,0 @@
-import { watch, type FSWatcher } from 'node:fs';
-import { isRecord } from '@metro-labs/core/is-record';
-import { errMsg, log } from '@metro-labs/core/log';
-import type { ToolResult } from '@metro-labs/core/stations/types';
-import { signInState } from './config.js';
-import type { RelayTarget } from './relay-target.js';
-import { localRelayTarget, readLocalConnectors, type LocalConnectorRow } from './store.js';
-import { UpstreamClient, type UpstreamTool } from './upstream.js';
-
-const SEP = '__';
-const SLUG_MAX = 24;
-const NAME_MAX = 64;
-const WATCH_DEBOUNCE_MS = 300;
-const CONNECTORS_FILE = 'connectors.json';
-
-export interface ConnectorToolView {
-  name: string;
-  description: string;
-  inputSchema: unknown;
-  annotations?: unknown;
-}
-
-interface Entry {
-  row: LocalConnectorRow;
-  stamp: string;
-  slug: string;
-  client: UpstreamClient;
-  tools: UpstreamTool[];
-}
-
-type TargetOf = (connectorId: string, force: boolean, dir: string) => Promise<RelayTarget>;
-
-export function slugOf(name: string): string {
-  const slug = name
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, '_')
-    .replace(/^_+|_+$/g, '')
-    .slice(0, SLUG_MAX)
-    .replace(/_+$/, '');
-  return slug === '' ? 'connector' : slug;
-}
-
-const stampOf = (row: LocalConnectorRow): string =>
-  JSON.stringify([row.name, row.url, row.config.auth.kind, row.config.verified.at, row.config.oauth]);
-
-const toolName = (slug: string, tool: string): string => `${slug}${SEP}${tool}`.slice(0, NAME_MAX);
-
-const textBlock = (text: string): { type: 'text'; text: string } => ({ type: 'text', text });
-
-function blockOf(block: unknown): { type: 'text'; text: string } {
-  if (isRecord(block) && block.type === 'text' && typeof block.text === 'string') return textBlock(block.text);
-  const kind = isRecord(block) && typeof block.type === 'string' ? block.type : 'unknown';
-  return textBlock(`[${kind} block omitted by metro]`);
-}
-
-export function toToolResult(raw: unknown): ToolResult {
-  if (isRecord(raw) && Array.isArray(raw.content)) {
-    const content = raw.content.map(blockOf);
-    return raw.isError === true ? { content, isError: true } : { content };
-  }
-  return { content: [textBlock(JSON.stringify(raw ?? null))] };
-}
-
-function dedupeSlugs(entries: Map<string, Entry>): void {
-  const bySlug = new Map<string, Entry[]>();
-  for (const entry of entries.values()) bySlug.set(entry.slug, [...(bySlug.get(entry.slug) ?? []), entry]);
-  for (const group of bySlug.values()) {
-    if (group.length < 2) continue;
-    for (const entry of group) entry.slug = `${entry.slug}_${entry.row.id.toLowerCase().replace(/[^a-z0-9]/g, '').slice(0, 4)}`;
-  }
-}
-
-export class ConnectorAggregate {
-  private entries = new Map<string, Entry>();
-  private watcher: FSWatcher | null = null;
-  private timer: ReturnType<typeof setTimeout> | null = null;
-  private loading: Promise<void> | null = null;
-
-  constructor(
-    private readonly dir: string,
-    private readonly onChange: () => void,
-    private readonly targetOf: TargetOf = localRelayTarget,
-  ) {}
-
-  start(): void {
-    try {
-      this.watcher = watch(this.dir, (_event, file) => {
-        if (file === null || file === CONNECTORS_FILE) this.schedule();
-      });
-      this.watcher.on('error', (err: unknown) => {
-        log.warn({ err: errMsg(err) }, 'connectors: watcher failed; tools refresh on the next daemon start');
-      });
-      this.watcher.unref();
-    } catch (err) {
-      log.warn({ err: errMsg(err) }, 'connectors: could not watch the agents dir');
-    }
-    this.schedule(0);
-  }
-
-  stop(): void {
-    this.watcher?.close();
-    this.watcher = null;
-    if (this.timer !== null) clearTimeout(this.timer);
-    this.timer = null;
-  }
-
-  private schedule(ms = WATCH_DEBOUNCE_MS): void {
-    if (this.timer !== null) clearTimeout(this.timer);
-    this.timer = setTimeout(() => {
-      this.timer = null;
-      this.reload().catch((err: unknown) => {
-        log.warn({ err: errMsg(err) }, 'connectors: reload failed');
-      });
-    }, ms);
-    this.timer.unref();
-  }
-
-  reload(): Promise<void> {
-    this.loading ??= this.load().finally(() => {
-      this.loading = null;
-    });
-    return this.loading;
-  }
-
-  private async load(): Promise<void> {
-    const rows = readLocalConnectors(this.dir).filter((row) => signInState(row.config) !== 'disconnected');
-    const next = new Map<string, Entry>();
-    const jobs: Promise<void>[] = [];
-    for (const row of rows) {
-      const stamp = stampOf(row);
-      const kept = this.entries.get(row.id);
-      if (kept?.stamp === stamp && kept !== undefined) {
-        next.set(row.id, kept);
-        continue;
-      }
-      const entry: Entry = { row, stamp, slug: slugOf(row.name), client: new UpstreamClient((force) => this.targetOf(row.id, force, this.dir)), tools: [] };
-      next.set(row.id, entry);
-      jobs.push(this.fill(entry));
-    }
-    await Promise.all(jobs);
-    dedupeSlugs(next);
-    const before = this.signature();
-    this.entries = next;
-    if (this.signature() !== before) this.onChange();
-  }
-
-  private async fill(entry: Entry): Promise<void> {
-    try {
-      entry.tools = await entry.client.listTools();
-      log.info({ connector: entry.row.name, tools: entry.tools.length }, 'connectors: tools listed');
-    } catch (err) {
-      log.warn({ connector: entry.row.name, err: errMsg(err) }, 'connectors: tools not listed; the connector has no tools until it answers');
-    }
-  }
-
-  signature(): string {
-    return JSON.stringify([...this.entries.values()].map((e) => [e.row.id, e.slug, e.tools.map((t) => t.name)]).sort());
-  }
-
-  list(): ConnectorToolView[] {
-    const out: ConnectorToolView[] = [];
-    for (const entry of [...this.entries.values()].sort((a, b) => a.slug.localeCompare(b.slug)))
-      for (const tool of entry.tools)
-        out.push({
-          name: toolName(entry.slug, tool.name),
-          description: tool.description === '' ? `${entry.row.name}: ${tool.name}` : `${tool.description} (${entry.row.name})`,
-          inputSchema: tool.inputSchema,
-          ...(tool.annotations === undefined ? {} : { annotations: tool.annotations }),
-        });
-    return out;
-  }
-
-  private resolve(name: string): { entry: Entry; tool: UpstreamTool } | null {
-    const at = name.indexOf(SEP);
-    if (at <= 0) return null;
-    const slug = name.slice(0, at);
-    for (const entry of this.entries.values()) {
-      if (entry.slug !== slug) continue;
-      const tool = entry.tools.find((t) => toolName(slug, t.name) === name);
-      return tool === undefined ? null : { entry, tool };
-    }
-    return null;
-  }
-
-  owns(name: string): boolean {
-    return this.resolve(name) !== null;
-  }
-
-  async call(name: string, args: Record<string, unknown>): Promise<ToolResult> {
-    const found = this.resolve(name);
-    if (found === null) return { content: [textBlock(`metro: no connector serves ${name}`)], isError: true };
-    try {
-      return toToolResult(await found.entry.client.callTool(found.tool.name, args));
-    } catch (err) {
-      log.warn({ connector: found.entry.row.name, tool: found.tool.name, err: errMsg(err) }, 'connectors: tool call failed');
-      return { content: [textBlock(`metro: connector ${found.entry.row.name} ${errMsg(err)}`)], isError: true };
-    }
-  }
-}

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

@@ -1,172 +0,0 @@
-import { isRecord } from '@metro-labs/core/is-record';
-import { errMsg } from '@metro-labs/core/log';
-import type { RelayTarget } from './relay-target.js';
-
-const ACCEPT = 'application/json, text/event-stream';
-const PROTOCOL = '2025-11-25';
-const MAX_PAGES = 10;
-const LIST_MS = 15_000;
-const CALL_MS = 120_000;
-
-export interface UpstreamTool {
-  name: string;
-  description: string;
-  inputSchema: unknown;
-  annotations: unknown;
-}
-
-export type TargetOf = (force: boolean) => Promise<RelayTarget>;
-
-export class UpstreamRefused extends Error {}
-export class UpstreamFailed extends Error {}
-
-interface Live {
-  session: string | null;
-  protocol: string;
-}
-
-interface Answer {
-  status: number;
-  text: string;
-  contentType: string;
-  session: string | null;
-}
-
-function dataLines(text: string): string[] {
-  return text
-    .replace(/\r\n/g, '\n')
-    .split('\n')
-    .filter((line) => line.startsWith('data:'))
-    .map((line) => line.slice(5).trim());
-}
-
-function messageFor(answer: Answer, id: number): Record<string, unknown> | null {
-  const candidates = answer.contentType.includes('text/event-stream') ? dataLines(answer.text) : [answer.text];
-  for (const candidate of candidates) {
-    try {
-      const parsed: unknown = JSON.parse(candidate);
-      if (isRecord(parsed) && parsed.id === id) return parsed;
-    } catch {
-      continue;
-    }
-  }
-  return null;
-}
-
-function resultOf(answer: Answer, id: number): unknown {
-  const message = messageFor(answer, id);
-  if (message === null) throw new UpstreamFailed('answered without a result for the request');
-  if (isRecord(message.error)) {
-    const text = typeof message.error.message === 'string' ? message.error.message : JSON.stringify(message.error);
-    throw new UpstreamFailed(text);
-  }
-  return message.result;
-}
-
-const initializeBody = (id: number): unknown => ({
-  jsonrpc: '2.0',
-  id,
-  method: 'initialize',
-  params: { protocolVersion: PROTOCOL, capabilities: {}, clientInfo: { name: 'metro', version: '0.1.0' } },
-});
-
-function toolOf(raw: unknown): UpstreamTool | null {
-  if (!isRecord(raw) || typeof raw.name !== 'string' || raw.name === '') return null;
-  return {
-    name: raw.name,
-    description: typeof raw.description === 'string' ? raw.description : '',
-    inputSchema: isRecord(raw.inputSchema) ? raw.inputSchema : { type: 'object' },
-    annotations: isRecord(raw.annotations) ? raw.annotations : undefined,
-  };
-}
-
-export class UpstreamClient {
-  private live: Live | null = null;
-  private seq = 0;
-
-  constructor(private readonly target: TargetOf) {}
-
-  forget(): void {
-    this.live = null;
-  }
-
-  async listTools(): Promise<UpstreamTool[]> {
-    const tools: UpstreamTool[] = [];
-    let cursor = '';
-    for (let page = 0; page < MAX_PAGES; page += 1) {
-      const result = await this.rpc('tools/list', cursor === '' ? {} : { cursor }, LIST_MS);
-      if (!isRecord(result)) break;
-      if (Array.isArray(result.tools)) for (const raw of result.tools) {
-        const tool = toolOf(raw);
-        if (tool !== null) tools.push(tool);
-      }
-      const next = result.nextCursor;
-      if (typeof next !== 'string' || next === '' || next === cursor) break;
-      cursor = next;
-    }
-    return tools;
-  }
-
-  callTool(name: string, args: Record<string, unknown>): Promise<unknown> {
-    return this.rpc('tools/call', { name, arguments: args }, CALL_MS);
-  }
-
-  private async post(body: unknown, headers: Record<string, string>, force: boolean, ms: number): Promise<Answer> {
-    const target = await this.target(force);
-    if (target.kind === 'missing') throw new UpstreamRefused('this connector no longer exists on the daemon');
-    if (target.kind === 'signin') throw new UpstreamRefused('this connector needs signing in again on its page');
-    let res: Response;
-    try {
-      res = await fetch(target.url, {
-        method: 'POST',
-        redirect: 'manual',
-        signal: AbortSignal.timeout(ms),
-        headers: { 'content-type': 'application/json', accept: ACCEPT, ...target.headers, ...headers },
-        body: JSON.stringify(body),
-      });
-    } catch (err) {
-      throw new UpstreamFailed(`could not be reached (${errMsg(err)})`);
-    }
-    const text = await res.text().catch(() => '');
-    return { status: res.status, text, contentType: res.headers.get('content-type') ?? '', session: res.headers.get('mcp-session-id') };
-  }
-
-  private async withCredentialLadder(body: unknown, headers: Record<string, string>, ms: number): Promise<Answer> {
-    const first = await this.post(body, headers, false, ms);
-    if (first.status !== 401 && first.status !== 403) return first;
-    const again = await this.post(body, headers, true, ms);
-    if (again.status === 401 || again.status === 403) throw new UpstreamRefused('rejected the credential; sign in again on its page');
-    return again;
-  }
-
-  private async ensureSession(): Promise<Live> {
-    if (this.live !== null) return this.live;
-    const id = ++this.seq;
-    const answer = await this.withCredentialLadder(initializeBody(id), {}, LIST_MS);
-    if (answer.status >= 300) throw new UpstreamFailed(`answered ${String(answer.status)} to initialize`);
-    const result = resultOf(answer, id);
-    const protocol = isRecord(result) && typeof result.protocolVersion === 'string' ? result.protocolVersion : PROTOCOL;
-    this.live = { session: answer.session, protocol };
-    await this.post({ jsonrpc: '2.0', method: 'notifications/initialized' }, this.sessionHeaders(this.live), false, LIST_MS).catch(() => undefined);
-    return this.live;
-  }
-
-  private sessionHeaders(live: Live): Record<string, string> {
-    const headers: Record<string, string> = { 'mcp-protocol-version': live.protocol };
-    if (live.session !== null && live.session !== '') headers['mcp-session-id'] = live.session;
-    return headers;
-  }
-
-  private async rpc(method: string, params: unknown, ms: number): Promise<unknown> {
-    const live = await this.ensureSession();
-    const id = ++this.seq;
-    const body = { jsonrpc: '2.0', id, method, params };
-    let answer = await this.withCredentialLadder(body, this.sessionHeaders(live), ms);
-    if (answer.status === 404 && live.session !== null) {
-      this.live = null;
-      answer = await this.withCredentialLadder(body, this.sessionHeaders(await this.ensureSession()), ms);
-    }
-    if (answer.status >= 300) throw new UpstreamFailed(`answered ${String(answer.status)}${answer.text === '' ? '' : `: ${answer.text.slice(0, 200)}`}`);
-    return resultOf(answer, id);
-  }
-}

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

@@ -1,31 +0,0 @@
-import type { ToolResult } from '@metro-labs/core/stations/types';
-import { errResult } from './ctx.js';
-
-export interface ConnectorToolEntry {
-  name: string;
-  description: string;
-  inputSchema: unknown;
-  annotations?: unknown;
-}
-
-export interface ConnectorToolProvider {
-  list: () => ConnectorToolEntry[];
-  owns: (name: string) => boolean;
-  call: (name: string, args: Record<string, unknown>) => Promise<ToolResult>;
-}
-
-const NONE: ConnectorToolProvider = {
-  list: () => [],
-  owns: () => false,
-  call: (name) => Promise.resolve(errResult(`metro: no connector serves ${name}`)),
-};
-
-let provider: ConnectorToolProvider = NONE;
-
-export function setConnectorToolProvider(next: ConnectorToolProvider | null): void {
-  provider = next ?? NONE;
-}
-
-export const connectorToolList = (): ConnectorToolEntry[] => provider.list();
-export const isConnectorTool = (name: string): boolean => provider.owns(name);
-export const callConnectorTool = (name: string, args: Record<string, unknown>): Promise<ToolResult> => provider.call(name, args);