@rtc-agent/component 0.2.7-rc.3 → 0.2.7-rc.4

package/dist/components/rtc-agent/rtc-agent.d.ts

@@ -0,0 +1,702 @@
+/**
+ * RTC Agent — Root Component
+ *
+ * The only public custom element exposed by the library. This component is a
+ * pure "assembler": it creates Reactive Controllers, wires each controller's
+ * value to a @lit/context provider, and renders the top-level shell UI.
+ *
+ * All state logic (session, message, tool call, auth, mode, window state,
+ * toast, fork) is delegated to controllers in `src/controllers/`. The root
+ * component handles cross-controller coordination, event routing, and
+ * lifecycle management. Complex subscription logic (e.g., UIUpdateBus handling)
+ * is extracted to `helpers/` for maintainability.
+ *
+ * @element rtc-agent
+ *
+ * @cssprop [--rtc-window-default-width=420px] - Default window width
+ * @cssprop [--rtc-window-default-height=640px] - Default window height
+ * @cssprop [--rtc-bubble-size=40px] - Minimized bubble diameter
+ * @cssprop [--rtc-bubble-bg] - Bubble background (defaults to --rtc-color-bg-secondary)
+ *
+ * @attr {string} [theme=system] - Theme: 'light' | 'dark' | 'system'
+ * @attr {string} [app-label=RTC Agent] - Application label (title bar + bubble tooltip)
+ * @attr {string} [bubble-icon] - SVG/HTML string rendered inside the minimized bubble
+ * @attr {string} [scenarios-url] - URL to load scenario documents from (auto-loads manifest.json + .md files)
+ * @attr {string} [server-url] - Backend server URL (overrides VITE_SERVER_URL env and the default http://localhost:28080)
+ *
+ * @attr {string} [data-mode='normal'|'maximized'|'minimized'] - Reflected window state
+ *
+ * ## Event Naming Convention
+ *
+ * All public events dispatched by <rtc-agent> follow the pattern:
+ *   `rtc-<domain>-<action>-<past-tense>`
+ *
+ * Examples: rtc-session-created, rtc-message-sent, rtc-auth-login-requested
+ *
+ * ### Event prefix taxonomy:
+ * - `rtc-*`         : Public API events (external developers listen to these)
+ * - No prefix       : Internal component events (may change without notice)
+ * - `demo-*`        : Demo/test-only events (not for production use)
+ *
+ * ### Architecture — Reactive Controller Pattern:
+ * - Each controller encapsulates one context's state + actions
+ * - Root creates controllers and wires them to context providers
+ * - Controllers call `host.requestUpdate()` after state mutations
+ * - Root syncs controller.value to provider via `updated()` lifecycle + `updateComplete` Promise
+ * - Using `updateComplete` ensures Context consumers update after host finishes, avoiding change-in-update warnings
+ * - Cross-controller communication (e.g., session switch -> clear messages)
+ *   is handled by the root via callbacks
+ *
+ * Window-state events (rtc-window-{minimize,maximize,restore}) flow from
+ * <rtc-title-bar> → <rtc-agent> listener → controller → reflected `data-mode`
+ * attribute → CSS :host([data-mode=...]) visual state.
+ */
+import { LitElement } from 'lit';
+import { WindowStateController } from '../../controllers/window-state.controller.js';
+import { AuthController } from '../../controllers/auth.controller.js';
+import { SessionController } from '../../controllers/session.controller.js';
+import { MessageController } from '../../controllers/message.controller.js';
+import { ModeController } from '../../controllers/mode.controller.js';
+import { ToolCallController } from '../../controllers/tool-call.controller.js';
+import { PersistenceController } from '../../controllers/persistence.controller.js';
+import { SkillController } from '../../controllers/skill.controller.js';
+import { ToastController } from '../../controllers/toast.controller.js';
+import { ForkController } from '../../controllers/fork.controller.js';
+import { ActivityController } from '../../controllers/activity.controller.js';
+import { FileExplorerController } from '../../controllers/file-explorer.controller.js';
+import { EditorAreaController } from '../../controllers/editor-area.controller.js';
+import { StatusBarController } from '../../controllers/status-bar.controller.js';
+import { SessionTreeController } from '../../controllers/session-tree.controller.js';
+import { SessionTabController } from '../../controllers/session-tab.controller.js';
+import { SettingsController } from '../../controllers/settings.controller.js';
+import { NotificationController } from '../../controllers/notification.controller.js';
+import type { FunctionRegistry } from '../../core/function-registry.js';
+import type { AgentConfig } from '../../types/agent-config.js';
+import type { WindowConfig } from '../../types/window-config.js';
+import type { ActivityBarConfig } from '../../types/activity-bar-config.js';
+import type { StaticTokenAuth, DynamicTokenAuth, AuthProvider } from '../../types/factory.js';
+import '../../types/events.js';
+import '../overlay/rtc-tool-confirm.js';
+import '../overlay/rtc-ask-user.js';
+import '../overlay/rtc-restore-confirm.js';
+import '../title-bar/rtc-title-bar.js';
+import '../login/rtc-login-page.js';
+import '../login/rtc-login-dialog.js';
+import '../overlay/rtc-toast.js';
+import '../activity-bar/rtc-activity-bar.js';
+import '../file-explorer/rtc-file-explorer.js';
+import '../editor-area/rtc-editor-area.js';
+import '../status-bar/rtc-status-bar.js';
+import '../chat-layout/rtc-chat-layout.js';
+import '../settings-layout/rtc-settings-layout.js';
+import '../drawer/rtc-drawer.js';
+import '../logo/rtc-logo.js';
+export declare class RtcAgent extends LitElement {
+    static styles: import("lit").CSSResult[];
+    theme: 'light' | 'dark' | 'system';
+    /**
+     * Language/locale for the component UI.
+     *
+     * Priority: HTML attribute > localStorage > browser language > default (zh-CN).
+     *
+     * Host applications can set this attribute declaratively:
+     * ```html
+     * <rtc-agent lang="en-US"></rtc-agent>
+     * ```
+     *
+     * Or update dynamically:
+     * ```js
+     * rtcAgentEl.lang = 'en-US';
+     * ```
+     */
+    set lang(value: string);
+    get lang(): string;
+    private _lang;
+    appLabel: string;
+    bubbleIcon: string;
+    /**
+     * Custom logo for host application branding.
+     *
+     * When set, replaces the default RTC Agent logo everywhere it appears:
+     * login page, empty state, settings "about" section.
+     *
+     * Provide separate SVG/HTML strings for light and dark themes:
+     * ```ts
+     * agent.logo = {
+     *   light: '<svg>...</svg>',  // rendered in light theme
+     *   dark: '<svg>...</svg>',   // rendered in dark theme
+     * };
+     * ```
+     *
+     * Either field can be omitted; missing variants fall back to the default logo.
+     *
+     * **Security note**: Same as `bubbleIcon` — callers should sanitize input
+     * before assignment. The component does NOT sanitize this value.
+     */
+    set logo(value: {
+        light?: string;
+        dark?: string;
+    } | null);
+    get logo(): {
+        light?: string;
+        dark?: string;
+    } | null;
+    private _logo;
+    /**
+     * FunctionRegistry instance (host-app injection, advanced usage).
+     *
+     * On set, automatically:
+     * 1. Injects the registry into SkillController (for UI use).
+     * 2. Creates an rtcAgentAPI Proxy and injects it into ToolRegistry (for script tools).
+     *
+     * For simpler scenarios, prefer the `agentConfig` property (declarative API).
+     */
+    set registry(value: FunctionRegistry | null);
+    get registry(): FunctionRegistry | null;
+    /**
+     * Generate docs after the registry property is set.
+     *
+     * Handles a timing issue: connectedCallback() may complete connect() before
+     * the registry is injected, causing generateAllDocsContent() to return an empty
+     * array. When the registry is set later, docs need to be regenerated.
+     */
+    private _regenerateDocsAfterRegistrySet;
+    /**
+     * Declarative agent configuration (recommended host integration approach).
+     *
+     * After setting, the component automatically:
+     * 1. Builds a FunctionRegistry from config (with persona / groups / functions).
+     * 2. Injects the registry into SkillController.
+     * 3. Bridges the rtcAgent API to ToolRegistry (for script tool use).
+     *
+     * Host applications don't need to understand internal concepts like
+     * FunctionRegistry / toolRegistry.
+     *
+     * @example
+     * ```ts
+     * const agent = document.querySelector<RtcAgent>('#agent')!;
+     * agent.agentConfig = {
+     *   name: 'MermaidEditor',
+     *   persona: 'You are a helpful Mermaid diagram assistant...',
+     *   groups: [{
+     *     name: 'editor',
+     *     description: 'Editor operations',
+     *     functions: [
+     *       { name: 'getCode', description: 'Get current code', handler: () => editorAPI.getCode() },
+     *     ],
+     *   }],
+     * };
+     * ```
+     */
+    set agentConfig(value: AgentConfig | null);
+    get agentConfig(): AgentConfig | null;
+    private _agentConfig;
+    /**
+     * Backend server URL (overrides VITE_SERVER_URL env and the built-in default).
+     *
+     * Propagated to AUTH_CONFIG so OAuth / WebSocket endpoints pick it up.
+     *
+     * @example
+     * <rtc-agent server-url="http://localhost:28080"></rtc-agent>
+     */
+    set serverURL(value: string);
+    get serverURL(): string;
+    private _serverURL;
+    /**
+     * OAuth callback URL (overrides the default window.location.origin + '/auth/callback.html').
+     *
+     * Propagated to AUTH_CONFIG so OAuth flow uses the correct redirect URI.
+     *
+     * @example
+     * <rtc-agent redirect-uri="https://example.com/auth/callback.html"></rtc-agent>
+     */
+    set redirectURI(value: string);
+    get redirectURI(): string;
+    private _redirectURI;
+    /**
+     * Scenario documents URL (optional).
+     *
+     * When set, automatically loads scenario documents from the specified URL into VirtualFS.
+     * The URL should point to a directory containing manifest.json.
+     *
+     * @example
+     * <rtc-agent scenarios-url="./scenarios/"></rtc-agent>
+     */
+    set scenariosURL(value: string);
+    get scenariosURL(): string;
+    private _scenariosURL;
+    /**
+     * Custom database name prefix (optional).
+     *
+     * When set, the database name becomes `${databaseName}-${userId}` instead of `rtc-agent-${userId}`.
+     *
+     * @example
+     * <rtc-agent database-name="my-app"></rtc-agent>
+     * // Creates database: my-app-{userId}
+     */
+    set databaseName(value: string);
+    get databaseName(): string;
+    private _databaseName;
+    /**
+     * Custom SharedWorker URL (optional).
+     *
+     * When the component is loaded from NPM, the worker file may not be accessible
+     * from the default location. Use this to specify a custom URL where the worker
+     * file is served (e.g., '/rtc-agent/shared-worker.js').
+     *
+     * Must be set before the element is mounted to the DOM.
+     *
+     * @example
+     * <rtc-agent worker-url="/rtc-agent/shared-worker.js"></rtc-agent>
+     *
+     * @example
+     * ```ts
+     * agent.workerUrl = '/rtc-agent/shared-worker.js';
+     * ```
+     */
+    set workerUrl(value: string);
+    get workerUrl(): string;
+    private _workerUrl;
+    /**
+     * Window configuration (optional).
+     *
+     * Controls the window's default state, dimensions, position, interaction limits, etc.
+     *
+     * @example
+     * ```ts
+     * agent.windowConfig = {
+     *   defaultMode: 'maximized',
+     *   embedded: true,  // Disable all window interactions
+     *   showMinimize: false,
+     *   showMaximize: false,
+     * };
+     * ```
+     */
+    set windowConfig(value: WindowConfig | null);
+    get windowConfig(): WindowConfig | null;
+    private _windowConfig;
+    /**
+     * Activity Bar configuration (optional).
+     *
+     * Controls visibility of activity buttons in the Activity Bar.
+     * Note: the chat button is always visible and cannot be hidden.
+     *
+     * @example
+     * ```ts
+     * agent.activityBarConfig = {
+     *   disabledActivities: ['files', 'settings'],  // Only show chat
+     *   defaultActivity: 'chat',
+     * };
+     * ```
+     */
+    set activityBarConfig(value: ActivityBarConfig | null);
+    get activityBarConfig(): ActivityBarConfig | null;
+    private _activityBarConfig;
+    private _resolvedActivityBarConfig;
+    /**
+     * @internal Pending auth configuration from factory function.
+     *
+     * Set by `createRtcAgent` factory when StaticTokenAuth is provided.
+     * Applied in `connectedCallback` after controllers are initialized.
+     * Cleared after application to prevent re-application on reconnect.
+     */
+    _pendingAuthConfig?: StaticTokenAuth;
+    /**
+     * @internal Pending dynamic auth configuration from factory function.
+     *
+     * Set by `createRtcAgent` factory when DynamicTokenAuth is provided.
+     * Applied in `connectedCallback` after controllers are initialized.
+     */
+    _pendingDynamicAuth?: DynamicTokenAuth;
+    /**
+     * @internal Pending auth provider configuration from factory function.
+     *
+     * Set by `createRtcAgent` factory when AuthProvider is provided.
+     * Applied in `connectedCallback` after controllers are initialized.
+     */
+    _pendingAuthProvider?: AuthProvider;
+    /**
+     * Load scenarios into VirtualFS.
+     *
+     * Writes to the Worker's VirtualFS via WorkerBridge.
+     */
+    private _loadScenarios;
+    /**
+     * Build a FunctionRegistry from AgentConfig (internal use).
+     *
+     * Flow:
+     * 1. Create FunctionRegistry using config.name / description / persona.
+     * 2. Create groups from config.groups and register functions in each.
+     * 3. If config.functions (flat) exists, auto-place them in a 'default' group.
+     */
+    private _buildRegistryFromConfig;
+    /** Resolved window configuration. */
+    private _resolvedWindowConfig;
+    private _windowState;
+    private _auth;
+    private _persistence;
+    private _session;
+    private _message;
+    private _mode;
+    private _toolCall;
+    private _interaction;
+    private _skill;
+    private _toast;
+    private _fork;
+    private _activity;
+    private _fileExplorer;
+    private _editorArea;
+    private _statusBar;
+    private _sessionTree;
+    private _sessionTab;
+    private _settings;
+    private _notification;
+    /** Whether the file tree has been loaded (loaded once on first entry to files activity). */
+    private _fileTreeLoaded;
+    /** Mode announcement text for screen readers (updated on mode transition). */
+    private _modeAnnouncement;
+    /** Show login dialog */
+    private _showLoginDialog;
+    /** Selected OAuth2 provider for login dialog */
+    private _selectedProvider;
+    /** Connection state. */
+    private _connectionState;
+    /** Connection state unsubscribe function. */
+    private _unsubConnection?;
+    /** Whether connection failed (used to show retry button). */
+    private _connectionFailed;
+    /** Error message when connection failed. */
+    private _connectionError;
+    /**
+     * In-flight connection promise — prevents concurrent _connectWithRetry calls
+     * from racing (e.g. connectedCallback + onLogin firing in quick succession).
+     *
+     * Without this guard, concurrent calls would create duplicate RTC processors,
+     * duplicate connection listeners, and race on session list loading.
+     */
+    private _connecting?;
+    /**
+     * Connection generation counter for race-condition prevention.
+     *
+     * When logout (or disconnect) clears `_connecting` while the underlying Promise
+     * is still in-flight, a subsequent login can set a new `_connecting`. When the
+     * OLD Promise finally resolves, its `finally` block would wrongly clear the NEW
+     * `_connecting`, leaving the new connection attempt invisible to the concurrency
+     * guard — leading to duplicate connection attempts and inconsistent state.
+     *
+     * Fix: each connection attempt captures the current generation; in `finally`,
+     * we only clear `_connecting` if the generation still matches. Any code path
+     * that invalidates an in-flight connection (logout, disconnect) bumps the
+     * generation instead of clearing `_connecting`, so stale Promises self-inhibit.
+     */
+    private _connectGeneration;
+    /** Tracks the last mode we applied DOM side-effects for, to avoid redundant work. */
+    private _appliedMode;
+    /**
+     * Guard flag to prevent infinite loop when auto-creating unsaved tab
+     *
+     * Set to true before creating tab, false after. Prevents updated() from
+     * recursively triggering itself when the newly created tab triggers another update.
+     */
+    private _creatingUnsavedTab;
+    /** Tracks whether we've done the initial session load (for auto-select logic). */
+    private _initialSessionLoadDone;
+    /** Tracks whether locale has been initialized (only once). */
+    private _localeInitialized;
+    /** Auto-save debounce timers per file */
+    private _autoSaveTimers;
+    /** Bound event handlers (stored so we can remove them in disconnectedCallback). */
+    private _boundOnMinimize;
+    private _boundOnMaximize;
+    private _boundOnRestore;
+    private _boundOnLoginRequested;
+    private _boundOnNewSession;
+    private _boundOnLogout;
+    private _boundOnInputSubmit;
+    private _boundOnForkInitiated;
+    private _boundOnKeydown;
+    private _boundOnStopRequested;
+    private _boundOnResendMessage;
+    private _boundOnSessionDeleteRequested;
+    private _boundOnSessionRenameConfirmed;
+    private _boundOnToastRequested;
+    private _boundOnToastClose;
+    private _boundOnCommandRequested;
+    private _boundOnActivityChange;
+    private _boundOnFileSelect;
+    private _boundOnFolderToggle;
+    private _boundOnEditorAreaSave;
+    private _boundOnEditorAreaTabClose;
+    private _boundOnEditorAreaTabSelect;
+    private _boundOnEditorAreaContentChange;
+    private _boundOnEditorAreaViewModeChange;
+    private _boundOnEditorAreaCursorMove;
+    private _boundOnEditorAreaRestoreDefault;
+    private _boundOnFileExplorerRefresh;
+    private _boundOnChatLayoutSessionSelect;
+    private _boundOnChatLayoutTabActivate;
+    private _boundOnChatLayoutTabClose;
+    private _boundOnDrawerClose;
+    /**
+     * Wheel event handler to prevent scroll chaining to host page.
+     *
+     * When a scrollable container inside the shadow DOM reaches its boundary
+     * (top/bottom for vertical, left/right for horizontal), continuing to scroll
+     * would propagate the wheel event to the host page, causing it to scroll.
+     * This handler:
+     * 1. If a scrollable parent exists and is at its boundary, prevents propagation
+     * 2. If no scrollable parent exists, always prevents propagation (wheel events
+     *    inside the component should never affect the host page)
+     *
+     * Supports both vertical and horizontal scroll containers.
+     */
+    private _boundOnWheel;
+    /** UIUpdateBus unsubscribe reference (set in connectedCallback, cleared in disconnectedCallback). */
+    private _busUnsubMessage?;
+    /** UIUpdateBus bulk update unsubscribe reference (set in connectedCallback, cleared in disconnectedCallback). */
+    private _busUnsubBulkUpdate?;
+    /** UIUpdateBus gap fill state unsubscribe reference (set in connectedCallback, cleared in disconnectedCallback). */
+    private _busUnsubGapFill?;
+    /**
+     * @internal Async beforeMessageSend hook, set by the `createRtcAgent` factory
+     * when the `beforeMessageSend` callback is provided.
+     *
+     * Called before each message send. Returning `false` cancels the send.
+     * The hook may also mutate the message detail in place.
+     *
+     * Cleared in disconnectedCallback to prevent leaks.
+     */
+    _beforeMessageSendHook?: (detail: {
+        message: {
+            content: string;
+            metadata?: Record<string, unknown>;
+        };
+    }) => boolean | Promise<boolean>;
+    /** Whether gap fill syncing overlay is shown. */
+    private _isSyncing;
+    /** RTC processor (instantiated after persistence connect). */
+    private _rtcProcessor?;
+    get windowStateController(): WindowStateController;
+    get authController(): AuthController;
+    get persistenceController(): PersistenceController;
+    get sessionController(): SessionController;
+    get messageController(): MessageController;
+    get modeController(): ModeController;
+    get toolCallController(): ToolCallController;
+    get skillController(): SkillController;
+    get toastController(): ToastController;
+    get forkController(): ForkController;
+    get activityController(): ActivityController;
+    get fileExplorerController(): FileExplorerController;
+    get editorAreaController(): EditorAreaController;
+    get statusBarController(): StatusBarController;
+    get sessionTreeController(): SessionTreeController;
+    get sessionTabController(): SessionTabController;
+    get settingsController(): SettingsController;
+    get notificationController(): NotificationController;
+    /**
+     * Manually reconnect when connection fails.
+     *
+     * Call this when SharedWorker initialization fails or WebSocket connection
+     * cannot be established.
+     */
+    reconnect(): Promise<void>;
+    /**
+     * Whether connection has failed.
+     *
+     * Used by UI components to show retry button or error message.
+     */
+    get connectionFailed(): boolean;
+    /**
+     * Error message when connection failed.
+     */
+    get connectionError(): string;
+    private _sessionProvider;
+    private _messageProvider;
+    private _toolCallProvider;
+    private _authProvider;
+    private _modeProvider;
+    private _windowStateProvider;
+    private _turnCountProvider;
+    private _skillProvider;
+    private _activityProvider;
+    private _fileExplorerProvider;
+    private _sessionTreeProvider;
+    private _sessionTabProvider;
+    private _settingsProvider;
+    private _notificationProvider;
+    private _logoProvider;
+    private _localeProvider;
+    connectedCallback(): void;
+    /**
+     * Connect to the persistence layer with error handling and retry.
+     *
+     * If the connection fails, sets _connectionFailed state so the user
+     * can see the error in the UI and manually retry.
+     *
+     * Delegates to connection-setup helper for the heavy orchestration.
+     *
+     * Concurrency guard: if a connection is already in-flight, returns the
+     * existing promise instead of starting a new one. This prevents duplicate
+     * initialization when connectedCallback and onLogin fire in quick succession.
+     */
+    private _connectWithRetry;
+    private _doConnectWithRetry;
+    /** Show tool confirmation dialog (delegated to dialog-helpers). */
+    private _showToolConfirm;
+    /**
+     * Show AskUser multi-select dialog (delegated to dialog-helpers).
+     *
+     * Returns the user's answer dict ({answers, annotations?, metadata?}) or null if dismissed.
+     */
+    private _showAskUser;
+    /**
+     * Lifecycle: element disconnected from DOM.
+     *
+     * Memory management strategy:
+     * Performs comprehensive cleanup of all resources registered in connectedCallback():
+     * 1. Dispatch 'rtc-before-destroy' event (for external listeners)
+     * 2. Clear async hooks (_beforeMessageSendHook) to release captured closures
+     * 3. Remove all DOM event listeners (mirrors connectedCallback's addEventListener calls)
+     * 4. Unsubscribe all UIUpdateBus listeners (message, bulk update, gap fill)
+     * 5. Release RTC processor and connection state references
+     * 6. Clear auth onLogin callback (prevents closure leak to _connectWithRetry)
+     * 7. Invalidate in-flight connection attempts via generation counter
+     * 8. Clear all auto-save timers
+     *
+     * Note: disconnectedCallback may fire for temporary removal (e.g. DOM reordering).
+     * The factory's destroy() method provides permanent cleanup.
+     */
+    disconnectedCallback(): void;
+    updated(): void;
+    firstUpdated(): void;
+    /**
+     * Run the beforeMessageSend interception pipeline.
+     *
+     * Two layers of interception:
+     * 1. **Factory hook** (`_beforeMessageSendHook`): async-aware, set by the
+     *    `createRtcAgent` factory when `on.beforeMessageSend` is provided.
+     *    Supports async callbacks (e.g. server-side validation).
+     * 2. **DOM event** (`rtc-before-message-send`): synchronous cancelable event,
+     *    allows external listeners (not registered via factory) to cancel the send
+     *    via `preventDefault()`.
+     *
+     * If either layer returns `false` / calls `preventDefault()`, the message is
+     * not sent. The callback may mutate `detail.message.content` / `detail.message.metadata`
+     * in place to modify the outgoing message.
+     *
+     * @returns `true` to proceed with send, `false` to cancel.
+     */
+    private _beforeMessageSend;
+    /**
+     * Handle user clicking the retry button.
+     *
+     * When SharedWorker initialization fails or WebSocket connection cannot be established,
+     * the user can click the retry button in the title bar to trigger this method.
+     */
+    private _handleConnectionRetry;
+    private _handleModeTransition;
+    private _handleBubbleClick;
+    private _handleBubbleKeydown;
+    /**
+     * Find the nearest scrollable ancestor of an element within the component.
+     *
+     * Traverses up the DOM tree (crossing shadow DOM boundaries via composedPath)
+     * to find the first element with overflow-y: auto|scroll that has scrollable
+     * content (scrollHeight > clientHeight).
+     */
+    private _findScrollableParent;
+    private _handleLoginRequested;
+    private _handleLoginComplete;
+    private _handleLoginDialogClose;
+    /**
+     * Read current session's pending_turn_count / running_turn_count from persistence,
+     * write to TurnCountContext for <rtc-input-area> to render send/stop buttons.
+     *
+     * Pushes zero values when there's no currentSessionId or persistence isn't ready.
+     */
+    private _refreshTurnCounts;
+    /**
+     * Load sessions list from persistence and sync into SessionController (delegated to session-loader).
+     * On initial load (after refresh), auto-selects the most recently updated session if none selected.
+     */
+    private _loadSessions;
+    /**
+     * Handle slash commands (delegated to command-handler helper).
+     *
+     * Currently supported commands:
+     * - /compact [custom_instruction]: compress current session context
+     */
+    private _handleCommand;
+    /** VFS dependency adapter (created lazily, reused across calls). */
+    private get _vfsDeps();
+    /**
+     * Load file tree from virtualFS (delegated to vfs-operations helper).
+     */
+    private _loadFileTree;
+    /**
+     * Lazy-load children of a directory (delegated to vfs-operations helper).
+     */
+    private _loadFolderChildren;
+    /**
+     * Open a file: read content from VFS and open in editor (delegated to vfs-operations).
+     */
+    private _handleFileOpen;
+    /**
+     * Restore Editor Area content for open files after page refresh (delegated to vfs-operations).
+     */
+    private _restoreEditorAreaContent;
+    /**
+     * Save file: write editor content to VFS (delegated to vfs-operations).
+     */
+    private _handleEditorSave;
+    /**
+     * Schedule auto-save (debounced).
+     */
+    private _scheduleAutoSave;
+    /**
+     * Handle file change events from other tabs (delegated to vfs-operations).
+     */
+    private _handleFileChange;
+    /**
+     * Sanitize and render bubble icon content.
+     *
+     * Uses DOMPurify (already loaded by rtc-message for Markdown) to strip
+     * any script/event-handler attributes, preventing XSS even if the value
+     * accidentally contains unsanitized user input.
+     */
+    private _sanitizeBubbleIcon;
+    private _renderBubbleContent;
+    /** Cached sanitized bubble icon HTML. */
+    private _sanitizedBubbleIcon;
+    /** Recompute sanitized icon when bubbleIcon changes. */
+    willUpdate(changed: Map<string, unknown>): void;
+    render(): import("lit").TemplateResult<1>;
+    /**
+     * Render the main layout (after login).
+     *
+     * Chat mode: Activity Bar + Chat Layout (containing drawer + Tab + chat).
+     * Files mode: Activity Bar + [Drawer(file tree)] + Editor Area + Status Bar.
+     * Settings mode: Activity Bar + Settings Layout (containing drawer + settings content).
+     *
+     * All side panels use <rtc-drawer> overlay drawers uniformly, without squeezing the main content area.
+     */
+    private _renderMainLayout;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'rtc-agent': RtcAgent;
+    }
+    /**
+     * Debug API available in dev/test builds.
+     *
+     * Provides state inspection, data manipulation, auth bypass, event simulation,
+     * VirtualFS access, and UI control for Playwright E2E tests.
+     *
+     * Only present when import.meta.env.DEV or import.meta.env.MODE === 'test'.
+     */
+    interface Window {
+        rtcAgentDebug?: import('../../debug-api.js').RtcAgentDebugAPI;
+    }
+}
+//# sourceMappingURL=rtc-agent.d.ts.map