@robota-sdk/agent-transport 3.0.0-beta.78 → 3.0.0-beta.81

package/src/headless/cli-input.ts

@@ -1,50 +0,0 @@
-const PRINTABLE_ASCII_START = 32;
-
-export const promptInput = (label: string, masked = false): Promise<string> =>
-  new Promise<string>((resolve, reject) => {
-    process.stdout.write(label);
-    let input = '';
-    const stdin = process.stdin;
-    const wasRaw = stdin.isRaw;
-    if (!stdin.isTTY) {
-      reject(
-        new Error(
-          'Cannot prompt for input: stdin is not a TTY.\n' +
-            'Set your API key via environment variable instead:\n' +
-            '  ANTHROPIC_API_KEY=<key> robota\n' +
-            '  OPENAI_API_KEY=<key> robota',
-        ),
-      );
-      return;
-    }
-    stdin.setRawMode(true);
-    stdin.resume();
-    stdin.setEncoding('utf8');
-    const onData = (data: string): void => {
-      for (const ch of data) {
-        if (ch === '\r' || ch === '\n') {
-          stdin.removeListener('data', onData);
-          stdin.setRawMode(wasRaw ?? false);
-          stdin.pause();
-          process.stdout.write('\n');
-          resolve(input.trim());
-          return;
-        } else if (ch === '\x7f' || ch === '\b') {
-          if (input.length > 0) {
-            input = input.slice(0, -1);
-            process.stdout.write('\b \b');
-          }
-        } else if (ch === '\x03') {
-          stdin.removeListener('data', onData);
-          stdin.setRawMode(wasRaw ?? false);
-          stdin.pause();
-          process.stdout.write('\n');
-          process.exit(0);
-        } else if (ch.charCodeAt(0) >= PRINTABLE_ASCII_START) {
-          input += ch;
-          process.stdout.write(masked ? '*' : ch);
-        }
-      }
-    };
-    stdin.on('data', onData);
-  });

package/src/headless/headless-runner.ts

@@ -1,230 +0,0 @@
-import { executeSlashCommandIfPresent, subscribeStreamJsonEvents } from './headless-stream-json.js';
-
-import type {
-  IExecutionResult,
-  IGoalEvent,
-  IInteractiveSession,
-} from '@robota-sdk/agent-interface-transport';
-
-export type TOutputFormat = 'text' | 'json' | 'stream-json';
-
-/** GOAL-001: options for an autonomous headless goal run. */
-export interface IHeadlessGoalOptions {
-  maxIterations?: number;
-}
-
-export interface IHeadlessRunnerOptions {
-  session: IInteractiveSession;
-  outputFormat: TOutputFormat;
-}
-
-/** Exit code for a goal that stopped cleanly without being satisfied (bound/convergence/cancel). */
-export const GOAL_NOT_SATISFIED_EXIT_CODE = 2;
-
-export function createHeadlessRunner(options: IHeadlessRunnerOptions): {
-  run: (prompt: string) => Promise<number>;
-  runGoal: (objective: string, goalOptions?: IHeadlessGoalOptions) => Promise<number>;
-} {
-  const { session, outputFormat } = options;
-  return {
-    run: (prompt: string): Promise<number> => {
-      if (outputFormat === 'text') return runTextFormat(session, prompt);
-      if (outputFormat === 'json') return runJsonFormat(session, prompt);
-      return runStreamJsonFormat(session, prompt);
-    },
-    runGoal: (objective: string, goalOptions: IHeadlessGoalOptions = {}): Promise<number> =>
-      runGoalFormat(session, objective, goalOptions, outputFormat),
-  };
-}
-
-/**
- * GOAL-001: drive an autonomous goal to completion in headless mode. Streams each turn's response
- * for progress, then resolves when the goal stops: exit 0 if satisfied, {@link GOAL_NOT_SATISFIED_EXIT_CODE}
- * if it stopped at a bound (max-iterations / no-progress / cancelled), or 1 on a turn error.
- */
-function runGoalFormat(
-  session: IInteractiveSession,
-  objective: string,
-  goalOptions: IHeadlessGoalOptions,
-  outputFormat: TOutputFormat,
-): Promise<number> {
-  return new Promise<number>((resolve) => {
-    const cleanup = (): void => {
-      session.off('complete', onComplete);
-      session.off('error', onError);
-      session.off('goal_event', onGoal);
-    };
-    const onComplete = (result: IExecutionResult): void => {
-      if (result.response) process.stdout.write(result.response + '\n');
-    };
-    const onError = (error: Error): void => {
-      cleanup();
-      if (outputFormat === 'text') process.stderr.write(error.message + '\n');
-      else writeJsonResult(getSessionId(session), '', 'error', error);
-      resolve(1);
-    };
-    const onGoal = (event: IGoalEvent): void => {
-      if (event.type !== 'goal_stopped') return;
-      cleanup();
-      const goal = event.goal;
-      const satisfied = goal.stopReason === 'satisfied';
-      const summary = satisfied
-        ? `Goal satisfied after ${goal.iterations} iteration(s).`
-        : `Goal stopped: ${goal.stopReason} (after ${goal.iterations} iteration(s)).`;
-      if (outputFormat === 'text')
-        (satisfied ? process.stdout : process.stderr).write(summary + '\n');
-      else writeJsonResult(getSessionId(session), summary, satisfied ? 'success' : 'error');
-      resolve(satisfied ? 0 : GOAL_NOT_SATISFIED_EXIT_CODE);
-    };
-
-    session.on('complete', onComplete);
-    session.on('error', onError);
-    session.on('goal_event', onGoal);
-
-    void session.setGoal(
-      objective,
-      goalOptions.maxIterations ? { maxIterations: goalOptions.maxIterations } : {},
-    );
-  });
-}
-
-export function resolveErrorCode(error: Error): string {
-  const msg = error.message.toLowerCase();
-  if (msg.includes('api key') || msg.includes('no provider') || msg.includes('provider')) {
-    return 'config_error';
-  }
-  if (msg.includes('tool') || msg.includes('execution')) {
-    return 'tool_error';
-  }
-  return 'api_error';
-}
-
-export function writeJsonResult(
-  sessionId: string,
-  result: string,
-  subtype: 'success' | 'error',
-  error?: Error,
-): void {
-  const payload: Record<string, unknown> = {
-    type: 'result',
-    result,
-    session_id: sessionId,
-    subtype,
-  };
-  if (subtype === 'error' && error !== undefined) {
-    payload['error_code'] = resolveErrorCode(error);
-  }
-  const output = JSON.stringify(payload);
-  process.stdout.write(output + '\n');
-}
-
-export function getSessionId(session: IInteractiveSession): string {
-  try {
-    return session.getSession().getSessionId();
-  } catch {
-    // allow-fallback: session may not be initialized yet
-    return '';
-  }
-}
-
-function runTextFormat(session: IInteractiveSession, prompt: string): Promise<number> {
-  return new Promise<number>((resolve) => {
-    const cleanup = (): void => {
-      session.off('complete', onComplete);
-      session.off('interrupted', onInterrupted);
-      session.off('error', onError);
-    };
-    const onComplete = (result: IExecutionResult): void => {
-      cleanup();
-      process.stdout.write(result.response + '\n');
-      resolve(0);
-    };
-    const onInterrupted = (result: IExecutionResult): void => {
-      cleanup();
-      if (result.response) process.stdout.write(result.response + '\n');
-      resolve(0);
-    };
-    const onError = (error: Error): void => {
-      cleanup();
-      process.stderr.write(error.message + '\n');
-      resolve(1);
-    };
-
-    session.on('complete', onComplete);
-    session.on('interrupted', onInterrupted);
-    session.on('error', onError);
-
-    void executeSlashCommandIfPresent(session, prompt).then((cmd) => {
-      if (cmd.kind === 'command-result') {
-        cleanup();
-        process.stdout.write(cmd.result.message + '\n');
-        resolve(cmd.result.success ? 0 : 1);
-        return;
-      }
-      if (cmd.kind !== 'session-execution') void session.submit(prompt);
-    });
-  });
-}
-
-function runJsonFormat(session: IInteractiveSession, prompt: string): Promise<number> {
-  return new Promise<number>((resolve) => {
-    const cleanup = (): void => {
-      session.off('complete', onComplete);
-      session.off('interrupted', onInterrupted);
-      session.off('error', onError);
-    };
-    const onComplete = (result: IExecutionResult): void => {
-      cleanup();
-      writeJsonResult(getSessionId(session), result.response, 'success');
-      resolve(0);
-    };
-    const onInterrupted = (result: IExecutionResult): void => {
-      cleanup();
-      writeJsonResult(getSessionId(session), result.response, 'success');
-      resolve(0);
-    };
-    const onError = (error: Error): void => {
-      cleanup();
-      writeJsonResult(getSessionId(session), '', 'error', error);
-      resolve(1);
-    };
-
-    session.on('complete', onComplete);
-    session.on('interrupted', onInterrupted);
-    session.on('error', onError);
-
-    void executeSlashCommandIfPresent(session, prompt).then((cmd) => {
-      if (cmd.kind === 'command-result') {
-        cleanup();
-        writeJsonResult(
-          getSessionId(session),
-          cmd.result.message,
-          cmd.result.success ? 'success' : 'error',
-        );
-        resolve(cmd.result.success ? 0 : 1);
-        return;
-      }
-      if (cmd.kind !== 'session-execution') void session.submit(prompt);
-    });
-  });
-}
-
-function runStreamJsonFormat(session: IInteractiveSession, prompt: string): Promise<number> {
-  return new Promise<number>((resolve) => {
-    const cleanup = subscribeStreamJsonEvents(session, getSessionId, writeJsonResult, resolve);
-
-    void executeSlashCommandIfPresent(session, prompt).then((cmd) => {
-      if (cmd.kind === 'command-result') {
-        cleanup();
-        writeJsonResult(
-          getSessionId(session),
-          cmd.result.message,
-          cmd.result.success ? 'success' : 'error',
-        );
-        resolve(cmd.result.success ? 0 : 1);
-        return;
-      }
-      if (cmd.kind !== 'session-execution') void session.submit(prompt);
-    });
-  });
-}

package/src/headless/headless-stream-json.ts

@@ -1,148 +0,0 @@
-import { randomUUID } from 'node:crypto';
-
-import type {
-  ICommandResult,
-  IExecutionResult,
-  IInteractiveSession,
-  TBackgroundJobGroupEvent,
-} from '@robota-sdk/agent-interface-transport';
-import type { TBackgroundTaskEvent } from '@robota-sdk/agent-interface-transport';
-
-type TSlashCommandExecution =
-  | { readonly kind: 'not-slash' }
-  | { readonly kind: 'command-result'; readonly result: ICommandResult }
-  | { readonly kind: 'session-execution' };
-
-function parseSlashCommand(prompt: string): { name: string; args: string } | null {
-  const trimmed = prompt.trimStart();
-  if (!trimmed.startsWith('/')) return null;
-  const withoutSlash = trimmed.slice(1);
-  const [name = '', ...args] = withoutSlash.split(/\s+/);
-  if (name.length === 0) return null;
-  return { name, args: args.join(' ') };
-}
-
-export async function executeSlashCommandIfPresent(
-  session: IInteractiveSession,
-  prompt: string,
-): Promise<TSlashCommandExecution> {
-  const command = parseSlashCommand(prompt);
-  if (!command) return { kind: 'not-slash' };
-
-  const result = await session.executeCommand(command.name, command.args);
-  if (result) {
-    if (result.effects?.some((effect) => effect.type === 'session-execution-started')) {
-      return { kind: 'session-execution' };
-    }
-    return { kind: 'command-result', result };
-  }
-  return {
-    kind: 'command-result',
-    result: { message: `Unknown command "/${command.name}".`, success: false },
-  };
-}
-
-type TStreamJsonEvent =
-  | {
-      type: 'content_block_delta';
-      delta: { type: 'text_delta'; text: string };
-    }
-  | {
-      type: 'background_task_event';
-      background_task_event: TBackgroundTaskEvent;
-    }
-  | {
-      type: 'background_job_group_event';
-      background_job_group_event: TBackgroundJobGroupEvent;
-    };
-
-interface IStreamJsonHandlers {
-  onTextDelta: (text: string) => void;
-  onBackgroundTaskEvent: (event: TBackgroundTaskEvent) => void;
-  onBackgroundJobGroupEvent: (event: TBackgroundJobGroupEvent) => void;
-  onComplete: (result: IExecutionResult) => void;
-  onInterrupted: (result: IExecutionResult) => void;
-  onError: (error: Error) => void;
-}
-
-function writeStreamJsonEvent(
-  session: IInteractiveSession,
-  getSessionId: (s: IInteractiveSession) => string,
-  event: TStreamJsonEvent,
-): void {
-  const output = JSON.stringify({
-    type: 'stream_event',
-    event,
-    session_id: getSessionId(session),
-    uuid: randomUUID(),
-  });
-  process.stdout.write(output + '\n');
-}
-
-export function subscribeStreamJsonEvents(
-  session: IInteractiveSession,
-  getSessionId: (s: IInteractiveSession) => string,
-  writeJsonResult: (
-    sessionId: string,
-    result: string,
-    subtype: 'success' | 'error',
-    error?: Error,
-  ) => void,
-  resolve: (exitCode: number) => void,
-): () => void {
-  const emit = (event: TStreamJsonEvent): void =>
-    writeStreamJsonEvent(session, getSessionId, event);
-
-  const onTextDelta = (text: string): void =>
-    emit({ type: 'content_block_delta', delta: { type: 'text_delta', text } });
-  const onBackgroundTaskEvent = (event: TBackgroundTaskEvent): void =>
-    emit({ type: 'background_task_event', background_task_event: event });
-  const onBackgroundJobGroupEvent = (event: TBackgroundJobGroupEvent): void =>
-    emit({ type: 'background_job_group_event', background_job_group_event: event });
-
-  const cleanup = (): void =>
-    unsubscribeStreamJsonEvents(session, {
-      onTextDelta,
-      onBackgroundTaskEvent,
-      onBackgroundJobGroupEvent,
-      onComplete,
-      onInterrupted,
-      onError,
-    });
-
-  const onComplete = (result: IExecutionResult): void => {
-    cleanup();
-    writeJsonResult(getSessionId(session), result.response, 'success');
-    resolve(0);
-  };
-  const onInterrupted = (result: IExecutionResult): void => {
-    cleanup();
-    writeJsonResult(getSessionId(session), result.response, 'success');
-    resolve(0);
-  };
-  const onError = (error: Error): void => {
-    cleanup();
-    writeJsonResult(getSessionId(session), '', 'error', error);
-    resolve(1);
-  };
-
-  session.on('text_delta', onTextDelta);
-  session.on('background_task_event', onBackgroundTaskEvent);
-  session.on('background_job_group_event', onBackgroundJobGroupEvent);
-  session.on('complete', onComplete);
-  session.on('interrupted', onInterrupted);
-  session.on('error', onError);
-  return cleanup;
-}
-
-function unsubscribeStreamJsonEvents(
-  session: IInteractiveSession,
-  handlers: IStreamJsonHandlers,
-): void {
-  session.off('text_delta', handlers.onTextDelta);
-  session.off('background_task_event', handlers.onBackgroundTaskEvent);
-  session.off('background_job_group_event', handlers.onBackgroundJobGroupEvent);
-  session.off('complete', handlers.onComplete);
-  session.off('interrupted', handlers.onInterrupted);
-  session.off('error', handlers.onError);
-}

package/src/headless/headless-transport.ts

@@ -1,43 +0,0 @@
-/**
- * ITransportAdapter implementation for headless transport.
- *
- * Wraps createHeadlessRunner into the unified ITransportAdapter interface.
- * After start() completes, getExitCode() returns the runner's exit code.
- */
-
-import { createHeadlessRunner } from './headless-runner.js';
-
-import type { TOutputFormat } from './headless-runner.js';
-import type { IInteractiveSession, ITransportAdapter } from '@robota-sdk/agent-interface-transport';
-
-export interface IHeadlessTransportOptions {
-  /** Output format: 'text', 'json', or 'stream-json'. */
-  outputFormat: TOutputFormat;
-  /** The prompt to execute. */
-  prompt: string;
-}
-
-export function createHeadlessTransport(
-  options: IHeadlessTransportOptions,
-): ITransportAdapter<IInteractiveSession> & { getExitCode(): number } {
-  let session: IInteractiveSession | null = null;
-  let exitCode = 0;
-
-  return {
-    name: 'headless',
-    attach(s: IInteractiveSession) {
-      session = s;
-    },
-    async start() {
-      if (!session) throw new Error('No session attached. Call attach() first.');
-      const runner = createHeadlessRunner({ session, outputFormat: options.outputFormat });
-      exitCode = await runner.run(options.prompt);
-    },
-    async stop() {
-      /* no-op: headless runner completes in start() */
-    },
-    getExitCode() {
-      return exitCode;
-    },
-  };
-}

package/src/headless/index.ts

@@ -1,8 +0,0 @@
-export { PrintTerminal } from './print-terminal.js';
-export { promptInput } from './cli-input.js';
-export { createHeadlessRunner } from './headless-runner.js';
-export type { IHeadlessRunnerOptions, TOutputFormat } from './headless-runner.js';
-export { createHeadlessTransport } from './headless-transport.js';
-export type { IHeadlessTransportOptions } from './headless-transport.js';
-export { HeadlessInteractionChannel } from './HeadlessInteractionChannel.js';
-export type { IHeadlessInteractionChannelOptions } from './HeadlessInteractionChannel.js';

package/src/headless/print-terminal.ts

@@ -1,57 +0,0 @@
-/**
- * ITerminalOutput implementation for print mode (-p).
- *
- * Writes to stdout/stderr directly. The readline-based prompt and select are
- * only invoked if the agent triggers a permission-gated tool, which is rare in
- * one-shot print mode but must still work correctly.
- */
-
-import * as readline from 'node:readline';
-
-import type { ITerminalOutput, ISpinner } from '@robota-sdk/agent-core';
-
-export class PrintTerminal implements ITerminalOutput {
-  write(text: string): void {
-    process.stdout.write(text);
-  }
-  writeLine(text: string): void {
-    process.stdout.write(text + '\n');
-  }
-  writeMarkdown(md: string): void {
-    process.stdout.write(md);
-  }
-  writeError(text: string): void {
-    process.stderr.write(text + '\n');
-  }
-  prompt(question: string): Promise<string> {
-    return new Promise<string>((resolve) => {
-      const rl = readline.createInterface({
-        input: process.stdin,
-        output: process.stdout,
-        terminal: false,
-        historySize: 0,
-      });
-      rl.question(question, (answer) => {
-        rl.close();
-        resolve(answer);
-      });
-    });
-  }
-  async select(options: string[], initialIndex = 0): Promise<number> {
-    for (let i = 0; i < options.length; i++) {
-      const marker = i === initialIndex ? '>' : ' ';
-      process.stdout.write(`  ${marker} ${i + 1}) ${options[i]}\n`);
-    }
-    const answer = await this.prompt(
-      `  Choose [1-${options.length}] (default: ${options[initialIndex]}): `,
-    );
-    const trimmed = answer.trim().toLowerCase();
-    if (trimmed === '') return initialIndex;
-    const num = parseInt(trimmed, 10);
-    if (!isNaN(num) && num >= 1 && num <= options.length) return num - 1;
-    return initialIndex;
-  }
-  spinner(_message: string): ISpinner {
-    return { stop(): void {}, update(): void {} };
-  }
-}

package/src/programmatic/ProgrammaticInteractionChannel.ts

@@ -1,82 +0,0 @@
-/**
- * ProgrammaticInteractionChannel — an in-process IInteractionChannel adapter (INFRA-019).
- *
- * The "programmatic preset" adapter slot reserved by the interaction contract: instead of an Ink TUI
- * or a print runner, this channel lets a caller push a message in-process and read back the structured
- * `InteractionEvent` stream the framework already emits. It uses the documented one-way `write()`
- * protocol consumed by `createInteractiveRuntime` (not the TUI's direct-wiring path).
- *
- * Production transport adapter — lives in transport core. Tests and automation consume it; it never
- * depends on test code.
- */
-
-import type { IActionRequest, TActionResponse } from '@robota-sdk/agent-core';
-import type {
-  IInteractionChannel,
-  ICommandInfo,
-  InteractionEvent,
-} from '@robota-sdk/agent-interface-transport';
-
-export class ProgrammaticInteractionChannel implements IInteractionChannel {
-  /** Full structured event stream pushed by the framework, in order. */
-  readonly events: InteractionEvent[] = [];
-
-  availableCommands: ICommandInfo[] = [];
-  busy = false;
-  started = false;
-  stopped = false;
-
-  private submitHandler: ((text: string) => Promise<void>) | null = null;
-  private readonly userActionResponses: TActionResponse[] = [];
-
-  // ── IInteractionChannel ──────────────────────────────────────
-
-  onSubmit(handler: (text: string) => Promise<void>): void {
-    this.submitHandler = handler;
-  }
-
-  write(event: InteractionEvent): void {
-    this.events.push(event);
-  }
-
-  /**
-   * CMD-004 unified ask. Resolves from the pre-supplied queue (FIFO); an empty queue resolves
-   * `{ type: 'cancelled' }` so a programmatic run never blocks on an un-answered question.
-   */
-  async askUser(_request: IActionRequest): Promise<TActionResponse> {
-    return this.userActionResponses.shift() ?? { type: 'cancelled' };
-  }
-
-  setAvailableCommands(commands: ICommandInfo[]): void {
-    this.availableCommands = commands;
-  }
-
-  setBusy(busy: boolean): void {
-    this.busy = busy;
-  }
-
-  async start(): Promise<void> {
-    this.started = true;
-  }
-
-  async stop(): Promise<void> {
-    this.stopped = true;
-  }
-
-  // ── Programmatic driving surface ─────────────────────────────
-
-  /** Push a user submission into the framework (the programmatic "user types and presses enter"). */
-  async submit(text: string): Promise<void> {
-    if (!this.submitHandler) {
-      throw new Error(
-        'ProgrammaticInteractionChannel: no submit handler registered — start the runtime first',
-      );
-    }
-    await this.submitHandler(text);
-  }
-
-  /** Pre-answer the next `askUser` (CMD-004 unified ask). */
-  queueUserAction(response: TActionResponse): void {
-    this.userActionResponses.push(response);
-  }
-}

package/src/programmatic/createProgrammaticAgent.ts

@@ -1,71 +0,0 @@
-/**
- * createProgrammaticAgent — the in-process implementation of the client-side agent contract
- * (`IAgentDriver`, INFRA-020; introduced as the programmatic driver in INFRA-019).
- *
- * Wraps `createInteractiveRuntime` with a {@link ProgrammaticInteractionChannel} so a caller can drive
- * the real agent structurally: `start()`, `send(text)` (awaits the whole turn), then read assistant
- * replies / tool calls / errors as data — no terminal, no PTY, no scraping. The observation accessors
- * delegate to the shared `read*` helpers in `@robota-sdk/agent-interface-transport`, so the
- * filter/derivation logic is not re-implemented here.
- */
-
-import { createInteractiveRuntime } from '@robota-sdk/agent-framework';
-import {
-  readAssistantReplies,
-  readErrors,
-  readLastAssistantText,
-  readToolCalls,
-} from '@robota-sdk/agent-interface-transport';
-
-import { ProgrammaticInteractionChannel } from './ProgrammaticInteractionChannel.js';
-
-import type { IAIProvider, TActionResponse, TPermissionMode } from '@robota-sdk/agent-core';
-import type { ICommandModule, IInteractiveRuntime } from '@robota-sdk/agent-framework';
-import type { IAgentDriver, IInteractiveSessionStore } from '@robota-sdk/agent-interface-transport';
-
-export interface ICreateProgrammaticAgentOptions {
-  /** Provider that answers the agent loop (e.g. a real provider, or the scripted provider in tests). */
-  provider: IAIProvider;
-  /** Working directory for session creation. */
-  cwd: string;
-  /** Slash-command modules to register (defaults to none). */
-  commandModules?: readonly ICommandModule[];
-  /** Optional session store for persistence. */
-  sessionStore?: IInteractiveSessionStore;
-  /** Permission mode for tool execution (e.g. `'bypassPermissions'` for unattended driving). */
-  permissionMode?: TPermissionMode;
-}
-
-/**
- * Construct an in-process {@link IAgentDriver} bound to a real `InteractiveSession`. The returned
- * driver's accessors are the shared `read*` helpers applied to the captured event stream.
- */
-export function createProgrammaticAgent(options: ICreateProgrammaticAgentOptions): IAgentDriver {
-  const channel = new ProgrammaticInteractionChannel();
-  const runtime: IInteractiveRuntime = createInteractiveRuntime({
-    channel,
-    commandModules: options.commandModules ?? [],
-    provider: options.provider,
-    cwd: options.cwd,
-    sessionStore: options.sessionStore,
-    permissionMode: options.permissionMode,
-  });
-
-  let started = false;
-
-  return {
-    events: channel.events,
-    start: async (): Promise<void> => {
-      if (started) return;
-      started = true;
-      await runtime.start();
-    },
-    send: (text: string): Promise<void> => channel.submit(text),
-    queueUserAction: (response: TActionResponse): void => channel.queueUserAction(response),
-    assistantReplies: (): string[] => readAssistantReplies(channel.events),
-    lastAssistantText: (): string | undefined => readLastAssistantText(channel.events),
-    toolCalls: () => readToolCalls(channel.events),
-    errors: (): Error[] => readErrors(channel.events),
-    stop: (): Promise<void> => runtime.stop(),
-  };
-}