@meechi-ai/core 1.0.0

package/dist/lib/hooks/use-voice-loop.js

@@ -0,0 +1,313 @@
+import { useState, useRef, useEffect, useCallback } from 'react';
+import { AudioInputService } from '../audio/input';
+import { VADService } from '../audio/vad';
+import { TranscriberService } from '../audio/stt';
+import { SynthesizerService } from '../audio/tts';
+export function useVoiceLoop(sendMessage) {
+    const [state, setState] = useState('idle');
+    const stateRef = useRef('idle'); // Fix for stale closure in callbacks
+    const [transcript, setTranscript] = useState("");
+    const [vadProb, setVadProb] = useState(0);
+    // Sync ref with state
+    useEffect(() => {
+        stateRef.current = state;
+    }, [state]);
+    const audioInput = useRef(new AudioInputService());
+    const vad = useRef(new VADService());
+    const audioBuffer = useRef([]);
+    const audioChunksRef = useRef([]);
+    const isSpeechPrev = useRef(false);
+    // Audio Context for playback
+    const playbackCtx = useRef(null);
+    const playbackSource = useRef(null);
+    const chunksProcessedRef = useRef(0);
+    // STREAMING TTS STATE
+    const audioQueue = useRef([]);
+    const isPlayingRef = useRef(false);
+    const sentenceBuffer = useRef("");
+    const stopPlayback = useCallback(() => {
+        if (playbackSource.current) {
+            playbackSource.current.stop();
+            playbackSource.current = null;
+        }
+        // Clear Queue
+        audioQueue.current = [];
+        isPlayingRef.current = false;
+        sentenceBuffer.current = "";
+        setState('idle');
+    }, []);
+    const processTTSChunk = async (text) => {
+        if (!text.trim())
+            return;
+        // Strip Markdown for TTS (e.g. *italic*, **bold**, `code`)
+        // Also remove excessive punctuation runs
+        const cleanText = text
+            .replace(/[*_`~]/g, '') // Remove markdown symbols
+            .replace(/\[.*?\]/g, '') // Remove [instructions] if any leak
+            .replace(/\s+/g, ' ')
+            .trim();
+        if (!cleanText)
+            return;
+        try {
+            const rawAudio = await SynthesizerService.speak(cleanText);
+            if (rawAudio) {
+                audioQueue.current.push({ audio: rawAudio.audio, sampleRate: rawAudio.sampling_rate });
+                playNextInQueue();
+            }
+        }
+        catch (e) {
+            console.error("TTS Gen Error:", e);
+        }
+    };
+    const processAudio = async (text) => {
+        if (!text.trim())
+            return;
+        // PRE-FILTER: Ignore known hallucination strings from STT (Case-insensitive)
+        const lower = text.trim().toLowerCase();
+        if (lower === 'you' || // "You" is very common hallucination
+            /^\[.*\]$/.test(lower) || // [Music], [Silence]
+            /^\(.*\)$/.test(lower) || // (Music)
+            lower.includes('[music]') ||
+            lower.includes('[silence]') ||
+            // Common Whisper Hallucinations:
+            lower.includes('thank you for watching') ||
+            lower.includes('thanks for watching')) {
+            console.log("[VoiceLoop] Ignoring hallucination:", text);
+            setState('idle'); // Ensure we return to idle
+            return;
+        }
+        console.log("[VoiceLoop] Processing User Audio:", text);
+        setState('processing');
+        sentenceBuffer.current = "";
+        try {
+            // 1. Send to AI with STREAMING callback
+            const response = await sendMessage(text, (token) => {
+                // Check for interruption
+                if (stateRef.current === 'listening')
+                    return; // Abort if user started talking again?
+                sentenceBuffer.current += token;
+                // Split by sentence endings (. ! ? \n)
+                // Regex lookbehind is not supported in all browsers, so use simple split
+                // Capture delimiters
+                // Note: This matches "Dr." as a split. Improved regex needed for "Dr." etc, but for now simple is ok.
+                // Heuristic: Ends with [.!?] AND (followed by space or newline) - logic applied to buffer
+                // Check if we have a full sentence in buffer
+                // Regex: Match anything ending in [.!?] followed by space or EOS
+                // We only split if we have enough content
+                // HALLUCINATION/NOISE FILTER
+                // If the *entire* buffer is just these common patterns, we suppress it.
+                // We only check this if probability is low, but better safe.
+                if (/^[\(\[\{]?(music|silence|sound|background|noise)[\)\]\}]?$/i.test(sentenceBuffer.current.trim())) {
+                    console.log("[VoiceLoop] Filtered Hallucination:", sentenceBuffer.current);
+                    sentenceBuffer.current = "";
+                    return;
+                }
+                // FIRST CHUNK STRATEGY:
+                // To lower latency, we split the FIRST sentence on commas or small pauses (length)
+                const isFirstChunk = !isPlayingRef.current && audioQueue.current.length === 0;
+                const splitRegex = isFirstChunk
+                    ? /([,;:.!?\n])\s+/ // Split on commas too for the first burst
+                    : /([.!?\n])\s+/; // Standard sentence split
+                const minChars = isFirstChunk ? 30 : 100; // Allow smaller first chunk
+                if (splitRegex.test(sentenceBuffer.current) && sentenceBuffer.current.length > minChars) {
+                    // Attempt to split
+                    const match = sentenceBuffer.current.match(new RegExp(`^(.*?${splitRegex.source})`));
+                    if (match) {
+                        const chunk = match[0];
+                        const remaining = sentenceBuffer.current.slice(chunk.length);
+                        if (chunk.trim()) {
+                            processTTSChunk(chunk.trim());
+                            sentenceBuffer.current = remaining;
+                        }
+                    }
+                }
+            });
+            // 2. Flush remaining buffer
+            if (sentenceBuffer.current.trim()) {
+                await processTTSChunk(sentenceBuffer.current.trim());
+            }
+            console.log("[VoiceLoop] Generation Complete.");
+            // Wait for queue to drain?
+            // We need a loop to check if playing is done
+            const checkDone = setInterval(() => {
+                if (stateRef.current !== 'speaking' && stateRef.current !== 'processing') {
+                    clearInterval(checkDone);
+                    return;
+                }
+                if (!isPlayingRef.current && audioQueue.current.length === 0) {
+                    clearInterval(checkDone);
+                    setState('idle');
+                }
+            }, 200);
+        }
+        catch (e) {
+            console.error("Voice Loop Error:", e);
+            setState('idle');
+        }
+    };
+    const silenceChunksRef = useRef(0);
+    // 30 chunks * 512 samples / 16000 Hz ~= 1.0 second roughly. 
+    // Let's use 1.2s to be safe for slow speakers.
+    // 1.2 / 0.032 = 37.5 ~ 40 chunks
+    const MAX_SILENCE_CHUNKS = 40;
+    // Track Playing State for UI
+    const [isPlaying, setIsPlaying] = useState(false);
+    // Sync Ref with State for internal logic
+    useEffect(() => {
+        setIsPlaying(isPlayingRef.current);
+    }, [isPlayingRef.current]); // This dependency might not trigger if ref mutates, we need to set state where we set ref.
+    // Helper to update playing state
+    const setPlayingState = (val) => {
+        isPlayingRef.current = val;
+        setIsPlaying(val);
+    };
+    // ... (stopPlayback updates)
+    // We need to update stopPlayback to use setPlayingState
+    // But since stopPlayback is memoized and we are inside the hook function body (recreated?), let's just update the internal logic below
+    // Process and Play next chunk in queue
+    const playNextInQueue = async () => {
+        if (isPlayingRef.current || audioQueue.current.length === 0) {
+            return;
+        }
+        const next = audioQueue.current.shift();
+        if (!next || !playbackCtx.current)
+            return;
+        setPlayingState(true);
+        setState('speaking');
+        try {
+            if (playbackCtx.current.state === 'suspended') {
+                await playbackCtx.current.resume();
+            }
+            const buffer = playbackCtx.current.createBuffer(1, next.audio.length, next.sampleRate);
+            buffer.copyToChannel(new Float32Array(next.audio), 0);
+            const source = playbackCtx.current.createBufferSource();
+            source.buffer = buffer;
+            source.connect(playbackCtx.current.destination);
+            source.start();
+            playbackSource.current = source;
+            source.onended = () => {
+                setPlayingState(false);
+                if (audioQueue.current.length > 0) {
+                    playNextInQueue();
+                }
+                else {
+                    // Queue empty. 
+                }
+            };
+        }
+        catch (e) {
+            console.error("Playback Error:", e);
+            setPlayingState(false);
+        }
+    };
+    // Update stopPlayback
+    // We can't easily overwrite the previous useCallback in this 'replace' block without context. 
+    // But we can just ensuring setPlayingState(false) is called where isPlayingRef.current = false was.
+    // I will replace start() logic mostly here.
+    const start = async () => {
+        if (!playbackCtx.current) {
+            playbackCtx.current = new AudioContext();
+        }
+        if (playbackCtx.current.state === 'suspended') {
+            await playbackCtx.current.resume();
+        }
+        await vad.current.init();
+        await audioInput.current.start(async (data) => {
+            // 1. VAD Check
+            let { isSpeech, probability } = await vad.current.process(data);
+            const maxAmp = Math.max(...data);
+            if (!isSpeech && maxAmp > 0.05) {
+                isSpeech = true;
+                probability = 0.8;
+            }
+            setVadProb(probability);
+            isSpeechPrev.current = isSpeech;
+            const currentState = stateRef.current;
+            if (isSpeech) {
+                // SPEECH DETECTED
+                silenceChunksRef.current = 0; // Reset silence counter
+                if (currentState === 'speaking') {
+                    stopPlayback(); // Interruption
+                }
+                if (currentState !== 'listening' && currentState !== 'processing') {
+                    setState('listening');
+                }
+                audioBuffer.current.push(data);
+            }
+            else if (currentState === 'listening') {
+                // SILENCE (DETECTED)
+                // We are in listening mode, but VAD says silence.
+                // We do NOT stop immediately. We accumulate silence.
+                silenceChunksRef.current++;
+                audioBuffer.current.push(data); // Keep recording the "silence" (sentence pause)
+                if (silenceChunksRef.current > MAX_SILENCE_CHUNKS) {
+                    // TIMEOUT: Speech Actually Ended
+                    silenceChunksRef.current = 0;
+                    const length = audioBuffer.current.reduce((acc, chunk) => acc + chunk.length, 0);
+                    // IGNORE SHORT CLICKS (Under 0.5s of effective content?)
+                    // Since we included silence, the total length is huge now.
+                    // We should check the length MINUS the silence tail?
+                    // Or just rely on the fact that if we hit the timeout, it was probably speech + silence.
+                    // But what if it was JUST silence (false trigger)?
+                    // Check total length: 40 chunks * 512 = 20k samples. 
+                    // If we have < 30k total samples, it means we ONLY recorded the silence tail + tiny blip.
+                    if (length < 24000) { // < 1.5s total (mostly silence)
+                        console.log("[VoiceLoop] Speech too short (mostly silence), ignoring. Length:", length);
+                        audioBuffer.current = [];
+                        setState('idle');
+                        return;
+                    }
+                    console.log(`[VoiceLoop] Speech Ended (Silence Timeout). Processing...`);
+                    const fullAudio = new Float32Array(length);
+                    let offset = 0;
+                    for (const chunk of audioBuffer.current) {
+                        fullAudio.set(chunk, offset);
+                        offset += chunk.length;
+                    }
+                    audioBuffer.current = [];
+                    stateRef.current = 'processing';
+                    setState('processing');
+                    console.log("[VoiceLoop] Transcribing...");
+                    let text = "";
+                    try {
+                        text = await TranscriberService.transcribe(fullAudio);
+                        console.log(`[VoiceLoop] Transcribed Text: "${text}"`);
+                        setTranscript(text);
+                    }
+                    catch (err) {
+                        console.error("[VoiceLoop] Transcription Error:", err);
+                        setTranscript("");
+                    }
+                    if (text.trim()) {
+                        await processAudio(text);
+                    }
+                    else {
+                        stateRef.current = 'idle';
+                        setState('idle');
+                    }
+                }
+            }
+        });
+    };
+    const stop = () => {
+        audioInput.current.stop();
+        stopPlayback();
+        setState('idle');
+    };
+    // Kept for backward compatibility if manual playback is needed
+    const playResponse = async (text) => {
+        stopPlayback();
+        await processTTSChunk(text);
+    };
+    return {
+        start,
+        stop,
+        stopPlayback,
+        state,
+        vadProb,
+        transcript,
+        playResponse,
+        isPlaying,
+        getAnalyser: () => audioInput.current.getAnalyser()
+    };
+}

package/dist/lib/mcp/McpClient.d.ts

@@ -0,0 +1,19 @@
+/**
+ * McpClient - The MCP Host/Client for Meechi
+ *
+ * This class initializes the MCP registry with native (built-in) servers.
+ * It acts as the "host" that manages tool providers.
+ *
+ * Architecture:
+ * - Native servers: In-process TypeScript classes (MeechiNativeCore, etc.)
+ * - External servers: Real MCP protocol via SDK (coming in future releases)
+ */
+export declare class McpClient {
+    constructor();
+    getTools(): Promise<any[]>;
+    executeTool(name: string, args: any): Promise<any>;
+}
+export declare const mcpClient: McpClient;
+export { mcpRegistry } from './McpRegistry';
+export * from './types';
+export * from './native';

package/dist/lib/mcp/McpClient.js

@@ -0,0 +1,42 @@
+import { mcpRegistry } from './McpRegistry';
+import { MeechiNativeCore, GroqVoiceNative, LocalVoiceNative, LocalSyncNative } from './native';
+/**
+ * McpClient - The MCP Host/Client for Meechi
+ *
+ * This class initializes the MCP registry with native (built-in) servers.
+ * It acts as the "host" that manages tool providers.
+ *
+ * Architecture:
+ * - Native servers: In-process TypeScript classes (MeechiNativeCore, etc.)
+ * - External servers: Real MCP protocol via SDK (coming in future releases)
+ */
+export class McpClient {
+    constructor() {
+        // 1. Mandatory Core System (permanent)
+        mcpRegistry.registerServer(new MeechiNativeCore());
+        // 2. Pluggable Native Servers (can be activated/deactivated)
+        mcpRegistry.registerServer(new GroqVoiceNative());
+        mcpRegistry.registerServer(new LocalVoiceNative());
+        mcpRegistry.registerServer(new LocalSyncNative());
+    }
+    async getTools() {
+        const tools = await mcpRegistry.getAllTools();
+        return tools.map(t => ({
+            type: 'function',
+            function: {
+                name: t.name,
+                description: t.description,
+                parameters: t.inputSchema
+            }
+        }));
+    }
+    async executeTool(name, args) {
+        return await mcpRegistry.executeTool(name, args);
+    }
+}
+// Global instance for the app
+export const mcpClient = new McpClient();
+// Re-exports
+export { mcpRegistry } from './McpRegistry';
+export * from './types';
+export * from './native';

package/dist/lib/mcp/McpRegistry.d.ts

@@ -0,0 +1,47 @@
+import { McpTool, McpResource } from './types';
+/**
+ * Basic interface for ANY MCP Server (Internal or External)
+ */
+export interface McpConnector {
+    id: string;
+    name: string;
+    description: string;
+    isPermanent: boolean;
+    isAgenticMemory?: boolean;
+    getTools(): Promise<McpTool[]>;
+    getResources?(): Promise<McpResource[]>;
+    executeTool(name: string, args: any): Promise<any>;
+    getSystemInstructions?(): Promise<string>;
+}
+export type MeechiTier = 'tier1' | 'tier2' | 'tier3';
+/**
+ * The Central Registry that manages "Slotted" MCP Servers.
+ */
+export declare class McpRegistry {
+    private servers;
+    private activeSlots;
+    private activeMemories;
+    private tier;
+    private TIER_CONSTRAINTS;
+    constructor(tier?: MeechiTier);
+    setTier(tier: MeechiTier): void;
+    getMaxSlots(): number;
+    registerServer(server: McpConnector): void;
+    activateSlot(serverId: string): boolean;
+    deactivateSlot(serverId: string): void;
+    getAllTools(): Promise<McpTool[]>;
+    executeTool(name: string, args: any): Promise<any>;
+    getCombinedInstructions(): Promise<string>;
+    /**
+     * Gets instructions for a SPECIFIC agent (e.g. for Mode switching)
+     */
+    getAgentInstructions(agentId: string): Promise<string | null>;
+    getMarketplace(): {
+        id: string;
+        name: string;
+        description: string;
+        isActive: boolean;
+        isPermanent: boolean;
+    }[];
+}
+export declare const mcpRegistry: McpRegistry;

package/dist/lib/mcp/McpRegistry.js

@@ -0,0 +1,117 @@
+/**
+ * The Central Registry that manages "Slotted" MCP Servers.
+ */
+export class McpRegistry {
+    constructor(tier = 'tier1') {
+        this.servers = new Map();
+        this.activeSlots = new Set();
+        this.activeMemories = new Set();
+        this.tier = 'tier1';
+        this.TIER_CONSTRAINTS = {
+            tier1: { maxSlots: 2, maxMemories: 5 },
+            tier2: { maxSlots: 10, maxMemories: 5 },
+            tier3: { maxSlots: -1, maxMemories: 5 } // Unlimited slots, 5 agents
+        };
+        this.tier = tier;
+    }
+    setTier(tier) {
+        this.tier = tier;
+    }
+    getMaxSlots() {
+        return this.TIER_CONSTRAINTS[this.tier].maxSlots;
+    }
+    registerServer(server) {
+        this.servers.set(server.id, server);
+        if (server.isPermanent) {
+            this.activeSlots.add(server.id);
+        }
+    }
+    activateSlot(serverId) {
+        const server = this.servers.get(serverId);
+        if (!server)
+            return false;
+        if (this.activeSlots.has(serverId))
+            return true;
+        const constraints = this.TIER_CONSTRAINTS[this.tier];
+        // Agentic Memory Specific Logic (Uses interface flag, not hardcoded IDs)
+        const isAgentic = server.isAgenticMemory === true;
+        if (isAgentic) {
+            if (this.activeMemories.size >= constraints.maxMemories) {
+                // Return false or throw error for UI to catch
+                throw new Error(`Memory limit reached. You can have up to ${constraints.maxMemories} active memories. Please deactivate one first.`);
+            }
+            this.activeMemories.add(serverId);
+            this.activeSlots.add(serverId);
+            return true;
+        }
+        // Generic Marketplace Logic
+        const nonPermanentCount = Array.from(this.activeSlots).filter(id => {
+            const s = this.servers.get(id);
+            return !(s === null || s === void 0 ? void 0 : s.isPermanent) && !(s === null || s === void 0 ? void 0 : s.isAgenticMemory);
+        }).length;
+        if (constraints.maxSlots !== -1 && nonPermanentCount >= constraints.maxSlots) {
+            throw new Error(`Slot limit reached (${constraints.maxSlots}). Please upgrade your plan for more slots.`);
+        }
+        this.activeSlots.add(serverId);
+        return true;
+    }
+    deactivateSlot(serverId) {
+        const server = this.servers.get(serverId);
+        if (server === null || server === void 0 ? void 0 : server.isPermanent)
+            return;
+        this.activeSlots.delete(serverId);
+        this.activeMemories.delete(serverId);
+    }
+    async getAllTools() {
+        let allTools = [];
+        for (const serverId of this.activeSlots) {
+            const server = this.servers.get(serverId);
+            if (server) {
+                const tools = await server.getTools();
+                allTools = [...allTools, ...tools];
+            }
+        }
+        return allTools;
+    }
+    async executeTool(name, args) {
+        // Find which server has this tool
+        for (const serverId of this.activeSlots) {
+            const server = this.servers.get(serverId);
+            if (server) {
+                const tools = await server.getTools();
+                if (tools.find(t => t.name === name)) {
+                    return await server.executeTool(name, args);
+                }
+            }
+        }
+        throw new Error(`Tool ${name} not found in any active MCP slots.`);
+    }
+    async getCombinedInstructions() {
+        let instructions = "";
+        for (const serverId of this.activeMemories) {
+            const server = this.servers.get(serverId);
+            if (server === null || server === void 0 ? void 0 : server.getSystemInstructions) {
+                const instructionsText = await server.getSystemInstructions();
+                instructions += `\n\n--- PERSONA: ${server.name} ---\n${instructionsText}\n`;
+            }
+        }
+        return instructions;
+    }
+    /**
+     * Gets instructions for a SPECIFIC agent (e.g. for Mode switching)
+     */
+    async getAgentInstructions(agentId) {
+        const server = this.servers.get(agentId);
+        return (server === null || server === void 0 ? void 0 : server.getSystemInstructions) ? await server.getSystemInstructions() : null;
+    }
+    getMarketplace() {
+        return Array.from(this.servers.values()).map(s => ({
+            id: s.id,
+            name: s.name,
+            description: s.description,
+            isActive: this.activeSlots.has(s.id),
+            isPermanent: s.isPermanent
+        }));
+    }
+}
+export const mcpRegistry = new McpRegistry();

package/dist/lib/mcp/native/GroqVoiceNative.d.ts

@@ -0,0 +1,21 @@
+import { McpTool } from '../types';
+import { McpConnector } from '../McpRegistry';
+/**
+ * NATIVE SERVER: GroqVoiceNative
+ *
+ * Cloud Voice capability for Groq.
+ * Enables high-speed voice interaction when a Groq key is available.
+ *
+ * This is a "capability" native - it exposes UI features rather than AI tools.
+ */
+export declare class GroqVoiceNative implements McpConnector {
+    id: string;
+    name: string;
+    description: string;
+    isPermanent: boolean;
+    private apiKey?;
+    constructor(apiKey?: string);
+    getTools(): Promise<McpTool[]>;
+    executeTool(name: string, args: any): Promise<any>;
+    isVoiceReady(): boolean;
+}

package/dist/lib/mcp/native/GroqVoiceNative.js

@@ -0,0 +1,29 @@
+/**
+ * NATIVE SERVER: GroqVoiceNative
+ *
+ * Cloud Voice capability for Groq.
+ * Enables high-speed voice interaction when a Groq key is available.
+ *
+ * This is a "capability" native - it exposes UI features rather than AI tools.
+ */
+export class GroqVoiceNative {
+    constructor(apiKey) {
+        this.id = "native-groq-voice";
+        this.name = "Native Cloud Voice (Groq)";
+        this.description = "High-speed cloud voice interaction via Groq. Requires a valid API key.";
+        this.isPermanent = false;
+        this.apiKey = apiKey;
+    }
+    async getTools() {
+        // Voice doesn't necessarily expose tools to the AI, 
+        // it exposes capabilities to the UI.
+        return [];
+    }
+    async executeTool(name, args) {
+        throw new Error(`Tool ${name} not implemented in GroqVoiceNative`);
+    }
+    // Custom capability for the UI to check
+    isVoiceReady() {
+        return !!this.apiKey;
+    }
+}

package/dist/lib/mcp/native/LocalSyncNative.d.ts

@@ -0,0 +1,19 @@
+import { McpTool } from '../types';
+import { McpConnector } from '../McpRegistry';
+/**
+ * NATIVE SERVER: LocalSyncNative
+ *
+ * Local Folder Synchronization capability.
+ * Allows the browser-based IndexedDB to be mirrored to a local file system folder.
+ *
+ * This is a "capability" native - it exposes sync features rather than AI tools.
+ */
+export declare class LocalSyncNative implements McpConnector {
+    id: string;
+    name: string;
+    description: string;
+    isPermanent: boolean;
+    getTools(): Promise<McpTool[]>;
+    executeTool(name: string, args: any): Promise<any>;
+    isSyncCapable(): boolean;
+}

package/dist/lib/mcp/native/LocalSyncNative.js

@@ -0,0 +1,26 @@
+/**
+ * NATIVE SERVER: LocalSyncNative
+ *
+ * Local Folder Synchronization capability.
+ * Allows the browser-based IndexedDB to be mirrored to a local file system folder.
+ *
+ * This is a "capability" native - it exposes sync features rather than AI tools.
+ */
+export class LocalSyncNative {
+    constructor() {
+        this.id = "native-local-sync";
+        this.name = "Native Local Folder Sync";
+        this.description = "Mirrors your database to a local folder for backup and cross-browser sync.";
+        this.isPermanent = false;
+    }
+    async getTools() {
+        return [];
+    }
+    async executeTool(name, args) {
+        throw new Error(`Tool ${name} not implemented in LocalSyncNative`);
+    }
+    // Capability check for Storage UI
+    isSyncCapable() {
+        return true;
+    }
+}

package/dist/lib/mcp/native/LocalVoiceNative.d.ts

@@ -0,0 +1,19 @@
+import { McpTool } from '../types';
+import { McpConnector } from '../McpRegistry';
+/**
+ * NATIVE SERVER: LocalVoiceNative
+ *
+ * Experimental Local Voice capability.
+ * Uses client-side ONNX models (Whisper/Kokoro) for private, offline interaction.
+ *
+ * This is a "capability" native - it exposes UI features rather than AI tools.
+ */
+export declare class LocalVoiceNative implements McpConnector {
+    id: string;
+    name: string;
+    description: string;
+    isPermanent: boolean;
+    getTools(): Promise<McpTool[]>;
+    executeTool(name: string, args: any): Promise<any>;
+    isVoiceCapable(): boolean;
+}