@robota-sdk/agent-transport 3.0.0-beta.72 → 3.0.0-beta.74

package/src/tui/__tests__/status-bar.test.tsx

@@ -109,18 +109,19 @@ describe('StatusBar', () => {
     );
     const frame = lastFrame()!;
     expect(frame).not.toContain('Activity:');
-    expect(frame).toContain('Tools x2');
+    expect(frame).toContain('Tools (2)');
+    expect(frame).not.toContain('Tools x2');
     expect(frame).toContain('queued');
     expect(frame).not.toContain('thinking...');
-    expect(frame.indexOf('Tools x2')).toBeLessThan(frame.indexOf('test-model'));
+    expect(frame.indexOf('Tools (2)')).toBeLessThan(frame.indexOf('test-model'));
     expect(frame).not.toContain('Thinking...');
   });
 
   it('shows background activity when no foreground execution is active', () => {
     const { lastFrame } = render(<StatusBar {...baseProps} activeBackgroundTaskCount={3} />);
     const frame = lastFrame()!;
-    expect(frame).toContain('Background x3');
-    expect(frame.indexOf('Background x3')).toBeLessThan(frame.indexOf('test-model'));
+    expect(frame).toContain('Background (3)');
+    expect(frame.indexOf('Background (3)')).toBeLessThan(frame.indexOf('test-model'));
   });
 
   it('keeps the activity segment compact for narrow terminals', () => {
@@ -134,10 +135,10 @@ describe('StatusBar', () => {
       />,
     );
     const frame = lastFrame()!;
-    const firstLine = frame.split('\n')[1] ?? '';
+    const firstLine = frame.split('\n')[0] ?? '';
     const activityEnd = firstLine.indexOf('test-model');
     const activitySegment = firstLine.slice(0, activityEnd);
-    expect(activitySegment).toContain('Tools x12');
+    expect(activitySegment).toContain('Tools (12)');
     expect(activitySegment.length).toBeLessThanOrEqual(40);
   });
 

package/src/tui/__tests__/tui-channel-init-failure.test.ts

@@ -0,0 +1,57 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import type { IAIProvider } from '@robota-sdk/agent-core';
+
+vi.mock('@robota-sdk/agent-framework', async (importOriginal) => {
+  const mod = await importOriginal<typeof import('@robota-sdk/agent-framework')>();
+
+  class FakeInteractiveSession {
+    on(): void {}
+    off(): void {}
+    getFullHistory(): unknown[] {
+      return [];
+    }
+    getContextState(): never {
+      throw new Error('ENOENT: session store unreadable');
+    }
+    getName(): string | undefined {
+      return undefined;
+    }
+    getSession(): { getSessionId: () => string } {
+      return { getSessionId: () => 'test-session' };
+    }
+    async shutdown(): Promise<void> {}
+  }
+
+  return { ...mod, InteractiveSession: FakeInteractiveSession };
+});
+
+import { TuiInteractionChannel } from '../TuiInteractionChannel.js';
+
+describe('TuiInteractionChannel init failure surfacing', () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it('TC-05: a real init error records a session-init-error entry and sets error state', async () => {
+    const channel = new TuiInteractionChannel({
+      cwd: '/tmp/project',
+      provider: {} as IAIProvider,
+    });
+    await channel.start();
+
+    vi.advanceTimersByTime(400);
+
+    const entries = channel.stateManager.history;
+    const initError = entries.find((e) => e.type === 'session-init-error');
+    expect(initError).toBeDefined();
+    const message = (initError?.data as { message?: string } | undefined)?.message ?? '';
+    expect(message).toContain('Session initialization failed');
+    expect(message).toContain('ENOENT');
+
+    await channel.stop();
+  });
+});

package/src/tui/__tests__/tui-state-manager.test.ts

@@ -5,7 +5,7 @@
 
 import { describe, it, expect, vi } from 'vitest';
 import { TuiStateManager } from '../tui-state-manager.js';
-import type { IToolState, IExecutionResult } from '@robota-sdk/agent-framework';
+import type { IExecutionResult, IToolState } from '@robota-sdk/agent-interface-transport';
 
 function makeResult(overrides?: Partial<IExecutionResult>): IExecutionResult {
   return {

package/src/tui/background-task-row-format.ts

@@ -1,6 +1,6 @@
 import { formatExecutionWorkspaceEntryRow } from './execution-workspace-view-model.js';
 
-import type { IExecutionWorkspaceEntry } from '@robota-sdk/agent-framework';
+import type { IExecutionWorkspaceEntry } from '@robota-sdk/agent-interface-transport';
 
 export interface IBackgroundTaskRow {
   connector: '├' | '└';

package/src/tui/execution-workspace-view-model.ts

@@ -3,7 +3,7 @@ import type {
   IExecutionWorkspaceEntry,
   IExecutionWorkspaceSnapshot,
   TExecutionWorkspaceStatus,
-} from '@robota-sdk/agent-framework';
+} from '@robota-sdk/agent-interface-transport';
 
 const ACTIVE_STATUSES: readonly TExecutionWorkspaceStatus[] = [
   'active',

package/src/tui/flows/input-area-flow.ts

@@ -1,7 +1,7 @@
 import { isSlashCommand, tokeniseSlashCommand } from '@robota-sdk/agent-framework';
 
 import type { IHistoryEntry, TUniversalValue } from '@robota-sdk/agent-core';
-import type { ICommand } from '@robota-sdk/agent-framework';
+import type { ICommand } from '@robota-sdk/agent-interface-transport';
 
 export interface IAutocompleteInputKey {
   upArrow?: boolean;

package/src/tui/flows/permission-prompt-flow.ts

@@ -67,7 +67,7 @@ export function applyPermissionPromptInput(
   };
 }
 
-export function getPermissionDecision(index: number): TPermissionPromptDecision {
+function getPermissionDecision(index: number): TPermissionPromptDecision {
   if (index === 0) return true;
   if (index === 1) return 'allow-session';
   if (index === 2) return 'allow-project';

package/src/tui/flows/session-init-poller.ts

@@ -0,0 +1,77 @@
+/**
+ * Bounded polling helper for asynchronous session initialization.
+ *
+ * Distinguishes benign "not yet initialized" errors (retried until a timeout)
+ * from real failures (surfaced immediately), so the TUI can show an error
+ * instead of spinning forever.
+ */
+
+export type TSessionInitFailure =
+  | { kind: 'timeout'; lastError: Error | undefined }
+  | { kind: 'error'; error: Error };
+
+export interface ISessionInitPollerOptions {
+  /** Throws while the session is not ready; returns normally when ready. */
+  check: () => void;
+  intervalMs: number;
+  timeoutMs: number;
+  /** Returns true when an error means "keep polling". Defaults to /not initialized/i. */
+  isBenignError?: (error: Error) => boolean;
+  onReady: () => void;
+  onFailure: (failure: TSessionInitFailure) => void;
+}
+
+export interface ISessionInitPoller {
+  start(): void;
+  stop(): void;
+}
+
+function defaultIsBenignError(error: Error): boolean {
+  return /not initialized/i.test(error.message);
+}
+
+export function createSessionInitPoller(options: ISessionInitPollerOptions): ISessionInitPoller {
+  const isBenign = options.isBenignError ?? defaultIsBenignError;
+  let timer: ReturnType<typeof setInterval> | null = null;
+  let elapsedMs = 0;
+  let lastBenignError: Error | undefined;
+
+  function stop(): void {
+    if (timer !== null) {
+      clearInterval(timer);
+      timer = null;
+    }
+  }
+
+  function tick(): void {
+    elapsedMs += options.intervalMs;
+    try {
+      options.check();
+    } catch (raw) {
+      // allow-fallback: poller's purpose is to classify and route this error, never to swallow it
+      const error = raw instanceof Error ? raw : new Error(String(raw));
+      if (!isBenign(error)) {
+        stop();
+        options.onFailure({ kind: 'error', error });
+        return;
+      }
+      lastBenignError = error;
+      if (elapsedMs >= options.timeoutMs) {
+        stop();
+        options.onFailure({ kind: 'timeout', lastError: lastBenignError });
+      }
+      return;
+    }
+    stop();
+    options.onReady();
+  }
+
+  return {
+    start(): void {
+      if (timer !== null) return;
+      elapsedMs = 0;
+      timer = setInterval(tick, options.intervalMs);
+    },
+    stop,
+  };
+}

package/src/tui/hooks/command-effect-handler.ts

@@ -3,7 +3,10 @@ import { isStatusLineCommandSettingsPatch } from '@robota-sdk/agent-framework';
 
 import type { ITuiCliAdapter } from '../tui-cli-adapter.js';
 import type { IHistoryEntry, TSessionEndReason } from '@robota-sdk/agent-core';
-import type { TCommandEffect, TStatusLineCommandSettingsPatch } from '@robota-sdk/agent-framework';
+import type {
+  TCommandEffect,
+  TStatusLineCommandSettingsPatch,
+} from '@robota-sdk/agent-interface-transport';
 
 export interface ICommandEffectHandlerDeps {
   addEntry: (entry: IHistoryEntry) => void;

package/src/tui/hooks/command-effect-queue.ts

@@ -1,4 +1,4 @@
-import type { ICommandInteraction, TCommandEffect } from '@robota-sdk/agent-framework';
+import type { ICommandInteraction, TCommandEffect } from '@robota-sdk/agent-interface-transport';
 
 export type TQueuedCommandState =
   | {

package/src/tui/hooks/side-effects-types.ts

@@ -2,9 +2,9 @@ import type { ICommandEffectQueue } from './command-effect-queue.js';
 import type { IHistoryEntry } from '@robota-sdk/agent-core';
 import type { InteractiveSession } from '@robota-sdk/agent-framework';
 import type {
-  TCommandInteractionPrompt as TInteractivePrompt,
   IStatusLineCommandSettings as TStatusLineSettings,
-} from '@robota-sdk/agent-framework';
+  TCommandInteractionPrompt as TInteractivePrompt,
+} from '@robota-sdk/agent-interface-transport';
 
 export type { TInteractivePrompt, TStatusLineSettings };
 

package/src/tui/hooks/useAutocomplete.ts

@@ -5,10 +5,11 @@
 
 import React, { useState, useMemo } from 'react';
 
-import type { CommandRegistry, ICommand } from '@robota-sdk/agent-framework';
+import type { CommandRegistry } from '@robota-sdk/agent-framework';
+import type { ICommand } from '@robota-sdk/agent-interface-transport';
 
 /** Parse input to determine autocomplete state */
-export function parseSlashInput(value: string): {
+function parseSlashInput(value: string): {
   isSlash: boolean;
   parentCommand: string;
   filter: string;

package/src/tui/hooks/usePluginCallbacks.ts

@@ -8,7 +8,7 @@
 
 import { useMemo } from 'react';
 
-import type { ICommandPluginAdapter } from '@robota-sdk/agent-framework';
+import type { ICommandPluginAdapter } from '@robota-sdk/agent-interface-transport';
 
 function createNoOpPluginAdapter(): ICommandPluginAdapter {
   return {

package/src/tui/hooks/usePluginScreenData.ts

@@ -6,7 +6,7 @@
 import { useState, useEffect } from 'react';
 
 import type { IMenuSelectItem } from '../MenuSelect.js';
-import type { ICommandPluginAdapter } from '@robota-sdk/agent-framework';
+import type { ICommandPluginAdapter } from '@robota-sdk/agent-interface-transport';
 
 export function usePluginScreenData(
   screen: string,

package/src/tui/hooks/useSideEffects.ts

@@ -8,7 +8,7 @@ import { useTuiCliAdapter } from '../tui-cli-adapter-context.js';
 import type { IUseSideEffectsOptions, IUseSideEffectsResult } from './side-effects-types.js';
 import type { TInteractivePrompt } from './side-effects-types.js';
 import type { TSessionEndReason } from '@robota-sdk/agent-core';
-import type { ICommandInteraction, ICommandResult } from '@robota-sdk/agent-framework';
+import type { ICommandInteraction, ICommandResult } from '@robota-sdk/agent-interface-transport';
 
 const EXIT_DELAY_MS = 500;
 

package/src/tui/hooks/useSlashRouting.ts

@@ -8,12 +8,12 @@ import { useCallback } from 'react';
 
 import type { TuiStateManager } from '../tui-state-manager.js';
 import type { ICommandEffectQueue } from './command-effect-queue.js';
+import type { CommandRegistry } from '@robota-sdk/agent-framework';
 import type {
-  IInteractiveSession,
-  CommandRegistry,
   ICommandResult,
+  IInteractiveSession,
   TCommandEffect,
-} from '@robota-sdk/agent-framework';
+} from '@robota-sdk/agent-interface-transport';
 
 export function useSlashRouting(
   interactiveSession: IInteractiveSession,

package/src/tui/hooks/useStatusLineSettings.ts

@@ -4,7 +4,7 @@ import { useState } from 'react';
 import { useTuiCliAdapter } from '../tui-cli-adapter-context.js';
 
 import type { TUniversalValue } from '@robota-sdk/agent-core';
-import type { IStatusLineCommandSettings } from '@robota-sdk/agent-framework';
+import type { IStatusLineCommandSettings } from '@robota-sdk/agent-interface-transport';
 
 function readStatusLineSettings(
   settings: Record<string, TUniversalValue>,

package/src/tui/hooks/useTuiChannel.ts

@@ -13,10 +13,10 @@ import type { IPermissionRequest } from '../types.js';
 import type { IHistoryEntry, TSessionEndReason } from '@robota-sdk/agent-core';
 import type { InteractiveSession, CommandRegistry } from '@robota-sdk/agent-framework';
 import type {
-  IToolState,
-  IExecutionWorkspaceSnapshot,
   IExecutionDetailPage,
-} from '@robota-sdk/agent-framework';
+  IExecutionWorkspaceSnapshot,
+  IToolState,
+} from '@robota-sdk/agent-interface-transport';
 
 export interface IInteractiveSessionState {
   interactiveSession: InteractiveSession;

package/src/tui/plugin-tui-handlers.ts

@@ -4,7 +4,7 @@
  */
 
 import type { IMenuSelectItem } from './MenuSelect.js';
-import type { ICommandPluginAdapter } from '@robota-sdk/agent-framework';
+import type { ICommandPluginAdapter } from '@robota-sdk/agent-interface-transport';
 
 interface IConfirmState {
   message: string;

package/src/tui/render.tsx

@@ -15,13 +15,15 @@ import type {
   IBackgroundTaskRunner,
   ICommandHostAdapters,
   ICommandModule,
-  IInteractiveSession,
-  IInteractiveSessionStore,
   TSubagentRunnerFactory,
   TShellExecFn,
   CommandRegistry,
 } from '@robota-sdk/agent-framework';
-import type { ITransportRegistryView } from '@robota-sdk/agent-interface-transport';
+import type {
+  IInteractiveSession,
+  IInteractiveSessionStore,
+  ITransportRegistryView,
+} from '@robota-sdk/agent-interface-transport';
 
 export interface IRenderOptions {
   cwd: string;
@@ -32,6 +34,8 @@ export interface IRenderOptions {
   language?: string;
   permissionMode?: TPermissionMode;
   maxTurns?: number;
+  allowedTools?: string[];
+  deniedTools?: string[];
   version?: string;
   sessionStore?: IInteractiveSessionStore;
   resumeSessionId?: string;
@@ -50,6 +54,34 @@ export interface IRenderOptions {
   agentName?: string;
 }
 
+/** Map render options to TuiInteractionChannel constructor options. */
+export function toChannelOptions(
+  options: IRenderOptions,
+  resumeSessionId?: string,
+): ConstructorParameters<typeof TuiInteractionChannel>[0] {
+  return {
+    cwd: options.cwd,
+    provider: options.provider,
+    permissionMode: options.permissionMode,
+    maxTurns: options.maxTurns,
+    allowedTools: options.allowedTools,
+    deniedTools: options.deniedTools,
+    sessionStore: options.sessionStore,
+    resumeSessionId,
+    forkSession: options.forkSession,
+    sessionName: options.sessionName,
+    backgroundTaskRunners: options.backgroundTaskRunners,
+    subagentRunnerFactory: options.subagentRunnerFactory,
+    commandModules: options.commandModules,
+    commandHostAdapters: options.commandHostAdapters,
+    shellExec: options.shellExec,
+    transportRegistry: options.transportRegistry,
+    language: options.language,
+    reloadPluginCommandSource: options.reloadPluginCommandSource,
+    agentName: options.agentName,
+  };
+}
+
 export async function renderApp(options: IRenderOptions): Promise<void> {
   process.on('unhandledRejection', (reason) => {
     process.stderr.write(`\n[UNHANDLED REJECTION] ${reason}\n`);
@@ -58,33 +90,14 @@ export async function renderApp(options: IRenderOptions): Promise<void> {
     }
   });
 
+  // Single-owner lifecycle (CLI-B12): render.tsx supplies only the factory;
+  // App creates, replaces, and stops channels exclusively through React state.
   const createChannel = (resumeSessionId?: string): TuiInteractionChannel =>
-    new TuiInteractionChannel({
-      cwd: options.cwd,
-      provider: options.provider,
-      permissionMode: options.permissionMode,
-      maxTurns: options.maxTurns,
-      sessionStore: options.sessionStore,
-      resumeSessionId,
-      forkSession: options.forkSession,
-      sessionName: options.sessionName,
-      backgroundTaskRunners: options.backgroundTaskRunners,
-      subagentRunnerFactory: options.subagentRunnerFactory,
-      commandModules: options.commandModules,
-      commandHostAdapters: options.commandHostAdapters,
-      shellExec: options.shellExec,
-      transportRegistry: options.transportRegistry,
-      language: options.language,
-      reloadPluginCommandSource: options.reloadPluginCommandSource,
-      agentName: options.agentName,
-    });
-
-  const channel = createChannel(options.resumeSessionId);
+    new TuiInteractionChannel(toChannelOptions(options, resumeSessionId));
 
   const instance = render(
     <App
       cwd={options.cwd}
-      channel={channel}
       createChannel={createChannel}
       providerOverride={options.providerOverride}
       providerType={options.providerType}

package/src/tui/status-activity.ts

@@ -30,7 +30,7 @@ function getPrimaryActivity(
   if (input.activeToolCount > NO_ACTIVE_ITEMS) {
     return {
       kind: 'tools',
-      label: `Tools x${input.activeToolCount}`,
+      label: `Tools (${input.activeToolCount})`,
       color: 'cyan',
     };
   }
@@ -44,7 +44,7 @@ function getPrimaryActivity(
   if (input.activeBackgroundTaskCount > NO_ACTIVE_ITEMS) {
     return {
       kind: 'background',
-      label: `Background x${input.activeBackgroundTaskCount}`,
+      label: `Background (${input.activeBackgroundTaskCount})`,
       color: 'cyan',
     };
   }

package/src/tui/tui-cli-adapter.ts

@@ -1,9 +1,9 @@
 import type { TUniversalValue } from '@robota-sdk/agent-core';
+import type { CommandRegistry } from '@robota-sdk/agent-framework';
 import type {
-  TStatusLineCommandSettingsPatch,
   IStatusLineCommandSettings,
-  CommandRegistry,
-} from '@robota-sdk/agent-framework';
+  TStatusLineCommandSettingsPatch,
+} from '@robota-sdk/agent-interface-transport';
 
 export interface ITuiCliAdapter {
   getUserSettingsPath(): string;

package/src/tui/tui-state-manager.ts

@@ -10,10 +10,10 @@
 
 import type { IContextWindowState, IHistoryEntry } from '@robota-sdk/agent-core';
 import type {
-  IToolState,
   IExecutionResult,
   IExecutionWorkspaceSnapshot,
-} from '@robota-sdk/agent-framework';
+  IToolState,
+} from '@robota-sdk/agent-interface-transport';
 
 /** Max messages kept in rendering state */
 const MAX_RENDERED_MESSAGES = 100;

package/src/tui/tui-transport.ts

@@ -1,8 +1,10 @@
 import { renderApp, type IRenderOptions } from './render.js';
 
 import type { TUniversalValue } from '@robota-sdk/agent-core';
-import type { IInteractiveSession } from '@robota-sdk/agent-framework';
-import type { IConfigurableTransport } from '@robota-sdk/agent-interface-transport';
+import type {
+  IConfigurableTransport,
+  IInteractiveSession,
+} from '@robota-sdk/agent-interface-transport';
 
 export class TuiTransport implements IConfigurableTransport<IInteractiveSession> {
   readonly name = 'tui';

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

@@ -6,15 +6,17 @@ import { describe, it, expect, vi } from 'vitest';
 import { createWsHandler } from '../ws-handler.js';
 import type { TServerMessage } from '../ws-protocol.js';
 import type {
-  IBackgroundTaskLogPage,
-  IBackgroundTaskState,
+  IBackgroundJobGroupState,
   IExecutionWorkspaceEvent,
   IExecutionWorkspaceSnapshot,
   IInteractiveSession,
-  IBackgroundJobGroupState,
   TBackgroundJobGroupEvent,
-  TBackgroundTaskEvent,
   TExecutionWorkspaceUpdateCause,
+} from '@robota-sdk/agent-interface-transport';
+import type {
+  IBackgroundTaskLogPage,
+  IBackgroundTaskState,
+  TBackgroundTaskEvent,
 } from '@robota-sdk/agent-framework';
 
 const backgroundTask: IBackgroundTaskState = {

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

@@ -1,6 +1,6 @@
 import { describe, it, expect, vi } from 'vitest';
 import { createWsTransport } from '../ws-transport.js';
-import type { IInteractiveSession } from '@robota-sdk/agent-framework';
+import type { IInteractiveSession } from '@robota-sdk/agent-interface-transport';
 
 function createMockSession(): IInteractiveSession {
   return {

package/src/ws/ws-background-messages.ts

@@ -1,5 +1,5 @@
 import type { TBackgroundControlAction, TClientMessage, TServerMessage } from './ws-protocol.js';
-import type { IInteractiveSession } from '@robota-sdk/agent-framework';
+import type { IInteractiveSession } from '@robota-sdk/agent-interface-transport';
 
 export function handleBackgroundQueryMessage(
   session: IInteractiveSession,

package/src/ws/ws-handler.ts

@@ -14,14 +14,14 @@ import {
 } from './ws-background-messages.js';
 
 import type { TClientMessage, TServerMessage } from './ws-protocol.js';
+import type { TBackgroundTaskEvent } from '@robota-sdk/agent-framework';
 import type {
-  IInteractiveSession,
   IExecutionResult,
   IExecutionWorkspaceEvent,
-  TBackgroundJobGroupEvent,
-  TBackgroundTaskEvent,
+  IInteractiveSession,
   IToolState,
-} from '@robota-sdk/agent-framework';
+  TBackgroundJobGroupEvent,
+} from '@robota-sdk/agent-interface-transport';
 
 export interface IWsHandlerOptions {
   /** IInteractiveSession to expose. */

package/src/ws/ws-protocol.ts

@@ -1,18 +1,20 @@
 import type {
   InteractiveSession,
-  ICommandResult,
-  IBackgroundJobGroupState,
   IBackgroundTaskInput,
   IBackgroundTaskListFilter,
   IBackgroundTaskLogCursor,
   IBackgroundTaskLogPage,
   IBackgroundTaskState,
+  TBackgroundTaskEvent,
+} from '@robota-sdk/agent-framework';
+import type {
+  IBackgroundJobGroupState,
+  ICommandResult,
   IExecutionResult,
   IExecutionWorkspaceSnapshot,
   IToolState,
   TBackgroundJobGroupEvent,
-  TBackgroundTaskEvent,
-} from '@robota-sdk/agent-framework';
+} from '@robota-sdk/agent-interface-transport';
 
 export type TBackgroundControlAction = 'cancel' | 'close' | 'send';
 

package/src/ws/ws-transport-configurable.ts

@@ -11,8 +11,10 @@ import { createWsHandler } from './ws-handler.js';
 
 import type { TServerMessage } from './ws-protocol.js';
 import type { TUniversalValue } from '@robota-sdk/agent-core';
-import type { IInteractiveSession } from '@robota-sdk/agent-framework';
-import type { IConfigurableTransport } from '@robota-sdk/agent-interface-transport';
+import type {
+  IConfigurableTransport,
+  IInteractiveSession,
+} from '@robota-sdk/agent-interface-transport';
 
 const DEFAULT_PORT = 7070;
 const DEFAULT_MAX_RETRIES = 20;

package/src/ws/ws-transport.ts

@@ -8,8 +8,7 @@
 import { createWsHandler } from './ws-handler.js';
 
 import type { TServerMessage } from './ws-protocol.js';
-import type { IInteractiveSession } from '@robota-sdk/agent-framework';
-import type { ITransportAdapter } from '@robota-sdk/agent-interface-transport';
+import type { IInteractiveSession, ITransportAdapter } from '@robota-sdk/agent-interface-transport';
 
 export interface IWsTransportOptions {
   /** Send a JSON message to the connected WebSocket client. */