@stage-labs/metro 0.1.0-beta.259 → 0.1.0-beta.260

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

@@ -0,0 +1,161 @@
+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 {
+  claudeSetupStatus,
+  ensureClaudeSetup,
+  isPermissionMode,
+  liveEvents,
+  permissionMode,
+  setLiveEvents,
+  setMemoryRoutine,
+  setPermissionMode,
+  setPrivacy,
+  setSystemPrompt,
+  systemPrompt,
+  SYSTEM_PROMPT_MAX,
+  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 { 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;
+  setup?: SetupDeps;
+  liveEvents?: (on: boolean) => void;
+  memoryJob?: (on: boolean) => void;
+}
+
+interface SetupChange {
+  privacy?: boolean;
+  permissionMode?: PermissionMode;
+  runner?: HarnessRunner;
+  sdkOnLogin?: boolean;
+  systemPrompt?: string;
+  liveEvents?: boolean;
+  memoryRoutine?: boolean;
+}
+
+function promptChange(raw: unknown): string | undefined {
+  if (raw === undefined) return undefined;
+  if (typeof raw !== 'string') throw new ApiError('systemPrompt must be text', 400);
+  if (Buffer.byteLength(raw) > SYSTEM_PROMPT_MAX) throw new ApiError(`systemPrompt must be under ${String(SYSTEM_PROMPT_MAX / 1024)} KiB`, 400);
+  return raw;
+}
+
+function flagChange(raw: unknown, name: string): boolean | undefined {
+  if (raw === undefined) return undefined;
+  if (typeof raw !== 'boolean') throw new ApiError(`${name} must be true or false`, 400);
+  return raw;
+}
+
+function modeChange(raw: unknown): PermissionMode | undefined {
+  if (raw === undefined) return undefined;
+  if (!isPermissionMode(raw)) throw new ApiError('permissionMode must be auto or bypass', 400);
+  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'),
+  };
+  const given = Object.fromEntries(Object.entries(change).filter(([, value]) => value !== undefined)) as SetupChange;
+  if (Object.keys(given).length === 0) throw new ApiError('nothing to change', 400);
+  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))
+    || (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);
+  deps.liveEvents?.(on);
+}
+
+function applyMemoryRoutine(on: boolean, deps: SetupApiDeps): void {
+  setMemoryRoutine(on, deps.setup?.agents);
+  (deps.memoryJob ?? tryMemoryJob)(on);
+}
+
+async function applySetupChange(change: SetupChange, session: ApiSession, deps: SetupApiDeps, req: IncomingMessage): Promise<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);
+  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> {
+  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));
+  return claudeSetupStatus(setup);
+}

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

@@ -0,0 +1,18 @@
+import { mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { isRecord } from '@metro-labs/core/is-record';
+import { readJson, writeJson } from '@metro-labs/core/secure-fs';
+
+const STATE_FILE = 'claude-setup.json';
+
+const statePath = (agents: string): string => join(agents, STATE_FILE);
+
+export function readSetupState(agents: string): Record<string, unknown> {
+  const raw = readJson<unknown>(statePath(agents), null);
+  return isRecord(raw) ? raw : {};
+}
+
+export function writeSetupState(agents: string, patch: Record<string, unknown>): void {
+  mkdirSync(agents, { recursive: true });
+  writeJson(statePath(agents), { ...readSetupState(agents), ...patch });
+}

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

@@ -1,17 +1,19 @@
 import { createHash } from 'node:crypto';
-import { mkdirSync, rmSync } from 'node:fs';
+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 { readJson, writeAtomic, writeJson } from '@metro-labs/core/secure-fs';
+import { writeAtomic } from '@metro-labs/core/secure-fs';
 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 { 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> = {
   DISABLE_TELEMETRY: '1',
@@ -20,7 +22,6 @@ export const PRIVACY_ENV: Record<string, string> = {
   CLAUDE_CODE_GB_DISK_CACHE_WHEN_TELEMETRY_OFF: '1',
 };
 export const RETENTION_DAYS = 7;
-const STATE_FILE = 'claude-setup.json';
 const RULES_FILE = 'METRO.md';
 const RULES_SKILL = 'metro';
 const RENAMED_SKILL = 'metro-orchestrator';
@@ -68,6 +69,9 @@ export interface SetupReport {
 export interface SetupStatus {
   privacy: boolean;
   permissionMode: PermissionMode;
+  runner: HarnessRunner;
+  runnerAllowed: boolean;
+  sdkOnLogin: boolean;
   systemPrompt: string;
   liveEvents: boolean;
   memoryRoutine: boolean;
@@ -81,48 +85,36 @@ export interface SetupStatus {
   retentionDays: number | null;
 }
 
-const statePath = (agents: string): string => join(agents, STATE_FILE);
-
 const PERMISSION_MODES = ['auto', 'bypass'] as const;
 export type PermissionMode = (typeof PERMISSION_MODES)[number];
 
-function readState(agents: string): Record<string, unknown> {
-  const raw = readJson<unknown>(statePath(agents), null);
-  return isRecord(raw) ? raw : {};
-}
-
-function writeState(agents: string, patch: Record<string, unknown>): void {
-  mkdirSync(agents, { recursive: true });
-  writeJson(statePath(agents), { ...readState(agents), ...patch });
-}
-
-const privacyEnabled = (agents = agentsDir()): boolean => readState(agents).privacy !== false;
+const privacyEnabled = (agents = agentsDir()): boolean => readSetupState(agents).privacy !== false;
 
 export function setPrivacy(enabled: boolean, agents = agentsDir()): void {
-  writeState(agents, { privacy: enabled });
+  writeSetupState(agents, { privacy: enabled });
 }
 
 export const isPermissionMode = (value: unknown): value is PermissionMode => PERMISSION_MODES.some((m) => m === value);
 
 export function permissionMode(agents = agentsDir()): PermissionMode {
-  const mode = readState(agents).permissionMode;
+  const mode = readSetupState(agents).permissionMode;
   return isPermissionMode(mode) ? mode : 'auto';
 }
 
 export function setPermissionMode(mode: PermissionMode, agents = agentsDir()): void {
-  writeState(agents, { permissionMode: mode });
+  writeSetupState(agents, { permissionMode: mode });
 }
 
-export const liveEvents = (agents = agentsDir()): boolean => readState(agents).liveEvents !== false;
+export const liveEvents = (agents = agentsDir()): boolean => readSetupState(agents).liveEvents !== false;
 
 export function setLiveEvents(on: boolean, agents = agentsDir()): void {
-  writeState(agents, { liveEvents: on });
+  writeSetupState(agents, { liveEvents: on });
 }
 
-export const memoryRoutine = (agents = agentsDir()): boolean => readState(agents).memoryRoutine !== false;
+export const memoryRoutine = (agents = agentsDir()): boolean => readSetupState(agents).memoryRoutine !== false;
 
 export function setMemoryRoutine(on: boolean, agents = agentsDir()): void {
-  writeState(agents, { memoryRoutine: on });
+  writeSetupState(agents, { memoryRoutine: on });
 }
 
 const promptPath = (agents: string): string => join(agents, SYSTEM_PROMPT_FILE);
@@ -295,6 +287,9 @@ 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),
@@ -320,11 +315,7 @@ export function tryClaudeSetup(deps: SetupDeps = {}): void {
 const MODELS_KEY = 'availableModels';
 const ENFORCE_KEY = 'enforceAvailableModels';
 
-export function routeOf(cfg: ModelConfig): string | null {
-  const conn = routedConnection(cfg);
-  if (conn === null || conn.provider === 'anthropic' || conn.model === '') return null;
-  return `${conn.provider}:${conn.model}`;
-}
+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 };
@@ -336,11 +327,9 @@ export function syncAvailableModels(cfg: ModelConfig, deps: SetupDeps = {}): Set
   const dir = deps.dir ?? claudeDir();
   const agents = deps.agents ?? agentsDir();
   const route = routeOf(cfg);
-  const state = readJson<unknown>(statePath(agents), null);
-  const metroWrote = isRecord(state) && state.modelsByMetro === true;
+  const metroWrote = readSetupState(agents).modelsByMetro === true;
   return mergeSettings(dir, (current) => {
-    mkdirSync(agents, { recursive: true });
-    writeJson(statePath(agents), { ...(isRecord(state) ? state : {}), modelsByMetro: route !== null });
+    writeSetupState(agents, { modelsByMetro: route !== null });
     return withAvailableModels(current, route, metroWrote);
   });
 }

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

@@ -28,6 +28,7 @@ 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,6 +2,7 @@ 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,
@@ -97,6 +98,11 @@ 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> {
@@ -293,9 +299,15 @@ 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') {

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

@@ -6,7 +6,8 @@ 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 { sessionRunning, stopSession } from '../claude/session.js';
+import { harnessRunner, runnerModel, sdkAllowed } from '../claude/runner.js';
+import { sessionLive, sessionRunning, stopSession } from '../claude/session.js';
 import { forgetOne, forgetReported } from './usage.js';
 import {
   addConnection,
@@ -47,13 +48,35 @@ function restartRunningSession(): boolean {
   return true;
 }
 
+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');
+}
+
 function kept(store: Store, next: ModelConfig, deps: ModelApiDeps, note: string, fields: Record<string, unknown>): unknown {
-  const before = routeOf(store.read());
+  const before = store.read();
   store.write(next);
+  try {
+    followModel(before, next, deps);
+  } catch (err) {
+    store.write(before);
+    throw err;
+  }
   syncAvailableModelsQuietly(deps.setup ?? {}, next);
   log.info(fields, note);
-  if (routeOf(next) !== before && (deps.restartSession ?? restartRunningSession)())
-    log.info({ was: before, now: routeOf(next) }, 'model-api: the model changed, so the Claude session restarts on it');
   return settingsBody(next);
 }
 
@@ -191,6 +214,15 @@ 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 })))();
+
+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);
+}
+
 export function handleModelRequest(req: IncomingMessage, res: ServerResponse, deps: ModelApiDeps): boolean {
   const path = (req.url ?? '').split('?')[0] ?? '';
   if (!mine(path)) return false;
@@ -203,7 +235,13 @@ export function handleModelRequest(req: IncomingMessage, res: ServerResponse, de
     sendJson(req, res, route, { error: route === 404 ? 'not found' : 'method not allowed' });
     return true;
   }
-  const store: Store = { read: deps.read ?? readModelConfig, write: deps.write ?? writeModelConfig };
+  const store: Store = {
+    read: deps.read ?? readModelConfig,
+    write: (cfg) => {
+      checkRunnerRoute(store.read(), cfg, deps);
+      (deps.write ?? writeModelConfig)(cfg);
+    },
+  };
   apiSession(req)
     .then(async (session) => {
       if (!session) throw new ApiError('unauthorized', 401);

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

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

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

@@ -14,6 +14,7 @@ import {
   isStandaloneGet,
   serveChannelGet,
 } from './raw-get-stream.js';
+import { errMsg } from '@metro-labs/core/log';
 import { channelLog, type McpSession } from './session.js';
 import { SessionSlot } from './session-slot.js';
 
@@ -95,10 +96,21 @@ const isVoicePath = (req: IncomingMessage): boolean => (req.url ?? '').split('?'
 
 let activeSlots: SessionSlot[] = [];
 
+const MODEL_NOTICE = 'notifications/metro/model';
+
+function noticeModel(session: McpSession | undefined, model: string | null): boolean {
+  if (session?.streamAttached !== true) return false;
+  session.server.notification({ method: MODEL_NOTICE, params: { model } }).catch((err: unknown) => {
+    channelLog('session: the model notice failed', errMsg(err));
+  });
+  return true;
+}
+
 export async function createMetroMcp(options: { liveEvents?: boolean } = {}): Promise<{
   httpHandler: (req: IncomingMessage, res: ServerResponse) => Promise<void>;
   startInbound: () => void;
   setLiveEvents: (on: boolean) => void;
+  switchModel: (model: string | null) => boolean;
 }> {
   await Promise.all(activeSlots.map((s) => s.close()));
   const slot = new SessionSlot(options.liveEvents);
@@ -146,5 +158,7 @@ export async function createMetroMcp(options: { liveEvents?: boolean } = {}): Pr
     slot.setLive(on);
   };
 
-  return { httpHandler, startInbound, setLiveEvents };
+  const switchModel = (model: string | null): boolean => noticeModel(slot.current, model);
+
+  return { httpHandler, startInbound, setLiveEvents, switchModel };
 }

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

@@ -6,6 +6,9 @@ import { bearerSession, clientId, jwksUrl, SigningKeys, workosBase, type KeyStor
 import { ensureSecureDir, writeSecure } from '@metro-labs/core/secure-fs';
 
 const KEYS_FILE = '.jwks';
+const OPERATOR_USER = 'user_01M2TN3K6NRVX675M617GR4WVE';
+
+export const isOperatorUser = (user: string): boolean => user === OPERATOR_USER;
 
 export function jwksStore(dir: string): KeyStore {
   const path = join(dir, KEYS_FILE);
@@ -25,7 +28,7 @@ export function bearerSessionsFor(owner: () => string | null, keys: SigningKeys)
     const held = owner();
     if (held === null || session.organization === null || session.organization !== held)
       throw new ApiError('this machine belongs to another organization', 403);
-    return { subject: held, role: session.role === 'admin' ? 'admin' : 'member' };
+    return { subject: held, role: session.role === 'admin' ? 'admin' : 'member', ...(isOperatorUser(session.userId) ? { operator: true as const } : {}) };
   };
 }
 

package/runtime/node_modules/@metro-labs/daemon/src/routes/local-mode.ts

@@ -58,6 +58,7 @@ export interface LocalModeDeps {
   toolGroups?: AgentApiDeps['toolGroups'];
   prepareAccount: AccountApiDeps['prepareAccount'];
   liveEvents?: (on: boolean) => void;
+  switchModel?: (model: string | null) => boolean;
 }
 
 function attachSessions(deps: LocalModeDeps): AttachSessions {
@@ -201,7 +202,7 @@ export function localSessionApis(deps: LocalModeDeps): SessionApis {
     controlApi: { restart: deps.restart, stop: deps.stop },
     ownerApi: { setOwner: (owner) => setLocalOwner(owner) },
     machineApi: {},
-    modelApi: {},
+    modelApi: { switchModel: deps.switchModel },
     gateway: { config: readModelConfig },
     terminalApi: {},
     mode: localModeInfo,

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

@@ -1,14 +1,9 @@
-import { randomInt } from 'node:crypto';
+import { approvalId } from '@metro-labs/core/ids';
 import { errMsg, log } from '@metro-labs/core/log';
 import { forgetPromptsOf, holdPrompt, type Behavior } from '../approvals/pending.js';
 import { promptBody } from '../mcp/permission-prompt.js';
 import type { ToolAsk } from './brain.js';
 
-const ID_LETTERS = 'abcdefghijkmnopqrstuvwxyz';
-const ID_LENGTH = 5;
-
-export const approvalId = (): string => Array.from({ length: ID_LENGTH }, () => ID_LETTERS[randomInt(ID_LETTERS.length)]).join('');
-
 export class CallApprovals {
   private closed = false;
 

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

@@ -9,6 +9,7 @@ export type Role = 'admin' | 'member';
 export interface ApiSession {
   subject: string;
   role: Role;
+  operator?: true;
 }
 
 export type BearerSessions = (req: IncomingMessage) => Promise<ApiSession | null>;

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.259"
+  "version": "0.1.0-beta.260"
 }

package/runtime/sdk-runner/node_modules/@metro-labs/core/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@metro-labs/core",
+  "version": "0.1.0",
+  "private": true,
+  "description": "What every metro process shares: the logger, the event bus and its types, ids, secure file writes, the train protocol, station types and attachment handling. No HTTP, no policy.",
+  "type": "module",
+  "exports": {
+    "./log": "./src/log.ts",
+    "./events": "./src/events.ts",
+    "./is-record": "./src/is-record.ts",
+    "./runner-activity": "./src/runner-activity.ts",
+    "./secure-fs": "./src/secure-fs.ts",
+    "./version": "./src/version.ts",
+    "./train-error": "./src/train-error.ts",
+    "./trains/protocol": "./src/protocol.ts",
+    "./ids": "./src/ids.ts",
+    "./tickets": "./src/tickets.ts",
+    "./station-names": "./src/station-names.ts",
+    "./str": "./src/str.ts",
+    "./lines": "./src/lines.ts",
+    "./endpoints": "./src/endpoints.ts",
+    "./stations/types": "./src/stations/types.ts",
+    "./stations/account-files": "./src/stations/account-files.ts",
+    "./stations/station-runtime": "./src/stations/station-runtime.ts",
+    "./stations/account-store": "./src/stations/account-store.ts",
+    "./stations/attachments": "./src/stations/attachments.ts",
+    "./stations/mail": "./src/stations/mail.ts",
+    "./stations/mail-text": "./src/stations/mail-text.ts",
+    "./stations/mail-trust": "./src/stations/mail-trust.ts",
+    "./stations/oauth": "./src/stations/oauth.ts",
+    "./stations/messaging-normalize": "./src/stations/messaging-normalize.ts",
+    "./stations/profile": "./src/stations/profile.ts",
+    "./stations/sender-profile": "./src/stations/sender-profile.ts",
+    "./stations/train-events": "./src/stations/train-events.ts",
+    "./stations/train-boot": "./src/stations/train-boot.ts"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "tsc --noEmit && METRO_STATE_DIR=\"$(mktemp -d /tmp/metro-test.XXXXXX)\" bun test test/"
+  },
+  "dependencies": {
+    "pino": "^9.5.0",
+    "pino-pretty": "^13.1.3"
+  },
+  "devDependencies": {
+    "@stage-labs/config": "0.1.0-beta.3",
+    "eslint": "^10.3.0",
+    "knip": "^6.15.0",
+    "madge": "^8.0.0",
+    "typescript": "^5"
+  }
+}

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

@@ -0,0 +1,7 @@
+export interface Endpoint {
+  id: string;
+  webhookId?: string;
+  label: string;
+  secret?: string;
+  createdAt: string;
+}