@fiodos/web-core 0.1.0

package/dist/cjs/controller/AgentController.js

@@ -0,0 +1,594 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentController = void 0;
+/**
+ * AgentController — the framework-free orchestrator.
+ *
+ * This is the vanilla port of @fiodos/react's `useAgent` hook: it assembles the
+ * @fiodos/core runtime (executor, consent, sanitizer, telemetry, messages,
+ * lexicon, conversation) ONCE, drives the listen → think → (confirm) → speak
+ * state machine, and exposes its state through a `subscribe` listener and
+ * imperative methods. Every framework binding (Vue, Svelte, Angular) wraps the
+ * SAME controller, so the security and reasoning behaviour is identical across
+ * frameworks and matches React / React Native.
+ *
+ * Security invariants (unchanged from the shared core):
+ *  - The MANIFEST decides what needs confirmation, never the LLM.
+ *  - Strict (payment-grade) confirmations still require the exact phrase or a
+ *    deliberate modal tap; a loose "yes" never confirms them.
+ *  - The agent only ever executes actions declared in the manifest.
+ */
+const core_1 = require("@fiodos/core");
+const errors_1 = require("../api/errors");
+const backendClient_1 = require("../api/backendClient");
+const screenContextStore_1 = require("../context/screenContextStore");
+const speechSession_1 = require("../speech/speechSession");
+const turnEngine_1 = require("../core/turnEngine");
+const types_1 = require("../config/types");
+const messages_1 = require("../ui/messages");
+function randomSessionId() {
+    return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+class AgentController {
+    constructor(config) {
+        this.enabled = true;
+        this.phase = 'idle';
+        this.lastExchange = null;
+        this.confirmationMessage = null;
+        this.confirmationVoiceHint = null;
+        this.consentModalVisible = false;
+        this.sessionId = randomSessionId();
+        this.sessionStarted = false;
+        this.conversation = (0, core_1.createConversationSession)();
+        this.pending = null;
+        this.confirmationReasked = false;
+        this.confirmationVoiceActive = false;
+        this.silentTurn = false;
+        this.voiceBlocked = false;
+        this.abort = null;
+        this.watchdog = null;
+        this.confirmWindow = null;
+        this.pendingConsentIntent = null;
+        this.listeners = new Set();
+        this.unsubscribeSpeech = null;
+        // Fail fast on an invalid manifest — same contract as every platform.
+        (0, core_1.validateManifest)(config.manifest);
+        this.config = config;
+        this.messages = (0, core_1.resolveMessages)(config.locale, {
+            catalogs: config.messages?.catalogs,
+            overrides: config.messages?.overrides,
+        });
+        this.ui = (0, messages_1.resolveUiMessages)(config.locale, config.uiMessages);
+        this.lexicon = config.confirmationLexicon ?? (0, core_1.resolveConfirmationLexicon)(config.locale);
+        this.sanitizer = config.sanitizer ?? (0, core_1.createSanitizer)();
+        this.telemetry = (0, core_1.createSafeTelemetry)(config.telemetry);
+        this.consent = (0, core_1.createConsentManager)({
+            storage: config.storage,
+            appId: config.manifest.appId,
+            version: config.consentVersion,
+        });
+        this.executor = (0, core_1.createActionExecutor)({
+            manifest: config.manifest,
+            registries: config.registries,
+            navigation: config.navigation,
+            messages: this.messages,
+            isAuthenticated: config.isAuthenticated,
+        });
+        this.timings = { ...types_1.DEFAULT_AGENT_TIMINGS, ...config.timings };
+        this.ttsLocale = config.ttsLocale ?? config.sttLocale;
+        this.notifyError =
+            config.notifyError ??
+                ((message) => {
+                    // eslint-disable-next-line no-console
+                    console.error(`[fyodos] ${message}`);
+                });
+        this.screenStore = (0, screenContextStore_1.createScreenContextStore)({
+            getCurrentRoute: () => config.navigation.getCurrentRoute(),
+            routeFallback: config.routeContextFallback,
+        });
+        this.speech = (0, speechSession_1.createSpeechSession)({
+            adapter: config.voice,
+            locale: config.sttLocale,
+            maxSeconds: this.timings.maxListeningSeconds,
+            onTranscript: (text) => this.onTranscript(text),
+            onError: (error) => this.onSpeechError(error),
+        });
+        // Re-emit combined state whenever the speech machine advances.
+        this.unsubscribeSpeech = this.speech.subscribe(() => this.emit());
+    }
+    // ── Subscription / state ───────────────────────────────────────────────────
+    getState() {
+        const speech = this.speech.getSnapshot();
+        const showWaveform = (this.phase === 'listening' || this.phase === 'confirming') && speech.state === 'recording';
+        const showThinking = this.phase === 'thinking' || (this.phase === 'listening' && speech.state === 'transcribing');
+        return {
+            phase: this.phase,
+            interimText: speech.interimText,
+            volumeLevel: speech.volumeLevel,
+            showWaveform,
+            showThinking,
+            isBusy: showThinking || this.phase === 'speaking',
+            isListening: this.phase === 'listening' && speech.state !== 'idle',
+            lastExchange: this.lastExchange,
+            confirmationMessage: this.confirmationMessage,
+            confirmationVoiceHint: this.confirmationVoiceHint,
+            consentModalVisible: this.consentModalVisible,
+            voiceBlocked: this.voiceBlocked,
+        };
+    }
+    /** Whether speech recognition can actually run (API present AND mic not denied). */
+    get voiceAvailable() {
+        return this.config.voice.isRecognitionAvailable() && !this.voiceBlocked;
+    }
+    /** Unlock audio playback inside a user gesture (orb tap) so the spoken reply
+     *  is allowed/audible on mobile browsers. Must be called synchronously from
+     *  the tap handler, before any await. No-op where unnecessary. */
+    primeAudio() {
+        this.config.voice.primePlayback?.();
+    }
+    /** Flag the mic as denied/unusable (called on a permission error or upfront
+     *  permission detection) so the orb routes taps to the keyboard instead. */
+    markVoiceBlocked(blocked) {
+        if (this.voiceBlocked === blocked)
+            return;
+        this.voiceBlocked = blocked;
+        this.emit();
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+    emit() {
+        const state = this.getState();
+        for (const l of this.listeners)
+            l(state);
+    }
+    setEnabled(value) {
+        this.enabled = value;
+        if (!value)
+            this.cancelAll();
+    }
+    getTtsVoice() {
+        return typeof this.config.ttsVoice === 'function'
+            ? this.config.ttsVoice()
+            : this.config.ttsVoice;
+    }
+    setPhase(next) {
+        const prev = this.phase;
+        if (prev === next)
+            return;
+        this.phase = next;
+        this.config.onPhaseChange?.(next, prev);
+        this.emit();
+    }
+    clearWatchdog() {
+        if (this.watchdog) {
+            clearTimeout(this.watchdog);
+            this.watchdog = null;
+        }
+    }
+    clearConfirmWindow() {
+        if (this.confirmWindow) {
+            clearTimeout(this.confirmWindow);
+            this.confirmWindow = null;
+        }
+        this.confirmationVoiceActive = false;
+    }
+    // ── Speech playback (ONE consistent voice) ─────────────────────────────────
+    async speakReply(text, audioBase64) {
+        if (this.silentTurn)
+            return;
+        if (!text && !audioBase64)
+            return;
+        this.setPhase('speaking');
+        try {
+            let audio = audioBase64;
+            if (!audio && text) {
+                audio = await this.config.backend.previewTts(this.getTtsVoice() ?? '', text);
+            }
+            if (audio) {
+                await this.config.voice.playAudioBase64Mp3(audio);
+            }
+            else if (text) {
+                await this.config.voice.speakWithDeviceTts(text, { locale: this.ttsLocale });
+            }
+        }
+        catch {
+            /* playback best-effort */
+        }
+        finally {
+            if (this.phase === 'speaking')
+                this.setPhase('idle');
+        }
+    }
+    // ── Confirmation resolution ─────────────────────────────────────────────────
+    beginConfirmationVoiceWindow() {
+        const pending = this.pending;
+        if (!pending || pending.silent || pending.voiceMode === 'disabled')
+            return;
+        if (!this.config.voice.isRecognitionAvailable())
+            return;
+        this.clearConfirmWindow();
+        this.setPhase('confirming');
+        this.confirmationVoiceActive = true;
+        void this.speech.start();
+        this.confirmWindow = setTimeout(() => {
+            this.speech.stop();
+            this.confirmationVoiceActive = false;
+        }, this.timings.confirmationVoiceWindowMs);
+    }
+    async confirmPendingAction() {
+        this.clearConfirmWindow();
+        const pending = this.pending;
+        if (!pending) {
+            this.confirmationMessage = null;
+            this.confirmationVoiceHint = null;
+            this.emit();
+            return;
+        }
+        // Double confirmation: ask a second time before executing.
+        if (pending.remainingConfirmations > 1) {
+            pending.remainingConfirmations -= 1;
+            this.confirmationReasked = false;
+            const second = this.messages.doubleConfirmationQuestion;
+            this.confirmationMessage = second;
+            if (this.lastExchange)
+                this.lastExchange = { ...this.lastExchange, replyText: second };
+            this.emit();
+            await this.speakReply(second, null);
+            if (this.pending)
+                this.beginConfirmationVoiceWindow();
+            return;
+        }
+        this.pending = null;
+        this.confirmationMessage = null;
+        this.confirmationVoiceHint = null;
+        if (this.phase === 'confirming')
+            this.setPhase('idle');
+        this.emit();
+        const result = await this.executor.execute(pending.action, pending.context);
+        this.telemetry.logEvent({
+            eventType: result.success ? 'action_executed' : 'action_failed',
+            intentDetected: pending.intent,
+            sessionId: this.sessionId,
+            actionExecuted: { intent: pending.intent, confirmed: true },
+        });
+        if (result.message) {
+            if (this.lastExchange)
+                this.lastExchange = { ...this.lastExchange, replyText: result.message };
+            this.emit();
+            await this.speakReply(result.message, null);
+        }
+    }
+    cancelPendingAction() {
+        this.clearConfirmWindow();
+        const pending = this.pending;
+        this.pending = null;
+        this.confirmationMessage = null;
+        this.confirmationVoiceHint = null;
+        if (this.phase === 'confirming')
+            this.setPhase('idle');
+        this.emit();
+        if (!pending)
+            return;
+        this.telemetry.logEvent({
+            eventType: 'action_cancelled',
+            intentDetected: pending.intent,
+            sessionId: this.sessionId,
+        });
+        if (this.lastExchange)
+            this.lastExchange = { ...this.lastExchange, replyText: this.messages.cancelled };
+        this.emit();
+        void this.speakReply(this.messages.cancelled, null);
+    }
+    async handleConfirmationTranscript(text) {
+        this.confirmationVoiceActive = false;
+        this.clearConfirmWindow();
+        const pending = this.pending;
+        if (this.phase === 'confirming')
+            this.setPhase('idle');
+        if (!pending)
+            return;
+        // Tap-only confirmations can never be resolved by a stray transcript.
+        if (pending.voiceMode === 'disabled' || pending.silent)
+            return;
+        const reply = (0, turnEngine_1.classifyPendingReply)(text, pending, this.lexicon, { silent: pending.silent });
+        if (reply === 'affirmative') {
+            await this.confirmPendingAction();
+            return;
+        }
+        if (reply === 'negative') {
+            this.cancelPendingAction();
+            return;
+        }
+        // Ambiguous: re-ask ONCE, then fall back to modal-only.
+        if (!this.confirmationReasked) {
+            this.confirmationReasked = true;
+            const reask = `${this.messages.confirmationNotUnderstood} ${pending.question}`.trim();
+            this.confirmationMessage = reask;
+            this.emit();
+            await this.speakReply(reask, null);
+            if (this.pending)
+                this.beginConfirmationVoiceWindow();
+        }
+    }
+    // ── Main turn ────────────────────────────────────────────────────────────────
+    async handleTranscript(rawText) {
+        const text = rawText.trim();
+        if (!this.enabled || text.length < this.timings.minTranscriptChars) {
+            if (this.phase === 'thinking')
+                this.setPhase('idle');
+            return;
+        }
+        this.setPhase('thinking');
+        this.clearWatchdog();
+        this.watchdog = setTimeout(() => {
+            if (this.phase === 'thinking') {
+                this.telemetry.logEvent({ eventType: 'agent_watchdog_reset', sessionId: this.sessionId });
+                this.setPhase('idle');
+            }
+        }, this.timings.thinkingWatchdogMs);
+        const currentRoute = this.config.navigation.getCurrentRoute();
+        if (!this.sessionStarted) {
+            this.sessionStarted = true;
+            this.telemetry.logEvent({ eventType: 'agent_session_started', sessionId: this.sessionId });
+        }
+        this.telemetry.logEvent({
+            eventType: 'agent_invoked',
+            sessionId: this.sessionId,
+            currentRoute,
+        });
+        const snapshot = this.screenStore.getSnapshot();
+        const rawContext = (0, core_1.combineContexts)(this.config.getUserContextText?.() ?? null, this.screenStore.getText(), {
+            truncationSuffix: this.messages.contextTruncationSuffix,
+            maxChars: this.config.contextMaxChars,
+        });
+        const sanitized = rawContext ? this.sanitizer(rawContext).sanitized : undefined;
+        const conv = (0, core_1.prepareConversationForTurn)(this.conversation);
+        const controller = new AbortController();
+        this.abort = controller;
+        let reply = '';
+        let audioBase64 = null;
+        try {
+            const turn = await this.config.backend.sendTurn({
+                message: text,
+                language: this.config.locale,
+                voice: this.getTtsVoice(),
+                screenContext: sanitized,
+                currentRoute: currentRoute ?? undefined,
+                conversationHistory: conv.history,
+                conversationSummary: conv.summary ?? undefined,
+                sessionId: this.sessionId,
+                ...(0, backendClient_1.buildManifestPayload)(this.config.manifest),
+            }, { signal: controller.signal });
+            reply = turn.reply;
+            audioBase64 = turn.audioBase64;
+            const decision = await (0, turnEngine_1.decideAction)({
+                action: turn.action,
+                manifest: this.config.manifest,
+                executor: this.executor,
+                context: snapshot?.context ?? {},
+                messages: this.messages,
+                userMessage: text,
+            });
+            if (decision.kind === 'executed') {
+                const r = decision.result;
+                if (turn.action?.type === 'navigate') {
+                    this.telemetry.logEvent({
+                        eventType: r.success ? 'navigation_executed' : 'navigation_failed',
+                        intentDetected: turn.action.intent,
+                        sessionId: this.sessionId,
+                        currentRoute,
+                    });
+                }
+                else if (turn.action?.type === 'execute') {
+                    this.telemetry.logEvent({
+                        eventType: r.recoverable
+                            ? 'action_needs_context'
+                            : r.success
+                                ? 'action_executed'
+                                : 'action_failed',
+                        intentDetected: turn.action.intent,
+                        sessionId: this.sessionId,
+                        actionExecuted: { intent: turn.action.intent, confirmed: false },
+                    });
+                }
+                if (r.recoverable) {
+                    /* keep the assistant's guiding reply; never speak a refusal. */
+                }
+                else if (r.message) {
+                    reply = r.message;
+                    audioBase64 = null;
+                }
+            }
+            else if (decision.kind === 'precheck-resolved') {
+                if (decision.result.message && !decision.result.recoverable) {
+                    reply = decision.result.message;
+                    audioBase64 = null;
+                }
+            }
+            else if (decision.kind === 'needs-confirmation') {
+                this.pending = { ...decision.pending, silent: this.silentTurn };
+                this.confirmationReasked = false;
+                this.confirmationMessage = decision.pending.question;
+                this.confirmationVoiceHint =
+                    decision.pending.voiceMode === 'strict' &&
+                        decision.pending.strictPhrase &&
+                        !this.silentTurn
+                        ? (0, core_1.formatMessage)(this.messages.strictConfirmationModalHint, {
+                            phrase: decision.pending.strictPhrase,
+                        })
+                        : null;
+                this.emit();
+                this.telemetry.logEvent({
+                    eventType: 'action_confirmation_requested',
+                    intentDetected: decision.pending.intent,
+                    sessionId: this.sessionId,
+                });
+            }
+        }
+        catch (e) {
+            this.clearWatchdog();
+            this.abort = null;
+            if (e instanceof errors_1.AgentApiError && e.code === 'cancelled') {
+                if (this.phase === 'thinking')
+                    this.setPhase('idle');
+                return;
+            }
+            if (e instanceof errors_1.AgentApiError && e.code === 'quota_exceeded') {
+                this.config.onQuotaExceeded?.();
+            }
+            if (this.phase === 'thinking')
+                this.setPhase('idle');
+            this.notifyError(reply || (e instanceof Error ? e.message : 'error'));
+            return;
+        }
+        this.clearWatchdog();
+        this.abort = null;
+        if (reply) {
+            this.lastExchange = { userText: text, replyText: reply };
+            this.emit();
+            (0, core_1.recordConversationExchange)(this.conversation, text, reply);
+        }
+        const hasPending = this.pending != null;
+        await this.speakReply(reply, audioBase64);
+        if (hasPending) {
+            this.beginConfirmationVoiceWindow();
+        }
+        else if (this.phase !== 'speaking') {
+            this.setPhase('idle');
+        }
+        this.config.onTurnCompleted?.();
+    }
+    // ── Speech session wiring ────────────────────────────────────────────────────
+    onTranscript(text) {
+        if (this.confirmationVoiceActive || this.pending) {
+            void this.handleConfirmationTranscript(text);
+            return;
+        }
+        void this.handleTranscript(text);
+    }
+    onSpeechError(error) {
+        this.telemetry.logEvent({ eventType: 'agent_stt_failed', sessionId: this.sessionId });
+        if (this.phase === 'listening' || this.phase === 'confirming')
+            this.setPhase('idle');
+        const msg = error instanceof Error ? error.message : String(error);
+        // A permission/hardware error means voice can't run: flag it so taps route
+        // to the keyboard (the binding reacts to `voiceBlocked` to open the bubble).
+        const lower = msg.toLowerCase();
+        if (lower.includes('not-allowed') ||
+            lower.includes('not allowed') ||
+            lower.includes('service-not-allowed') ||
+            lower.includes('audio-capture') ||
+            lower.includes('permission')) {
+            this.markVoiceBlocked(true);
+            return;
+        }
+        this.notifyError(msg);
+    }
+    // ── Consent + listening ──────────────────────────────────────────────────────
+    async beginListening() {
+        if (!this.enabled)
+            return;
+        if (!this.config.voice.isRecognitionAvailable()) {
+            this.telemetry.logEvent({ eventType: 'agent_stt_failed', sessionId: this.sessionId });
+            this.notifyError(this.ui.voiceUnavailable);
+            return;
+        }
+        const gate = this.config.gateTurn?.();
+        if (gate && !gate.ok) {
+            if (gate.message)
+                this.notifyError(gate.message);
+            return;
+        }
+        this.config.voice.stopPlayback();
+        this.silentTurn = false;
+        this.setPhase('listening');
+        await this.speech.start();
+    }
+    async toggleListening() {
+        if (!this.enabled)
+            return;
+        if (this.phase === 'confirming')
+            return; // modal owns this phase
+        if (this.phase === 'listening') {
+            this.speech.stop();
+            this.setPhase('thinking');
+            return;
+        }
+        if (this.phase === 'thinking' || this.phase === 'speaking')
+            return;
+        const consented = await this.consent.hasConsented();
+        if (!consented) {
+            this.pendingConsentIntent = 'voice';
+            this.consentModalVisible = true;
+            this.emit();
+            return;
+        }
+        await this.beginListening();
+    }
+    async submitTextTurn(text, options) {
+        if (!this.enabled)
+            return;
+        const trimmed = text.trim();
+        if (!trimmed)
+            return;
+        const gate = this.config.gateTurn?.();
+        if (gate && !gate.ok) {
+            if (gate.message)
+                this.notifyError(gate.message);
+            return;
+        }
+        // A pending confirmation steals the next text turn (so typed "yes" resolves
+        // it instead of starting a fresh turn). Honours the same voice-mode rules.
+        if (this.pending && !this.pending.silent) {
+            await this.handleConfirmationTranscript(trimmed);
+            return;
+        }
+        this.silentTurn = options?.speak !== true;
+        await this.handleTranscript(trimmed);
+    }
+    async acceptConsent() {
+        await this.consent.grant();
+        this.consentModalVisible = false;
+        this.emit();
+        this.telemetry.logEvent({ eventType: 'agent_consent_granted', sessionId: this.sessionId });
+        const intent = this.pendingConsentIntent;
+        this.pendingConsentIntent = null;
+        if (intent === 'voice')
+            await this.beginListening();
+    }
+    declineConsent() {
+        this.consentModalVisible = false;
+        this.pendingConsentIntent = null;
+        this.emit();
+        this.telemetry.logEvent({ eventType: 'agent_consent_declined', sessionId: this.sessionId });
+    }
+    cancelAll() {
+        this.abort?.abort();
+        this.abort = null;
+        this.clearWatchdog();
+        this.clearConfirmWindow();
+        this.speech.cancel();
+        this.config.voice.stopPlayback();
+        this.pending = null;
+        this.confirmationMessage = null;
+        this.confirmationVoiceHint = null;
+        this.setPhase('idle');
+        this.emit();
+    }
+    /** Best-effort backend warm-up (cold-start mitigation). */
+    warmUp() {
+        void this.config.backend.warmUp?.();
+    }
+    dispose() {
+        this.cancelAll();
+        this.unsubscribeSpeech?.();
+        this.unsubscribeSpeech = null;
+        this.speech.dispose();
+        this.listeners.clear();
+    }
+}
+exports.AgentController = AgentController;

package/dist/cjs/core/turnEngine.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Framework-free turn decision engine.
+ *
+ * Concentrates the SECURITY-CRITICAL decision logic of a turn so it can be
+ * unit-tested without any framework, and so every web binding (Vue, Svelte,
+ * Angular) and React Native share the exact same rules. It does NOT
+ * reimplement the engine: it delegates execution, prechecks and confirmation
+ * classification to @fiodos/core. It only sequences them.
+ *
+ * Invariants enforced here (identical to @fiodos/react-native):
+ *  1. The source of truth for "needs confirmation" is the MANIFEST
+ *     (`requireConfirmation`), never the LLM's flag.
+ *  2. A sensitive action is NEVER executed by `decideAction`; it returns a
+ *     PendingConfirmation and waits for an explicit confirmation.
+ *  3. Voice confirmation honours the manifest mode: 'disabled' can never be
+ *     confirmed by voice (tap only); 'strict' requires the exact phrase; a
+ *     loose "yes" does not confirm a strict action. Negation always wins.
+ */
+import { type ActionExecutor, type ActionResult, type AgentAction, type AgentMessages, type AgentScreenContext, type AppManifest, type ConfirmationLexicon, type ConfirmationReply } from '@fiodos/core';
+export type VoiceConfirmationMode = 'standard' | 'strict' | 'disabled';
+export interface PendingConfirmation {
+    action: AgentAction;
+    context: AgentScreenContext;
+    /** Canonical question to show/speak. */
+    question: string;
+    voiceMode: VoiceConfirmationMode;
+    /** Strict-mode exact phrase, or null when not strict. */
+    strictPhrase: string | null;
+    /** Remaining confirmations (2 for doubleConfirmation, else 1). */
+    remainingConfirmations: number;
+    /** Original user message that triggered the action (telemetry). */
+    userMessage: string;
+    intent: string;
+}
+export type ActionDecision = {
+    kind: 'executed';
+    result: ActionResult;
+} | {
+    kind: 'precheck-resolved';
+    result: ActionResult;
+} | {
+    kind: 'needs-confirmation';
+    pending: PendingConfirmation;
+} | {
+    kind: 'noop';
+};
+export interface DecideActionParams {
+    action: AgentAction | null;
+    manifest: AppManifest;
+    executor: ActionExecutor;
+    /** Structured screen snapshot captured at invocation time. */
+    context: AgentScreenContext;
+    messages: AgentMessages;
+    userMessage: string;
+}
+/**
+ * Decides what to do with a backend-proposed action. Sensitive actions are
+ * never executed here — they return `needs-confirmation`.
+ */
+export declare function decideAction(params: DecideActionParams): Promise<ActionDecision>;
+/**
+ * Classifies a spoken reply against a pending confirmation, honouring the
+ * manifest's voice mode. Returns 'ambiguous' when voice cannot resolve it
+ * (disabled mode, silent turn, or unclear speech) — the caller must then rely
+ * on the tactile modal. NEVER returns 'affirmative' for a disabled/silent
+ * confirmation.
+ */
+export declare function classifyPendingReply(text: string, pending: PendingConfirmation, lexicon: ConfirmationLexicon, opts?: {
+    silent?: boolean;
+}): ConfirmationReply;