pi-harness-delegate 0.1.0 → 0.2.0

package/extensions/progress.ts

@@ -8,135 +8,135 @@
  *     re-show with /delegate watch)
  */
 
-import { Key, matchesKey, truncateToWidth, visibleWidth, type Component, type TUI } from '@earendil-works/pi-tui';
 import type { Theme } from '@earendil-works/pi-coding-agent';
+import { type Component, Key, matchesKey, type TUI, truncateToWidth, visibleWidth } from '@earendil-works/pi-tui';
 
 const SPINNER = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
 const SPIN_INTERVAL_MS = 100;
 const MAX_VISIBLE_ENTRIES = 12;
 
 export type FeedEntry =
-	| { kind: 'tool'; text: string; ok?: boolean }
-	| { kind: 'thinking'; text: string }
-	| { kind: 'text'; text: string };
+  | { kind: 'tool'; text: string; ok?: boolean }
+  | { kind: 'thinking'; text: string }
+  | { kind: 'text'; text: string };
 
 export interface ProgressWindowOptions {
-	/** Harness name shown in title. */
-	harness?: string;
-	/** Mode name, shown in the title bar (e.g. "review"). */
-	mode: string;
-	/** Model (or alias) shown in the title bar. */
-	model?: string | null;
-	/** Epoch ms when the run started — drives the live elapsed timer. */
-	startedAt: number;
-	/** Live feed entries (tool calls, thinking, text tail). */
-	getEntries: () => FeedEntry[];
-	/** Show an "unrestricted permissions" warning banner. */
-	dangerous?: boolean;
-	/** Called when the user confirms cancel. */
-	onCancel: () => void;
-	/** Called when the user presses `m` (minimize — keep the run going). */
-	onMinimize: () => void;
+  /** Harness name shown in title. */
+  harness?: string;
+  /** Mode name, shown in the title bar (e.g. "review"). */
+  mode: string;
+  /** Model (or alias) shown in the title bar. */
+  model?: string | null;
+  /** Epoch ms when the run started — drives the live elapsed timer. */
+  startedAt: number;
+  /** Live feed entries (tool calls, thinking, text tail). */
+  getEntries: () => FeedEntry[];
+  /** Show an "unrestricted permissions" warning banner. */
+  dangerous?: boolean;
+  /** Called when the user confirms cancel. */
+  onCancel: () => void;
+  /** Called when the user presses `m` (minimize — keep the run going). */
+  onMinimize: () => void;
 }
 
 export function fmtElapsed(ms: number): string {
-	const total = Math.max(0, Math.floor(ms / 1000));
-	const m = Math.floor(total / 60);
-	const s = total % 60;
-	return m > 0 ? `${m}:${String(s).padStart(2, '0')}` : `0:${String(s).padStart(2, '0')}`;
+  const total = Math.max(0, Math.floor(ms / 1000));
+  const m = Math.floor(total / 60);
+  const s = total % 60;
+  return m > 0 ? `${m}:${String(s).padStart(2, '0')}` : `0:${String(s).padStart(2, '0')}`;
 }
 
 /** Style one feed entry; the returned string may contain ANSI colors. */
 export function renderEntry(entry: FeedEntry, theme: Theme): string {
-	switch (entry.kind) {
-		case 'tool': {
-			const mark = entry.ok === undefined ? '' : entry.ok ? theme.fg('success', ' ✓') : theme.fg('error', ' ✗');
-			return theme.fg('accent', '▶ ') + theme.fg('muted', entry.text) + mark;
-		}
-		case 'thinking':
-			return theme.fg('dim', entry.text);
-		case 'text':
-			return theme.fg('text', entry.text);
-	}
+  switch (entry.kind) {
+    case 'tool': {
+      const mark = entry.ok === undefined ? '' : entry.ok ? theme.fg('success', ' ✓') : theme.fg('error', ' ✗');
+      return theme.fg('accent', '▶ ') + theme.fg('muted', entry.text) + mark;
+    }
+    case 'thinking':
+      return theme.fg('dim', entry.text);
+    case 'text':
+      return theme.fg('text', entry.text);
+  }
 }
 
 /** Create the overlay component; disposes the spinner timer. */
 export function progressWindow(tui: TUI, theme: Theme, opts: ProgressWindowOptions): Component & { dispose(): void } {
-	let frame = 0;
-	let armed = false;
-	let armTimer: ReturnType<typeof setTimeout> | null = null;
-	const timer = setInterval(() => {
-		frame++;
-		tui.requestRender();
-	}, SPIN_INTERVAL_MS);
+  let frame = 0;
+  let armed = false;
+  let armTimer: ReturnType<typeof setTimeout> | null = null;
+  const timer = setInterval(() => {
+    frame++;
+    tui.requestRender();
+  }, SPIN_INTERVAL_MS);
 
-	const disarm = () => {
-		armed = false;
-		if (armTimer) {
-			clearTimeout(armTimer);
-			armTimer = null;
-		}
-	};
+  const disarm = () => {
+    armed = false;
+    if (armTimer) {
+      clearTimeout(armTimer);
+      armTimer = null;
+    }
+  };
 
-	return {
-		render(width: number): string[] {
-			const inner = Math.max(10, width - 4);
-			const padTo = (s: string, w: number) => `${s}${' '.repeat(Math.max(1, w - visibleWidth(s)))}`;
-			const out: string[] = [];
+  return {
+    render(width: number): string[] {
+      const inner = Math.max(10, width - 4);
+      const padTo = (s: string, w: number) => `${s}${' '.repeat(Math.max(1, w - visibleWidth(s)))}`;
+      const out: string[] = [];
 
-			// title bar: ⠋ <harness> <mode> · <model> · ⏱ elapsed
-			const harness = opts.harness ?? 'delegate';
-			const title = `${SPINNER[frame % SPINNER.length]} ${harness} ${opts.mode}`;
-			const status = [opts.model ?? '', `⏱ ${fmtElapsed(Date.now() - opts.startedAt)}`].filter(Boolean).join(' · ');
-			const titleStr = status ? `${title} · ${status}` : title;
-			const dash = '─'.repeat(Math.max(1, inner - visibleWidth(titleStr) - 2));
-			out.push(theme.fg('accent', `╭─ ${titleStr} ${dash}─╮`));
+      // title bar: ⠋ <harness> <mode> · <model> · ⏱ elapsed
+      const harness = opts.harness ?? 'delegate';
+      const title = `${SPINNER[frame % SPINNER.length]} ${harness} ${opts.mode}`;
+      const status = [opts.model ?? '', `⏱ ${fmtElapsed(Date.now() - opts.startedAt)}`].filter(Boolean).join(' · ');
+      const titleStr = status ? `${title} · ${status}` : title;
+      const dash = '─'.repeat(Math.max(1, inner - visibleWidth(titleStr) - 2));
+      out.push(theme.fg('accent', `╭─ ${titleStr} ${dash}─╮`));
 
-			// danger banner
-			if (opts.dangerous) {
-				const banner = theme.fg('error', '⚠ danger — unrestricted access');
-				out.push(`│ ${padTo(banner, inner)} │`);
-			}
+      // danger banner
+      if (opts.dangerous) {
+        const banner = theme.fg('error', '⚠ danger — unrestricted access');
+        out.push(`│ ${padTo(banner, inner)} │`);
+      }
 
-			// feed
-			for (const entry of opts.getEntries().slice(-MAX_VISIBLE_ENTRIES)) {
-				out.push(`│ ${padTo(truncateToWidth(renderEntry(entry, theme), inner), inner)} │`);
-			}
+      // feed
+      for (const entry of opts.getEntries().slice(-MAX_VISIBLE_ENTRIES)) {
+        out.push(`│ ${padTo(truncateToWidth(renderEntry(entry, theme), inner), inner)} │`);
+      }
 
-			// hint row (double-ESC guard + minimize)
-			const hint = armed
-				? theme.fg('warning', 'press esc again to cancel') + theme.fg('dim', ' · m minimize')
-				: theme.fg('dim', 'esc cancel') + theme.fg('dim', ' · m minimize');
-			out.push(`│ ${padTo(hint, inner)} │`);
+      // hint row (double-ESC guard + minimize)
+      const hint = armed
+        ? theme.fg('warning', 'press esc again to cancel') + theme.fg('dim', ' · m minimize')
+        : theme.fg('dim', 'esc cancel') + theme.fg('dim', ' · m minimize');
+      out.push(`│ ${padTo(hint, inner)} │`);
 
-			out.push(theme.fg('accent', `╰${'─'.repeat(Math.max(1, width - 2))}╯`));
-			return out;
-		},
-		handleInput(data: string): void {
-			if (matchesKey(data, Key.escape)) {
-				if (armed) {
-					disarm();
-					opts.onCancel();
-				} else {
-					armed = true;
-					armTimer = setTimeout(() => {
-						armed = false;
-						armTimer = null;
-						tui.requestRender();
-					}, 1500);
-					tui.requestRender();
-				}
-			} else if (data === 'm') {
-				disarm();
-				opts.onMinimize();
-			}
-		},
-		invalidate(): void {
-			// stateless render — nothing to clear
-		},
-		dispose(): void {
-			clearInterval(timer);
-			disarm();
-		},
-	};
+      out.push(theme.fg('accent', `╰${'─'.repeat(Math.max(1, width - 2))}╯`));
+      return out;
+    },
+    handleInput(data: string): void {
+      if (matchesKey(data, Key.escape)) {
+        if (armed) {
+          disarm();
+          opts.onCancel();
+        } else {
+          armed = true;
+          armTimer = setTimeout(() => {
+            armed = false;
+            armTimer = null;
+            tui.requestRender();
+          }, 1500);
+          tui.requestRender();
+        }
+      } else if (data === 'm') {
+        disarm();
+        opts.onMinimize();
+      }
+    },
+    invalidate(): void {
+      // stateless render — nothing to clear
+    },
+    dispose(): void {
+      clearInterval(timer);
+      disarm();
+    },
+  };
 }

package/extensions/run-claude.ts

@@ -1,52 +1,61 @@
 /** @deprecated use extensions/runner.ts + harnesses/claude.ts directly */
-import type { ActivityEvent, StreamedResult } from './harnesses/types.ts';
+
 import { claudeHarness } from './harnesses/claude.ts';
+import type { ActivityEvent, StreamedResult } from './harnesses/types.ts';
 import { runHarness } from './runner.ts';
 
 export interface RunClaudeOptions {
-	prompt: string;
-	cwd: string;
-	permissionMode: string;
-	model?: string;
-	maxBudgetUsd?: number;
-	addDirs?: string[];
-	signal?: AbortSignal;
-	timeoutMs?: number;
-	resumeSessionId?: string;
-	onStream?: (text: string) => void;
-	onActivity?: (ev: ActivityEvent) => void;
+  prompt: string;
+  cwd: string;
+  permissionMode: string;
+  model?: string;
+  maxBudgetUsd?: number;
+  addDirs?: string[];
+  signal?: AbortSignal;
+  timeoutMs?: number;
+  resumeSessionId?: string;
+  onStream?: (text: string) => void;
+  onActivity?: (ev: ActivityEvent) => void;
 }
 
 export interface ClaudeResult extends StreamedResult {
-	streamedText: string;
+  streamedText: string;
 }
 
 export const DEFAULT_TIMEOUT_MS = 600_000;
 
 function mapPerm(mode: string): 'readonly' | 'edit' | 'danger' {
-	if (mode === 'plan') return 'readonly';
-	if (mode === 'bypassPermissions') return 'danger';
-	return 'edit';
+  if (mode === 'plan') return 'readonly';
+  if (mode === 'bypassPermissions') return 'danger';
+  return 'edit';
 }
 
 export function runClaude(opts: RunClaudeOptions): Promise<ClaudeResult> {
-	const perm = mapPerm(opts.permissionMode);
-	const nativePerm = perm === 'readonly' && opts.permissionMode !== 'plan' ? opts.permissionMode : perm === 'danger' && opts.permissionMode !== 'bypassPermissions' ? opts.permissionMode : undefined;
-	// normalize: if caller passed a non-standard mode, preserve as native
-	const isStandard = opts.permissionMode === 'plan' || opts.permissionMode === 'acceptEdits' || opts.permissionMode === 'bypassPermissions';
-	return runHarness({
-		harness: claudeHarness,
-		prompt: opts.prompt,
-		cwd: opts.cwd,
-		permission: perm,
-		nativePermission: isStandard ? undefined : opts.permissionMode,
-		model: opts.model,
-		maxBudgetUsd: opts.maxBudgetUsd,
-		addDirs: opts.addDirs,
-		signal: opts.signal,
-		timeoutMs: opts.timeoutMs,
-		resumeSessionId: opts.resumeSessionId,
-		onStream: opts.onStream,
-		onActivity: opts.onActivity,
-	}).then((r) => ({ ...r, streamedText: r.streamedText }));
+  const perm = mapPerm(opts.permissionMode);
+  const nativePerm =
+    perm === 'readonly' && opts.permissionMode !== 'plan'
+      ? opts.permissionMode
+      : perm === 'danger' && opts.permissionMode !== 'bypassPermissions'
+        ? opts.permissionMode
+        : undefined;
+  // normalize: if caller passed a non-standard mode, preserve as native
+  const isStandard =
+    opts.permissionMode === 'plan' ||
+    opts.permissionMode === 'acceptEdits' ||
+    opts.permissionMode === 'bypassPermissions';
+  return runHarness({
+    harness: claudeHarness,
+    prompt: opts.prompt,
+    cwd: opts.cwd,
+    permission: perm,
+    nativePermission: isStandard ? undefined : opts.permissionMode,
+    model: opts.model,
+    maxBudgetUsd: opts.maxBudgetUsd,
+    addDirs: opts.addDirs,
+    signal: opts.signal,
+    timeoutMs: opts.timeoutMs,
+    resumeSessionId: opts.resumeSessionId,
+    onStream: opts.onStream,
+    onActivity: opts.onActivity,
+  }).then(r => ({ ...r, streamedText: r.streamedText }));
 }

package/extensions/runner.ts

@@ -3,118 +3,130 @@ import { createInterface } from 'node:readline';
 import type { Harness, ParseState, StreamedResult } from './harnesses/types.ts';
 
 export interface RunHarnessOptions {
-	harness: Harness;
-	prompt: string;
-	cwd: string;
-	permission: import('./harnesses/types.ts').NormalizedPermission;
-	nativePermission?: string;
-	model?: string;
-	maxBudgetUsd?: number;
-	addDirs?: string[];
-	signal?: AbortSignal;
-	timeoutMs?: number;
-	resumeSessionId?: string;
-	onStream?: (text: string) => void;
-	onActivity?: (ev: import('./harnesses/types.ts').ActivityEvent) => void;
+  harness: Harness;
+  prompt: string;
+  cwd: string;
+  permission: import('./harnesses/types.ts').NormalizedPermission;
+  nativePermission?: string;
+  model?: string;
+  maxBudgetUsd?: number;
+  addDirs?: string[];
+  signal?: AbortSignal;
+  timeoutMs?: number;
+  resumeSessionId?: string;
+  onStream?: (text: string) => void;
+  onActivity?: (ev: import('./harnesses/types.ts').ActivityEvent) => void;
 }
 
 export interface HarnessResult extends StreamedResult {
-	streamedText: string;
-	harness: string;
+  streamedText: string;
+  harness: string;
 }
 
 import { DEFAULT_TIMEOUT_MS } from './harnesses/types.ts';
 
 export function runHarness(opts: RunHarnessOptions): Promise<HarnessResult> {
-	return new Promise((resolve, reject) => {
-		const args = opts.harness.buildArgs({
-			prompt: opts.prompt,
-			cwd: opts.cwd,
-			permission: opts.permission,
-			nativePermission: opts.nativePermission,
-			model: opts.model,
-			maxBudgetUsd: opts.maxBudgetUsd,
-			addDirs: opts.addDirs,
-			resumeSessionId: opts.resumeSessionId,
-		});
+  return new Promise((resolve, reject) => {
+    const args = opts.harness.buildArgs({
+      prompt: opts.prompt,
+      cwd: opts.cwd,
+      permission: opts.permission,
+      nativePermission: opts.nativePermission,
+      model: opts.model,
+      maxBudgetUsd: opts.maxBudgetUsd,
+      addDirs: opts.addDirs,
+      resumeSessionId: opts.resumeSessionId,
+    });
 
-		const proc = spawn(opts.harness.binary, args, { cwd: opts.cwd, stdio: ['ignore', 'pipe', 'pipe'] });
+    const proc = spawn(opts.harness.binary, args, { cwd: opts.cwd, stdio: ['ignore', 'pipe', 'pipe'] });
 
-		const state: ParseState = { streamedText: '', activities: [], result: null, _harness: {} };
-		let stderr = '';
-		let settled = false;
-		let firstTokenAt: number | null = null;
-		const startAt = Date.now();
+    const state: ParseState = { streamedText: '', activities: [], result: null, _harness: {} };
+    let stderr = '';
+    let settled = false;
+    let firstTokenAt: number | null = null;
+    const startAt = Date.now();
+    const MAX_STREAMED = 5 * 1024 * 1024; // 5MB cap to prevent OOM on compromised harness
+    const MAX_ACTIVITIES = 5000;
 
-		const finish = (r: StreamedResult) => {
-			if (settled) return;
-			settled = true;
-			clearTimeout(timer);
-			const ttft = firstTokenAt !== null ? firstTokenAt - startAt : r.ttftMs;
-			resolve({ ...r, ttftMs: ttft, streamedText: state.streamedText, harness: opts.harness.name });
-		};
-		const fail = (err: Error) => {
-			if (settled) return;
-			settled = true;
-			clearTimeout(timer);
-			reject(err);
-		};
+    const finish = (r: StreamedResult) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      const ttft = firstTokenAt !== null ? firstTokenAt - startAt : r.ttftMs;
+      resolve({ ...r, ttftMs: ttft, streamedText: state.streamedText, harness: opts.harness.name });
+    };
+    const fail = (err: Error) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      reject(err);
+    };
 
-		const rl = createInterface({ input: proc.stdout });
-		rl.on('line', (line) => {
-			const outcome = opts.harness.parseLine(line, state);
-			if (outcome.streamedText) {
-				if (firstTokenAt === null) firstTokenAt = Date.now();
-				state.streamedText += outcome.streamedText;
-				opts.onStream?.(outcome.streamedText);
-			}
-			if (outcome.activities) {
-				for (const a of outcome.activities) {
-					state.activities.push(a);
-					opts.onActivity?.(a);
-				}
-			}
-			if (outcome.result) {
-				// merge streamedText into result if empty
-				if (!outcome.result.result) outcome.result.result = state.streamedText;
-				state.result = outcome.result;
-			}
-		});
+    const rl = createInterface({ input: proc.stdout });
+    rl.on('line', line => {
+      const outcome = opts.harness.parseLine(line, state);
+      if (outcome.streamedText) {
+        if (firstTokenAt === null) firstTokenAt = Date.now();
+        // Cap streamedText to prevent OOM on compromised harness
+        if (state.streamedText.length < MAX_STREAMED) {
+          const remaining = MAX_STREAMED - state.streamedText.length;
+          const chunk =
+            outcome.streamedText.length > remaining
+              ? `${outcome.streamedText.slice(0, remaining)} [truncated ${outcome.streamedText.length - remaining} chars]`
+              : outcome.streamedText;
+          state.streamedText += chunk;
+          opts.onStream?.(chunk);
+        }
+      }
+      if (outcome.activities) {
+        for (const a of outcome.activities) {
+          if (state.activities.length < MAX_ACTIVITIES) {
+            state.activities.push(a);
+            opts.onActivity?.(a);
+          }
+        }
+      }
+      if (outcome.result) {
+        // merge streamedText into result if empty
+        if (!outcome.result.result) outcome.result.result = state.streamedText;
+        state.result = outcome.result;
+      }
+    });
 
-		proc.stderr.on('data', (d: Buffer) => (stderr += d.toString()));
-		proc.on('close', (code) => {
-			// Don't synthesize fallback on non-zero exit without explicit result — surface the error
-			if (code !== 0 && !state.result) {
-				fail(new Error(stderr.trim() || `${opts.harness.binary} exited with code ${code}`));
-				return;
-			}
-			const final = opts.harness.extractResult(state);
-			if (final) {
-				if (!final.result) final.result = state.streamedText;
-				finish(final);
-			} else if (code !== 0) {
-				fail(new Error(stderr.trim() || `${opts.harness.binary} exited with code ${code}`));
-			} else {
-				fail(new Error(`${opts.harness.binary} finished without emitting a result`));
-			}
-		});
-		proc.on('error', (err) => {
-			fail(new Error(`failed to start ${opts.harness.binary}: ${err.message}`));
-		});
+    proc.stderr.on('data', (d: Buffer) => (stderr += d.toString()));
+    proc.on('close', code => {
+      // Don't synthesize fallback on non-zero exit without explicit result — surface the error
+      if (code !== 0 && !state.result) {
+        fail(new Error(stderr.trim() || `${opts.harness.binary} exited with code ${code}`));
+        return;
+      }
+      const final = opts.harness.extractResult(state);
+      if (final) {
+        if (!final.result) final.result = state.streamedText;
+        finish(final);
+      } else if (code !== 0) {
+        fail(new Error(stderr.trim() || `${opts.harness.binary} exited with code ${code}`));
+      } else {
+        fail(new Error(`${opts.harness.binary} finished without emitting a result`));
+      }
+    });
+    proc.on('error', err => {
+      fail(new Error(`failed to start ${opts.harness.binary}: ${err.message}`));
+    });
 
-		const timer = setTimeout(() => {
-			proc.kill('SIGKILL');
-			fail(new Error(`${opts.harness.binary} timed out after ${opts.timeoutMs ?? DEFAULT_TIMEOUT_MS}ms`));
-		}, opts.timeoutMs ?? DEFAULT_TIMEOUT_MS);
-		timer.unref?.();
+    const timer = setTimeout(() => {
+      proc.kill('SIGKILL');
+      fail(new Error(`${opts.harness.binary} timed out after ${opts.timeoutMs ?? DEFAULT_TIMEOUT_MS}ms`));
+    }, opts.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+    timer.unref?.();
 
-		opts.signal?.addEventListener(
-			'abort',
-			() => {
-				proc.kill('SIGKILL');
-				fail(new Error('cancelled'));
-			},
-			{ once: true },
-		);
-	});
+    opts.signal?.addEventListener(
+      'abort',
+      () => {
+        proc.kill('SIGKILL');
+        fail(new Error('cancelled'));
+      },
+      { once: true },
+    );
+  });
 }

package/extensions/stream-parse.ts

@@ -1,29 +1,37 @@
 /** @deprecated use extensions/harnesses/claude.ts parse directly */
-export type { StreamedUsage, StreamedResult, ActivityEvent, StreamParseOutcome, ParseState, ParseOutcome } from './harnesses/types.ts';
-import type { ParseState, StreamParseOutcome } from './harnesses/types.ts';
+export type {
+  ActivityEvent,
+  ParseOutcome,
+  ParseState,
+  StreamedResult,
+  StreamedUsage,
+  StreamParseOutcome,
+} from './harnesses/types.ts';
+
 import { parseClaudeLine } from './harnesses/claude.ts';
+import type { ParseState, StreamParseOutcome } from './harnesses/types.ts';
 
 export function parseStreamLines(lines: Iterable<string>): StreamParseOutcome {
-	const state: ParseState = { streamedText: '', activities: [], result: null };
-	let streamedText = '';
-	const activities: StreamParseOutcome['activities'] = [];
-	let result: StreamParseOutcome['result'] = null;
-	for (const line of lines) {
-		const out = parseClaudeLine(line, state);
-		if (out.streamedText) {
-			streamedText += out.streamedText;
-			state.streamedText += out.streamedText;
-		}
-		if (out.activities) {
-			for (const a of out.activities) {
-				activities.push(a);
-				state.activities.push(a);
-			}
-		}
-		if (out.result) {
-			result = out.result;
-			state.result = out.result;
-		}
-	}
-	return { streamedText, result, activities };
+  const state: ParseState = { streamedText: '', activities: [], result: null };
+  let streamedText = '';
+  const activities: StreamParseOutcome['activities'] = [];
+  let result: StreamParseOutcome['result'] = null;
+  for (const line of lines) {
+    const out = parseClaudeLine(line, state);
+    if (out.streamedText) {
+      streamedText += out.streamedText;
+      state.streamedText += out.streamedText;
+    }
+    if (out.activities) {
+      for (const a of out.activities) {
+        activities.push(a);
+        state.activities.push(a);
+      }
+    }
+    if (out.result) {
+      result = out.result;
+      state.result = out.result;
+    }
+  }
+  return { streamedText, result, activities };
 }