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

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

@@ -8,7 +8,7 @@ import { errMsg } from '@metro-labs/core/log';
 import { allowlistForLine, mayApprove, senderPermitted } from '../agents/map.js';
 import { accountStationNames, stationByName } from '../stations/registry.js';
 import { eventInScope } from '../agents/scope.js';
-import { MCP_INSTRUCTIONS, VOICE_MCP_INSTRUCTIONS } from './instructions.js';
+import { MCP_INSTRUCTIONS } from './instructions.js';
 import { BoundedEventStore } from './event-store.js';
 import { registerPermissionRelay } from './permission-relay.js';
 import { registerToolHandlers, toolSchemaSignature } from './tool-dispatch.js';
@@ -55,12 +55,7 @@ function makeTransport(
   return t;
 }
 
-export type SessionKind = 'chat' | 'voice';
-
-const CHANNEL_CAPABILITIES = { experimental: { 'claude/channel': {}, 'claude/channel/permission': {} } };
-
 export interface SessionInit {
-  kind?: SessionKind;
   id: string;
   scope: Set<string>;
   adopted: boolean;
@@ -84,7 +79,6 @@ export class McpSession {
   private issuedSchema: string | undefined;
   private announcing = false;
   private readonly onClosed: (session: McpSession) => void;
-  private readonly kind: SessionKind;
   private readonly openedAt = new Date().toISOString();
   private clientInitializedAt: string | null = null;
   private lastStreamAttachedAt: string | null = null;
@@ -92,20 +86,15 @@ export class McpSession {
 
   private constructor(init: SessionInit) {
     this.id = init.id;
-    this.kind = init.kind ?? 'chat';
     this.scope = init.scope;
     this.live = init.live;
     this.issuedSchema = init.adopted ? undefined : toolSchemaSignature();
     this.onClosed = init.onClosed;
     this.eventStore = new BoundedEventStore();
     this.transport = makeTransport(init.id, this.eventStore, init.adopted);
-    const voice = init.kind === 'voice';
     this.server = new Server(
       { name: 'metro', version: '0.1.0' },
-      {
-        capabilities: { ...(voice ? {} : CHANNEL_CAPABILITIES), tools: { listChanged: true } },
-        instructions: voice ? VOICE_MCP_INSTRUCTIONS : MCP_INSTRUCTIONS,
-      },
+      { capabilities: { tools: { listChanged: true } }, instructions: MCP_INSTRUCTIONS },
     );
     this.server.oninitialized = (): void => {
       this.clientInitializedAt = new Date().toISOString();
@@ -130,16 +119,15 @@ export class McpSession {
       approves,
       noteDirect,
       answerPermission,
-      callMeta: (event) => voice ? () => ({}) : sharedCalls.bindChat(event, this.scope),
+      callMeta: (event) => sharedCalls.bindChat(event, this.scope),
+    });
+    registerPermissionRelay({
+      mcp: this.server,
+      relay: this.relay,
+      inScope: (line) => this.inScope(line),
+      live: this.live,
+      log: channelLog,
     });
-    if (!voice)
-      registerPermissionRelay({
-        mcp: this.server,
-        relay: this.relay,
-        inScope: (line) => this.inScope(line),
-        live: this.live,
-        log: channelLog,
-      });
     this.channel = new ChannelRelay({
       relay: this.relay,
       log: channelLog,
@@ -214,7 +202,7 @@ export class McpSession {
   }
 
   private announceCallState(): void {
-    if (this.kind !== 'chat' || !this.streamAttached || this.server.getClientVersion()?.name !== 'metro-sdk-runner') return;
+    if (!this.streamAttached || this.server.getClientVersion()?.name !== 'metro-sdk-runner') return;
     const active = sharedCalls.snapshot();
     const route = active !== null && this.scope.has(active.agentId) && eventInScope(this.scope, active.line) ? active : null;
     this.server.notification({ method: CALL_STATE, params: { route, ...(route === null ? {} : { meta: { line: route.line } }) } }).catch((err: unknown) => {
@@ -264,7 +252,7 @@ export class McpSession {
   async close(): Promise<void> {
     if (this.closed) return;
     this.closed = true;
-    if (this.kind === 'chat') sharedCalls.revoke();
+    sharedCalls.revoke();
     this.onClosed(this);
     forgetPromptsOf(this.server);
     this.dropStream();

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

@@ -6,9 +6,6 @@ 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);
@@ -28,7 +25,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, userId: session.userId, sessionId: session.sessionId, role: session.role === 'admin' ? 'admin' : 'member', ...(isOperatorUser(session.userId) ? { operator: true as const } : {}) };
+    return { subject: held, userId: session.userId, sessionId: session.sessionId, role: session.role === 'admin' ? 'admin' : 'member' };
   };
 }
 

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

@@ -38,7 +38,6 @@ import { applyMcpCors, handleMcpPreflight } from '@metro-labs/http/cors';
 import { METRO_VERSION } from '@metro-labs/core/version';
 
 const LRU_CAP = 2_000;
-export const VOICE_MCP_PATH = '/mcp/voice';
 
 function dedupKey(
   e: Pick<MetroEvent, 'station' | 'line' | 'messageId'>,
@@ -214,7 +213,7 @@ export async function startWebhookServer(
 
 function isMcpPath(req: IncomingMessage): boolean {
   const path = (req.url ?? '').split('?')[0];
-  return path === '/' || path === '/mcp' || path === VOICE_MCP_PATH || path === MCP_STATUS_PATH;
+  return path === '/' || path === '/mcp' || path === MCP_STATUS_PATH;
 }
 
 function flatHeaders(req: IncomingMessage): Record<string, string> {

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/agent-signature.ts

@@ -1,4 +1,4 @@
-import { createHash, createPublicKey, diffieHellman, generateKeyPairSync, randomBytes, sign, verify, type KeyObject } from 'node:crypto';
+import { createHash, createPublicKey, randomBytes, sign, verify, type KeyObject } from 'node:crypto';
 import { strongEd25519 } from './ed25519.js';
 
 export const AGENT_SCHEME = 'MetroAgent';
@@ -25,40 +25,25 @@ export interface AgentProof {
   signature: string;
 }
 
-type Curve = 'Ed25519' | 'X25519';
-
 const digest = (bytes: Uint8Array): string => createHash('sha256').update(bytes).digest('base64url');
 
 export const agentKeyId = (signingKey: string): string => digest(Buffer.from(signingKey, 'base64url'));
 
-function publicKeyOf(raw: string, curve: Curve): KeyObject | null {
+function publicKeyOf(raw: string): KeyObject | null {
   if (!RAW_KEY_RE.test(raw) || Buffer.from(raw, 'base64url').toString('base64url') !== raw) return null;
   try {
-    const key = createPublicKey({ key: { kty: 'OKP', crv: curve, x: raw }, format: 'jwk' });
-    return key.asymmetricKeyType === curve.toLowerCase() ? key : null;
+    const key = createPublicKey({ key: { kty: 'OKP', crv: 'Ed25519', x: raw }, format: 'jwk' });
+    return key.asymmetricKeyType === 'ed25519' ? key : null;
   } catch {
     return null;
   }
 }
 
 export function signingKeyOf(raw: string): KeyObject | null {
-  const key = publicKeyOf(raw, 'Ed25519');
+  const key = publicKeyOf(raw);
   return key !== null && strongEd25519(Buffer.from(raw, 'base64url')) ? key : null;
 }
 
-function contributes(key: KeyObject): boolean {
-  try {
-    return diffieHellman({ privateKey: generateKeyPairSync('x25519').privateKey, publicKey: key }).some((byte) => byte !== 0);
-  } catch {
-    return false;
-  }
-}
-
-export function sealingKeyOf(raw: string): KeyObject | null {
-  const key = publicKeyOf(raw, 'X25519');
-  return key !== null && contributes(key) ? key : null;
-}
-
 export function rawPublicKey(key: KeyObject): string {
   const { x } = key.export({ format: 'jwk' });
   if (typeof x !== 'string') throw new Error('not an OKP public key');

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.306"
+  "version": "0.1.0-beta.308"
 }

package/runtime/sdk-runner/runner.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.1.0-beta.306",
+  "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`;
-}