@nextpa/chat-core 0.1.0

package/dist/core/text-mode-manager.js

@@ -0,0 +1,154 @@
+import { logger } from '../utils/logger';
+import { resolveToolCallState } from '../utils/tool-status';
+import { GreetingGate } from './greeting-gate';
+export class TextModeManager {
+    isStreaming = false;
+    streamContent = '';
+    agentStatus = null;
+    isSessionEnding = false;
+    isDelegationActive = false;
+    language;
+    connectionManager = null;
+    chatManager = null;
+    persistence = null;
+    logPrefix = '';
+    currentStreamMessageId = null;
+    pendingStreamingUpdate = false;
+    apiClient;
+    onStateChanged;
+    pendingExternalExecutor = null;
+    greetingGate = new GreetingGate((text) => { void this.sendMessage(text); });
+    constructor(apiClient, onStateChanged) {
+        this.apiClient = apiClient;
+        this.onStateChanged = onStateChanged;
+    }
+    setLanguage(language) {
+        this.language = language;
+    }
+    setWaitForGreeting(waitForGreeting) {
+        this.greetingGate.waitForGreeting = waitForGreeting;
+    }
+    async ensureConnection() {
+        if (this.connectionManager)
+            return this.connectionManager;
+        const { TextConnectionManager: TextConnMgr } = await import('./text-connection-manager');
+        this.connectionManager = new TextConnMgr(this.apiClient);
+        if (this.pendingExternalExecutor) {
+            this.connectionManager.setExternalExecutor(this.pendingExternalExecutor);
+        }
+        return this.connectionManager;
+    }
+    setupEventHandlers(deps) {
+        if (!this.connectionManager)
+            return;
+        this.connectionManager.removeAllListeners();
+        this.chatManager = deps.chatManager;
+        this.persistence = deps.persistence;
+        this.logPrefix = deps.logPrefix;
+        this.connectionManager.on('connectionStateChanged', () => this.onStateChanged());
+        this.connectionManager.on('streamDelta', ({ delta, messageId }) => {
+            if (!this.isDelegationActive) {
+                this.agentStatus = null;
+            }
+            this.handleStreamDelta(delta, messageId);
+            this.scheduleStreamingUpdate();
+        });
+        this.connectionManager.on('streamCompleted', ({ fullText }) => {
+            deps.chatManager.addAssistantMessage(fullText);
+            this.resetStreamState();
+            this.onStateChanged();
+            this.greetingGate.release();
+        });
+        this.connectionManager.on('toolCall', ({ toolName, status }) => {
+            logger.debug(`${deps.logPrefix} Text tool call:`, toolName, status);
+            const state = resolveToolCallState(toolName, status, this.isDelegationActive, this.language);
+            this.agentStatus = state.agentStatus;
+            this.isDelegationActive = state.isDelegationActive;
+            this.onStateChanged();
+        });
+        this.connectionManager.on('error', (err) => {
+            logger.error(`${deps.logPrefix} Text connection error:`, err);
+            this.isStreaming = false;
+            deps.onError();
+            this.onStateChanged();
+        });
+        this.connectionManager.on('stopConversation', deps.onStopConversation);
+        this.connectionManager.on('openUrl', (url) => deps.navigationManager.openUrl(url));
+        this.connectionManager.on('openFile', (url) => deps.navigationManager.openUrl(url));
+    }
+    async sendMessage(text, pageUrl, pageTitle) {
+        if (!this.connectionManager || !this.chatManager || !this.persistence)
+            return;
+        // Hold the first user message fully (display + send) until the greeting has streamed.
+        if (this.greetingGate.shouldHold()) {
+            this.greetingGate.enqueue(text);
+            return;
+        }
+        this.chatManager.addUserMessage(text);
+        this.isStreaming = true;
+        this.onStateChanged();
+        try {
+            await this.connectionManager.sendMessage(text, pageUrl, pageTitle);
+        }
+        catch (err) {
+            logger.error(`${this.logPrefix} Failed to send text message:`, err);
+            this.isStreaming = false;
+            this.onStateChanged();
+            throw err;
+        }
+    }
+    requestGreeting(pageUrl, pageTitle) {
+        if (!this.connectionManager)
+            return;
+        this.greetingGate.beginGreeting();
+        this.isStreaming = true;
+        this.onStateChanged();
+        this.connectionManager.sendGreeting(pageUrl, pageTitle).catch((err) => {
+            logger.debug(`${this.logPrefix} Failed to request greeting:`, err);
+            this.isStreaming = false;
+            this.onStateChanged();
+        });
+    }
+    async disconnect() {
+        this.greetingGate.reset();
+        await this.connectionManager?.disconnect();
+        this.resetStreamState();
+    }
+    getConnectionState() {
+        return this.connectionManager?.getConnectionState() ?? 'disconnected';
+    }
+    setDocumentProvider(getDoc, getWin) {
+        this.connectionManager?.setDocumentProvider(getDoc, getWin);
+    }
+    setExternalExecutor(executor) {
+        this.pendingExternalExecutor = executor;
+        this.connectionManager?.setExternalExecutor(executor);
+    }
+    resetStreamState() {
+        this.isStreaming = false;
+        this.currentStreamMessageId = null;
+        this.streamContent = '';
+        this.agentStatus = null;
+        this.isDelegationActive = false;
+    }
+    dispose() {
+        this.connectionManager?.dispose();
+    }
+    handleStreamDelta(delta, messageId) {
+        if (this.currentStreamMessageId !== messageId) {
+            this.currentStreamMessageId = messageId;
+            this.streamContent = '';
+            this.isStreaming = true;
+        }
+        this.streamContent += delta;
+    }
+    scheduleStreamingUpdate() {
+        if (this.pendingStreamingUpdate)
+            return;
+        this.pendingStreamingUpdate = true;
+        requestAnimationFrame(() => {
+            this.pendingStreamingUpdate = false;
+            this.onStateChanged();
+        });
+    }
+}

package/dist/core/text-types.d.ts

@@ -0,0 +1,20 @@
+import type { ChatMessage, ConnectionState, WidgetConfig } from '../types';
+import type { ResolvedTheme } from '../utils/theme-detection';
+export interface TextWidgetState {
+    config: WidgetConfig | null;
+    resolvedTheme: ResolvedTheme;
+    isLoading: boolean;
+    initFailed: boolean;
+    hasError: boolean;
+    isMinimized: boolean;
+    isConnecting: boolean;
+    connectionState: ConnectionState;
+    isStreaming: boolean;
+    streamingContent: string;
+    agentStatus: string | null;
+    messages: ChatMessage[];
+    showTermsModal: boolean;
+    hasConsented: boolean;
+    blockedUrl: string | null;
+    showPopover: boolean;
+}

package/dist/core/text-types.js

@@ -0,0 +1 @@
+export {};

package/dist/core/text-widget-controller.d.ts

@@ -0,0 +1,47 @@
+import { EventEmitter } from './event-emitter';
+import type { WidgetControllerOptions } from './types';
+import type { ConnectOptions } from '../types';
+import type { TextWidgetState } from './text-types';
+interface TextWidgetControllerEvents {
+    stateChanged: (state: TextWidgetState) => void;
+}
+export declare class TextWidgetController extends EventEmitter<TextWidgetControllerEvents> {
+    private readonly core;
+    private readonly connectionManager;
+    private readonly sessionBeacon;
+    private isStreaming;
+    private currentStreamContent;
+    private currentStreamMessageId;
+    private agentStatus;
+    private isDelegationActive;
+    private sessionEnded;
+    private greetingOverride;
+    private readonly greetingGate;
+    constructor(options: WidgetControllerOptions);
+    initialize(): Promise<void>;
+    connect(options?: ConnectOptions): Promise<void>;
+    disconnect(trimFarewell?: boolean): Promise<void>;
+    private handleSessionResumed;
+    resetConversation(): Promise<void>;
+    submitFeedback(messageId: string, rating: number | undefined): void;
+    sendMessage(text: string): Promise<void>;
+    toggleMinimized(): void;
+    setMinimized(minimized: boolean): void;
+    acceptTerms(): void;
+    declineTerms(): void;
+    dismissBlockedUrl(): void;
+    openBlockedUrl(): void;
+    dismissPopover(): void;
+    getState(): TextWidgetState;
+    dispose(): void;
+    private get language();
+    private notifyStateChanged;
+    private resetStreamState;
+    private setupConnectionHandlers;
+    private handleStopConversation;
+    private requestGreeting;
+    private sendDemoResponse;
+    private updateDocumentProviders;
+    private setupExtensionBridge;
+}
+export {};

package/dist/core/text-widget-controller.js

@@ -0,0 +1,278 @@
+import { isDemoMode } from '../constants/defaults';
+import { logger } from '../utils/logger';
+import { resolveToolCallState } from '../utils/tool-status';
+import { initExtensionBridge, refreshExtensionContext } from '../services/page-interaction/extension-bridge';
+import { TextConnectionManager } from './text-connection-manager';
+import { EventEmitter } from './event-emitter';
+import { SessionBeacon } from './session-beacon';
+import { WidgetCore } from './widget-core';
+import { GreetingGate } from './greeting-gate';
+const LOG_PREFIX = '[TextWidgetController]';
+const DEMO_MESSAGE_DELAY_MS = 1000;
+export class TextWidgetController extends EventEmitter {
+    core;
+    connectionManager;
+    sessionBeacon;
+    isStreaming = false;
+    currentStreamContent = '';
+    currentStreamMessageId = null;
+    agentStatus = null;
+    isDelegationActive = false;
+    sessionEnded = false;
+    greetingOverride;
+    greetingGate = new GreetingGate((text) => { void this.sendMessage(text); });
+    constructor(options) {
+        super();
+        const notify = () => this.notifyStateChanged();
+        this.core = new WidgetCore(options, notify, (getDoc, getWin) => this.updateDocumentProviders(getDoc, getWin), () => this.connect(), LOG_PREFIX);
+        this.connectionManager = new TextConnectionManager(this.core.apiClient);
+        this.sessionBeacon = new SessionBeacon();
+        this.setupConnectionHandlers();
+        this.setupExtensionBridge();
+    }
+    async initialize() {
+        await this.core.initialize();
+    }
+    async connect(options) {
+        this.greetingGate.waitForGreeting = options?.waitForGreeting ?? true;
+        this.greetingOverride = options?.greeting;
+        const config = this.core.configManager.getConfig();
+        if (!config)
+            return;
+        if (!this.core.requireConsentOrConnect(config))
+            return;
+        const startFresh = this.sessionEnded;
+        this.sessionEnded = false;
+        this.core.isConnecting = true;
+        this.core.hasError = false;
+        this.core.chatManager.clearMessages();
+        this.notifyStateChanged();
+        try {
+            if (!startFresh) {
+                await this.core.persistence.loadHistory(this.core.chatManager);
+            }
+            await this.connectionManager.connect();
+            this.core.persistence.setAssistantId(config.assistantId);
+            const clientId = this.core.apiClient.getClientId();
+            if (clientId) {
+                this.sessionBeacon.register(this.core.apiClient.getBaseUrl(), clientId, config.assistantId, () => this.handleSessionResumed());
+            }
+            this.core.persistence.startNewSession();
+            if (isDemoMode) {
+                this.core.showDemoWelcome(config);
+                return;
+            }
+            const greetingOn = this.greetingOverride ?? config.greetingEnabled !== false;
+            if (greetingOn && this.core.chatManager.getMessages().length === 0) {
+                this.requestGreeting();
+            }
+        }
+        catch (err) {
+            logger.debug(`${LOG_PREFIX} Failed to connect:`, err);
+            this.core.isConnecting = false;
+            this.notifyStateChanged();
+        }
+    }
+    async disconnect(trimFarewell = false) {
+        this.greetingGate.reset();
+        this.sessionBeacon.unregister();
+        this.core.persistence.saveToLocalStorage(this.core.chatManager);
+        this.core.persistence.endSession(trimFarewell);
+        await this.connectionManager.disconnect();
+        this.resetStreamState();
+        this.notifyStateChanged();
+    }
+    handleSessionResumed() {
+        this.core.persistence.startNewSession();
+    }
+    async resetConversation() {
+        logger.debug(`${LOG_PREFIX} Resetting conversation...`);
+        await this.connectionManager.disconnect();
+        this.core.chatManager.clearMessages();
+        this.resetStreamState();
+        await this.core.persistence.resetMemory();
+        this.notifyStateChanged();
+        await this.connect();
+    }
+    submitFeedback(messageId, rating) {
+        if (rating == null) {
+            this.core.chatManager.setFeedback(messageId, undefined);
+            this.notifyStateChanged();
+            return;
+        }
+        this.core.chatManager.setFeedback(messageId, rating);
+        this.notifyStateChanged();
+        this.core.apiClient.submitFeedback(messageId, rating).catch((err) => {
+            logger.debug(`${LOG_PREFIX} Failed to submit feedback:`, err);
+        });
+    }
+    async sendMessage(text) {
+        if (!text.trim())
+            return;
+        // Hold the first user message fully (display + send) until the greeting has streamed.
+        if (this.greetingGate.shouldHold()) {
+            this.greetingGate.enqueue(text);
+            return;
+        }
+        this.core.chatManager.addUserMessage(text);
+        if (isDemoMode) {
+            this.sendDemoResponse(text);
+            return;
+        }
+        this.isStreaming = true;
+        this.notifyStateChanged();
+        const refreshedContext = await refreshExtensionContext();
+        if (refreshedContext) {
+            this.core.pageUrl = refreshedContext.url;
+            this.core.pageTitle = refreshedContext.title;
+        }
+        try {
+            await this.connectionManager.sendMessage(text, this.core.pageUrl, this.core.pageTitle);
+        }
+        catch (err) {
+            logger.error(`${LOG_PREFIX} Failed to send message:`, err);
+            this.isStreaming = false;
+            this.core.hasError = true;
+            this.notifyStateChanged();
+        }
+    }
+    toggleMinimized() {
+        this.core.toggleMinimized();
+    }
+    setMinimized(minimized) {
+        this.core.setMinimized(minimized);
+    }
+    acceptTerms() {
+        this.core.acceptTerms(() => this.connect());
+    }
+    declineTerms() {
+        this.core.declineTerms();
+    }
+    dismissBlockedUrl() {
+        this.core.dismissBlockedUrl();
+    }
+    openBlockedUrl() {
+        this.core.openBlockedUrl();
+    }
+    dismissPopover() {
+        this.core.dismissPopover();
+    }
+    getState() {
+        return {
+            config: this.core.configManager.getConfig(),
+            resolvedTheme: this.core.themeManager.resolvedTheme,
+            isLoading: this.core.isLoading,
+            initFailed: this.core.initFailed,
+            hasError: this.core.hasError,
+            isMinimized: this.core.isMinimized,
+            isConnecting: this.core.isConnecting,
+            connectionState: this.connectionManager.getConnectionState(),
+            isStreaming: this.isStreaming,
+            streamingContent: this.currentStreamContent,
+            agentStatus: this.agentStatus,
+            messages: this.core.chatManager.getMessages(),
+            showTermsModal: this.core.consentManager.showTermsModal,
+            hasConsented: this.core.consentManager.hasConsented,
+            blockedUrl: this.core.navigationManager.blockedUrl,
+            showPopover: this.core.popoverManager.showPopover,
+        };
+    }
+    dispose() {
+        this.connectionManager.dispose();
+        this.core.dispose();
+        this.removeAllListeners();
+    }
+    get language() {
+        return this.core.configManager.getConfig()?.language;
+    }
+    notifyStateChanged() {
+        this.emit('stateChanged', this.getState());
+    }
+    resetStreamState() {
+        this.isStreaming = false;
+        this.currentStreamMessageId = null;
+        this.currentStreamContent = '';
+        this.agentStatus = null;
+        this.isDelegationActive = false;
+    }
+    setupConnectionHandlers() {
+        this.connectionManager.on('connectionStateChanged', (state) => {
+            if (state !== 'connecting') {
+                this.core.isConnecting = false;
+            }
+            this.notifyStateChanged();
+        });
+        this.connectionManager.on('streamDelta', ({ delta, messageId }) => {
+            if (this.currentStreamMessageId !== messageId) {
+                this.currentStreamMessageId = messageId;
+                this.currentStreamContent = '';
+                this.isStreaming = true;
+            }
+            if (!this.isDelegationActive) {
+                this.agentStatus = null;
+            }
+            this.currentStreamContent += delta;
+            this.notifyStateChanged();
+        });
+        this.connectionManager.on('streamCompleted', ({ fullText }) => {
+            this.core.chatManager.addAssistantMessage(fullText);
+            this.resetStreamState();
+            this.notifyStateChanged();
+            // The greeting finished — replay any user message held meanwhile (after the greeting).
+            this.greetingGate.release();
+        });
+        this.connectionManager.on('toolCall', ({ toolName, status, agentLabel }) => {
+            logger.debug(`${LOG_PREFIX} Tool call:`, toolName, status, agentLabel);
+            const state = resolveToolCallState(toolName, status, this.isDelegationActive, this.language, agentLabel);
+            this.agentStatus = state.agentStatus;
+            this.isDelegationActive = state.isDelegationActive;
+            this.notifyStateChanged();
+        });
+        this.connectionManager.on('error', (err) => {
+            logger.error(`${LOG_PREFIX} Connection error:`, err);
+            this.core.hasError = true;
+            this.isStreaming = false;
+            this.notifyStateChanged();
+        });
+        this.connectionManager.on('stopConversation', () => this.handleStopConversation());
+        this.connectionManager.on('openUrl', (url) => this.core.navigationManager.openUrl(url));
+        this.connectionManager.on('openFile', (url) => this.core.navigationManager.openUrl(url));
+    }
+    async handleStopConversation() {
+        logger.debug(`${LOG_PREFIX} StopConversation received`);
+        this.sessionEnded = true;
+        await this.disconnect(true);
+        this.core.isMinimized = true;
+        this.notifyStateChanged();
+    }
+    requestGreeting() {
+        this.greetingGate.beginGreeting();
+        this.isStreaming = true;
+        this.notifyStateChanged();
+        this.connectionManager.sendGreeting(this.core.pageUrl, this.core.pageTitle).catch((err) => {
+            logger.debug(`${LOG_PREFIX} Failed to request greeting:`, err);
+            this.isStreaming = false;
+            this.notifyStateChanged();
+        });
+    }
+    sendDemoResponse(text) {
+        this.isStreaming = true;
+        this.notifyStateChanged();
+        setTimeout(() => {
+            this.core.chatManager.addAssistantMessage(`Dies ist eine Demo-Antwort auf: "${text}"\n\nIm Produktivbetrieb würde hier die KI-Antwort erscheinen.`);
+            this.isStreaming = false;
+            this.notifyStateChanged();
+        }, DEMO_MESSAGE_DELAY_MS);
+    }
+    updateDocumentProviders(getDoc, getWin) {
+        this.connectionManager.setDocumentProvider(getDoc, getWin);
+    }
+    setupExtensionBridge() {
+        initExtensionBridge([
+            (executor) => this.connectionManager.setExternalExecutor(executor),
+        ], (ctx) => {
+            this.core.pageUrl = ctx.url;
+            this.core.pageTitle = ctx.title;
+        });
+    }
+}

package/dist/core/theme-manager.d.ts

@@ -0,0 +1,10 @@
+import { type ResolvedTheme } from '../utils/theme-detection';
+type ThemeChangeCallback = (theme: ResolvedTheme) => void;
+export declare class ThemeManager {
+    private _resolvedTheme;
+    private observerCleanup;
+    get resolvedTheme(): ResolvedTheme;
+    initialize(configTheme: string, onChange: ThemeChangeCallback): void;
+    dispose(): void;
+}
+export {};

package/dist/core/theme-manager.js

@@ -0,0 +1,25 @@
+import { detectHostTheme, observeThemeChanges } from '../utils/theme-detection';
+import { logger } from '../utils/logger';
+export class ThemeManager {
+    _resolvedTheme = 'dark';
+    observerCleanup = null;
+    get resolvedTheme() {
+        return this._resolvedTheme;
+    }
+    initialize(configTheme, onChange) {
+        if (configTheme !== 'auto') {
+            this._resolvedTheme = configTheme === 'light' ? 'light' : 'dark';
+            return;
+        }
+        this._resolvedTheme = detectHostTheme();
+        logger.debug('[ThemeManager] Auto theme detected:', this._resolvedTheme);
+        this.observerCleanup = observeThemeChanges((newTheme) => {
+            this._resolvedTheme = newTheme;
+            onChange(newTheme);
+        });
+    }
+    dispose() {
+        this.observerCleanup?.();
+        this.observerCleanup = null;
+    }
+}

package/dist/core/types.d.ts

@@ -0,0 +1,50 @@
+import type { ChatMessage, ConnectionState, WidgetConfig } from '../types';
+import type { ResolvedTheme } from '../utils/theme-detection';
+import type { WidgetApiClient, WidgetTokenProvider } from '../services/api';
+export type ChatMode = 'voice' | 'text';
+export interface WidgetState {
+    config: WidgetConfig | null;
+    resolvedTheme: ResolvedTheme;
+    isLoading: boolean;
+    initFailed: boolean;
+    hasError: boolean;
+    isMicrophoneBlocked: boolean;
+    isMinimized: boolean;
+    isConnecting: boolean;
+    connectionState: ConnectionState;
+    currentMode: ChatMode;
+    isMuted: boolean;
+    isMicrophoneReady: boolean;
+    isUserSpeaking: boolean;
+    /** Normalised microphone input level (0..1), updated continuously during voice. */
+    audioLevel: number;
+    isAiThinking: boolean;
+    isStreaming: boolean;
+    /** Assistant audio is still playing back, even after the transcript is complete (voice only). */
+    isAssistantSpeaking: boolean;
+    streamingContent: string;
+    isTranscribing: boolean;
+    transcribingContent: string;
+    messages: ChatMessage[];
+    agentStatus: string | null;
+    showTermsModal: boolean;
+    hasConsented: boolean;
+    blockedUrl: string | null;
+    showPopover: boolean;
+}
+export type WidgetEventType = 'stateChanged' | 'error' | 'configLoaded' | 'connected' | 'disconnected' | 'messageReceived';
+export interface WidgetEvents {
+    stateChanged: (state: WidgetState) => void;
+    error: (error: string) => void;
+    configLoaded: (config: WidgetConfig) => void;
+    connected: () => void;
+    disconnected: () => void;
+    messageReceived: (message: ChatMessage) => void;
+}
+export interface WidgetControllerOptions {
+    apiKey?: string;
+    baseUrl?: string;
+    source?: string;
+    tokenProvider?: WidgetTokenProvider;
+    apiClient?: WidgetApiClient;
+}

package/dist/core/types.js

@@ -0,0 +1 @@
+export {};

package/dist/core/voice-state-manager.d.ts

@@ -0,0 +1,85 @@
+import type { WidgetApiClient } from '../services/api';
+import type { ConnectionManager } from './connection-manager';
+import type { ChatManager } from './chat-manager';
+import type { ConversationPersistence } from './conversation-persistence';
+import type { NavigationManager } from './navigation-manager';
+type StateChangeCallback = () => void;
+type VoiceEventDeps = {
+    connectionManager: ConnectionManager;
+    apiClient: WidgetApiClient;
+    chatManager: ChatManager;
+    persistence: ConversationPersistence;
+    navigationManager: NavigationManager;
+    onStopConversation: () => Promise<void>;
+    logPrefix: string;
+};
+export declare class VoiceStateManager {
+    isUserSpeaking: boolean;
+    isAiThinking: boolean;
+    isMuted: boolean;
+    isMicrophoneReady: boolean;
+    isMicrophoneBlocked: boolean;
+    isTranscribing: boolean;
+    transcribingContent: string;
+    isStreaming: boolean;
+    isAssistantSpeaking: boolean;
+    streamContent: string;
+    agentStatus: string | null;
+    audioLevel: number;
+    private audioLevelLastTime;
+    private isDelegationActive;
+    private connectionManager;
+    private apiClient;
+    private logPrefix;
+    language?: string;
+    private latestUsage;
+    private accumulatedUsage;
+    private pendingToolCalls;
+    private thinkingStartedAt;
+    private pendingStreamingUpdate;
+    private toolAbortController;
+    private readonly onStateChanged;
+    constructor(onStateChanged: StateChangeCallback);
+    setupEventHandlers(deps: VoiceEventDeps): void;
+    setLanguage(language?: string): void;
+    toggleMute(): void;
+    /**
+     * User pressed stop while the assistant was busy. If a backend tool (e.g. a
+     * long web research) is in flight, abort its HTTP call so the server cancels
+     * it (RequestAborted) and let the model wrap up gracefully. Otherwise the
+     * assistant is thinking/talking — interrupt the response and drop the audio.
+     */
+    stop(): void;
+    /**
+     * The assistant transcript completes before its audio finishes playing.
+     * Hold the speaking flag until playback truly ends (audioDone + playback
+     * monitor) so the stop button stays visible while the user can still hear
+     * the assistant.
+     */
+    private trackAssistantPlayback;
+    resetState(): void;
+    /**
+     * Asymmetric envelope follower over a dBFS-mapped input. Two stages:
+     *
+     * 1. dBFS perceptual map — raw RMS (0..1) lives mostly under 0.1 so a
+     *    linear halo would barely move at normal volumes. Mapping through
+     *    20·log10(level) and clamping to roughly -50..0 dBFS spreads the
+     *    normal-speech range across the visual.
+     * 2. One-pole IIR with split time constants — 10 ms attack so syllables
+     *    pop, 150 ms release so the avatar doesn't twitch off between words.
+     *
+     * Sweet spots picked from common voice-visualisation guidance (attack
+     * 5–50 ms, release 100–300 ms, dBFS floor -60 .. -50, ceiling -10 .. 0).
+     */
+    private smoothAudioLevel;
+    prepareForConnection(): void;
+    private setupSpeechHandlers;
+    private setupConnectionHandlers;
+    private setupActionHandlers;
+    private handleToolCall;
+    private handleFunctionCall;
+    private handleStopConversation;
+    private accumulateUsage;
+    private scheduleStreamingUpdate;
+}
+export {};