@stage-labs/metro 0.1.0-beta.293 → 0.1.0-beta.295

package/package.json

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

package/runtime/marketplace/plugin/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "metro",
-  "version": "0.1.0-beta.293",
+  "version": "0.1.0-beta.295",
   "description": "Metro for Claude Code, installed by the metro daemon on this machine: every connector the agent holds as its own MCP server relayed through the daemon, the orchestrator-only guard on the main thread, and the standing rules loaded at each session start. No vendor credential ever sits in a config file.",
   "author": {
     "name": "Bonustrack",

package/runtime/node_modules/@metro-labs/core/src/runner-activity.ts

@@ -26,6 +26,9 @@ const FAILURE = {
   status_unavailable: 'The SDK status file cannot be written. Check its path and permissions before starting.',
   saved_state: 'The saved Agent SDK state cannot be read. Restore it before starting.',
   executable: 'The SDK executable could not start. Prepare the SDK runtime again.',
+  module: 'The SDK runtime could not load a required module. Prepare the SDK runtime again.',
+  configuration: 'The SDK launch configuration is missing or invalid. Check Harness and the Model page before starting.',
+  process_exit: 'The SDK process exited unexpectedly. Check its reported exit code or signal before retrying.',
   connection: 'The SDK connection failed. Check the server and provider connection.',
   session_ended: 'The Agent SDK session ended unexpectedly.',
   interrupted: 'The SDK stopped before finishing a chat request. Check Conversations before retrying; actions may already have run.',
@@ -33,8 +36,40 @@ const FAILURE = {
 } as const;
 export type RunnerFailureCode = keyof typeof FAILURE;
 
-export function runnerFailureSummary(code: RunnerFailureCode, tool: string | null = null): string {
-  return code === 'tool_error' && name(tool) !== null ? `${tool} failed. See its result in Conversations.` : FAILURE[code];
+const ERROR_CODES = ['ENOENT', 'EACCES', 'EPERM', 'ENOEXEC', 'ENOMEM', 'ERR_MODULE_NOT_FOUND', 'MODULE_NOT_FOUND', 'ERR_DLOPEN_FAILED', 'ECONNREFUSED', 'ECONNRESET', 'ENOTFOUND', 'EAI_AGAIN', 'ETIMEDOUT', 'CERT_HAS_EXPIRED', 'UNABLE_TO_VERIFY_LEAF_SIGNATURE'] as const;
+const SIGNALS = ['SIGTERM', 'SIGKILL', 'SIGSEGV', 'SIGABRT', 'SIGBUS', 'SIGILL', 'SIGINT', 'SIGHUP', 'SIGPIPE'] as const;
+
+export interface RunnerDiagnostic {
+  source: 'exception' | 'stderr';
+  errorCode?: (typeof ERROR_CODES)[number];
+  httpStatus?: number;
+  exitCode?: number;
+  signal?: (typeof SIGNALS)[number];
+}
+
+const boundedNumber = (value: unknown, min: number, max: number): number | undefined => typeof value === 'number' && Number.isInteger(value) && value >= min && value <= max ? value : undefined;
+
+export function runnerDiagnostic(raw: unknown): RunnerDiagnostic | undefined {
+  if (!isRecord(raw) || (raw.source !== 'exception' && raw.source !== 'stderr')) return undefined;
+  const errorCode = ERROR_CODES.find((code) => code === raw.errorCode);
+  const signal = SIGNALS.find((value) => value === raw.signal);
+  const httpStatus = boundedNumber(raw.httpStatus, 400, 599);
+  const exitCode = boundedNumber(raw.exitCode, 0, 255);
+  return {
+    source: raw.source,
+    ...(errorCode === undefined ? {} : { errorCode }),
+    ...(httpStatus === undefined ? {} : { httpStatus }),
+    ...(exitCode === undefined ? {} : { exitCode }),
+    ...(signal === undefined ? {} : { signal }),
+  };
+}
+
+export function runnerFailureSummary(code: RunnerFailureCode, tool: string | null = null, diagnostic?: RunnerDiagnostic): string {
+  const summary = code === 'tool_error' && name(tool) !== null ? `${tool} failed. See its result in Conversations.` : FAILURE[code];
+  const safe = runnerDiagnostic(diagnostic);
+  if (safe === undefined) return summary;
+  const details = [safe.errorCode, safe.httpStatus === undefined ? null : `HTTP ${safe.httpStatus}`, safe.exitCode === undefined ? null : `exit ${safe.exitCode}`, safe.signal].filter((value) => value !== undefined && value !== null);
+  return details.length === 0 ? summary : `${summary} Observed: ${details.join(', ')} (${safe.source === 'stderr' ? 'startup stderr' : 'exception'}).`;
 }
 
 export interface RunnerTask {
@@ -70,6 +105,7 @@ export interface RunnerEvent {
   toolUseId?: string;
   taskId: string | null;
   code?: RunnerFailureCode;
+  diagnostic?: RunnerDiagnostic;
 }
 
 export interface RunnerFailure extends RunnerEvent {
@@ -146,16 +182,17 @@ function tool(raw: unknown): RunnerTool | null {
   return { id: String(raw.id), name: String(raw.name), taskId: name(raw.taskId), startedAt: count(raw.startedAt), ...(typeof raw.worker === 'boolean' ? { worker: raw.worker } : {}) };
 }
 
-const failureCode = (value: unknown): value is RunnerFailureCode => typeof value === 'string' && Object.hasOwn(FAILURE, value);
+export const runnerFailureCode = (value: unknown): value is RunnerFailureCode => typeof value === 'string' && Object.hasOwn(FAILURE, value);
 const failureKind = (value: RunnerEventKind): boolean => ['turn_failed', 'tool_failed', 'task_failed', 'compact_failed', 'session_failed'].includes(value);
 
 function event(raw: unknown): RunnerEvent | null {
   if (!isRecord(raw) || !eventKind(raw.kind) || count(raw.at) === 0) return null;
+  const diagnostic = runnerDiagnostic(raw.diagnostic);
   return {
     at: count(raw.at), kind: raw.kind, tool: name(raw.tool), taskId: name(raw.taskId),
     ...(name(raw.id) === null ? {} : { id: String(raw.id) }),
     ...(name(raw.toolUseId) === null ? {} : { toolUseId: String(raw.toolUseId) }),
-    ...(failureKind(raw.kind) && failureCode(raw.code) ? { code: raw.code } : {}),
+    ...(failureKind(raw.kind) && runnerFailureCode(raw.code) ? { code: raw.code, ...(diagnostic === undefined ? {} : { diagnostic }) } : {}),
   };
 }
 
@@ -184,7 +221,7 @@ function processIdentity(value: unknown): Pick<RunnerActivity, 'procStart'> {
 function failureFields(raw: Record<string, unknown>): Pick<RunnerActivity, 'lastError' | 'activeFailure' | 'lastFailure'> {
   const activeFailure = failure(raw.activeFailure);
   return {
-    lastError: Object.hasOwn(raw, 'activeFailure') ? activeFailure === null ? null : runnerFailureSummary(activeFailure.code, activeFailure.tool) : safeError(raw.lastError),
+    lastError: Object.hasOwn(raw, 'activeFailure') ? activeFailure === null ? null : runnerFailureSummary(activeFailure.code, activeFailure.tool, activeFailure.diagnostic) : safeError(raw.lastError),
     ...(Object.hasOwn(raw, 'activeFailure') ? { activeFailure } : {}),
     ...(Object.hasOwn(raw, 'lastFailure') ? { lastFailure: failure(raw.lastFailure) } : {}),
   };

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

@@ -42,6 +42,10 @@ export class ChannelRelay {
     });
   }
 
+  whenIdle(): Promise<void> {
+    return this.chain;
+  }
+
   replayMissed(): void {
     const missed = bufferedSince(this.ledger.startAt).filter(
       (b) => !this.ledger.delivered.has(b.busSeq),

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

@@ -71,7 +71,9 @@ function callFailure(error: unknown, action: string): ApiError {
 
 function received(record: MigrationRecord, snapshot: DeliverySnapshot): boolean {
   const delivered = snapshot.connectors.find((row) => row.id === record.destinationId);
-  return delivered?.state === 'ready' && delivered.name === record.name && samePolicy(delivered.policy, record.policy);
+  if (delivered?.state !== 'ready' || delivered.name !== record.name) return false;
+  const layers = delivered.policyLayers;
+  return layers === undefined ? samePolicy(delivered.policy, record.policy) : samePolicy(layers.organization, record.policy) && samePolicy(layers.agent, {});
 }
 
 export class ConnectorMigrations {

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

@@ -1,7 +1,7 @@
 import type { FetchLike } from '@metro-labs/core/stations/oauth';
 import type { ToolGroup } from '@metro-labs/core/stations/types';
 import { ApiError } from '@metro-labs/http/api-error';
-import type { DeliveredConnector } from '@metro-labs/http/connector-delivery';
+import { validConnectorToolName, type DeliveredConnector } from '@metro-labs/http/connector-delivery';
 import { MetroApiRefusal } from './metro-api.js';
 import { listRemoteTools } from './tools.js';
 
@@ -106,8 +106,8 @@ export async function discoverOrgGroups(url: string, guard: DiscoveryGuard): Pro
     if (failure.error !== null) throw failure.error;
     guard.current();
     guard.signal.throwIfAborted();
-    if (tools.length > MAX_TOOLS) throw orgUnavailable();
-    return Object.fromEntries(tools.filter((tool) => /^[A-Za-z0-9_.-]{1,128}$/.test(tool.name)).map((tool) => [tool.name, tool.readOnly ? 'read' : 'write']));
+    if (tools.length > MAX_TOOLS || tools.some((tool) => !validConnectorToolName(tool.name))) throw orgUnavailable();
+    return Object.fromEntries(tools.map((tool) => [tool.name, tool.readOnly ? 'read' : 'write']));
   } catch (error) {
     throw orgRuntimeError(error);
   }

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

@@ -3,7 +3,7 @@ import { agentsDir } from '../agents/files.js';
 import { assertMigrationOutcomeKnown, beginMigrationOperation, migrationRequestEffectful, type MigrationOperation } from './migration-operations.js';
 import type { FetchLike } from '@metro-labs/core/stations/oauth';
 import type { ToolGroup } from '@metro-labs/core/stations/types';
-import type { DeliveredConnector } from '@metro-labs/http/connector-delivery';
+import { effectiveConnectorPolicy, type DeliveredConnector } from '@metro-labs/http/connector-delivery';
 import type { ApiError } from '@metro-labs/http/api-error';
 import { requestConnectorBlocker, type GateRow } from './gates.js';
 import { publishOrgConnectors } from './publication.js';
@@ -49,7 +49,7 @@ interface Session {
 
 const stampOf = (row: RuntimeRow): string => JSON.stringify([
   row.relayId, row.relayName, row.name, row.url, row.auth, row.policy.read ?? 'allow', row.policy.write ?? 'allow',
-  Object.entries(row.policy.tools ?? {}).sort(([a], [b]) => a.localeCompare(b)),
+  Object.entries(row.policy.tools ?? {}).sort(([a], [b]) => a.localeCompare(b)), row.policyLayers,
 ]);
 
 const rowError = (row: DeliveredConnector | undefined): ApiError | null => {
@@ -94,7 +94,7 @@ export class OrgConnectorRuntime {
   private publish(rows: RuntimeRow[]): void {
     const metadata: GateRow[] = rows.filter((row) => row.state === 'ready').map((row) => ({
       id: row.relayId, name: row.relayName,
-      config: { policy: structuredClone(row.policy), toolGroups: { ...this.entries.get(row.id)?.groups } },
+      config: { policy: effectiveConnectorPolicy(row, this.entries.get(row.id)?.groups ?? {}), toolGroups: { ...this.entries.get(row.id)?.groups } },
     }));
     const text = JSON.stringify(metadata);
     if (text === this.published) return;
@@ -230,15 +230,21 @@ export class OrgConnectorRuntime {
   private discover(entry: Entry): Promise<void> | null {
     if (entry.scan !== null) return entry.scan;
     if (performance.now() < entry.nextScan) {
-      if (entry.error !== null) throw entry.error;
+      if (entry.error !== null) {
+        log.debug({ stage: 'discovery_backoff', status: entry.error.status }, 'organization connectors: request unavailable');
+        throw entry.error;
+      }
       return null;
     }
-    if (this.scans >= 4) throw orgUnavailable();
+    if (this.scans >= 4) {
+      log.debug({ stage: 'discovery_capacity', active: this.scans }, 'organization connectors: request unavailable');
+      throw orgUnavailable();
+    }
     this.scans += 1;
     entry.scan = this.scan(entry).catch((error: unknown) => {
       entry.error = orgRuntimeError(error);
       entry.nextScan = performance.now() + 30_000;
-      log.debug({ status: entry.error.status }, 'organization connectors: tool discovery failed');
+      log.debug({ stage: 'tool_discovery', status: entry.error.status }, 'organization connectors: tool discovery failed');
       throw entry.error;
     }).finally(() => {
       this.scans -= 1;

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

@@ -11,6 +11,7 @@ import type { RelaySession } from './relay-session.js';
 import type { DeliverySnapshot } from '@metro-labs/http/connector-delivery';
 import { localMigrationIdle, migrationRuntimeMapping } from './migration-guard.js';
 import { publishConnectors } from './publication.js';
+import { orgRuntimeError, orgUnavailable } from './org-runtime-discovery.js';
 
 type ControlDeps = Pick<OrgSyncDeps, 'owner' | 'key' | 'monotonic'> & { api?: MetroApi; dir?: string };
 type Context = Pick<ConnectorSyncStatus, 'owner' | 'agentId' | 'scope' | 'enrolled'>;
@@ -163,10 +164,22 @@ export class OrgConnectorControl {
     this.clear();
   }
 
-  open(id: string): RelaySession {
+  async open(id: string): Promise<RelaySession> {
     if (this.runtime === null && !syncOptedIn(this.dir)) throw new ApiError('Organization connectors are not available on this agent.', 503);
     this.reconcile(true);
-    if (this.runtime === null) throw new ApiError('Organization connectors are not available on this agent.', 503);
-    return this.runtime.open(id);
+    const runtime = this.runtime;
+    const sync = this.sync;
+    if (runtime === null || sync === null) throw new ApiError('Organization connectors are not available on this agent.', 503);
+    const state = sync.status().state;
+    try {
+      await sync.recover();
+      this.reconcile(false);
+      if (this.runtime !== runtime || this.sync !== sync) throw orgUnavailable();
+    } catch (error) {
+      const safe = orgRuntimeError(error);
+      log.debug({ stage: 'receipt_open', state, status: safe.status }, 'organization connectors: request unavailable');
+      throw safe;
+    }
+    return runtime.open(id);
   }
 }

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

@@ -13,7 +13,7 @@ function control(): OrgConnectorControl {
   return active;
 }
 
-export function orgConnectorRelaySession(id: string): RelaySession | null {
+export function orgConnectorRelaySession(id: string): Promise<RelaySession> | null {
   return isOrgRelayId(id) || migrationSource(id)?.phase === 'active' ? control().open(id) : null;
 }
 

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

@@ -47,6 +47,7 @@ export class OrgConnectorSync {
   private wallDeadline = 0;
   private generation = 0;
   private running: Promise<void> | null = null;
+  private recovery: Promise<void> | null = null;
   private expiry: ReturnType<typeof setTimeout> | null = null;
   private readonly monotonic: () => number;
   private readonly listeners = new Set<() => void>();
@@ -153,6 +154,12 @@ export class OrgConnectorSync {
     return this.running;
   }
 
+  recover(): Promise<void> {
+    if (this.read() !== null) return Promise.resolve();
+    this.recovery ??= this.syncFresh().finally(() => { this.recovery = null; });
+    return this.recovery;
+  }
+
   async syncFresh(refresh?: RefreshRequest): Promise<void> {
     if (this.running !== null) {
       await this.running.catch(() => {
@@ -167,7 +174,7 @@ export class OrgConnectorSync {
     const context = { ...identity.context, requestId };
     const started = this.deps.api.now();
     const clock = this.monotonic();
-    const response = await agentCall(this.deps.api, identity.key, '/api/agents/connectors', { requestId, ...(refresh === undefined ? {} : { refresh }) }, { answerMax: CONNECTOR_DELIVERY_MAX_BYTES, timeoutMs: 60_000, signal });
+    const response = await agentCall(this.deps.api, identity.key, '/api/agents/connectors?policy_layers=1', { requestId, ...(refresh === undefined ? {} : { refresh }) }, { answerMax: CONNECTOR_DELIVERY_MAX_BYTES, timeoutMs: 60_000, signal });
     this.validate(this.identity());
     if (generation !== this.generation || this.token !== identity.token) throw invalid();
     const snapshot = openConnectorDelivery(identity.key.sealing, context, response.sealed);

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

@@ -19,7 +19,7 @@ export interface RelayApiDeps {
   identify: (req: IncomingMessage) => { subject: string; agentId: string } | null;
   signedOut: (connectorId: string) => void;
   blocked?: BlockedReason;
-  open?: (connectorId: string) => RelaySession | null;
+  open?: (connectorId: string) => RelaySession | Promise<RelaySession> | null;
 }
 
 const ID_PATH_RE = /^\/relay\/((?:org-)?[A-Za-z0-9][A-Za-z0-9_-]{10})$/;
@@ -306,7 +306,7 @@ async function deliver(
 }
 
 async function relayOrg(req: IncomingMessage, res: ServerResponse, id: string, deps: RelayApiDeps, read: Uint8Array<ArrayBuffer> | null, signal: AbortSignal): Promise<void> {
-  const session = deps.open?.(id);
+  const session = await deps.open?.(id);
   if (session === undefined || session === null) throw new ApiError('Organization connector tools are not switched on yet.', 503);
   try {
     const out = await exchangeOrg(id, session, read, signal, (target, body, guard) => {

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

@@ -1,85 +1 @@
-import { isRecord } from '@metro-labs/core/is-record';
-import { errMsg, log } from '@metro-labs/core/log';
-import type { FetchLike } from '@metro-labs/core/stations/oauth';
-import { authHeaders, INITIALIZE, mcpPost, payloadOf, type ConnectorAuth } from '@metro-labs/http/connector-mcp';
-import { refused } from '@metro-labs/http/connector-url';
-
-export interface RemoteTool {
-  name: string;
-  title: string;
-  description: string;
-  readOnly: boolean;
-}
-
-const TIMEOUT_MS = 15_000;
-const MAX_PAGES = 10;
-
-function resultOf(text: string, contentType: string): Record<string, unknown> | null {
-  let parsed: unknown = null;
-  try {
-    parsed = JSON.parse(payloadOf(text, contentType));
-  } catch {
-    return null;
-  }
-  return isRecord(parsed) && isRecord(parsed.result) ? parsed.result : null;
-}
-
-async function rpc(url: URL, auth: ConnectorAuth, session: Map<string, string>, body: unknown, fetchImpl?: FetchLike): Promise<Record<string, unknown> | null> {
-  const res = await mcpPost(url, auth, body, { timeoutMs: TIMEOUT_MS, headers: Object.fromEntries(session), fetch: fetchImpl });
-  const id = res.headers.get('mcp-session-id');
-  if (id !== null && id !== '') session.set('mcp-session-id', id);
-  const text = await res.text().catch(() => '');
-  if (res.status === 401 || res.status === 403) throw refused(`${url.hostname} rejected the credential; connect it again`);
-  if (!res.ok) throw refused(`${url.hostname} answered ${String(res.status)}`);
-  return resultOf(text, res.headers.get('content-type') ?? '');
-}
-
-function toTool(raw: unknown): RemoteTool | null {
-  if (!isRecord(raw) || typeof raw.name !== 'string') return null;
-  const annotations = isRecord(raw.annotations) ? raw.annotations : {};
-  const title = typeof raw.title === 'string' && raw.title !== '' ? raw.title : raw.name;
-  return { name: raw.name, title, description: typeof raw.description === 'string' ? raw.description : '', readOnly: annotations.readOnlyHint === true };
-}
-
-async function endSession(url: URL, auth: ConnectorAuth, session: Map<string, string>, fetchImpl?: FetchLike): Promise<void> {
-  if (!session.has('mcp-session-id')) return;
-  try {
-    const send = fetchImpl ?? fetch;
-    const res = await send(url.toString(), { method: 'DELETE', redirect: 'manual', signal: AbortSignal.timeout(TIMEOUT_MS), headers: { ...authHeaders(auth), ...Object.fromEntries(session) } });
-    if (res.ok) await res.body?.pipeTo(new WritableStream<Uint8Array>());
-    else await res.body?.cancel();
-  } catch (err) {
-    log.debug(fetchImpl === undefined ? { host: url.hostname, err: errMsg(err) } : {}, 'connector-tools: the remote declined to end the session');
-  }
-}
-
-const toolsOf = (result: Record<string, unknown>): RemoteTool[] =>
-  Array.isArray(result.tools) ? result.tools.flatMap((raw: unknown) => toTool(raw) ?? []) : [];
-
-function nextCursor(result: Record<string, unknown>, current: string): string | null {
-  const next = result.nextCursor;
-  return typeof next !== 'string' || next === '' || next === current ? null : next;
-}
-
-async function walkTools(url: URL, auth: ConnectorAuth, session: Map<string, string>, fetchImpl?: FetchLike): Promise<RemoteTool[]> {
-  const tools: RemoteTool[] = [];
-  let cursor: string | null = '';
-  for (let page = 0; page < MAX_PAGES && cursor !== null; page += 1) {
-    const result = await rpc(url, auth, session, { jsonrpc: '2.0', id: 2 + page, method: 'tools/list', params: cursor === '' ? {} : { cursor } }, fetchImpl);
-    if (result === null) break;
-    tools.push(...toolsOf(result));
-    cursor = nextCursor(result, cursor);
-  }
-  return tools;
-}
-
-export async function listRemoteTools(url: URL, auth: ConnectorAuth, fetchImpl?: FetchLike): Promise<RemoteTool[]> {
-  const session = new Map<string, string>();
-  const init = await rpc(url, auth, session, INITIALIZE, fetchImpl);
-  if (init === null || typeof init.protocolVersion !== 'string') throw refused(`${url.hostname} answered, but it does not speak MCP.`);
-  session.set('mcp-protocol-version', init.protocolVersion);
-  await rpc(url, auth, session, { jsonrpc: '2.0', method: 'notifications/initialized' }, fetchImpl);
-  const tools = await walkTools(url, auth, session, fetchImpl);
-  await endSession(url, auth, session, fetchImpl);
-  return tools;
-}
+export { listRemoteTools, type RemoteTool } from '@metro-labs/http/connector-tools';

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

@@ -84,7 +84,7 @@ async function serveGet(
     scope: session.scope,
     req,
     res,
-    previous: session.currentSink,
+    previous: () => session.currentSink,
     log: channelLog,
     registerSink: (sink) => {
       session.bindSink(sink);

package/runtime/node_modules/@metro-labs/daemon/src/mcp/raw-get-stream.ts

@@ -55,6 +55,9 @@ export interface RawGetSink {
   close: () => void;
 }
 
+const streamEnded = (sink: RawGetSink, res: ServerResponse): boolean =>
+  sink.closed || res.destroyed || res.writableEnded;
+
 export interface ValidateResult {
   ok: boolean;
   status?: number;
@@ -93,6 +96,7 @@ export interface ServeOpts {
   res: ServerResponse;
   log: (...a: unknown[]) => void;
   registerSink: (sink: RawGetSink | undefined) => void;
+  previous?: () => RawGetSink | undefined;
 }
 
 export async function serveStandaloneGet(opts: ServeOpts): Promise<void> {
@@ -111,13 +115,17 @@ export async function serveStandaloneGet(opts: ServeOpts): Promise<void> {
   res.write(COMMENT);
 
   let active = transport;
+  let entry: StreamEntry | undefined;
   const timers: { keepalive?: ReturnType<typeof setInterval> } = {};
   const closeStream = (): void => {
     if (sink.closed) return;
     sink.closed = true;
     if (timers.keepalive) clearInterval(timers.keepalive);
-    web(active)?._streamMapping?.delete(STANDALONE_STREAM_ID);
-    registerSink(undefined);
+    const mapping = web(active)?._streamMapping;
+    if (entry !== undefined && mapping?.get(STANDALONE_STREAM_ID) === entry) {
+      mapping.delete(STANDALONE_STREAM_ID);
+      registerSink(undefined);
+    }
     try {
       res.end();
     } catch {
@@ -128,11 +136,10 @@ export async function serveStandaloneGet(opts: ServeOpts): Promise<void> {
     closed: false,
     attach: (next: StreamableHTTPServerTransport): void => {
       active = next;
-      const entry: StreamEntry = {
+      entry = {
         controller: {
           enqueue: (chunk: Uint8Array): void => {
-            if (sink.closed) return;
-            if (res.destroyed || res.writableEnded) {
+            if (streamEnded(sink, res)) {
               closeStream();
               return;
             }
@@ -147,6 +154,10 @@ export async function serveStandaloneGet(opts: ServeOpts): Promise<void> {
     close: closeStream,
   };
 
+  res.on('close', closeStream);
+  res.on('error', closeStream);
+  req.on('close', closeStream);
+
   const lastEventId = headerValue(req, 'last-event-id');
   if (lastEventId) {
     await eventStore.replayEventsAfter(lastEventId, {
@@ -168,12 +179,17 @@ export async function serveStandaloneGet(opts: ServeOpts): Promise<void> {
     });
   }
 
+  if (streamEnded(sink, res)) {
+    closeStream();
+    return;
+  }
+  opts.previous?.()?.close();
   sink.attach(transport);
   registerSink(sink);
+  if (sink.closed) return;
 
   timers.keepalive = setInterval(() => {
-    if (sink.closed) return;
-    if (res.destroyed || res.writableEnded) {
+    if (streamEnded(sink, res)) {
       closeStream();
       return;
     }
@@ -185,14 +201,10 @@ export async function serveStandaloneGet(opts: ServeOpts): Promise<void> {
     }
   }, KEEPALIVE_MS);
   timers.keepalive.unref?.();
-
-  res.on('close', closeStream);
-  res.on('error', closeStream);
-  req.on('close', closeStream);
 }
 
 export interface ChannelGetOpts extends ServeOpts {
-  previous: RawGetSink | undefined;
+  previous: () => RawGetSink | undefined;
 }
 
 export async function serveChannelGet(opts: ChannelGetOpts): Promise<boolean> {
@@ -201,7 +213,7 @@ export async function serveChannelGet(opts: ChannelGetOpts): Promise<boolean> {
     opts.res.writeHead(check.status ?? 400).end(check.message ?? 'bad request');
     return false;
   }
-  if (opts.previous && !opts.previous.closed) opts.previous.close();
+  opts.previous()?.close();
   await serveStandaloneGet(opts);
   return true;
 }

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

@@ -1,5 +1,6 @@
 import { randomUUID } from 'node:crypto';
 import { currentBusSeq } from '@metro-labs/core/events';
+import { errMsg } from '@metro-labs/core/log';
 import { newReplayLedger } from '../channels/relay.js';
 import { McpSession, channelLog, type SessionKind } from './session.js';
 import { allowedAgents, type RequestIdentity } from './request-identity.js';
@@ -9,6 +10,7 @@ export class SessionSlot {
   private readonly ledger = newReplayLedger();
   private started = false;
   private live: boolean;
+  private changing: Promise<void> = Promise.resolve();
 
   constructor(
     live = true,
@@ -45,10 +47,20 @@ export class SessionSlot {
     if (this.started) this.session?.startChannel();
   }
 
-  async open(
-    identity: RequestIdentity,
-    adoptId?: string,
-  ): Promise<McpSession> {
+  open(identity: RequestIdentity, adoptId?: string): Promise<McpSession> {
+    return this.change(() => this.replace(identity, adoptId));
+  }
+
+  private change<T>(run: () => Promise<T>): Promise<T> {
+    const changed = this.changing.then(run);
+    this.changing = changed.then(() => undefined).catch((err: unknown) => {
+      channelLog('session: change failed', errMsg(err));
+    });
+    return changed;
+  }
+
+  private async replace(identity: RequestIdentity, adoptId?: string): Promise<McpSession> {
+    if (adoptId !== undefined && this.session?.id === adoptId) return this.session;
     await this.session?.close();
     if (this.ledger.startAt < 0) this.ledger.startAt = currentBusSeq();
     const id = adoptId ?? randomUUID();
@@ -61,6 +73,11 @@ export class SessionSlot {
       live: () => this.live,
       onClosed: (s) => {
         if (this.session === s) this.session = undefined;
+        s.channel.whenIdle().then(() => {
+          if (this.session?.streamAttached) this.session.replayMissed();
+        }).catch((err: unknown) => {
+          channelLog('session: handoff replay failed', errMsg(err));
+        });
       },
     });
     this.session = session;
@@ -69,7 +86,9 @@ export class SessionSlot {
     return session;
   }
 
-  async close(): Promise<void> {
-    await this.session?.close();
+  close(): Promise<void> {
+    return this.change(async () => {
+      await this.session?.close();
+    });
   }
 }

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

@@ -177,6 +177,10 @@ export class McpSession {
   }
 
   bindSink(sink: RawGetSink | undefined): void {
+    if (this.closed) {
+      sink?.close();
+      return;
+    }
     this.sink = sink;
     if (sink !== undefined) {
       this.announceCallState();

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

@@ -18,6 +18,7 @@
     "./connector-resource": "./src/connector-resource.ts",
     "./connector-reach": "./src/connector-reach.ts",
     "./connector-mcp": "./src/connector-mcp.ts",
+    "./connector-tools": "./src/connector-tools.ts",
     "./connector-discovery": "./src/connector-discovery.ts",
     "./connector-oauth": "./src/connector-oauth.ts",
     "./connector-input": "./src/connector-input.ts",

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

@@ -1,7 +1,7 @@
 import { parseId } from '@metro-labs/core/ids';
 import { isRecord } from '@metro-labs/core/is-record';
 import { connectorName } from './connector-input.js';
-import { connectorPolicyOf, type ConnectorPolicy } from './connector-policy.js';
+import { connectorPolicyLayersOf, connectorPolicyOf, type ConnectorPolicy, type ConnectorPolicyLayers } from './connector-policy.js';
 import { parsePublicConnectorUrl } from './connector-public-url.js';
 import { isOrganizationId } from './workos-token.js';
 
@@ -23,6 +23,7 @@ export interface DeliveredConnector {
   auth: 'none' | 'header' | 'oauth';
   headers: Record<string, string>;
   policy: ConnectorPolicy;
+  policyLayers?: ConnectorPolicyLayers;
   revision: string;
   state: 'ready' | 'signin' | 'unavailable';
   expiresAt?: number;
@@ -91,7 +92,7 @@ function urlOf(value: unknown): string {
 }
 
 function connectorOf(raw: unknown): DeliveredConnector {
-  const value = deliveryRecord(raw, ['id', 'name', 'url', 'auth', 'headers', 'policy', 'revision', 'state', 'expiresAt']);
+  const value = deliveryRecord(raw, ['id', 'name', 'url', 'auth', 'headers', 'policy', 'policyLayers', 'revision', 'state', 'expiresAt']);
   const id = parseId(value.id);
   if (id === null || typeof value.name !== 'string' || connectorName(value.name) !== value.name) throw new Error('Invalid delivered connector.');
   const url = urlOf(value.url);
@@ -99,7 +100,7 @@ function connectorOf(raw: unknown): DeliveredConnector {
   const state = stateOf(value.state, auth);
   deliveryBytes(value.revision, 32);
   if (Object.hasOwn(value, 'expiresAt') && !timestamp(value.expiresAt)) throw new Error('Invalid delivered connector expiry.');
-  return { id, name: value.name, url, auth, state, revision: String(value.revision), headers: headersOf(value.headers, auth, state), policy: connectorPolicyOf(value.policy), ...(timestamp(value.expiresAt) ? { expiresAt: value.expiresAt } : {}) };
+  return { id, name: value.name, url, auth, state, revision: String(value.revision), headers: headersOf(value.headers, auth, state), policy: connectorPolicyOf(value.policy), ...(Object.hasOwn(value, 'policyLayers') ? { policyLayers: connectorPolicyLayersOf(value.policyLayers) } : {}), ...(timestamp(value.expiresAt) ? { expiresAt: value.expiresAt } : {}) };
 }
 
 export function deliverySnapshotOf(raw: unknown): DeliverySnapshot {

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

@@ -2,8 +2,8 @@ import type { KeyObject } from 'node:crypto';
 import { CONNECTOR_DELIVERY_MAX_BYTES, DELIVERY_PLAINTEXT_MAX, deliveryContextBytes, deliverySnapshotOf, type DeliveryContext, type DeliverySnapshot } from './connector-delivery-validation.js';
 import { openTransfer, sealTransfer, type SealedTransfer } from './transfer-crypto.js';
 
-export { CONNECTOR_DELIVERY_LEASE_MS, CONNECTOR_DELIVERY_MAX_BYTES, deliverySnapshotOf, type DeliveryContext, type DeliverySnapshot, type DeliveredConnector } from './connector-delivery-validation.js';
-export { combineConnectorPolicies, connectorPolicyOf, type ConnectorPolicy } from './connector-policy.js';
+export { CONNECTOR_DELIVERY_LEASE_MS, CONNECTOR_DELIVERY_MAX_BYTES, DELIVERY_PLAINTEXT_MAX, deliverySnapshotOf, type DeliveryContext, type DeliverySnapshot, type DeliveredConnector } from './connector-delivery-validation.js';
+export { combineConnectorPolicies, connectorPolicyOf, effectiveConnectorPolicy, connectorPoliciesBlocked, validConnectorToolName, type ConnectorPolicy, type ConnectorPolicyLayers } from './connector-policy.js';
 export type SealedDelivery = SealedTransfer;
 
 export function sealConnectorDelivery(publicKey: string, context: DeliveryContext, snapshot: DeliverySnapshot): SealedDelivery {