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

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

@@ -1,8 +1,7 @@
 import type { IncomingMessage } from 'node:http';
-import { log } from '@metro-labs/core/log';
 import { isRecord } from '@metro-labs/core/is-record';
 import { ApiError } from '@metro-labs/http/api-error';
-import { readJsonBody, type ApiSession } from '@metro-labs/http/api-http';
+import { readJsonBody } from '@metro-labs/http/api-http';
 import {
   claudeSetupStatus,
   ensureClaudeSetup,
@@ -19,12 +18,10 @@ import {
   type PermissionMode,
   type SetupDeps,
 } from './setup.js';
-import { harnessRunner, isHarnessRunner, sdkAllowed, sdkOnLogin, SDK_NEEDS_KEY, setHarnessRunner, setSdkOnLogin, type HarnessRunner } from './runner.js';
-import { assertSdkDrained, assertSessionStopped, prepareSessionRunner, setAutostart, withSessionChange, type SessionDeps } from './session.js';
+import { assertSessionStopped, type SessionDeps } from './session.js';
 import { tryMemoryJob } from './memory-routine.js';
 
 const SETUP_BODY_MAX = SYSTEM_PROMPT_MAX * 2;
-const OPERATOR_ONLY = 'only the Metro operator can allow the Agent SDK on a Claude login';
 
 export interface SetupApiDeps {
   session?: SessionDeps;
@@ -36,8 +33,6 @@ export interface SetupApiDeps {
 interface SetupChange {
   privacy?: boolean;
   permissionMode?: PermissionMode;
-  runner?: HarnessRunner;
-  sdkOnLogin?: boolean;
   systemPrompt?: string;
   liveEvents?: boolean;
   memoryRoutine?: boolean;
@@ -62,19 +57,11 @@ function modeChange(raw: unknown): PermissionMode | undefined {
   return raw;
 }
 
-function runnerChange(raw: unknown): HarnessRunner | undefined {
-  if (raw === undefined) return undefined;
-  if (!isHarnessRunner(raw)) throw new ApiError('runner must be cli or sdk', 400);
-  return raw;
-}
-
 function setupChange(body: unknown): SetupChange {
   if (!isRecord(body)) throw new ApiError('a body is required', 400);
   const change: SetupChange = {
     privacy: flagChange(body.privacy, 'privacy'),
     permissionMode: modeChange(body.permissionMode),
-    runner: runnerChange(body.runner),
-    sdkOnLogin: flagChange(body.sdkOnLogin, 'sdkOnLogin'),
     systemPrompt: promptChange(body.systemPrompt),
     liveEvents: flagChange(body.liveEvents, 'liveEvents'),
     memoryRoutine: flagChange(body.memoryRoutine, 'memoryRoutine'),
@@ -84,44 +71,11 @@ function setupChange(body: unknown): SetupChange {
   return given;
 }
 
-function checkRunnerChange(change: SetupChange, session: ApiSession, agents: string | undefined): void {
-  if (change.sdkOnLogin !== undefined && session.operator !== true) throw new ApiError(OPERATOR_ONLY, 403);
-  if (change.runner === 'sdk' && !sdkAllowed(agents, undefined, change.sdkOnLogin ?? sdkOnLogin(agents))) throw new ApiError(SDK_NEEDS_KEY, 403);
-}
-
-function nextRunner(change: SetupChange, agents: string | undefined): HarnessRunner {
-  const runner = change.runner ?? harnessRunner(agents);
-  return runner === 'sdk' && change.sdkOnLogin === false && !sdkAllowed(agents, undefined, false) ? 'cli' : runner;
-}
-
 function changesSession(change: SetupChange, agents: string | undefined): boolean {
-  return nextRunner(change, agents) !== harnessRunner(agents)
-    || (change.permissionMode !== undefined && change.permissionMode !== permissionMode(agents))
+  return (change.permissionMode !== undefined && change.permissionMode !== permissionMode(agents))
     || (change.systemPrompt !== undefined && change.systemPrompt.trim() !== systemPrompt(agents));
 }
 
-function saveSessionSettings(change: SetupChange, runner: HarnessRunner, agents: string | undefined): void {
-  if (change.sdkOnLogin !== undefined && change.sdkOnLogin !== sdkOnLogin(agents)) {
-    setSdkOnLogin(change.sdkOnLogin, agents);
-    log.info({ on: change.sdkOnLogin }, 'claude-setup: the operator changed whether the Agent SDK may run on this box’s Claude login');
-  }
-  if (runner !== harnessRunner(agents)) {
-    setAutostart(false, agents);
-    setHarnessRunner(runner, agents);
-  }
-  if (change.permissionMode !== undefined) setPermissionMode(change.permissionMode, agents);
-  if (change.systemPrompt !== undefined) setSystemPrompt(change.systemPrompt, agents);
-}
-
-function checkStoppedChange(change: SetupChange, deps: SetupApiDeps): HarnessRunner {
-  const agents = deps.setup?.agents;
-  const session = { ...deps.session, agents: deps.session?.agents ?? agents };
-  const runner = nextRunner(change, agents);
-  if (changesSession(change, agents)) assertSessionStopped(session);
-  if (runner !== harnessRunner(agents) && harnessRunner(agents) === 'sdk') assertSdkDrained(session);
-  return runner;
-}
-
 function applyLiveEvents(on: boolean, deps: SetupApiDeps): void {
   const agents = deps.setup?.agents;
   if (on !== liveEvents(agents)) setLiveEvents(on, agents);
@@ -133,29 +87,28 @@ function applyMemoryRoutine(on: boolean, deps: SetupApiDeps): void {
   (deps.memoryJob ?? tryMemoryJob)(on);
 }
 
-async function applySetupChange(change: SetupChange, session: ApiSession, deps: SetupApiDeps, req: IncomingMessage): Promise<void> {
+function saveSessionSettings(change: SetupChange, deps: SetupApiDeps): void {
+  const agents = deps.setup?.agents;
+  if (changesSession(change, agents)) assertSessionStopped({ ...deps.session, agents: deps.session?.agents ?? agents });
+  if (change.permissionMode !== undefined) setPermissionMode(change.permissionMode, agents);
+  if (change.systemPrompt !== undefined) setSystemPrompt(change.systemPrompt, agents);
+}
+
+function applySetupChange(change: SetupChange, deps: SetupApiDeps): void {
   const setup = deps.setup ?? {};
-  checkRunnerChange(change, session, setup.agents);
-  const runner = checkStoppedChange(change, deps);
-  if (runner !== harnessRunner(setup.agents)) {
-    await prepareSessionRunner(runner, deps.session);
-    checkRunnerChange(change, session, setup.agents);
-    if (checkStoppedChange(change, deps) !== runner) throw new ApiError('The model setup changed during preparation. Choose the runner again.', 409);
-  }
-  if (req.socket.destroyed) throw new ApiError('The request disconnected during preparation. The runner choice was not changed.', 409);
+  saveSessionSettings(change, deps);
   if (change.privacy !== undefined) setPrivacy(change.privacy, setup.agents);
   if (change.liveEvents !== undefined) applyLiveEvents(change.liveEvents, deps);
   if (change.memoryRoutine !== undefined) applyMemoryRoutine(change.memoryRoutine, deps);
-  saveSessionSettings(change, runner, setup.agents);
   ensureClaudeSetup(setup);
 }
 
-export async function setupAnswer(req: IncomingMessage, deps: SetupApiDeps, session: ApiSession): Promise<unknown> {
+export async function setupAnswer(req: IncomingMessage, deps: SetupApiDeps): Promise<unknown> {
   const setup = deps.setup ?? {};
   const method = req.method ?? 'GET';
   if (method === 'GET') return claudeSetupStatus(setup);
   if (method !== 'POST') throw new ApiError('method not allowed', 405);
   const change = setupChange(await readJsonBody(req, SETUP_BODY_MAX));
-  await withSessionChange(() => applySetupChange(change, session, deps, req));
+  applySetupChange(change, deps);
   return claudeSetupStatus(setup);
 }

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

@@ -11,8 +11,6 @@ import { claudeDir } from './files.js';
 import { memoryJobStatus, type MemoryJob } from './memory-routine.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';
 
 export const PRIVACY_ENV: Record<string, string> = {
@@ -69,9 +67,6 @@ export interface SetupReport {
 export interface SetupStatus {
   privacy: boolean;
   permissionMode: PermissionMode;
-  runner: HarnessRunner;
-  runnerAllowed: boolean;
-  sdkOnLogin: boolean;
   systemPrompt: string;
   liveEvents: boolean;
   memoryRoutine: boolean;
@@ -218,16 +213,23 @@ interface SettingsApplied {
   guard: boolean;
 }
 
-function applySettings(dir: string, privacy: boolean, hooks: string | null): SettingsApplied {
+const MODELS_KEYS = new Set(['availableModels', 'enforceAvailableModels']);
+
+const withoutMetroModels = (settings: Record<string, unknown>, metroWrote: boolean): Record<string, unknown> =>
+  metroWrote ? Object.fromEntries(Object.entries(settings).filter(([key]) => !MODELS_KEYS.has(key))) : settings;
+
+function applySettings(dir: string, agents: string, privacy: boolean, hooks: string | null): SettingsApplied {
+  const metroModels = readSetupState(agents).modelsByMetro === true;
   let guard = false;
   const settings = mergeSettings(dir, (current) => {
-    const next = withPrivacy(current, privacy);
+    const next = withPrivacy(withoutMetroModels(current, metroModels), 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;
   });
+  if (metroModels && settings !== 'unreadable') writeSetupState(agents, { modelsByMetro: false });
   return { settings, guard };
 }
 
@@ -280,9 +282,8 @@ export function ensureClaudeSetup(deps: SetupDeps = {}): SetupReport {
   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 applied = applySettings(dir, agents, 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 and metro hooks were not written');
@@ -299,9 +300,6 @@ export function claudeSetupStatus(deps: SetupDeps = {}): SetupStatus {
   return {
     privacy: privacyEnabled(agents),
     permissionMode: permissionMode(agents),
-    runner: harnessRunner(agents),
-    runnerAllowed: sdkAllowed(agents),
-    sdkOnLogin: sdkOnLogin(agents),
     systemPrompt: systemPrompt(agents),
     liveEvents: liveEvents(agents),
     memoryRoutine: memoryRoutine(agents),
@@ -323,33 +321,3 @@ export function tryClaudeSetup(deps: SetupDeps = {}): void {
     log.warn({ err: errMsg(err) }, 'claude-setup: could not apply the Claude Code setup');
   }
 }
-
-const MODELS_KEY = 'availableModels';
-const ENFORCE_KEY = 'enforceAvailableModels';
-
-export const routeOf = (cfg: ModelConfig): string | null => (routedConnection(cfg)?.provider === 'anthropic' ? null : runnerModel(cfg));
-
-function withAvailableModels(settings: Record<string, unknown>, route: string | null, metroWrote: boolean): Record<string, unknown> {
-  if (route !== null) return { ...settings, [MODELS_KEY]: [route], [ENFORCE_KEY]: true };
-  if (!metroWrote) return settings;
-  return Object.fromEntries(Object.entries(settings).filter(([key]) => key !== MODELS_KEY && key !== ENFORCE_KEY));
-}
-
-export function syncAvailableModels(cfg: ModelConfig, deps: SetupDeps = {}): SettingsOutcome {
-  const dir = deps.dir ?? claudeDir();
-  const agents = deps.agents ?? agentsDir();
-  const route = routeOf(cfg);
-  const metroWrote = readSetupState(agents).modelsByMetro === true;
-  return mergeSettings(dir, (current) => {
-    writeSetupState(agents, { modelsByMetro: route !== null });
-    return withAvailableModels(current, route, metroWrote);
-  });
-}
-
-export function syncAvailableModelsQuietly(deps: SetupDeps = {}, cfg?: ModelConfig): void {
-  try {
-    syncAvailableModels(cfg ?? readModelConfig(deps.agents ?? agentsDir()), deps);
-  } catch (err) {
-    log.warn({ err: errMsg(err) }, 'claude-setup: could not sync the model allowlist');
-  }
-}

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

@@ -1,7 +1,7 @@
 import { spawn } from 'node:child_process';
 import { isRecord } from '@metro-labs/core/is-record';
 import { errMsg, log } from '@metro-labs/core/log';
-import { agentCommand, agentUser, agentUserExpected, claudeBin } from '../agent-user/user.js';
+import { agentCommand, agentUser, agentUserExpected, CLAUDE_ENV, claudeBin } from '../agent-user/user.js';
 import { runningAsRoot } from '../metro-user/privilege.js';
 import { PRIVACY_ENV } from './setup.js';
 
@@ -24,7 +24,7 @@ const ARGS = [
 const BLOCKS_USAGE = 'CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC';
 const PROBE_ENV: Record<string, string> = {
   ...Object.fromEntries(Object.entries(PRIVACY_ENV).filter(([name]) => name !== BLOCKS_USAGE)),
-  DISABLE_AUTOUPDATER: '1',
+  ...CLAUDE_ENV,
   DISABLE_BUG_COMMAND: '1',
   ENABLE_CLAUDEAI_MCP_SERVERS: 'false',
 };

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/gateway/forward.ts

@@ -28,7 +28,6 @@ const HOP_BY_HOP = new Set([
   'upgrade',
   'accept-encoding',
   'x-metro-key',
-  'x-metro-runner',
 ]);
 const RESPONSE_DROP = new Set(['content-length', 'content-encoding', 'transfer-encoding', 'connection', 'keep-alive']);
 

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

@@ -2,7 +2,6 @@ import type { IncomingHttpHeaders, IncomingMessage, ServerResponse } from 'node:
 import { errMsg, log } from '@metro-labs/core/log';
 import { cameThroughProxy } from '@metro-labs/http/api-http';
 import { agentIdForKey } from '../agents/keys.js';
-import { sdkAllowed, sdkConnectionAllowed, SDK_NEEDS_KEY } from '../claude/runner.js';
 import {
   assertBedrockReady,
   bedrockBase,
@@ -98,11 +97,6 @@ const keyOf = (req: IncomingMessage): string => {
   return (Array.isArray(raw) ? raw[0] : raw)?.trim() ?? '';
 };
 
-const fromSdkRunner = (req: IncomingMessage): boolean => {
-  const raw = req.headers['x-metro-runner'];
-  return (Array.isArray(raw) ? raw[0] : raw)?.trim() === 'sdk';
-};
-
 const defaultIdentify = (key: string): boolean => key !== '' && agentIdForKey(key) !== undefined;
 
 function modelsBody(cfg: ModelConfig): Record<string, unknown> {
@@ -299,15 +293,9 @@ interface Request {
   cfg: ModelConfig;
 }
 
-function checkSdkRoute(req: IncomingMessage, route: Route, deps: GatewayDeps): void {
-  if (fromSdkRunner(req) && (!sdkAllowed(undefined, deps.config()) || !sdkConnectionAllowed(route.connection)))
-    throw new GatewayError(403, 'permission_error', SDK_NEEDS_KEY);
-}
-
 async function attempt(req: IncomingMessage, res: ServerResponse, ask: Request, route: Route, deps: GatewayDeps): Promise<void> {
   const { path, body } = ask;
   const conn = route.connection;
-  checkSdkRoute(req, route, deps);
   log.info({ route: routeLabel(route), connection: conn.label, path }, 'gateway: routing');
   if (path === MESSAGES) noteServed({ connection: conn.id, provider: conn.provider, model: route.model, at: new Date().toISOString() });
   if (conn.provider === 'bedrock') {
@@ -391,6 +379,6 @@ export function handleGatewayRequest(req: IncomingMessage, res: ServerResponse,
   }
   if (cameThroughProxy(req)) sendError(res, 401, 'authentication_error', 'metro gateway: the agent key works only on this machine, not through its public address');
   else if ((deps.identify ?? defaultIdentify)(keyOf(req))) answer(req, res, path, deps);
-  else sendError(res, 401, 'authentication_error', 'metro gateway: no agent key (x-metro-key); start Claude Code with metro claude');
+  else sendError(res, 401, 'authentication_error', 'metro gateway: no agent key (x-metro-key); start the agent with metro agent');
   return true;
 }

package/runtime/node_modules/@metro-labs/daemon/src/gateway/model-api.ts

@@ -5,9 +5,7 @@ import { isRecord } from '@metro-labs/core/is-record';
 import { log } from '@metro-labs/core/log';
 import { openrouterModels, openrouterZdrModels } from './openrouter.js';
 import { anthropicModels, bedrockModels } from './provider-models.js';
-import { routeOf, syncAvailableModelsQuietly } from '../claude/setup.js';
-import { harnessRunner, runnerModel, sdkAllowed } from '../claude/runner.js';
-import { sessionLive, sessionRunning, stopSession } from '../claude/session.js';
+import { runnerAlive } from '../claude/session.js';
 import { forgetOne, forgetReported } from './usage.js';
 import {
   addConnection,
@@ -16,6 +14,7 @@ import {
   readModelConfig,
   readModelSnapshot,
   removeConnection,
+  routedConnection,
   setFallbacks,
   setRoute,
   updateConnection,
@@ -45,40 +44,29 @@ const DEVICE_ID_RE = /^[A-Za-z0-9_-]{16,64}$/;
 
 export type { ModelApiDeps } from './model-store.js';
 
-function restartRunningSession(): boolean {
-  if (!sessionRunning()) return false;
-  stopSession();
-  return true;
+function runnerModel(cfg: ModelConfig): string | null {
+  const conn = routedConnection(cfg);
+  if (conn === null || conn.model === '') return null;
+  return conn.provider === 'anthropic' ? conn.model : `${conn.provider}:${conn.model}`;
 }
 
 function switchLive(before: ModelConfig, next: ModelConfig, deps: ModelApiDeps): void {
   const [was, now] = [runnerModel(before), runnerModel(next)];
   if (was === now) return;
   if (deps.switchModel?.(now) === true) log.info({ was, now }, 'model-api: the model changed, so the Agent SDK session switches to it live, with no restart');
-  else if (runnerIsLive(deps)) throw new ApiError('The running Agent SDK could not be told about this model change. Nothing was saved. Let its work finish, stop it, then save and start it again.', 409);
-}
-
-function followModel(before: ModelConfig, next: ModelConfig, deps: ModelApiDeps): void {
-  const restart = deps.restartSession ?? restartRunningSession;
-  const agents = deps.setup?.agents;
-  if (harnessRunner(agents) === 'sdk') {
-    if (sdkAllowed(agents, next)) switchLive(before, next, deps);
-    return;
-  }
-  if (routeOf(next) !== routeOf(before) && restart())
-    log.info({ was: routeOf(before), now: routeOf(next) }, 'model-api: the model changed, so the Claude session restarts on it');
+  else if (runnerIsUp(deps)) throw new ApiError('The running Agent SDK could not be told about this model change. Nothing was saved. Let its work finish, stop it, then save and start it again.', 409);
+  else log.info({ was, now }, 'model-api: the model changed while no Agent SDK runner is up; its next start loads it');
 }
 
 function kept(store: Store, next: ModelConfig, deps: ModelApiDeps, note: string, fields: Record<string, unknown>): unknown {
   const before = store.read();
   store.write(next);
   try {
-    followModel(before, next, deps);
+    switchLive(before, next, deps);
   } catch (err) {
     store.write(before);
     throw err;
   }
-  syncAvailableModelsQuietly(deps.setup ?? {}, next);
   log.info(fields, note);
   return settingsBody(next);
 }
@@ -218,14 +206,12 @@ function routeFor(path: string, method: string | undefined): Route | number {
   return codexRoute(path.slice(CODEX.length), method);
 }
 
-const runnerIsLive = (deps: ModelApiDeps): boolean => (deps.sessionRunning ?? (() => sessionLive({ agents: deps.setup?.agents })))();
+const runnerIsUp = (deps: ModelApiDeps): boolean => (deps.runnerAlive ?? (() => runnerAlive()))();
 
-function checkRunnerRoute(before: ModelConfig, next: ModelConfig, deps: ModelApiDeps): void {
-  const agents = deps.setup?.agents;
-  if (harnessRunner(agents) !== 'sdk' || !sdkAllowed(agents, before) || sdkAllowed(agents, next)) return;
-  if (runnerIsLive(deps))
-    throw new ApiError('The Agent SDK session is running, and this change would leave a model or fallback it may not use. Let it finish its work, stop it, then save the change.', 409);
-}
+const storeFor = (path: string, deps: ModelApiDeps): Store => ({
+  read: deps.read ?? (path === SNAPSHOT ? readModelSnapshot : readModelConfig),
+  write: deps.write ?? writeModelConfig,
+});
 
 export function handleModelRequest(req: IncomingMessage, res: ServerResponse, deps: ModelApiDeps): boolean {
   const path = (req.url ?? '').split('?')[0] ?? '';
@@ -234,13 +220,7 @@ export function handleModelRequest(req: IncomingMessage, res: ServerResponse, de
     res.writeHead(204, cors(req)).end();
     return true;
   }
-  const store: Store = {
-    read: deps.read ?? (path === SNAPSHOT ? readModelSnapshot : readModelConfig),
-    write: (cfg) => {
-      checkRunnerRoute(store.read(), cfg, deps);
-      (deps.write ?? writeModelConfig)(cfg);
-    },
-  };
+  const store = storeFor(path, deps);
   if (handleOpenRouterSignIn(req, res, deps, store)) return true;
   const route = routeFor(path, req.method);
   if (typeof route === 'number') {

package/runtime/node_modules/@metro-labs/daemon/src/gateway/model-store.ts

@@ -27,8 +27,7 @@ export interface ModelApiDeps {
   anthropicBase?: string;
   bedrockControlBase?: string;
   setup?: SetupDeps;
-  restartSession?: () => boolean;
-  sessionRunning?: () => boolean;
+  runnerAlive?: () => boolean;
   switchModel?: (model: string | null) => boolean;
   claudeUsage?: (env?: Record<string, string>) => Promise<unknown>;
   claudeLoginsRoot?: string;

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

@@ -2,7 +2,6 @@ import type { IncomingMessage, ServerResponse } from 'node:http';
 import {
   BodyTooLargeError,
   readBody as readBodyBuffer,
-  VOICE_MCP_PATH,
 } from '../routes/http.js';
 import {
   authenticate,
@@ -97,9 +96,7 @@ async function serveGet(
   if (served) session.replayMissed();
 }
 
-const isVoicePath = (req: IncomingMessage): boolean => (req.url ?? '').split('?')[0] === VOICE_MCP_PATH;
-
-let activeSlots: SessionSlot[] = [];
+let activeSlot: SessionSlot | undefined;
 let stopToolNotices: (() => void) | undefined;
 
 const MODEL_NOTICE = 'notifications/metro/model';
@@ -118,13 +115,12 @@ export async function createMetroMcp(options: { liveEvents?: boolean } = {}): Pr
   setLiveEvents: (on: boolean) => void;
   switchModel: (model: string | null) => boolean;
 }> {
-  await Promise.all(activeSlots.map((s) => s.close()));
+  await activeSlot?.close();
   const slot = new SessionSlot(options.liveEvents);
-  const voiceSlot = new SessionSlot(false, 'voice');
-  activeSlots = [slot, voiceSlot];
+  activeSlot = slot;
   stopToolNotices?.();
   stopToolNotices = onConnectorToolsChanged(() => {
-    for (const each of [slot, voiceSlot]) each.current?.toolsChanged();
+    slot.current?.toolsChanged();
   });
   connectCallBridge(() => slot.current);
   connectServerApprovals(() => slot.current);
@@ -142,13 +138,7 @@ export async function createMetroMcp(options: { liveEvents?: boolean } = {}): Pr
     const parsed = await readOrReject(req, res);
     if (!parsed.ok) return;
     await runWithIdentity(identity, async () => {
-      const session = await resolveSession(
-        isVoicePath(req) ? voiceSlot : slot,
-        req,
-        parsed.body,
-        identity,
-        res,
-      );
+      const session = await resolveSession(slot, req, parsed.body, identity, res);
       if (!session) return;
       if (isStandaloneGet(req)) {
         await serveGet(session, req, res);

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

@@ -19,14 +19,3 @@ export const MCP_INSTRUCTIONS =
   '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 " +
-  'answer them with `send` or `reply` and do not post the call in a chat; post, react or act on ' +
-  'a channel only when the caller asks for it, once. `read` with a `line` (passed verbatim) ' +
-  'shows that chat; `group_info` and `list_members` show who is in it; `get_profile` with a ' +
-  '`from` names a sender. The owner may block a tool on an account or make 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 talking; the worker waits while the owner is asked in the chat of the call, where ' +
-  'they answer "yes <id>"/"no <id>". Connectors are reached through `tool_search` then `tool_call`.';

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

@@ -2,7 +2,7 @@ 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 { McpSession, channelLog } from './session.js';
 import { allowedAgents, type RequestIdentity } from './request-identity.js';
 import { diagnosticTag, type SessionDiagnostic, type SlotDiagnostic } from './diagnostics.js';
 
@@ -25,10 +25,7 @@ export class SessionSlot {
   private changing: Promise<void> = Promise.resolve();
   private readonly replacements: SlotReplacement[] = [];
 
-  constructor(
-    live = true,
-    private readonly kind: SessionKind = 'chat',
-  ) {
+  constructor(live = true) {
     this.live = live;
   }
 
@@ -111,7 +108,6 @@ export class SessionSlot {
     if (this.ledger.startAt < 0) this.ledger.startAt = currentBusSeq();
     const id = adoptId ?? randomUUID();
     const session = await McpSession.open({
-      kind: this.kind,
       id,
       scope: allowedAgents(identity),
       adopted: adoptId !== undefined,
@@ -129,7 +125,7 @@ export class SessionSlot {
     this.session = session;
     this.recordReplacement(session, adoptId, previous);
     if (this.started && this.live) session.startChannel();
-    channelLog('session: opened', 'id', id, 'kind', this.kind, 'adopted', adoptId !== undefined);
+    channelLog('session: opened', 'id', id, 'adopted', adoptId !== undefined);
     return session;
   }