@stage-labs/metro 0.1.0-beta.264 → 0.1.0-beta.265

package/runtime/sdk-runner/src/session-store.ts

@@ -13,6 +13,7 @@ interface Stored {
   sessionId: string | null;
   unanswered: Unanswered[];
   interrupted: Unanswered[];
+  context?: number;
 }
 
 function inputId(raw: unknown): Uuid | undefined {
@@ -35,11 +36,18 @@ function entry(raw: unknown): Unanswered | null {
 
 const UNREADABLE = 'The saved Agent SDK state cannot be read. Restore it before starting.';
 
+function contextOf(raw: unknown): number | undefined {
+  if (raw === undefined) return undefined;
+  if (typeof raw !== 'number' || !Number.isSafeInteger(raw) || raw < 0) throw new Error(UNREADABLE);
+  return raw;
+}
+
 function stored(raw: unknown): Stored {
   if (!isRecord(raw)) throw new Error(UNREADABLE);
   const id = raw.sessionId ?? null;
   if (id !== null && (typeof id !== 'string' || !SESSION_ID.test(id))) throw new Error(UNREADABLE);
-  return { sessionId: id, unanswered: entries(raw.unanswered), interrupted: entries(raw.interrupted) };
+  const context = contextOf(raw.context);
+  return { sessionId: id, unanswered: entries(raw.unanswered), interrupted: entries(raw.interrupted), ...(context === undefined ? {} : { context }) };
 }
 
 function entries(raw: unknown): Unanswered[] {
@@ -86,6 +94,11 @@ export class SessionStore {
     this.write({ ...this.read(), unanswered });
   }
 
+  saveContext(context: number): void {
+    const stored = this.read();
+    if (stored.context !== context) this.write({ ...stored, context });
+  }
+
   private read(): Stored {
     try {
       return stored(JSON.parse(readFileSync(this.path, 'utf8')));

package/runtime/sdk-runner/src/session-watch.ts

@@ -1,8 +1,6 @@
 import { isRecord } from '@metro-labs/core/is-record';
 
 const METRO_TOOL = /^mcp__metro__(.+)$/;
-const GATE_CAP_MS = 5_000;
-const COMPACT_CAP_MS = 20_000;
 
 export const uuidsOf = (m: Record<string, unknown>): string[] | null => {
   if (Array.isArray(m.user_message_uuids)) return m.user_message_uuids.filter((u): u is string => typeof u === 'string');
@@ -24,21 +22,14 @@ function toolResultIds(message: unknown): string[] {
   return message.content.filter(isRecord).filter((b) => b.type === 'tool_result' && typeof b.tool_use_id === 'string').map((b) => String(b.tool_use_id));
 }
 
-function capped(waiters: (() => void)[], capMs: number): Promise<void> {
-  return new Promise((resolve) => {
-    const timer = setTimeout(resolve, capMs);
-    waiters.push(() => {
-      clearTimeout(timer);
-      resolve();
-    });
-  });
-}
 
 export class SessionWatch {
   private readonly writes = new Set<string>();
   private readonly idle: (() => void)[] = [];
   private readonly compacted: (() => void)[] = [];
   private compactingNow = false;
+  private busy = false;
+  private sessionStateSeen = false;
   private lastContext = 0;
   private streamUsage: Record<string, unknown> = {};
 
@@ -56,26 +47,42 @@ export class SessionWatch {
     return this.writes.size > 0;
   }
 
+  get safe(): boolean { return !this.busy && !this.writing && !this.compacting; }
+
+  dispatched(): void { this.busy = true; }
+  restoreContext(context: number): void { this.lastContext = context; }
+
   observe(m: Record<string, unknown>): void {
-    if (m.type === 'system') this.system(m);
-    else if (m.type === 'result') this.settle();
-    if (m.parent_tool_use_id !== null) return;
+    if (m.parent_tool_use_id !== null && m.parent_tool_use_id !== undefined) return;
+    this.lifecycle(m);
     if (m.type === 'assistant' && isRecord(m.message)) this.assistant(m.message);
     else if (m.type === 'stream_event' && isRecord(m.event)) this.stream(m.event);
     else if (m.type === 'user') for (const id of toolResultIds(m.message)) this.done(id);
   }
 
-  whenNotWriting(capMs = GATE_CAP_MS): Promise<void> {
-    return this.writing ? capped(this.idle, capMs) : Promise.resolve();
+  whenNotWriting(): Promise<void> {
+    return this.writing ? new Promise((resolve) => { this.idle.push(resolve); }) : Promise.resolve();
   }
 
-  whenNotCompacting(capMs = COMPACT_CAP_MS): Promise<void> {
-    return this.compactingNow ? capped(this.compacted, capMs) : Promise.resolve();
+  whenNotCompacting(): Promise<void> {
+    return this.compactingNow ? new Promise((resolve) => { this.compacted.push(resolve); }) : Promise.resolve();
+  }
+
+  private lifecycle(m: Record<string, unknown>): void {
+    if (m.type === 'system') this.system(m);
+    else if (m.type === 'result' && !this.sessionStateSeen) {
+      this.busy = typeof m.queued_turn_count === 'number' && m.queued_turn_count > 0;
+      this.settle();
+    }
+    if (m.type === 'assistant' || m.type === 'stream_event' || startedCommand(m) !== null) this.busy = true;
   }
 
   private system(m: Record<string, unknown>): void {
-    if (m.subtype === 'init') this.settle();
-    else if (m.subtype === 'status') this.setCompacting(m.status === 'compacting');
+    if (m.subtype === 'session_state_changed') {
+      this.sessionStateSeen = true;
+      if (m.state === 'running' || m.state === 'requires_action') this.busy = true;
+      else if (m.state === 'idle') { this.busy = false; this.settle(); }
+    } else if (m.subtype === 'status') this.setCompacting(m.status === 'compacting');
     else if (m.subtype === 'compact_boundary') {
       this.setCompacting(false);
       this.lastContext = 0;

package/runtime/sdk-runner/src/speech.ts

@@ -1,79 +0,0 @@
-import type { SDKMessage } from '@anthropic-ai/claude-agent-sdk';
-import { isRecord } from '@metro-labs/core/is-record';
-import type { InputKind } from './inbox.js';
-import { startedCommand, uuidsOf } from './session-watch.js';
-
-export interface SpeechSink {
-  say(text: string): void;
-  done(): void;
-  stalled?(): void;
-}
-
-
-function textDelta(event: unknown): string | null {
-  if (!isRecord(event) || event.type !== 'content_block_delta' || !isRecord(event.delta)) return null;
-  return event.delta.type === 'text_delta' && typeof event.delta.text === 'string' ? event.delta.text : null;
-}
-
-export class SpeechRouter {
-  private answering: string[] = [];
-  private speaking = false;
-  private live = false;
-
-  constructor(
-    private readonly kindOf: (uuid: string) => InputKind | undefined,
-    private readonly sink: SpeechSink,
-  ) {}
-
-  get callLive(): boolean {
-    return this.live;
-  }
-
-  get talking(): boolean {
-    return this.speaking;
-  }
-
-  setCallLive(on: boolean): void {
-    this.live = on;
-    if (!on) this.endTurn();
-  }
-
-  observe(message: SDKMessage): void {
-    const m: Record<string, unknown> = { ...message };
-    if (m.type === 'result') {
-      this.endTurn();
-      this.answering = [];
-      return;
-    }
-    if (m.type === 'system' && m.subtype === 'init') this.endTurn();
-    const started = startedCommand(m);
-    if (started !== null) this.answer([started]);
-    if (m.parent_tool_use_id === null) this.mainThread(m);
-  }
-
-  private answer(uuids: readonly string[]): void {
-    this.answering = [...new Set([...this.answering, ...uuids])];
-  }
-
-  private mainThread(m: Record<string, unknown>): void {
-    if (m.type !== 'stream_event' && m.type !== 'assistant') return;
-    const uuids = uuidsOf(m);
-    if (uuids !== null) this.answer(uuids);
-    const text = m.type === 'stream_event' ? textDelta(m.event) : null;
-    if (text === null || text === '' || !this.speaks()) return;
-    this.speaking = true;
-    this.sink.say(text);
-  }
-
-  private speaks(): boolean {
-    if (!this.live) return false;
-    if (this.answering.length === 0) return true;
-    return this.answering.some((uuid) => this.kindOf(uuid) === 'call');
-  }
-
-  private endTurn(): void {
-    if (!this.speaking) return;
-    this.speaking = false;
-    this.sink.done();
-  }
-}