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

package/src/ws-transport.ts

@@ -1,35 +1,81 @@
 /**
  * ITransportAdapter implementation for WebSocket transport.
  *
- * Wraps createWsHandler into the unified ITransportAdapter interface.
+ * Wraps createSessionMessageHandler into the unified ITransportAdapter interface.
  * After start(), the consumer must wire onMessage to their WebSocket.
  */
 
-import { createWsHandler } from './ws-handler.js';
+import { createOutboundDelivery, createSessionMessageHandler } from '@robota-sdk/agent-transport';
 
-import type { TServerMessage } from './ws-protocol.js';
-import type { IInteractiveSession, ITransportAdapter } from '@robota-sdk/agent-interface-transport';
+import type { TUsageSurface } from '@robota-sdk/agent-interface-analytics';
+import type { TDriverId } from '@robota-sdk/agent-interface-session';
+import type {
+  ITransportAdapter,
+  ITransportLifecycleError,
+} from '@robota-sdk/agent-interface-transport';
+import type {
+  IProtocolSession,
+  ISessionMessageHandlerOptions,
+  TServerMessage,
+} from '@robota-sdk/agent-transport';
 
 export interface IWsTransportOptions {
   /** Send a JSON message to the connected WebSocket client. */
   send: (message: TServerMessage) => void;
+  /** Owning socket lifecycle callback for outbound session-event delivery failures. */
+  onDeliveryError?: (error: Error, event: string) => void;
+  personalUsageReporter?: ISessionMessageHandlerOptions['personalUsageReporter'];
+  usageReporter?: ISessionMessageHandlerOptions['usageReporter'];
+  storedSessionUsageReporter?: ISessionMessageHandlerOptions['storedSessionUsageReporter'];
+  driverId?: TDriverId;
+  surface?: TUsageSurface;
 }
 
-export function createWsTransport(
-  options: IWsTransportOptions,
-): ITransportAdapter<IInteractiveSession> & { onMessage: ((data: string) => void) | null } {
-  let session: IInteractiveSession | null = null;
+export interface IWsTransport extends ITransportAdapter<IProtocolSession> {
+  onMessage: ((data: string) => void) | null;
+}
+
+export function createWsTransport(options: IWsTransportOptions): IWsTransport {
+  let session: IProtocolSession | null = null;
   let cleanup: (() => void) | null = null;
+  const lifecycleError = (code: ITransportLifecycleError['code']): ITransportLifecycleError =>
+    Object.assign(new Error(`WebSocket transport ${code}.`), {
+      name: 'TransportLifecycleError' as const,
+      code,
+      transportName: 'ws',
+    });
 
-  return {
+  const transport: IWsTransport = {
     name: 'ws',
+    lifecycle: Object.freeze({ kind: 'service' }),
     onMessage: null,
-    attach(s: IInteractiveSession) {
+    attach(s: IProtocolSession) {
       session = s;
     },
     async start() {
-      if (!session) throw new Error('No session attached. Call attach() first.');
-      const handler = createWsHandler({ session, send: options.send });
+      if (!session) throw lifecycleError('not-attached');
+      if (cleanup) throw lifecycleError('already-started');
+      // ARCH-030: this adapter is the carrier here, so it builds the connection's outbound boundary
+      // from its own injected sink and its own failure policy, then passes it down.
+      const deliver = createOutboundDelivery(options.send, (error, event) => {
+        handler.cleanup();
+        cleanup = null;
+        transport.onMessage = null;
+        options.onDeliveryError?.(error, event);
+      });
+      const handler = createSessionMessageHandler({
+        session,
+        deliver,
+        ...(options.driverId ? { driverId: options.driverId } : {}),
+        ...(options.surface ? { surface: options.surface } : {}),
+        ...(options.personalUsageReporter
+          ? { personalUsageReporter: options.personalUsageReporter }
+          : {}),
+        ...(options.usageReporter ? { usageReporter: options.usageReporter } : {}),
+        ...(options.storedSessionUsageReporter
+          ? { storedSessionUsageReporter: options.storedSessionUsageReporter }
+          : {}),
+      });
       cleanup = handler.cleanup;
       this.onMessage = handler.onMessage;
     },
@@ -37,6 +83,8 @@ export function createWsTransport(
       cleanup?.();
       cleanup = null;
       this.onMessage = null;
+      session = null;
     },
   };
+  return transport;
 }

package/src/__tests__/ws-handler.test.ts

@@ -1,429 +0,0 @@
-/**
- * Tests for WebSocket transport handler.
- */
-
-import { describe, it, expect, vi } from 'vitest';
-import { createWsHandler } from '../ws-handler.js';
-import type { TServerMessage } from '../ws-protocol.js';
-import type {
-  IBackgroundJobGroupState,
-  IExecutionWorkspaceEvent,
-  IExecutionWorkspaceSnapshot,
-  IInteractiveSession,
-  TBackgroundJobGroupEvent,
-  TExecutionWorkspaceUpdateCause,
-} from '@robota-sdk/agent-interface-transport';
-import type {
-  IBackgroundTaskLogPage,
-  IBackgroundTaskState,
-  TBackgroundTaskEvent,
-} from '@robota-sdk/agent-interface-transport';
-
-const backgroundTask: IBackgroundTaskState = {
-  id: 'task_1',
-  kind: 'agent',
-  label: 'Explore',
-  agentType: 'Explore',
-  status: 'running',
-  mode: 'background',
-  parentSessionId: 'session_1',
-  depth: 0,
-  cwd: '/repo',
-  updatedAt: '2026-05-01T00:00:00.000Z',
-  unread: false,
-  promptPreview: 'inspect code',
-};
-
-const backgroundTaskLogPage: IBackgroundTaskLogPage = {
-  taskId: 'task_1',
-  cursor: { offset: 0 },
-  lines: ['line one'],
-};
-
-const executionWorkspaceSnapshot: IExecutionWorkspaceSnapshot = {
-  sessionId: 'session_1',
-  entries: [],
-  updatedAt: '2026-05-01T00:00:00.000Z',
-};
-
-const backgroundJobGroup: IBackgroundJobGroupState = {
-  id: 'group_1',
-  parentSessionId: 'session_1',
-  waitPolicy: 'wait_all',
-  taskIds: ['task_1'],
-  status: 'running',
-  createdAt: '2026-05-01T00:00:00.000Z',
-  updatedAt: '2026-05-01T00:00:00.000Z',
-  results: [],
-};
-
-function createMockSession() {
-  const listeners = new Map<string, Set<(...args: unknown[]) => void>>();
-  return {
-    submit: vi.fn().mockResolvedValue(undefined),
-    abort: vi.fn(),
-    cancelQueue: vi.fn(),
-    getMessages: vi.fn().mockReturnValue([{ role: 'user', content: 'hi' }]),
-    getContextState: vi
-      .fn()
-      .mockReturnValue({ usedTokens: 500, maxTokens: 100000, usedPercentage: 0.5 }),
-    isExecuting: vi.fn().mockReturnValue(false),
-    getPendingPrompt: vi.fn().mockReturnValue(null),
-    listBackgroundTasks: vi.fn().mockReturnValue([backgroundTask]),
-    getBackgroundTask: vi.fn().mockReturnValue(backgroundTask),
-    listBackgroundJobGroups: vi.fn().mockReturnValue([backgroundJobGroup]),
-    getBackgroundJobGroup: vi.fn().mockReturnValue(backgroundJobGroup),
-    waitBackgroundJobGroup: vi.fn().mockResolvedValue({
-      ...backgroundJobGroup,
-      status: 'completed',
-      completedAt: '2026-05-01T00:00:01.000Z',
-      results: [{ taskId: 'task_1', label: 'Explore', status: 'completed', summary: 'done' }],
-    }),
-    cancelBackgroundTask: vi.fn().mockResolvedValue(undefined),
-    closeBackgroundTask: vi.fn().mockResolvedValue(undefined),
-    sendBackgroundTask: vi.fn().mockResolvedValue(undefined),
-    readBackgroundTaskLog: vi.fn().mockResolvedValue(backgroundTaskLogPage),
-    getExecutionWorkspaceSnapshot: vi.fn().mockReturnValue(executionWorkspaceSnapshot),
-    executeCommand: vi.fn().mockResolvedValue({ message: 'done', success: true, data: {} }),
-    listCommands: vi.fn().mockReturnValue([]),
-    on: vi.fn((event: string, handler: (...args: unknown[]) => void) => {
-      if (!listeners.has(event)) listeners.set(event, new Set());
-      listeners.get(event)!.add(handler);
-    }),
-    off: vi.fn((event: string, handler: (...args: unknown[]) => void) => {
-      listeners.get(event)?.delete(handler);
-    }),
-    _emit: (event: string, ...args: unknown[]) => {
-      listeners.get(event)?.forEach((h) => h(...args));
-    },
-  } as unknown as IInteractiveSession & { _emit: (event: string, ...args: unknown[]) => void };
-}
-
-describe('WebSocket Transport Handler', () => {
-  function setup() {
-    const session = createMockSession();
-    const sent: TServerMessage[] = [];
-    const { onMessage, cleanup } = createWsHandler({
-      session: session as unknown as IInteractiveSession,
-      send: (msg) => sent.push(msg),
-    });
-    return { session, sent, onMessage, cleanup };
-  }
-
-  it('submit calls session.submit()', () => {
-    const { onMessage, session } = setup();
-    onMessage(JSON.stringify({ type: 'submit', prompt: 'hello' }));
-    expect(
-      (session as unknown as { submit: ReturnType<typeof vi.fn> }).submit,
-    ).toHaveBeenCalledWith('hello');
-  });
-
-  it('abort calls session.abort()', () => {
-    const { onMessage, session } = setup();
-    onMessage(JSON.stringify({ type: 'abort' }));
-    expect((session as unknown as { abort: ReturnType<typeof vi.fn> }).abort).toHaveBeenCalled();
-  });
-
-  it('cancel-queue calls session.cancelQueue()', () => {
-    const { onMessage, session } = setup();
-    onMessage(JSON.stringify({ type: 'cancel-queue' }));
-    expect(
-      (session as unknown as { cancelQueue: ReturnType<typeof vi.fn> }).cancelQueue,
-    ).toHaveBeenCalled();
-  });
-
-  it('get-messages sends messages back', () => {
-    const { onMessage, sent } = setup();
-    onMessage(JSON.stringify({ type: 'get-messages' }));
-    expect(sent).toHaveLength(1);
-    expect(sent[0]!.type).toBe('messages');
-  });
-
-  it('get-context sends context state back', () => {
-    const { onMessage, sent } = setup();
-    onMessage(JSON.stringify({ type: 'get-context' }));
-    expect(sent).toHaveLength(1);
-    expect(sent[0]!.type).toBe('context');
-  });
-
-  it('get-executing sends executing status', () => {
-    const { onMessage, sent } = setup();
-    onMessage(JSON.stringify({ type: 'get-executing' }));
-    expect(sent[0]).toEqual({ type: 'executing', executing: false });
-  });
-
-  it('get-pending sends pending prompt', () => {
-    const { onMessage, sent } = setup();
-    onMessage(JSON.stringify({ type: 'get-pending' }));
-    expect(sent[0]).toEqual({ type: 'pending', pending: null });
-  });
-
-  it('get-background-tasks sends current background task list', () => {
-    const { onMessage, sent, session } = setup();
-    onMessage(JSON.stringify({ type: 'get-background-tasks', filter: { kind: 'agent' } }));
-
-    expect(sent[0]).toEqual({ type: 'background_tasks', tasks: [backgroundTask] });
-    expect(
-      (session as unknown as { listBackgroundTasks: ReturnType<typeof vi.fn> }).listBackgroundTasks,
-    ).toHaveBeenCalledWith({ kind: 'agent' });
-  });
-
-  it('get-background-task sends one background task snapshot', () => {
-    const { onMessage, sent, session } = setup();
-    onMessage(JSON.stringify({ type: 'get-background-task', taskId: 'task_1' }));
-
-    expect(sent[0]).toEqual({
-      type: 'background_task',
-      taskId: 'task_1',
-      task: backgroundTask,
-    });
-    expect(
-      (session as unknown as { getBackgroundTask: ReturnType<typeof vi.fn> }).getBackgroundTask,
-    ).toHaveBeenCalledWith('task_1');
-  });
-
-  it('get-background-job-groups sends group snapshots', () => {
-    const { onMessage, sent, session } = setup();
-    onMessage(JSON.stringify({ type: 'get-background-job-groups' }));
-
-    expect(sent[0]).toEqual({ type: 'background_job_groups', groups: [backgroundJobGroup] });
-    expect(
-      (session as unknown as { listBackgroundJobGroups: ReturnType<typeof vi.fn> })
-        .listBackgroundJobGroups,
-    ).toHaveBeenCalled();
-  });
-
-  it('get-background-job-group sends one group snapshot', () => {
-    const { onMessage, sent, session } = setup();
-    onMessage(JSON.stringify({ type: 'get-background-job-group', groupId: 'group_1' }));
-
-    expect(sent[0]).toEqual({
-      type: 'background_job_group',
-      groupId: 'group_1',
-      group: backgroundJobGroup,
-    });
-    expect(
-      (session as unknown as { getBackgroundJobGroup: ReturnType<typeof vi.fn> })
-        .getBackgroundJobGroup,
-    ).toHaveBeenCalledWith('group_1');
-  });
-
-  it('wait-background-job-group waits and sends the completed group', async () => {
-    const { onMessage, sent, session } = setup();
-    onMessage(JSON.stringify({ type: 'wait-background-job-group', groupId: 'group_1' }));
-
-    await new Promise((r) => setTimeout(r, 10));
-
-    expect(
-      (session as unknown as { waitBackgroundJobGroup: ReturnType<typeof vi.fn> })
-        .waitBackgroundJobGroup,
-    ).toHaveBeenCalledWith('group_1');
-    expect(sent[0]).toMatchObject({
-      type: 'background_job_group',
-      groupId: 'group_1',
-      group: { id: 'group_1', status: 'completed' },
-    });
-  });
-
-  it('cancel-background-task maps to session control and emits control result', async () => {
-    const { onMessage, sent, session } = setup();
-    onMessage(JSON.stringify({ type: 'cancel-background-task', taskId: 'task_1', reason: 'stop' }));
-
-    await new Promise((r) => setTimeout(r, 10));
-
-    expect(
-      (session as unknown as { cancelBackgroundTask: ReturnType<typeof vi.fn> })
-        .cancelBackgroundTask,
-    ).toHaveBeenCalledWith('task_1', 'stop');
-    expect(sent[0]).toEqual({
-      type: 'background_task_control_result',
-      action: 'cancel',
-      taskId: 'task_1',
-      success: true,
-    });
-  });
-
-  it('send-background-task maps prompt input to session control', async () => {
-    const { onMessage, sent, session } = setup();
-    onMessage(
-      JSON.stringify({
-        type: 'send-background-task',
-        taskId: 'task_1',
-        input: { prompt: 'continue' },
-      }),
-    );
-
-    await new Promise((r) => setTimeout(r, 10));
-
-    expect(
-      (session as unknown as { sendBackgroundTask: ReturnType<typeof vi.fn> }).sendBackgroundTask,
-    ).toHaveBeenCalledWith('task_1', { prompt: 'continue' });
-    expect(sent[0]).toEqual({
-      type: 'background_task_control_result',
-      action: 'send',
-      taskId: 'task_1',
-      success: true,
-    });
-  });
-
-  it('read-background-task-log sends log page', async () => {
-    const { onMessage, sent, session } = setup();
-    onMessage(
-      JSON.stringify({
-        type: 'read-background-task-log',
-        taskId: 'task_1',
-        cursor: { offset: 0 },
-      }),
-    );
-
-    await new Promise((r) => setTimeout(r, 10));
-
-    expect(
-      (session as unknown as { readBackgroundTaskLog: ReturnType<typeof vi.fn> })
-        .readBackgroundTaskLog,
-    ).toHaveBeenCalledWith('task_1', { offset: 0 });
-    expect(sent[0]).toEqual({
-      type: 'background_task_log',
-      taskId: 'task_1',
-      page: backgroundTaskLogPage,
-    });
-  });
-
-  it('command executes via session.executeCommand()', async () => {
-    const { onMessage, sent, session } = setup();
-    onMessage(JSON.stringify({ type: 'command', name: 'clear' }));
-    await new Promise((r) => setTimeout(r, 10));
-    expect(sent).toHaveLength(1);
-    expect(sent[0]!.type).toBe('command_result');
-    expect(
-      (session as unknown as { executeCommand: ReturnType<typeof vi.fn> }).executeCommand,
-    ).toHaveBeenCalledWith('clear', '');
-  });
-
-  it('invalid JSON sends protocol_error', () => {
-    const { onMessage, sent } = setup();
-    onMessage('not json');
-    expect(sent[0]).toEqual({ type: 'protocol_error', message: 'Invalid JSON' });
-  });
-
-  it('unknown type sends protocol_error', () => {
-    const { onMessage, sent } = setup();
-    onMessage(JSON.stringify({ type: 'unknown_type' }));
-    expect(sent[0]!.type).toBe('protocol_error');
-  });
-
-  it('submit without prompt sends protocol_error', () => {
-    const { onMessage, sent } = setup();
-    onMessage(JSON.stringify({ type: 'submit' }));
-    expect(sent[0]).toEqual({ type: 'protocol_error', message: 'prompt is required' });
-  });
-
-  it('submit rejection surfaces a protocol_error (WS-001)', async () => {
-    const { onMessage, sent, session } = setup();
-    (session as unknown as { submit: ReturnType<typeof vi.fn> }).submit.mockRejectedValueOnce(
-      new Error('submit failed'),
-    );
-    onMessage(JSON.stringify({ type: 'submit', prompt: 'hello' }));
-    await new Promise((r) => setTimeout(r, 10));
-    expect(sent).toEqual([{ type: 'protocol_error', message: 'submit failed' }]);
-  });
-
-  it('command rejection surfaces a protocol_error (WS-001)', async () => {
-    const { onMessage, sent, session } = setup();
-    (
-      session as unknown as { executeCommand: ReturnType<typeof vi.fn> }
-    ).executeCommand.mockRejectedValueOnce(new Error('command failed'));
-    onMessage(JSON.stringify({ type: 'command', name: 'clear' }));
-    await new Promise((r) => setTimeout(r, 10));
-    expect(sent).toEqual([{ type: 'protocol_error', message: 'command failed' }]);
-  });
-
-  it('forwards InteractiveSession events to client', () => {
-    const { session, sent } = setup();
-    (session as unknown as { _emit: (e: string, ...args: unknown[]) => void })._emit(
-      'text_delta',
-      'hello',
-    );
-    expect(sent).toHaveLength(1);
-    expect(sent[0]).toEqual({ type: 'text_delta', delta: 'hello' });
-  });
-
-  it('forwards thinking event', () => {
-    const { session, sent } = setup();
-    (session as unknown as { _emit: (e: string, ...args: unknown[]) => void })._emit(
-      'thinking',
-      true,
-    );
-    expect(sent[0]).toEqual({ type: 'thinking', isThinking: true });
-  });
-
-  it('forwards background task events to the client', () => {
-    const { session, sent } = setup();
-    const event: TBackgroundTaskEvent = {
-      type: 'background_task_text_delta',
-      taskId: 'task_1',
-      delta: 'partial',
-    };
-    (session as unknown as { _emit: (e: string, ...args: unknown[]) => void })._emit(
-      'background_task_event',
-      event,
-    );
-
-    expect(sent[0]).toEqual({ type: 'background_task_event', event });
-  });
-
-  it('forwards background job group events to the client', () => {
-    const { session, sent } = setup();
-    const event: TBackgroundJobGroupEvent = {
-      type: 'background_job_group_completed',
-      group: { ...backgroundJobGroup, status: 'completed' },
-    };
-    (session as unknown as { _emit: (e: string, ...args: unknown[]) => void })._emit(
-      'background_job_group_event',
-      event,
-    );
-
-    expect(sent[0]).toEqual({ type: 'background_job_group_event', event });
-  });
-
-  it('forwards execution_workspace_event to the client', () => {
-    const { session, sent } = setup();
-    const event: IExecutionWorkspaceEvent = {
-      type: 'execution_workspace_updated',
-      cause: 'main_thread',
-      snapshot: executionWorkspaceSnapshot,
-    };
-    (session as unknown as { _emit: (e: string, ...args: unknown[]) => void })._emit(
-      'execution_workspace_event',
-      event,
-    );
-
-    expect(sent[0]).toEqual({
-      type: 'execution_workspace_event',
-      snapshot: executionWorkspaceSnapshot,
-    });
-  });
-
-  it('get-execution-workspace sends current snapshot', () => {
-    const { onMessage, sent, session } = setup();
-    onMessage(JSON.stringify({ type: 'get-execution-workspace' }));
-
-    expect(sent[0]).toEqual({
-      type: 'execution_workspace_event',
-      snapshot: executionWorkspaceSnapshot,
-    });
-    expect(
-      (
-        session as unknown as {
-          getExecutionWorkspaceSnapshot: ReturnType<typeof vi.fn>;
-        }
-      ).getExecutionWorkspaceSnapshot,
-    ).toHaveBeenCalled();
-  });
-
-  it('cleanup unsubscribes from all events', () => {
-    const { session, cleanup } = setup();
-    cleanup();
-    expect((session as unknown as { off: ReturnType<typeof vi.fn> }).off).toHaveBeenCalledTimes(11);
-  });
-});

package/src/ws-background-messages.ts

@@ -1,170 +0,0 @@
-import type { TBackgroundControlAction, TClientMessage, TServerMessage } from './ws-protocol.js';
-import type { IInteractiveSession } from '@robota-sdk/agent-interface-transport';
-
-export function handleBackgroundQueryMessage(
-  session: IInteractiveSession,
-  send: (message: TServerMessage) => void,
-  msg: Extract<
-    TClientMessage,
-    | { type: 'get-background-tasks' | 'get-background-task' | 'read-background-task-log' }
-    | {
-        type:
-          | 'get-background-job-groups'
-          | 'get-background-job-group'
-          | 'wait-background-job-group';
-      }
-  >,
-): void {
-  if (msg.type === 'get-background-tasks') {
-    send({ type: 'background_tasks', tasks: session.listBackgroundTasks(msg.filter) });
-    return;
-  }
-  if (msg.type === 'get-background-task') {
-    sendBackgroundTaskSnapshot(session, send, msg);
-    return;
-  }
-  if (msg.type === 'get-background-job-groups') {
-    send({ type: 'background_job_groups', groups: session.listBackgroundJobGroups() });
-    return;
-  }
-  if (msg.type === 'get-background-job-group') {
-    sendBackgroundJobGroupSnapshot(session, send, msg);
-    return;
-  }
-  if (msg.type === 'wait-background-job-group') {
-    sendBackgroundJobGroupWaitResult(session, send, msg);
-    return;
-  }
-  sendBackgroundTaskLogPage(session, send, msg);
-}
-
-export function handleBackgroundControlMessage(
-  session: IInteractiveSession,
-  send: (message: TServerMessage) => void,
-  msg: Extract<
-    TClientMessage,
-    { type: 'cancel-background-task' | 'close-background-task' | 'send-background-task' }
-  >,
-): void {
-  if (!msg.taskId) {
-    send({ type: 'protocol_error', message: 'taskId is required' });
-    return;
-  }
-  if (msg.type === 'cancel-background-task') {
-    sendBackgroundTaskControlResult(
-      send,
-      'cancel',
-      msg.taskId,
-      session.cancelBackgroundTask(msg.taskId, msg.reason),
-    );
-    return;
-  }
-  if (msg.type === 'close-background-task') {
-    sendBackgroundTaskControlResult(
-      send,
-      'close',
-      msg.taskId,
-      session.closeBackgroundTask(msg.taskId),
-    );
-    return;
-  }
-  sendBackgroundTaskInput(session, send, msg);
-}
-
-function sendBackgroundTaskSnapshot(
-  session: IInteractiveSession,
-  send: (message: TServerMessage) => void,
-  msg: Extract<TClientMessage, { type: 'get-background-task' }>,
-): void {
-  if (!msg.taskId) {
-    send({ type: 'protocol_error', message: 'taskId is required' });
-    return;
-  }
-  send({
-    type: 'background_task',
-    taskId: msg.taskId,
-    task: session.getBackgroundTask(msg.taskId) ?? null,
-  });
-}
-
-function sendBackgroundTaskLogPage(
-  session: IInteractiveSession,
-  send: (message: TServerMessage) => void,
-  msg: Extract<TClientMessage, { type: 'read-background-task-log' }>,
-): void {
-  if (!msg.taskId) {
-    send({ type: 'protocol_error', message: 'taskId is required' });
-    return;
-  }
-  session.readBackgroundTaskLog(msg.taskId, msg.cursor).then(
-    (page) => send({ type: 'background_task_log', taskId: msg.taskId, page }),
-    (error: Error) => send({ type: 'protocol_error', message: error.message }),
-  );
-}
-
-function sendBackgroundJobGroupSnapshot(
-  session: IInteractiveSession,
-  send: (message: TServerMessage) => void,
-  msg: Extract<TClientMessage, { type: 'get-background-job-group' }>,
-): void {
-  if (!msg.groupId) {
-    send({ type: 'protocol_error', message: 'groupId is required' });
-    return;
-  }
-  send({
-    type: 'background_job_group',
-    groupId: msg.groupId,
-    group: session.getBackgroundJobGroup(msg.groupId) ?? null,
-  });
-}
-
-function sendBackgroundJobGroupWaitResult(
-  session: IInteractiveSession,
-  send: (message: TServerMessage) => void,
-  msg: Extract<TClientMessage, { type: 'wait-background-job-group' }>,
-): void {
-  if (!msg.groupId) {
-    send({ type: 'protocol_error', message: 'groupId is required' });
-    return;
-  }
-  session.waitBackgroundJobGroup(msg.groupId).then(
-    (group) => send({ type: 'background_job_group', groupId: msg.groupId, group }),
-    (error: Error) => send({ type: 'protocol_error', message: error.message }),
-  );
-}
-
-function sendBackgroundTaskInput(
-  session: IInteractiveSession,
-  send: (message: TServerMessage) => void,
-  msg: Extract<TClientMessage, { type: 'send-background-task' }>,
-): void {
-  if (!msg.input) {
-    send({ type: 'protocol_error', message: 'input is required' });
-    return;
-  }
-  sendBackgroundTaskControlResult(
-    send,
-    'send',
-    msg.taskId,
-    session.sendBackgroundTask(msg.taskId, msg.input),
-  );
-}
-
-function sendBackgroundTaskControlResult(
-  send: (message: TServerMessage) => void,
-  action: TBackgroundControlAction,
-  taskId: string,
-  operation: Promise<void>,
-): void {
-  operation.then(
-    () => send({ type: 'background_task_control_result', action, taskId, success: true }),
-    (error: Error) =>
-      send({
-        type: 'background_task_control_result',
-        action,
-        taskId,
-        success: false,
-        message: error.message,
-      }),
-  );
-}