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

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

@@ -1,20 +1,15 @@
 import { randomUUID } from 'node:crypto';
 import type { CallRoute } from '@metro-labs/core/call';
 import { errMsg, log } from '@metro-labs/core/log';
-import { isRecord } from '@metro-labs/core/is-record';
 import { forwardTrainCall } from '../stations/train-call.js';
-import { CallApprovals } from './approvals.js';
 import type { Playback } from './audio.js';
 import { Peer, type PeerEvents } from './peer.js';
 import { SharedTalk } from './shared-talk.js';
-import { endSharedCall, hearSharedCall, openSharedCall, sharedCallsSelected, type SharedCallTransport } from './shared.js';
-import { Talk } from './talk.js';
+import { endSharedCall, hearSharedCall, openSharedCall, type SharedCallTransport } from './shared.js';
 import type { VoiceConfig } from './store.js';
 
 const OFFER_WAIT_MS = 45_000;
 const LONGEST_CALL_MS = 60 * 60_000;
-const CONTEXT_MESSAGES = 12;
-const CONTEXT_CHARS = 400;
 const LEAVE_RETRY_MS = 3_000;
 const SIGNAL_WAIT_MS = 2_000;
 
@@ -22,24 +17,18 @@ export interface CallStart {
   agentId: string;
   sourceId: string;
   line: string;
-  lineName: string;
-  direct: boolean;
   from: string;
-  callerName: string;
   callId: string;
   callerPeer: string;
 }
 
-type CallAudio = Pick<Talk, 'connect' | 'hear' | 'finish'>;
+type CallAudio = Pick<SharedTalk, 'connect' | 'hear' | 'finish'> & SharedCallTransport;
 type CallPeer = Pick<Peer, 'answer' | 'sendOpus' | 'close'>;
-type ContextStart = Omit<CallStart, 'agentId' | 'sourceId'>;
 
 export interface CallDependencies {
   train: typeof trainCall;
   peer(events: PeerEvents): CallPeer;
-  cli(cfg: VoiceConfig, out: Playback['send'], ended: (reason: string) => void, approvals: CallApprovals): CallAudio & Pick<Talk, 'prime'>;
-  shared(cfg: VoiceConfig, out: Playback['send'], ended: (reason: string) => void, heard: (text: string, sourceId: string) => void): CallAudio & SharedCallTransport;
-  selected: typeof sharedCallsSelected;
+  shared(cfg: VoiceConfig, out: Playback['send'], ended: (reason: string) => void, heard: (text: string, sourceId: string) => void): CallAudio;
   open: typeof openSharedCall;
   heard: typeof hearSharedCall;
   ended: typeof endSharedCall;
@@ -47,8 +36,6 @@ export interface CallDependencies {
   leaveRetryMs: number;
 }
 
-const str = (value: unknown): string => (typeof value === 'string' ? value : '');
-
 export async function trainCall(action: string, args: Record<string, unknown>): Promise<unknown> {
   const answer = await forwardTrainCall('xmtp', action, args);
   if (answer.error !== undefined) throw new Error(answer.error);
@@ -58,9 +45,7 @@ export async function trainCall(action: string, args: Record<string, unknown>):
 const dependencies: CallDependencies = {
   train: trainCall,
   peer: (events) => new Peer(events),
-  cli: (cfg, out, ended, approvals) => new Talk(cfg, out, ended, approvals),
   shared: (cfg, out, ended, heard) => new SharedTalk(cfg, out, ended, heard),
-  selected: sharedCallsSelected,
   open: openSharedCall,
   heard: hearSharedCall,
   ended: endSharedCall,
@@ -68,51 +53,11 @@ const dependencies: CallDependencies = {
   leaveRetryMs: LEAVE_RETRY_MS,
 };
 
-function speaker(row: Record<string, unknown>, start: ContextStart): string {
-  if (row.self === true) return 'you';
-  return row.from === start.from ? start.callerName : `another member (${str(row.from)})`;
-}
-
-function contextLine(row: unknown, start: ContextStart): string | null {
-  if (!isRecord(row) || typeof row.text !== 'string' || row.text.startsWith('[call')) return null;
-  const who = speaker(row, start);
-  return `${str(row.ts).slice(11, 16)} ${who}: ${row.text.replace(/\s+/g, ' ').slice(0, CONTEXT_CHARS)}`;
-}
-
-async function recentChat(start: CallStart, train: typeof trainCall): Promise<string> {
-  try {
-    const result = await train('read', { line: start.line, limit: CONTEXT_MESSAGES });
-    const rows = isRecord(result) && Array.isArray(result.messages) ? result.messages : [];
-    return rows.map((row) => contextLine(row, start)).filter((l): l is string => l !== null).join('\n');
-  } catch (err) {
-    log.warn({ err: errMsg(err) }, 'voice: could not read the chat before the call');
-    return '';
-  }
-}
-
-function where(start: ContextStart): string {
-  if (start.lineName !== '') return `the group chat "${start.lineName}"`;
-  return start.direct ? `your direct chat with ${start.callerName}` : 'a group chat with no name';
-}
-
-export function opening(start: ContextStart, chat: string): string {
-  const recent = chat === '' ? 'No earlier messages were found there.' : `Recent messages there before the call, oldest first (times in UTC):\n${chat}`;
-  return [
-    `[A voice call with ${start.callerName} is starting on Stage, in ${where(start)}.`,
-    `Line of this chat: ${start.line} (pass it verbatim to the metro tools, e.g. read, to look at or act on this chat).`,
-    `Caller: ${start.callerName} (${start.from}).`,
-    recent,
-    `Greet ${start.callerName} in a few words.]`,
-  ].join('\n');
-}
-
 export class Call {
   readonly route: CallRoute;
   private readonly selfPeer = randomUUID();
   private readonly startedAt = Date.now();
   private readonly talk: CallAudio;
-  private readonly shared: SharedCallTransport | null;
-  private readonly prime: ((context: string) => void) | null;
   private readonly deps: CallDependencies;
   private peer: CallPeer | null = null;
   private timer: ReturnType<typeof setTimeout> | null = null;
@@ -136,24 +81,9 @@ export class Call {
     const ended = (reason: string): void => {
       this.hangUp(reason);
     };
-    if (this.deps.selected()) {
-      const shared = this.deps.shared(cfg, out, ended, (text, sourceId) => {
-        if (!this.over) this.deps.heard(this.route, text, sourceId);
-      });
-      this.talk = shared;
-      this.shared = shared;
-      this.prime = null;
-    } else {
-      const approvals = new CallApprovals(start.line, async (text) => {
-        await this.deps.train('send', { line: start.line, text });
-      });
-      const cli = this.deps.cli(cfg, out, ended, approvals);
-      this.talk = cli;
-      this.shared = null;
-      this.prime = (context) => {
-        cli.prime(context);
-      };
-    }
+    this.talk = this.deps.shared(cfg, out, ended, (text, sourceId) => {
+      if (!this.over) this.deps.heard(this.route, text, sourceId);
+    });
     this.longest = setTimeout(() => {
       this.hangUp('the call reached one hour');
     }, LONGEST_CALL_MS);
@@ -163,15 +93,7 @@ export class Call {
     if (this.over || this.begun) return;
     this.begun = true;
     log.info({ line: this.start.line, callId: this.start.callId }, 'voice: answering a call');
-    if (this.shared !== null) {
-      if (!this.deps.open(this.route, this.start.sourceId, this.shared)) throw new Error('the shared conversation is unavailable');
-    } else {
-      recentChat(this.start, this.deps.train).then((chat) => {
-        if (!this.over) this.prime?.(opening(this.start, chat));
-      }).catch((err: unknown) => {
-        log.warn({ err: errMsg(err) }, 'voice: could not start the agent on the call');
-      });
-    }
+    if (!this.deps.open(this.route, this.start.sourceId, this.talk)) throw new Error('the shared conversation is unavailable');
     await this.signal({ kind: 'join', callId: this.start.callId, from: this.selfPeer });
     if (this.over) {
       await this.sendLeave();
@@ -235,14 +157,9 @@ export class Call {
     log.info({ reason, seconds: Math.round((Date.now() - this.startedAt) / 1000) }, 'voice: call over');
     this.talk.finish();
     this.peer?.close();
-    if (this.shared !== null) this.deps.ended(this.route);
+    this.deps.ended(this.route);
     this.onOver();
-    this.left = this.sendLeave().then(async () => {
-      if (this.shared !== null || reason.startsWith('the caller') || reason === 'no offer arrived') return;
-      await this.deps.train('send', { line: this.start.line, text: `The voice call ended: ${reason}.` });
-    }).catch((err: unknown) => {
-      log.warn({ err: errMsg(err) }, 'voice: wrapping up the call failed');
-    });
+    this.left = this.sendLeave();
   }
 
   private async sendLeave(): Promise<void> {

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

@@ -26,7 +26,6 @@ const str = (value: unknown): string => (typeof value === 'string' ? value : '')
 
 const contentTypeOf = (env: TrainEvent): string => str(record(env.payload).contentType);
 const sourceIdOf = (env: TrainEvent): string => str(env.message_id) || str(env.id) || randomUUID();
-const callerNameOf = (env: TrainEvent): string => str(env.from_display_name) || str(env.from_name) || 'the caller';
 
 export const isCallEvent = (env: TrainEvent): boolean => CALL_TYPES.has(contentTypeOf(env));
 
@@ -74,9 +73,7 @@ function invite(env: TrainEvent, body: Record<string, unknown>, create: MakeCall
   invites.add(key);
   if (invites.size > INVITES_MAX) invites.delete(invites.values().next().value ?? '');
   current?.hangUp('the caller started a new call');
-  const callerName = callerNameOf(env);
-  const sourceId = sourceIdOf(env);
-  const start = { agentId, sourceId, line, lineName: str(env.line_name), direct: env.is_private === true, from, callerName, callId, callerPeer };
+  const start = { agentId, sourceId: sourceIdOf(env), line, from, callId, callerPeer };
   const call = create(start, readVoice(), () => {
     if (current === call) current = null;
   });

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

@@ -7,7 +7,7 @@ export const elevenLabs = (): string => process.env.METRO_ELEVENLABS_URL ?? 'wss
 const STT_RATE = 16_000;
 const CHUNK_SAMPLES = STT_RATE / 10;
 const HELD_SAMPLES = STT_RATE * 2;
-export const VAD_SILENCE_SECS = 0.5;
+const VAD_SILENCE_SECS = 0.5;
 
 export interface Heard {
   partial(text: string): void;

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

@@ -4,7 +4,6 @@ import { str } from '@metro-labs/core/str';
 import { log } from '@metro-labs/core/log';
 import { agentIdForLine, allowlistForLine, lineReceives, mayApprove, senderPermitted, accountFromLine } from '../agents/map.js';
 import { eventInScope } from '../agents/scope.js';
-import { harnessRunner } from '../claude/runner.js';
 import { policyFor, type Access } from '../policy/policy.js';
 
 export interface SharedSpeechAction {
@@ -194,7 +193,6 @@ export class SharedCalls {
 }
 
 export const sharedCalls = new SharedCalls();
-export const sharedCallsSelected = (): boolean => harnessRunner() === 'sdk';
 export const openSharedCall = (route: CallRoute, sourceId: string, transport: SharedCallTransport): boolean => sharedCalls.open(route, sourceId, transport);
 export const hearSharedCall = (route: CallRoute, text: string, sourceId: string): void => { sharedCalls.heard(route, text, sourceId); };
 export const endSharedCall = (route: CallRoute): void => { sharedCalls.end(route); };

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

@@ -61,10 +61,6 @@ export class Utterance {
     });
   }
 
-  get usable(): boolean {
-    return !this.closed && this.listener === null && this.ws.readyState <= WebSocket.OPEN;
-  }
-
   attach(listener: Voiced): void {
     if (!this.aborted && !this.finished) this.listener = listener;
   }

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

@@ -3,7 +3,6 @@ import { readJson, writeSecure } from '@metro-labs/core/secure-fs';
 import { isRecord } from '@metro-labs/core/is-record';
 import { ApiError } from '@metro-labs/http/api-error';
 import { agentsDir } from '../agents/files.js';
-import { readModelConfig, type ModelConfig } from '../gateway/model-config.js';
 
 const VOICE_PROVIDERS = ['elevenlabs'] as const;
 type VoiceProvider = (typeof VOICE_PROVIDERS)[number];
@@ -12,7 +11,6 @@ export interface VoiceConfig {
   provider: VoiceProvider;
   apiKey: string;
   voiceId: string;
-  model: string;
   language: string;
   enabled: boolean;
 }
@@ -22,7 +20,6 @@ const AUTO_LANGUAGE = 'auto';
 const LANGUAGE_RE = /^(?:[a-z]{2,3}|auto)$/;
 
 const DEFAULT_VOICE_ID = 'EXAVITQu4vr4xnSDxMaL';
-const DEFAULT_VOICE_MODEL = 'anthropic:claude-sonnet-5-5';
 
 const VOICE_FILE = 'voice.json';
 const MAX_FIELD = 512;
@@ -38,7 +35,6 @@ export function parseVoice(raw: unknown): VoiceConfig {
     provider: isProvider(r.provider) ? r.provider : 'elevenlabs',
     apiKey: text(r.apiKey),
     voiceId: text(r.voiceId),
-    model: text(r.model),
     language: LANGUAGE_RE.test(text(r.language)) ? text(r.language) : '',
     enabled: r.enabled !== false,
   };
@@ -52,13 +48,6 @@ export function writeVoice(cfg: VoiceConfig, dir = agentsDir()): void {
 }
 
 export const voiceIdOf = (cfg: VoiceConfig): string => (cfg.voiceId === '' ? DEFAULT_VOICE_ID : cfg.voiceId);
-const voiceModelOf = (cfg: VoiceConfig): string => (cfg.model === '' ? DEFAULT_VOICE_MODEL : cfg.model);
-export function brainModel(cfg: VoiceConfig, models: ModelConfig = readModelConfig()): string {
-  const model = voiceModelOf(cfg);
-  const anthropic = /^anthropic:(.+)$/.exec(model)?.[1];
-  if (anthropic === undefined) return model;
-  return models.connections.some((c) => c.provider === 'anthropic') ? model : anthropic;
-}
 
 export function languageOf(cfg: VoiceConfig): string | null {
   const language = cfg.language === '' ? DEFAULT_LANGUAGE : cfg.language;
@@ -73,10 +62,9 @@ export function publicVoice(cfg: VoiceConfig): Record<string, unknown> {
     providers: VOICE_PROVIDERS,
     hasKey: cfg.apiKey !== '',
     voiceId: cfg.voiceId,
-    model: cfg.model,
     language: cfg.language,
     enabled: cfg.enabled,
-    defaults: { voiceId: DEFAULT_VOICE_ID, model: DEFAULT_VOICE_MODEL, language: DEFAULT_LANGUAGE },
+    defaults: { voiceId: DEFAULT_VOICE_ID, language: DEFAULT_LANGUAGE },
   };
 }
 
@@ -109,7 +97,6 @@ export function patchVoice(cfg: VoiceConfig, body: unknown): VoiceConfig {
     provider: isProvider(body.provider) ? body.provider : cfg.provider,
     apiKey: keyOf(body, cfg.apiKey),
     voiceId: field(body, 'voiceId', cfg.voiceId),
-    model: field(body, 'model', cfg.model),
     language: languageField(body, cfg.language),
     enabled: typeof body.enabled === 'boolean' ? body.enabled : cfg.enabled,
   };

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

@@ -11,7 +11,6 @@ export interface ApiSession {
   userId?: string;
   sessionId?: 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.307"
+  "version": "0.1.0-beta.308"
 }

package/runtime/sdk-runner/runner.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.1.0-beta.307",
+  "version": "0.1.0-beta.308",
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "0.3.287",
     "@modelcontextprotocol/sdk": "^1.29.0",

package/dist/background.js

@@ -1,141 +0,0 @@
-import { spawnSync } from 'node:child_process';
-import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { basename, join } from 'node:path';
-export const AGENT_VIEW_OFF = 'CLAUDE_CODE_DISABLE_AGENT_VIEW';
-const STOP_MS = 30_000;
-const SETTLE_MS = 5_000;
-const POLL_MS = 250;
-const given = (value) => value !== undefined && value.trim() !== '' ? value.trim() : undefined;
-export const isRecord = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
-export const keepInSession = (env) => given(env[AGENT_VIEW_OFF]) === undefined ? { ...env, [AGENT_VIEW_OFF]: '1' } : env;
-export const claudeDir = (env = process.env) => given(env.CLAUDE_CONFIG_DIR) ?? join(given(env.HOME) ?? homedir(), '.claude');
-export const projectDir = (dir, cwd) => join(dir, 'projects', cwd.replace(/[^A-Za-z0-9]/g, '-'));
-function startTime(pid) {
-    try {
-        const stat = readFileSync(`/proc/${String(pid)}/stat`, 'utf8');
-        return stat.slice(stat.lastIndexOf(')') + 2).split(' ')[19] ?? null;
-    }
-    catch {
-        return null;
-    }
-}
-export function processAlive(pid, procStart) {
-    try {
-        process.kill(pid, 0);
-    }
-    catch (err) {
-        if (err.code !== 'EPERM')
-            return false;
-    }
-    const started = procStart === undefined ? null : startTime(pid);
-    return started === null || started === procStart;
-}
-function backgroundEntry(file, alive) {
-    try {
-        const raw = JSON.parse(readFileSync(file, 'utf8'));
-        if (!isRecord(raw) || typeof raw.pid !== 'number' || typeof raw.sessionId !== 'string')
-            return null;
-        if (raw.kind === 'interactive' || typeof raw.kind !== 'string')
-            return null;
-        return alive(raw.pid, typeof raw.procStart === 'string' ? raw.procStart : undefined) ? raw.sessionId : null;
-    }
-    catch {
-        return null;
-    }
-}
-export function liveBackground(sessions, alive = processAlive) {
-    if (!existsSync(sessions))
-        return new Set();
-    const ids = readdirSync(sessions)
-        .filter((name) => name.endsWith('.json'))
-        .map((name) => backgroundEntry(join(sessions, name), alive));
-    return new Set(ids.filter((id) => id !== null));
-}
-function newestFirst(dir) {
-    if (!existsSync(dir))
-        return [];
-    return readdirSync(dir)
-        .filter((name) => name.endsWith('.jsonl'))
-        .map((name) => ({ path: join(dir, name), at: statSync(join(dir, name)).mtimeMs }))
-        .sort((a, b) => b.at - a.at)
-        .map((file) => file.path);
-}
-function continuedIn(text) {
-    const last = text.split('\n').findLast((line) => line.includes('"type":"continued-in"'));
-    if (last === undefined)
-        return null;
-    try {
-        const record = JSON.parse(last);
-        return isRecord(record) && typeof record.continuedInSessionId === 'string' ? record.continuedInSessionId : null;
-    }
-    catch {
-        return null;
-    }
-}
-const HAS_TURN = /"type":"(user|assistant)"/;
-export function heldConversation(dir, live) {
-    if (live.size === 0)
-        return null;
-    for (const file of newestFirst(dir)) {
-        const text = readFileSync(file, 'utf8');
-        if (!HAS_TURN.test(text))
-            continue;
-        const moved = continuedIn(text);
-        if (moved !== null && live.has(moved))
-            return moved;
-        if (!live.has(basename(file, '.jsonl')))
-            return null;
-    }
-    return null;
-}
-function stopBackground(id, env = process.env) {
-    const run = spawnSync('claude', ['stop', id], { env, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], timeout: STOP_MS });
-    if (run.error !== undefined)
-        return { ok: false, detail: run.error.message };
-    const said = `${run.stdout}${run.stderr}`.trim().split('\n').at(-1) ?? '';
-    return { ok: run.status === 0, detail: said === '' ? `exit ${String(run.status)}` : said };
-}
-export function resumeSessionId(args) {
-    const index = args.findLastIndex((arg) => arg === '--resume' || arg === '-r');
-    const id = index === -1 ? undefined : args[index + 1];
-    return id !== undefined && /^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/.test(id) ? id : undefined;
-}
-function pinnedHeld(dir, live, id) {
-    if (live.has(id))
-        return id;
-    const path = join(dir, `${id}.jsonl`);
-    if (!existsSync(path))
-        return null;
-    const moved = continuedIn(readFileSync(path, 'utf8'));
-    return moved !== null && live.has(moved) ? moved : null;
-}
-const sleep = (ms) => new Promise((resolve) => {
-    setTimeout(resolve, ms);
-});
-async function settled(sessions, held, alive, ms) {
-    if (!liveBackground(sessions, alive).has(held))
-        return true;
-    if (ms <= 0)
-        return false;
-    await sleep(POLL_MS);
-    return settled(sessions, held, alive, ms - POLL_MS);
-}
-function heldFor(deps, dir, live) {
-    const project = projectDir(dir, deps.cwd ?? process.cwd());
-    return deps.sessionId === undefined ? heldConversation(project, live) : pinnedHeld(project, live, deps.sessionId);
-}
-export async function takeBackConversation(deps = {}) {
-    const env = deps.env ?? process.env;
-    const alive = deps.alive ?? processAlive;
-    const dir = claudeDir(env);
-    const sessions = join(dir, 'sessions');
-    const held = heldFor(deps, dir, liveBackground(sessions, alive));
-    if (held === null)
-        return null;
-    const id = held.slice(0, 8);
-    const stopped = (deps.stop ?? stopBackground)(id, env);
-    if (!stopped.ok || !(await settled(sessions, held, alive, deps.settleMs ?? SETTLE_MS)))
-        return `the conversation is held by the Claude Code background session ${id} and it could not be stopped (${stopped.detail}), so Claude Code will refuse to continue it: run claude stop ${id}`;
-    return `the conversation had moved to the Claude Code background session ${id}, where no chat reaches it; stopped that session (its conversation is kept) and continuing it here`;
-}

package/dist/claude.js

@@ -1,204 +0,0 @@
-import { spawn, spawnSync } from 'node:child_process';
-import { markOnboardingDone, seedChannels } from './onboarding.js';
-import { writeMcpConfig } from './mcp-config.js';
-import { currentRoute, harnessRunner, permissionMode, routeModelEnv, systemPrompt } from './route.js';
-import { settingsConflicts, settingsFiles } from './claude-settings.js';
-import { localAgent } from './local.js';
-import { PROVIDER_FLAGS } from './provider-flags.js';
-import { localPort, localUrl } from './runtime.js';
-import { keepInSession, resumeSessionId, takeBackConversation } from './background.js';
-import { nativeRecoveryArgs } from './native-recovery.js';
-const CHANNEL_FLAGS = ['--dangerously-load-development-channels', 'server:metro'];
-const FRESH_PROMPT_FLAGS = ['--system-prompt-snapshot', 'off'];
-export const PERMISSION_MODE_FLAG = { auto: 'auto', bypass: 'bypassPermissions' };
-const KEY_HEADER = 'x-metro-key';
-const PROBE_MS = 3_000;
-const AUTH_STATUS_MS = 20_000;
-const KILL_GRACE_MS = 30_000;
-export const claudeArgs = (extra, mcpConfig, mode = 'auto', prompt = null) => [
-    ...CHANNEL_FLAGS,
-    '--permission-mode',
-    PERMISSION_MODE_FLAG[mode],
-    ...FRESH_PROMPT_FLAGS,
-    ...(mcpConfig === undefined ? [] : ['--mcp-config', mcpConfig]),
-    ...(prompt === null ? [] : ['--append-system-prompt', prompt]),
-    ...extra,
-];
-const set = (env, name) => (env[name] ?? '').trim() !== '';
-export function pinnedBy(env) {
-    if (set(env, 'ANTHROPIC_BASE_URL'))
-        return 'ANTHROPIC_BASE_URL';
-    return PROVIDER_FLAGS.find((flag) => set(env, flag)) ?? null;
-}
-export function gatewayEnv(base, agentKey, port) {
-    if (agentKey === null || pinnedBy(base) !== null)
-        return base;
-    const own = (base.ANTHROPIC_CUSTOM_HEADERS ?? '').trim();
-    const mine = `${KEY_HEADER}: ${agentKey}`;
-    return {
-        ...base,
-        ANTHROPIC_BASE_URL: `http://127.0.0.1:${String(port)}/gateway`,
-        ANTHROPIC_CUSTOM_HEADERS: own === '' ? mine : `${own}\n${mine}`,
-        CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY: '1',
-    };
-}
-export const channelEnv = (env) => set(env, 'MCP_PROTOCOL_NEGOTIATION') ? env : { ...env, MCP_PROTOCOL_NEGOTIATION: 'legacy' };
-export const toolSearchEnv = (env) => set(env, 'ENABLE_TOOL_SEARCH') ? env : { ...env, ENABLE_TOOL_SEARCH: 'true' };
-const RM_PROMPT_OFF = 'CLAUDE_CODE_DISABLE_INLINE_SHELL_RM_PROMPT';
-export const rmPromptEnv = (env) => set(env, RM_PROMPT_OFF) ? env : { ...env, [RM_PROMPT_OFF]: '1' };
-const OWN_CREDENTIALS = ['ANTHROPIC_API_KEY', 'ANTHROPIC_AUTH_TOKEN'];
-export function credentialEnv(env, agentKey, signedIn) {
-    if (signedIn || OWN_CREDENTIALS.some((name) => set(env, name)))
-        return env;
-    return { ...env, ANTHROPIC_AUTH_TOKEN: agentKey };
-}
-function claudeSignedIn() {
-    const run = spawnSync('claude', ['auth', 'status', '--json'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], timeout: AUTH_STATUS_MS });
-    if (run.error !== undefined || typeof run.stdout !== 'string')
-        return false;
-    try {
-        const parsed = JSON.parse(run.stdout);
-        return parsed.authenticated === true || parsed.loggedIn === true || typeof parsed.email === 'string' || typeof parsed.organization === 'string';
-    }
-    catch {
-        return false;
-    }
-}
-export function servingDaemon(body) {
-    if (typeof body !== 'object' || body === null)
-        return false;
-    const mode = body;
-    return mode.mode === 'local' && mode.stopped !== true;
-}
-async function daemonServing(base = localUrl()) {
-    try {
-        const res = await fetch(`${base}/api/mode`, { signal: AbortSignal.timeout(PROBE_MS) });
-        return res.ok && servingDaemon(await res.json());
-    }
-    catch {
-        return false;
-    }
-}
-export function agentKey(agent) {
-    return agent === null ? { skip: 'no agent lives on this machine yet, so Claude Code talks to Anthropic directly' } : { key: agent.key };
-}
-async function verdict() {
-    const pinned = pinnedBy(process.env);
-    if (pinned !== null)
-        return { skip: `${pinned} is set, so Claude Code keeps talking to it` };
-    const conflicts = settingsConflicts(settingsFiles());
-    if (conflicts.length > 0)
-        return { skip: `a settings file pins the provider (${conflicts.join(', ')}), so Claude Code keeps it` };
-    const picked = agentKey(localAgent());
-    if ('skip' in picked)
-        return picked;
-    if (await daemonServing())
-        return picked;
-    return { skip: 'the daemon is not serving here (stopped, or not running), so Claude Code talks to Anthropic directly' };
-}
-function deadline(child, timeoutMs) {
-    if (timeoutMs === undefined)
-        return () => undefined;
-    let kill;
-    const term = setTimeout(() => {
-        child.kill('SIGTERM');
-        kill = setTimeout(() => {
-            child.kill('SIGKILL');
-        }, KILL_GRACE_MS);
-    }, timeoutMs);
-    return () => {
-        clearTimeout(term);
-        clearTimeout(kill);
-    };
-}
-export function runClaude(args, env, headless, command = 'claude') {
-    return new Promise((resolve, reject) => {
-        const leaveToChild = () => undefined;
-        process.on('SIGINT', leaveToChild);
-        process.on('SIGTERM', leaveToChild);
-        const child = spawn(command, args, { stdio: [headless === undefined ? 'inherit' : 'ignore', 'inherit', 'inherit'], env });
-        const stop = deadline(child, headless?.timeoutMs);
-        child.on('error', (err) => {
-            reject(new Error(err.code === 'ENOENT'
-                ? `the \`${command}\` command is not on PATH${command === 'claude' ? ' — install Claude Code first' : ''}`
-                : err.message));
-        });
-        child.on('exit', (code) => {
-            stop();
-            resolve(code ?? 1);
-        });
-    });
-}
-async function servedKey(decision) {
-    if ('key' in decision)
-        return decision.key;
-    const picked = agentKey(localAgent());
-    if ('skip' in picked)
-        return null;
-    return (await daemonServing()) ? picked.key : null;
-}
-function mcpConfigFor(key, port) {
-    if (key === null)
-        return null;
-    const file = writeMcpConfig(key, port);
-    process.stderr.write(`metro claude: the metro MCP server is loaded for this session from the daemon at http://127.0.0.1:${String(port)}/mcp, nothing to add by hand\n`);
-    return file;
-}
-function gatewayLaunchEnv(key, port) {
-    process.stderr.write(`metro claude: inference goes through the daemon at http://127.0.0.1:${String(port)}/gateway (the Model page decides where)\n`);
-    const pointed = routeModelEnv(gatewayEnv(process.env, key, port), currentRoute());
-    const routed = toolSearchEnv(pointed);
-    if (routed !== pointed)
-        process.stderr.write('metro claude: MCP tool search is on, so connector tools load when Claude needs them instead of all at start\n');
-    const env = credentialEnv(routed, key, claudeSignedIn());
-    if (env !== routed)
-        process.stderr.write("metro claude: Claude Code has no login of its own here, so metro's key stands in as its credential; the Model page must route to Bedrock, OpenRouter or Codex\n");
-    if (seedChannels() === 'marked')
-        process.stderr.write('metro claude: marked Channels as available in Claude Code cached flags, since a box that sends no telemetry never fetches them\n');
-    if (markOnboardingDone() === 'marked')
-        process.stderr.write("metro claude: skipped Claude Code's first-run setup, since it already has a credential here\n");
-    return env;
-}
-function inferenceEnv(decision, port) {
-    if ('key' in decision)
-        return gatewayLaunchEnv(decision.key, port);
-    process.stderr.write(`metro claude: ${decision.skip}\n`);
-    return process.env;
-}
-export async function headlessEnv() {
-    return keepInSession(rmPromptEnv(inferenceEnv(await verdict(), localPort())));
-}
-const continues = (args) => args.includes('-c') || args.includes('--continue');
-async function reclaimConversation(extra) {
-    const sessionId = resumeSessionId(extra);
-    if (sessionId === undefined && !continues(extra))
-        return;
-    try {
-        const note = await takeBackConversation({ sessionId });
-        if (note !== null)
-            process.stderr.write(`metro claude: ${note}\n`);
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        process.stderr.write(`metro claude: could not check for a Claude Code background session holding the conversation (${message})\n`);
-    }
-}
-const SDK_HOLDS_CHAT = 'the Harness runs this agent as an Agent SDK session (metro agent), which holds the metro chat; a metro claude session would take it away. Switch the Harness runner back to the Claude Code session first, or open the conversation with plain claude --resume <session id>';
-export async function launchClaude(extra) {
-    if (harnessRunner() === 'sdk')
-        throw new Error(SDK_HOLDS_CHAT);
-    await reclaimConversation(extra);
-    const decision = await verdict();
-    const port = localPort();
-    const mcp = mcpConfigFor(await servedKey(decision), port);
-    const mode = permissionMode();
-    const prompt = systemPrompt();
-    if (prompt !== null)
-        process.stderr.write('metro claude: the system prompt from the Harness page is appended to this session\n');
-    try {
-        return await runClaude(claudeArgs(nativeRecoveryArgs(extra), mcp?.path, mode, prompt), keepInSession(rmPromptEnv(channelEnv(inferenceEnv(decision, port)))));
-    }
-    finally {
-        mcp?.cleanup();
-    }
-}