@hartren/assistant-js 0.0.0-stage → 2.3.1

package/dist/CopilotAgent/AuthenticationService.d.ts

@@ -0,0 +1,47 @@
+/** Host-supplied token provider: called for every request; resolves the current user token. */
+export type AccessTokenProvider = () => Promise<string | null | undefined> | string | null | undefined;
+/** Called after the API answered 401 for `rejectedToken`; resolves a different token to retry with, or null. */
+export type UnauthorizedHandler = (rejectedToken: string) => Promise<string | null | undefined> | string | null | undefined;
+/**
+ * Token handling for the API calls and the speech socket.
+ *
+ * Preferred: the host passes `getAccessToken` (for example `() => auth.getAccessToken()` from
+ * `@hartren/auth`) and optionally `onUnauthorized`. The library then never exchanges or refreshes
+ * anything itself: it asks the provider on every request and keeps no copy of the token.
+ *
+ * Deprecated (to be removed in a future major version): `pat`, the browser PAT exchange (`/token/exchange`)
+ * and the legacy refresh (`/token/refresh`). They run only when a PAT is passed and the provider
+ * is missing or returns nothing.
+ */
+export declare class AuthenticationService {
+    private pat;
+    private accessToken;
+    private refreshToken;
+    private tokenExpiration;
+    private refreshTimeout;
+    private pendingRefreshPromise;
+    private pendingExchangePromise;
+    private _baseUrl;
+    private _userId;
+    private _getAccessToken;
+    private _onUnauthorized;
+    constructor(copilotApi: any, pat: any, getAccessToken?: AccessTokenProvider | null, onUnauthorized?: UnauthorizedHandler | null);
+    /** Deprecated: the userId for the PAT exchange. Does nothing without a PAT. */
+    setUserId(userId: string | null): void;
+    getAccessToken(): Promise<string>;
+    /**
+     * After a 401 for `rejectedToken`: resolves a different token to retry with once, or null.
+     * Provider mode asks `onUnauthorized` (or, without it, the provider again); legacy mode drops the
+     * cached token and refreshes or re-exchanges.
+     */
+    handleUnauthorized(rejectedToken: string): Promise<string | null>;
+    /** One PAT exchange shared by concurrent callers. */
+    private exchangeOnce;
+    private exchangePatForTokens;
+    private refreshTokens;
+    private performTokenRefresh;
+    private handleTokenResponse;
+    private scheduleProactiveRefresh;
+    private isTokenExpired;
+    private clearRefreshTimer;
+}

package/dist/CopilotAgent/CommandsManager.d.ts

@@ -0,0 +1,20 @@
+export declare class CommandsManager {
+    private commands;
+    constructor({}?: {});
+    /**
+     * Register a new command with the command manager
+     *
+     * @method
+     * @param {string} commandName - Unique name identifying the command
+     * @param {CommandDefinition} definition - {@link CommandDefinition}
+     */
+    registerCommand(commandName: any, definition: any): void;
+    /**
+     *
+     * @method
+     * @param {String} commandName
+     * @param {Object} [options={}] - Extra options to pass the command. Like a mousedown event
+     */
+    runCommand(commandName: string, options?: {}): any;
+}
+export default CommandsManager;

package/dist/CopilotAgent/CopilotAgent.d.ts

@@ -0,0 +1,148 @@
+import type { AccessTokenProvider, UnauthorizedHandler } from './AuthenticationService';
+import { CopilotActivityState, CopilotMode } from '../types';
+import { SpeechErrorCode, SpeechProvider, SpeechRetryOptions } from '../SpeechRecognitionService/speechConfig';
+import { MicrophoneEnvironment, SpeechRecognitionFailure } from '../MicrophoneAccess/MicrophoneAccess';
+export interface CopilotWidgetState {
+    isListening?: boolean;
+    isSpeeking?: boolean;
+    isMuted?: boolean;
+    isEnabled?: boolean;
+    state?: string;
+    recognationState?: string;
+    mode?: CopilotMode;
+    activity?: CopilotActivityState;
+}
+export interface CopilotWidgetResult {
+    result?: string;
+}
+export interface CopilotError {
+    message: string;
+    error?: any;
+    stopAgent?: boolean;
+    asPopup?: boolean;
+    /**
+     * Speech errors: one of SpeechErrorCodes. Strategy errors from the opt-in browser provider
+     * carry a SpeechRecognitionFailure (e.g. 'mic-denied') instead.
+     */
+    code?: SpeechErrorCode | SpeechRecognitionFailure;
+    /** Speech retries: attempt number (1-based) and the retry budget. */
+    attempt?: number;
+    maxRetries?: number;
+    retryInMs?: number;
+    /** Speech: true when no more retries will happen. */
+    final?: boolean;
+    /** Speech: what failed ('connect-failed', 'socket-closed', 'audio-setup-failed', ...). */
+    reason?: string;
+    /** Speech: WebSocket close code, when a socket closed. */
+    closeCode?: number;
+    /** Microphone failures: the browser's error name (e.g. 'NotAllowedError'), never its raw message. */
+    detail?: string;
+    /** Microphone failures: what the browser reported about microphone access. */
+    environment?: MicrophoneEnvironment;
+}
+export interface RecognitionResult {
+    transcript?: string;
+    timestamp?: number;
+}
+interface ConstructorParams {
+    commands: any;
+    copilotApi: any;
+    clientId?: string | null;
+    language?: string;
+    /** @deprecated Browser PAT exchange; pass `getAccessToken` instead. To be removed in a future major version. */
+    pat?: string;
+    threshold?: number;
+    defaultContext?: string;
+    /**
+     * The user's token for every API call and the speech socket, asked for on each request (no copy
+     * is kept), e.g. `() => auth.getAccessToken()` from `@hartren/auth`. Resolve null when signed out.
+     */
+    getAccessToken?: AccessTokenProvider | null;
+    /**
+     * Optional. Called once when the API answers 401 for a token, e.g.
+     * `(t) => auth.handleUnauthorized(t)`. Resolve a different token to retry the request once, or null.
+     */
+    onUnauthorized?: UnauthorizedHandler | null;
+    /**
+     * Origin of the hosted speech WebSockets (`/ws/speech/transcribe`, `/ws/speech/speak`).
+     * Defaults to the origin of `copilotApi` with a ws(s) scheme.
+     */
+    transcribeWssUrl?: string | null;
+    mode?: string | null;
+    /**
+     * 'deepgram' (default): hosted transcription/TTS only. 'browser': explicit opt-in to the browser
+     * Web Speech APIs, which can send audio/text to the browser vendor (no BAA). Never automatic.
+     */
+    speechProvider?: SpeechProvider | string | null;
+    /** Reconnect policy for the hosted transcription socket. */
+    speechRetry?: SpeechRetryOptions | null;
+    /**
+     * Default false. When true (hosted provider only), dictation switches to the browser's
+     * SpeechRecognition when the transcription socket cannot connect or drops mid-session while the
+     * browser is online, and returns to the hosted service on 'online' or when the next dictation
+     * starts. Offline behaves as without the option. WARNING: browser speech can send audio to the browser vendor (e.g. Google,
+     * Microsoft), with no BAA. Enable only where that is acceptable (never with PHI).
+     */
+    browserTranscriptionFallback?: boolean | null;
+    /**
+     * Logs dictated text, prompts, AI replies and raw API responses to the console. Off by default:
+     * that text can be PHI. For local debugging only. Same as `setCopilotDebugLogging(true)`.
+     */
+    debug?: boolean;
+}
+export default class CopilotAgent {
+    #private;
+    constructor({ commands, copilotApi, clientId, language, pat, threshold, getAccessToken, onUnauthorized, transcribeWssUrl, mode, speechProvider: requestedSpeechProvider, speechRetry, browserTranscriptionFallback, debug, }: ConstructorParams);
+    private _setActivity;
+    getOrStartSession(): Promise<any>;
+    setSession(sessionId: string): void;
+    registerCommands(commands?: object): void;
+    private engageCopilot;
+    private executeTools;
+    addMessage(newMessage: string): void;
+    private _processAndSendMessage;
+    private _handleResponse;
+    sendMessage(message: any, clearLast: any): Promise<void>;
+    startListening(): void;
+    stopListening(forceStop?: boolean): void;
+    getState(): {
+        isListening: boolean;
+        isSpeeking: boolean;
+        isMuted: boolean;
+        isEnabled: boolean;
+        state: string;
+        recognationState: string;
+        mode: CopilotMode;
+        activity: CopilotActivityState;
+    };
+    /** Returns the current operating mode of the agent. */
+    getMode(): CopilotMode;
+    /** True when the agent is running in silent mode (never speaks). */
+    isSilent(): boolean;
+    /** True when the agent is in minimal mode (backend content mode; no local speech change). */
+    isMinimal(): boolean;
+    /** @deprecated Sets the userId used for the PAT exchange; does nothing without a PAT. To be removed in a future major version. */
+    setUserId(userId: string | null): void;
+    setMode(mode?: string | null): void;
+    private _broadCastEvt;
+    private _onCopilotResult;
+    /** Which speech provider this agent uses ('deepgram' unless the host opted into 'browser'). */
+    getSpeechProvider(): SpeechProvider;
+    /** True while dictation runs on the browser fallback (only with browserTranscriptionFallback: true). */
+    isUsingBrowserTranscriptionFallback(): boolean;
+    speak(message: string, onCompleteEvt?: any): Promise<void>;
+    mute(): void;
+    unMute(): void;
+    isEnabled(): boolean;
+    enable(enabled?: boolean): void;
+    onStateChange(listener: (state: CopilotWidgetState) => void): void;
+    onCopilotResult(listener: (state: CopilotWidgetResult) => void): void;
+    onCopilotError(listener: (state: CopilotError) => void): void;
+    onRecognitionResult(listener: (result: RecognitionResult) => void): void;
+    onRecognitionSilent(listener: (result: {
+        isSilent: boolean;
+    }) => void): void;
+    stopSession(): void;
+    getAccessToken(): Promise<any>;
+}
+export {};

package/dist/CopilotAgent/CopilotProxy.d.ts

@@ -0,0 +1,17 @@
+import { type AccessTokenProvider, type UnauthorizedHandler } from "./AuthenticationService";
+import type { CopilotMode } from "../types";
+export default class CopilotProxy {
+    private _session;
+    private _baseUrl;
+    private _AuthenticationService;
+    private _clientId?;
+    constructor(copilotApi: any, pat: any, getAccessToken?: AccessTokenProvider | null, clientId?: string | null, onUnauthorized?: UnauthorizedHandler | null);
+    setUserId(userId: string | null): void;
+    /** Creates a session. Mode is not sent here — it is applied per ViewerCopilot turn. */
+    startSession(): Promise<any>;
+    stopSession(): Promise<void>;
+    /** Sends a ViewerCopilot turn. `mode` is per-turn so the backend applies the right policy. */
+    engageCopilot(session: string, prompt: string, type: string, tools: any[], fromVoice: boolean, clearLast?: boolean, mode?: CopilotMode): Promise<any>;
+    private _callApi;
+    getAccessToken(): Promise<any>;
+}

package/dist/CopilotAgent/UserSessionService.d.ts

@@ -0,0 +1,9 @@
+export default class UserSessionService {
+    private _session;
+    private _proxy;
+    constructor(proxy: any);
+    setSession(sessionId: string): void;
+    getOrStartSession(): Promise<any>;
+    startSession(): Promise<void>;
+    stopSession(): Promise<void>;
+}

package/dist/CopilotAgent/index.d.ts

@@ -0,0 +1,2 @@
+import CopilotAgent from "./CopilotAgent";
+export default CopilotAgent;

package/dist/CustomSpeechRecognition/CustomSpeechRecognition.d.ts

@@ -0,0 +1,93 @@
+import { EventEmitter } from 'events';
+import { MicVAD } from '@ricky0123/vad-web';
+import { SpeechRetryOptions } from '../SpeechRecognitionService/speechConfig';
+export default class CustomSpeechRecognition {
+    lang: string;
+    continuous: boolean;
+    interimResults: boolean;
+    maxAlternatives: number;
+    onresult: ((event?: any) => void) | null;
+    onerror: ((event?: any) => void) | null;
+    onstart: (() => void) | null;
+    onspeechstart: (() => void) | null;
+    onspeechend: (() => void) | null;
+    onend: (() => void) | null;
+    socket: WebSocket | null;
+    socketUrl: string | null;
+    vad: MicVAD | null;
+    isRecording: boolean;
+    sessionService: {
+        getOrStartSession: () => Promise<string>;
+    } | null;
+    events: EventEmitter;
+    copilotIsSpeeking: boolean;
+    stream: MediaStream | null;
+    transcribeWssUrl: string | null;
+    private _abortAudioSetup;
+    private _hadTranscriptionPayload;
+    private _userRequestedStop;
+    private _activeTtsContext;
+    private _forceSpeakSettle;
+    private _getAccessToken;
+    private _retry;
+    private _retryAttempt;
+    private _retryTimer;
+    private _connecting;
+    private _openedAt;
+    /** Bumped by every connect and by stop(); callbacks from an older connect are ignored. */
+    private _connectGen;
+    /** Microphone start failures in a row; a repeat failure with an unknown permission state is a block. */
+    private _failedAttempts;
+    /**
+     * Optional hook asked on every hosted connection failure before a retry is scheduled. Returning
+     * true means the caller took over (browserTranscriptionFallback); no retry or error is raised here.
+     */
+    private _onConnectionFailure;
+    /** A connection that stayed open at least this long was healthy: its close gets a fresh retry budget. */
+    static HEALTHY_CONNECTION_MS: number;
+    constructor(transcribeWssUrl?: string, options?: {
+        getAccessToken?: (() => Promise<string> | string | null | undefined) | null;
+        retry?: SpeechRetryOptions | null;
+        onConnectionFailure?: ((failure: {
+            reason: string;
+            closeCode?: number;
+        }) => boolean) | null;
+    });
+    init({ sessionService, events }: {
+        sessionService: any;
+        events: EventEmitter;
+    }): Promise<void>;
+    /**
+     * URL `${transcribeWssUrl}${path}?sessionId=...` (no token) and the subprotocols. Browsers cannot set
+     * headers on a WebSocket, so the access token goes in the Sec-WebSocket-Protocol header as
+     * `bearer.<token>` next to `hartren.speech.v1`, which the Hartren API echoes. The token is never put in
+     * the URL, so it cannot reach access logs. Throws when the session or token cannot be obtained
+     * (handled as a connection failure).
+     */
+    private _speechSocket;
+    start(): Promise<void>;
+    /** Closes and forgets the current socket without running its handlers (they check the generation). */
+    private _detachSocket;
+    private _connect;
+    /**
+     * Retries the hosted transcription with exponential backoff, emitting an error event on each
+     * attempt, then a final error. Browser speech is used instead only when the host opted into
+     * `browserTranscriptionFallback` (the onConnectionFailure hook takes over); never by default.
+     */
+    private _handleConnectionFailure;
+    /** Configuration problem (refused URL): a final error, no retry, no socket. */
+    private _reportNotConfigured;
+    /** A final error that no retry can fix: report once, stop, no retry. */
+    private _reportFinal;
+    private _teardownAudio;
+    stop(): void;
+    abort(): void;
+    /**
+     * Immediately cancel any in-progress WS TTS playback.
+     * Closes the AudioContext (stopping all scheduled sources) and force-settles the
+     * pending speak() Promise so that SpeakinEnded is emitted and control returns to
+     * the caller.  Safe to call when no speech is active.
+     */
+    stopSpeaking(): void;
+    speak(text: any): Promise<void>;
+}

package/dist/MicrophoneAccess/MicrophoneAccess.d.ts

@@ -0,0 +1,65 @@
+export type SpeechRecognitionFailure = 'mic-denied' | 'mic-dismissed' | 'mic-os-blocked' | 'mic-policy-blocked' | 'mic-no-device' | 'mic-constraints' | 'mic-busy' | 'mic-unsupported' | 'mic-insecure-context' | 'mic-failed' | 'session-failed' | 'socket-failed' | 'vad-asset-failed' | 'engine-unavailable';
+/** Whether the browser will say what it thinks of the microphone. Not every browser will. */
+export type MicrophonePermission = 'granted' | 'denied' | 'prompt' | 'unknown';
+export interface MicrophoneEnvironment {
+    secureContext: boolean;
+    hasMediaDevices: boolean;
+    embedded: boolean;
+    policyAllows: boolean | null;
+    permission: MicrophonePermission;
+}
+export interface FailureFacts {
+    message: string;
+    stopAgent: boolean;
+    popup: boolean;
+    retryable: boolean;
+}
+export declare const SPEECH_RECOGNITION_FAILURES: Record<SpeechRecognitionFailure, FailureFacts>;
+export declare class SpeechRecognitionStartError extends Error {
+    readonly failure: SpeechRecognitionFailure;
+    readonly originalError: any;
+    constructor(failure: SpeechRecognitionFailure, originalError?: any);
+}
+export declare function isEmbedded(): boolean;
+/**
+ * Whether this page is allowed to ask for the microphone at all, according to the embedding page's
+ * permissions policy.
+ *
+ * This is the probe that separates "the user blocked it" from "the page that embeds us blocks it".
+ * Both arrive from `getUserMedia` as an identical `NotAllowedError`, so without this the two are
+ * indistinguishable and the user is sent to a browser setting that is already correct - advice they
+ * cannot act on, for a decision only the embedding page can reverse.
+ *
+ * `null` means the browser cannot answer, which is a real and common case; callers must treat it as
+ * "unknown" and never as permission granted.
+ */
+export declare function readPolicyAllowsMicrophone(): boolean | null;
+/**
+ * What the browser thinks of the microphone permission.
+ *
+ * Never load-bearing. Firefox throws `TypeError` for the `microphone` name, and older browsers have
+ * no Permissions API at all, so `'unknown'` is an expected answer rather than an error, and every
+ * caller has to stay correct without it.
+ */
+export declare function readMicrophonePermission(): Promise<MicrophonePermission>;
+/**
+ * Everything this browser will say about its microphone, in the form the classifier reads.
+ *
+ * The permission is the one part that has to be awaited, and for a policy-blocked frame it is not
+ * even asked: Chrome reports `denied` there, which would name the user's own settings as the cause
+ * of a decision the embedding page made.
+ */
+export declare function readMicrophoneEnvironment(): Promise<MicrophoneEnvironment>;
+export interface ClassifyOptions {
+    /**
+     * True when an attempt in this session has already failed.
+     *
+     * This exists for the browsers that cannot report their permission state - Firefox above all. On
+     * a first failure an unknown state is best read as a dismissed prompt, because offering a retry
+     * that works costs nothing. On a repeat failure the same evidence now points the other way: a
+     * block that survives an explicit retry is a block, and continuing to offer "Try Again" would
+     * trap the user in a loop that can never succeed.
+     */
+    repeatAttempt?: boolean;
+}
+export declare function classifyMicrophoneFailure(error: unknown, environment: MicrophoneEnvironment, options?: ClassifyOptions): SpeechRecognitionFailure;

package/dist/SpeakingService/SpeakingService.d.ts

@@ -0,0 +1,14 @@
+import { EventEmitter } from 'events';
+export declare enum stateEvents {
+    SpeakinStarted = "speakingStarted",
+    SpeakinEnded = "speakingEnded"
+}
+export default class SpeakingService {
+    isListening: boolean;
+    isMuted: boolean;
+    private _isActive;
+    private _events;
+    constructor(events: EventEmitter);
+    speak(textOrAudio: string, onCompleteEvt?: () => void): void;
+    isActive(): boolean;
+}

package/dist/SpeakingService/index.d.ts

@@ -0,0 +1,2 @@
+import SpeakingService from "./SpeakingService";
+export default SpeakingService;

package/dist/SpeechRecognitionService/ResultsGroupingService.d.ts

@@ -0,0 +1,44 @@
+export type Result = {
+    transcript: string;
+    timestamp: number;
+};
+declare class ResultsGroupingService {
+    private resultsBuffer;
+    private onResultsReadyCallback;
+    private threshold;
+    private executionTimeout;
+    constructor(threshold: number);
+    /**
+     * Adds a new result to the buffer and initiates execution.
+     * @param result - The result to add.
+     */
+    addResult(result: Result): void;
+    /**
+     * Sets the callback to be called when results are ready.
+     * @param callback - The callback function to execute with grouped results.
+     */
+    onResultsReady(callback: (results: string[]) => void): void;
+    /**
+     * Sends the recognized results to the callback.
+     */
+    private sendRecognizedResult;
+    /**
+     * Initiates the execution timeout.
+     */
+    private initiateExecution;
+    /**
+     * Delays execution by clearing the existing timeout and re-initiating it.
+     */
+    private delayExecution;
+    /**
+     * Cleans up resources and sends any remaining results.
+     */
+    cleanup(): void;
+    /**
+     * Formats a timestamp into a human-readable string.
+     * @param ms - The timestamp in milliseconds.
+     * @returns The formatted time string.
+     */
+    formatTime(ms: number): string;
+}
+export default ResultsGroupingService;

package/dist/SpeechRecognitionService/SpeechRecognitionService.d.ts

@@ -0,0 +1,108 @@
+import { EventEmitter } from 'events';
+import UserSessionService from '../CopilotAgent/UserSessionService';
+import { SpeechProvider, SpeechRetryOptions } from './speechConfig';
+export declare enum stateEvents {
+    StateChange = "recognationStateChange"
+}
+interface SpeechRecognitionServiceConfig {
+    language?: string;
+    threshold?: number;
+    events: EventEmitter;
+    sessionService: UserSessionService;
+    transcribeWssUrl?: string;
+    /** 'deepgram' (default, hosted) or 'browser' (explicit opt-in to Web Speech). */
+    speechProvider?: SpeechProvider | string | null;
+    /** Bearer token for the speech WebSocket handshake (sent as the `bearer.<token>` subprotocol, never in the URL). */
+    getAccessToken?: (() => Promise<string> | string | null | undefined) | null;
+    speechRetry?: SpeechRetryOptions | null;
+    /**
+     * Opt-in (default false): when the hosted transcription socket cannot connect or drops
+     * mid-session (while the browser reports itself online), dictate with the browser's
+     * SpeechRecognition until the connection is back. Browser speech can send audio to the browser vendor: only where that is acceptable.
+     */
+    browserTranscriptionFallback?: boolean | null;
+}
+export default class SpeechRecognitionService {
+    private recognition;
+    private _wsTtsRecognition;
+    private resultsGroupingService;
+    private isRecognitionInProgress;
+    private stoppedByUser;
+    private _isActive;
+    private copilotIsSpeeking;
+    private _events;
+    private _language;
+    private _provider;
+    private _unavailable;
+    /** Why hosted TTS is unavailable, when it is because the speech URL was refused. */
+    private _ttsUnavailable;
+    /** Hosted recognizer (kept while the browser fallback is in use, so dictation can hand back). */
+    private _hostedRecognition;
+    /** browserTranscriptionFallback: true only when the host explicitly opted in. */
+    private _fallbackEnabled;
+    /** Browser SpeechRecognition for the fallback, constructed lazily on the first failure only. */
+    private _browserFallback;
+    private _usingBrowserFallback;
+    private _fallbackUnsupportedLogged;
+    /** window 'online' listener, attached only while a dictation with the fallback is in progress. */
+    private _networkListenersAttached;
+    private readonly _onOnline;
+    /**
+     * The fallback is active but the browser is offline: Web Speech (cloud-based in Chrome/Edge) can
+     * only fail with 'network', so it is paused (no restarts, no popups) until 'online'.
+     */
+    private _fallbackPausedOffline;
+    private _listenerLastResultTime;
+    private _listenerResultTimeout;
+    constructor({ events, language, threshold, sessionService, transcribeWssUrl, speechProvider: provider, getAccessToken, speechRetry, browserTranscriptionFallback, }: SpeechRecognitionServiceConfig);
+    /** True while dictation runs on the browser fallback (browserTranscriptionFallback only). */
+    isUsingBrowserFallback(): boolean;
+    private isOffline;
+    private setNetworkListeners;
+    /** The fallback recognizer, built on first use. Null when the browser has no SpeechRecognition. */
+    private getBrowserFallback;
+    /**
+     * browserTranscriptionFallback: moves the dictation in progress from the hosted socket to the
+     * browser's SpeechRecognition. Returns false (the hosted recognizer then retries as usual) when the
+     * option is off, no dictation is in progress, the browser is offline (cloud Web Speech cannot work
+     * either, so offline behaves exactly as without the option), or there is no SpeechRecognition.
+     */
+    private switchToBrowserFallback;
+    /** Leaves the browser fallback and makes the hosted recognizer current again (does not start it). */
+    private handBackToHosted;
+    /**
+     * While the fallback is active and the browser is offline, pauses it instead of restarting:
+     * returns true when the caller must not restart or report. Logged once per pause (fixed text).
+     */
+    private pauseFallbackIfOffline;
+    /** Connection is back: hand the dictation in progress back to the hosted service. */
+    private handleOnline;
+    getProvider(): SpeechProvider;
+    /** True when replies can be spoken through the hosted /ws/speech/speak endpoint. */
+    hasHostedTts(): boolean;
+    /** Message and reason for tts-not-configured when hosted TTS was refused (e.g. remote ws://). */
+    getTtsUnavailable(): {
+        message: string;
+        reason: string;
+    } | null;
+    private bindEngineListeners;
+    private clearSilentListenerTimeout;
+    private setActive;
+    startRecognition(onTextRecognized: (results: string[]) => void): void;
+    stopRecognition(forceStop?: boolean): void;
+    private safeRestartRecognition;
+    private handleRecognitionError;
+    isActive(): boolean;
+    /**
+     * Speaks text via the hosted /ws/speech/speak endpoint. Returns false when there is no hosted
+     * TTS (the caller decides; CopilotAgent never falls back to browser TTS unless the host chose
+     * speechProvider 'browser'). Rejects when hosted TTS fails.
+     */
+    speak(text: string, onCompleteEvt?: () => void): Promise<boolean>;
+    /**
+     * Stops any active WS TTS playback immediately.
+     * No-op when using native browser speech recognition.
+     */
+    stopSpeaking(): void;
+}
+export {};

package/dist/SpeechRecognitionService/index.d.ts

@@ -0,0 +1,2 @@
+import SpeechRecognitionService from "./SpeechRecognitionService";
+export default SpeechRecognitionService;