arcane-os 0.2.0 → 0.2.2

package/runtime/arcane/modules/AI.js

@@ -1,10 +1,15 @@
 import './DBOPFS.js';
 import UserEntity from '../entities/User.js';
 import {getAIPreferencesForRuntime} from './AIPreferenceRuntime.js';
-import {getAIProviderRuntime} from './AIProviderRuntime.js';
+import {
+    AI_MODEL_AUTHORITY_PROTOCOL,
+    AI_PROVIDER_PROTOCOL,
+    getAIProviderRuntime
+} from './AIProviderRuntime.js';
 import {normalizeOllamaModelIdentifier} from './OllamaModelIdentifier.js';
 
 let credentials='include';
+const LEGACY_TTS_RESPONSE_FORMAT='opus';
 credentials='omit';
 
 const LEGACY_AI_SERVICES=new Set(['OPENAI','OLLAMA','LOCAL_SPEACH']);
@@ -27,9 +32,155 @@ function normalizeAIRequestAbort(error){
     return normalized;
 }
 
+function legacyAIProviderError(message,code,cause){
+    const error=cause===undefined
+        ?new Error(message)
+        :new Error(message,{cause});
+    error.code=code;
+    return error;
+}
+
+function createLegacyAIStreamBridge(execute,sourceSignal){
+    const controller=new AbortController();
+    const queue=[];
+    const waiters=[];
+    let complete=false;
+    let failure=null;
+    let detached=false;
+
+    function forwardLegacyAIStreamAbort(){
+        if(!controller.signal.aborted){
+            controller.abort(sourceSignal?.reason);
+        }
+    }
+
+    function detachLegacyAIStreamAbort(){
+        if(detached){
+            return;
+        }
+        detached=true;
+        sourceSignal?.removeEventListener?.(
+            'abort',
+            forwardLegacyAIStreamAbort
+        );
+    }
+
+    if(sourceSignal?.aborted){
+        forwardLegacyAIStreamAbort();
+    }else{
+        sourceSignal?.addEventListener?.(
+            'abort',
+            forwardLegacyAIStreamAbort,
+            {once:true}
+        );
+    }
+
+    function emitLegacyAIStreamChunk(chunk){
+        if(complete){
+            return false;
+        }
+        const waiter=waiters.shift();
+        if(waiter){
+            waiter.resolve({value:chunk,done:false});
+        }else{
+            queue.push(chunk);
+        }
+        return true;
+    }
+
+    function finishLegacyAIStream(error){
+        if(complete){
+            return;
+        }
+        complete=true;
+        failure=error||null;
+        detachLegacyAIStreamAbort();
+        while(waiters.length){
+            const waiter=waiters.shift();
+            if(failure){
+                waiter.reject(failure);
+            }else{
+                waiter.resolve({value:undefined,done:true});
+            }
+        }
+    }
+
+    const result=Promise.resolve().then(
+        function executeLegacyAIStream(){
+            if(controller.signal.aborted){
+                throw normalizeAIRequestAbort(controller.signal.reason);
+            }
+            return execute({
+                emit:emitLegacyAIStreamChunk,
+                signal:controller.signal
+            });
+        }
+    ).then(
+        function acceptLegacyAIStreamResult(value){
+            finishLegacyAIStream(null);
+            return value;
+        },
+        function rejectLegacyAIStreamResult(error){
+            const normalized=isAIRequestAbort(error,controller.signal)
+                ?normalizeAIRequestAbort(error)
+                :error;
+            finishLegacyAIStream(normalized);
+            throw normalized;
+        }
+    );
+    result.catch(function retainLegacyAIStreamFailure() {});
+
+    async function cancelLegacyAIStream(reason){
+        if(!controller.signal.aborted){
+            controller.abort(reason);
+        }
+        await result.catch(function retainCancelledLegacyAIStream() {});
+        return true;
+    }
+
+    const handle={
+        result,
+        cancel:cancelLegacyAIStream,
+        next:function readLegacyAIStreamChunk(){
+            if(queue.length){
+                return Promise.resolve({value:queue.shift(),done:false});
+            }
+            if(complete){
+                return failure
+                    ?Promise.reject(failure)
+                    :Promise.resolve({value:undefined,done:true});
+            }
+            return new Promise(function waitForLegacyAIStreamChunk(resolve,reject){
+                waiters.push({resolve,reject});
+            });
+        },
+        return:async function returnLegacyAIStream(value){
+            await cancelLegacyAIStream(
+                legacyAIProviderError(
+                    'The legacy AI stream consumer stopped before completion.',
+                    'ARCANE_AI_REQUEST_ABORTED'
+                )
+            );
+            return {value,done:true};
+        },
+        throw:async function throwLegacyAIStream(error){
+            await cancelLegacyAIStream(error);
+            throw error;
+        },
+        [Symbol.asyncIterator]:function iterateLegacyAIStream(){
+            return this;
+        }
+    };
+    return Object.freeze(handle);
+}
+
 function normalizeAIStartupOptions(options){
     if(options===undefined){
-        return Object.freeze({startMuted:true,signal:null});
+        return Object.freeze({
+            startMuted:true,
+            startTranscription:false,
+            signal:null
+        });
     }
     if(!options||typeof options!=='object'||Array.isArray(options)){
         throw new TypeError('AI startup options must be a plain object.');
@@ -40,7 +191,11 @@ function normalizeAIStartupOptions(options){
     }
     const descriptors=Object.getOwnPropertyDescriptors(options);
     for(const key of Reflect.ownKeys(descriptors)){
-        if(typeof key==='symbol'||(key!=='startMuted'&&key!=='signal')){
+        if(typeof key==='symbol'||(
+            key!=='startMuted'
+            &&key!=='startTranscription'
+            &&key!=='signal'
+        )){
             throw new TypeError('AI startup options contain an unknown option.');
         }
         if(!Object.hasOwn(descriptors[key],'value')){
@@ -50,12 +205,18 @@ function normalizeAIStartupOptions(options){
     const startMuted=Object.hasOwn(descriptors,'startMuted')
         ?descriptors.startMuted.value
         :true;
+    const startTranscription=Object.hasOwn(descriptors,'startTranscription')
+        ?descriptors.startTranscription.value
+        :false;
     const signal=Object.hasOwn(descriptors,'signal')
         ?descriptors.signal.value
         :null;
     if(typeof startMuted!=='boolean'){
         throw new TypeError('AI startup startMuted must be a boolean.');
     }
+    if(typeof startTranscription!=='boolean'){
+        throw new TypeError('AI startup startTranscription must be a boolean.');
+    }
     if(signal!==null&&signal!==undefined&&(
         typeof signal!=='object'
         ||typeof signal.aborted!=='boolean'
@@ -64,7 +225,7 @@ function normalizeAIStartupOptions(options){
     )){
         throw new TypeError('AI startup signal must be an AbortSignal.');
     }
-    return Object.freeze({startMuted,signal});
+    return Object.freeze({startMuted,startTranscription,signal});
 }
 
 class AI {
@@ -190,9 +351,23 @@ class AI {
         this.setAI(
             ...preferences
         );
+
+        const runtime=this;
+        globalThis.addEventListener?.(
+            'arcane-ollama-ready',
+            function reconcileLegacyOllamaReadiness(){
+                runtime.#retainLegacyLLMReadiness(
+                    runtime.#reconcileLegacyLLMReadiness()
+                );
+            }
+        );
     }
 
     #providerRuntime=getAIProviderRuntime();
+    #legacyLLMProviders=new Map();
+    #legacyLLMReadiness=Promise.resolve(null);
+    #legacySpeechProviders=new Map();
+    #legacySpeechReadiness=Promise.resolve(null);
     #preferenceTuple=Object.freeze([
         'OPENAI',
         'OPENAI',
@@ -240,11 +415,642 @@ class AI {
     
     set license(value){
         this.#license=typeof value==='string' ? value.trim():'';
+        this.#retainLegacyLLMReadiness(
+            this.#reconcileLegacyLLMReadiness()
+        );
+        this.#retainLegacySpeechReadiness(
+            this.#reconcileLegacySpeechReadiness()
+        );
         return this.#license;
     }
 
+    #legacyLLMCapability(providerId){
+        if(providerId==='OPENAI'){
+            return this.llmService==='OPENAI'
+                &&Boolean(this.model)
+                &&Boolean(this.license)
+                &&typeof globalThis.fetch==='function';
+        }
+        if(providerId==='OLLAMA'){
+            return this.llmService==='OLLAMA'
+                &&Boolean(this.model)
+                &&Boolean(this.#nativeOllama());
+        }
+        return false;
+    }
+
+    #legacyLLMInspection(providerId,selection){
+        const localOnly=providerId==='OLLAMA';
+        if(!selection
+            ||selection.providerId!==providerId
+            ||selection.modelId!==this.model
+            ||selection.localOnly!==localOnly
+            ||this.llmService!==providerId){
+            return Object.freeze({
+                available:false,
+                code:'ARCANE_AI_MODEL_AUTHORITY_REQUIRED',
+                message:'The selected legacy LLM route does not match the active AI configuration.'
+            });
+        }
+        if(!this.#legacyLLMCapability(providerId)){
+            return Object.freeze({
+                available:false,
+                code:providerId==='OLLAMA'
+                    ?'AI_NATIVE_LOCAL_REQUIRED'
+                    :'AI_PROVIDER_NOT_CONFIGURED',
+                message:providerId==='OLLAMA'
+                    ?'Local AI requires the capability-gated Arcane API.'
+                    :'AI provider is not configured.'
+            });
+        }
+        return Object.freeze({
+            available:true,
+            authority:Object.freeze({
+                protocol:AI_MODEL_AUTHORITY_PROTOCOL,
+                providerId,
+                modelId:selection.modelId,
+                admitted:true
+            })
+        });
+    }
+
+    #createLegacyLLMProvider(providerId){
+        const runtime=this;
+        const localOnly=providerId==='OLLAMA';
+        let state='unloaded';
+        let busy=false;
+
+        function statusLegacyLLMProvider(){
+            if(state==='ready'
+                &&!busy
+                &&!runtime.#legacyLLMCapability(providerId)){
+                state='unloaded';
+            }
+            return Object.freeze({
+                state,
+                loaded:state==='ready',
+                busy
+            });
+        }
+
+        function assertLegacyLLMSelection(selection){
+            const inspection=runtime.#legacyLLMInspection(
+                providerId,
+                selection
+            );
+            if(!inspection.available){
+                throw legacyAIProviderError(
+                    inspection.message,
+                    inspection.code
+                );
+            }
+            return inspection;
+        }
+
+        function releaseLegacyLLMRequest(){
+            busy=false;
+        }
+
+        return Object.freeze({
+            protocol:AI_PROVIDER_PROTOCOL,
+            role:'llm',
+            id:providerId,
+            localOnly,
+            catalog:function catalogLegacyLLMProvider(){
+                if(runtime.llmService!==providerId||!runtime.model){
+                    return Object.freeze([]);
+                }
+                return Object.freeze([
+                    Object.freeze({id:runtime.model})
+                ]);
+            },
+            inspect:function inspectLegacyLLMProvider(selection,{signal}={}){
+                if(signal?.aborted){
+                    throw normalizeAIRequestAbort(signal.reason);
+                }
+                return runtime.#legacyLLMInspection(providerId,selection);
+            },
+            status:statusLegacyLLMProvider,
+            load:function loadLegacyLLMProvider(context={}){
+                if(context.signal?.aborted){
+                    throw normalizeAIRequestAbort(context.signal.reason);
+                }
+                if(state==='disposed'){
+                    throw legacyAIProviderError(
+                        'The legacy LLM provider is disposed.',
+                        'ARCANE_AI_PROVIDER_DISPOSED'
+                    );
+                }
+                if(busy){
+                    throw legacyAIProviderError(
+                        'The legacy LLM provider owns an active request.',
+                        'ARCANE_AI_ROLE_BUSY'
+                    );
+                }
+                if(typeof context.progress!=='function'){
+                    throw new TypeError(
+                        'Legacy LLM provider load progress must be a function.'
+                    );
+                }
+                const inspection=assertLegacyLLMSelection(context.selection);
+                state='loading';
+                context.progress({
+                    phase:'capability',
+                    completed:0,
+                    total:1,
+                    unit:'items',
+                    heartbeat:false
+                });
+                if(context.signal?.aborted){
+                    state='unloaded';
+                    throw normalizeAIRequestAbort(context.signal.reason);
+                }
+                state='ready';
+                context.progress({
+                    phase:'capability',
+                    completed:1,
+                    total:1,
+                    unit:'items',
+                    heartbeat:false
+                });
+                return Object.freeze({
+                    authority:inspection.authority,
+                    status:statusLegacyLLMProvider()
+                });
+            },
+            request:function requestLegacyLLMProvider(context={}){
+                if(context.signal?.aborted){
+                    throw normalizeAIRequestAbort(context.signal.reason);
+                }
+                assertLegacyLLMSelection(context.selection);
+                const current=statusLegacyLLMProvider();
+                if(current.state!=='ready'||!current.loaded){
+                    throw legacyAIProviderError(
+                        'The legacy LLM provider is not ready.',
+                        'ARCANE_AI_ROLE_NOT_READY'
+                    );
+                }
+                if(busy){
+                    throw legacyAIProviderError(
+                        'The legacy LLM provider owns an active request.',
+                        'ARCANE_AI_ROLE_BUSY'
+                    );
+                }
+                busy=true;
+                if(context.operation==='chat'){
+                    return Promise.resolve(
+                        runtime.#requestLegacyLLMChat(
+                            context.payload,
+                            context.signal
+                        )
+                    ).finally(releaseLegacyLLMRequest);
+                }
+                if(context.operation==='stream'){
+                    const handle=createLegacyAIStreamBridge(
+                        function executeLegacyLLMProviderStream(bridge){
+                            return runtime.#requestLegacyLLMStream(
+                                context.payload,
+                                bridge
+                            );
+                        },
+                        context.signal
+                    );
+                    handle.result.then(
+                        releaseLegacyLLMRequest,
+                        releaseLegacyLLMRequest
+                    );
+                    return handle;
+                }
+                busy=false;
+                throw legacyAIProviderError(
+                    'The legacy LLM provider operation is unsupported.',
+                    'ARCANE_AI_PROVIDER_RUNTIME_INVALID'
+                );
+            },
+            unload:function unloadLegacyLLMProvider(context={}){
+                if(context.signal?.aborted){
+                    throw normalizeAIRequestAbort(context.signal.reason);
+                }
+                state='unloaded';
+                busy=false;
+                return statusLegacyLLMProvider();
+            },
+            dispose:function disposeLegacyLLMProvider(context={}){
+                if(context.signal?.aborted){
+                    throw normalizeAIRequestAbort(context.signal.reason);
+                }
+                state='disposed';
+                busy=false;
+                return statusLegacyLLMProvider();
+            }
+        });
+    }
+
+    #legacySpeechService(role){
+        return role==='stt'?this.sttService:this.ttsService;
+    }
+
+    #legacySpeechModel(role){
+        return role==='stt'?this.modelSTT:this.modelTTS;
+    }
+
+    #legacySpeechProviderKey(role,providerId){
+        return `${role}:${providerId}`;
+    }
+
+    #legacySpeechDefaultVoice(role,providerId){
+        if(role!=='tts'){
+            return null;
+        }
+        if(providerId==='OPENAI'){
+            const selected=typeof globalThis.window?.user?.AI_voice==='string'
+                ?globalThis.window.user.AI_voice.trim()
+                :'';
+            return selected||'alloy';
+        }
+        if(providerId==='LOCAL_SPEACH'){
+            return 'af_heart';
+        }
+        return null;
+    }
+
+    #legacySpeechCapability(role,providerId){
+        const service=this.#legacySpeechService(role);
+        const model=this.#legacySpeechModel(role);
+        if(service!==providerId||!model){
+            return false;
+        }
+        if(providerId==='OPENAI'){
+            return Boolean(this.license)&&typeof globalThis.fetch==='function';
+        }
+        if(providerId==='LOCAL_SPEACH'){
+            return Boolean(this.#nativeSpeech(service,role));
+        }
+        return false;
+    }
+
+    #legacySpeechInspection(role,providerId,selection){
+        const localOnly=providerId==='LOCAL_SPEACH';
+        if(!selection
+            ||selection.providerId!==providerId
+            ||selection.modelId!==this.#legacySpeechModel(role)
+            ||selection.localOnly!==localOnly
+            ||this.#legacySpeechService(role)!==providerId){
+            return Object.freeze({
+                available:false,
+                code:'ARCANE_AI_MODEL_AUTHORITY_REQUIRED',
+                message:`The selected legacy ${role.toUpperCase()} route does not match the active AI configuration.`
+            });
+        }
+        if(!this.#legacySpeechCapability(role,providerId)){
+            return Object.freeze({
+                available:false,
+                code:providerId==='LOCAL_SPEACH'
+                    ?'AI_NATIVE_LOCAL_REQUIRED'
+                    :'AI_PROVIDER_NOT_CONFIGURED',
+                message:providerId==='LOCAL_SPEACH'
+                    ?`Local ${role.toUpperCase()} requires the capability-gated Arcane API.`
+                    :'AI provider is not configured.'
+            });
+        }
+        return Object.freeze({
+            available:true,
+            authority:Object.freeze({
+                protocol:AI_MODEL_AUTHORITY_PROTOCOL,
+                providerId,
+                modelId:selection.modelId,
+                admitted:true
+            })
+        });
+    }
+
+    #createLegacySpeechProvider(role,providerId){
+        const runtime=this;
+        const localOnly=providerId==='LOCAL_SPEACH';
+        const expectedOperation=role==='stt'?'transcribe':'synthesize';
+        let state='unloaded';
+        let busy=false;
+
+        function statusLegacySpeechProvider(){
+            if(state==='ready'
+                &&!busy
+                &&!runtime.#legacySpeechCapability(role,providerId)){
+                state='unloaded';
+            }
+            return Object.freeze({
+                state,
+                loaded:state==='ready',
+                busy
+            });
+        }
+
+        function assertLegacySpeechSelection(selection){
+            const inspection=runtime.#legacySpeechInspection(
+                role,
+                providerId,
+                selection
+            );
+            if(!inspection.available){
+                throw legacyAIProviderError(
+                    inspection.message,
+                    inspection.code
+                );
+            }
+            return inspection;
+        }
+
+        function releaseLegacySpeechRequest(){
+            busy=false;
+        }
+
+        return Object.freeze({
+            protocol:AI_PROVIDER_PROTOCOL,
+            role,
+            id:providerId,
+            localOnly,
+            catalog:function catalogLegacySpeechProvider(){
+                const model=runtime.#legacySpeechModel(role);
+                if(runtime.#legacySpeechService(role)!==providerId||!model){
+                    return Object.freeze([]);
+                }
+                const defaultVoice=runtime.#legacySpeechDefaultVoice(
+                    role,
+                    providerId
+                );
+                return Object.freeze([
+                    Object.freeze({
+                        id:model,
+                        ...(defaultVoice?{defaultVoice}:{})
+                    })
+                ]);
+            },
+            inspect:function inspectLegacySpeechProvider(selection,{signal}={}){
+                if(signal?.aborted){
+                    throw normalizeAIRequestAbort(signal.reason);
+                }
+                return runtime.#legacySpeechInspection(role,providerId,selection);
+            },
+            status:statusLegacySpeechProvider,
+            load:function loadLegacySpeechProvider(context={}){
+                if(context.signal?.aborted){
+                    throw normalizeAIRequestAbort(context.signal.reason);
+                }
+                if(state==='disposed'){
+                    throw legacyAIProviderError(
+                        `The legacy ${role.toUpperCase()} provider is disposed.`,
+                        'ARCANE_AI_PROVIDER_DISPOSED'
+                    );
+                }
+                if(busy){
+                    throw legacyAIProviderError(
+                        `The legacy ${role.toUpperCase()} provider owns an active request.`,
+                        'ARCANE_AI_ROLE_BUSY'
+                    );
+                }
+                if(typeof context.progress!=='function'){
+                    throw new TypeError(
+                        `Legacy ${role.toUpperCase()} provider load progress must be a function.`
+                    );
+                }
+                const inspection=assertLegacySpeechSelection(context.selection);
+                state='loading';
+                context.progress({
+                    phase:'capability',
+                    completed:0,
+                    total:1,
+                    unit:'items',
+                    heartbeat:false
+                });
+                if(context.signal?.aborted){
+                    state='unloaded';
+                    throw normalizeAIRequestAbort(context.signal.reason);
+                }
+                state='ready';
+                context.progress({
+                    phase:'capability',
+                    completed:1,
+                    total:1,
+                    unit:'items',
+                    heartbeat:false
+                });
+                return Object.freeze({
+                    authority:inspection.authority,
+                    status:statusLegacySpeechProvider()
+                });
+            },
+            request:function requestLegacySpeechProvider(context={}){
+                if(context.signal?.aborted){
+                    throw normalizeAIRequestAbort(context.signal.reason);
+                }
+                assertLegacySpeechSelection(context.selection);
+                const current=statusLegacySpeechProvider();
+                if(current.state!=='ready'||!current.loaded){
+                    throw legacyAIProviderError(
+                        `The legacy ${role.toUpperCase()} provider is not ready.`,
+                        'ARCANE_AI_ROLE_NOT_READY'
+                    );
+                }
+                if(busy){
+                    throw legacyAIProviderError(
+                        `The legacy ${role.toUpperCase()} provider owns an active request.`,
+                        'ARCANE_AI_ROLE_BUSY'
+                    );
+                }
+                if(context.operation!==expectedOperation){
+                    throw legacyAIProviderError(
+                        `The legacy ${role.toUpperCase()} provider operation is unsupported.`,
+                        'ARCANE_AI_PROVIDER_RUNTIME_INVALID'
+                    );
+                }
+                busy=true;
+                const request=role==='stt'
+                    ?runtime.#requestLegacySpeechTranscription(
+                        context.payload,
+                        context.signal
+                    )
+                    :runtime.#requestLegacySpeechSynthesis(
+                        context.payload,
+                        context.signal
+                    );
+                return Promise.resolve(request).finally(releaseLegacySpeechRequest);
+            },
+            unload:function unloadLegacySpeechProvider(context={}){
+                if(context.signal?.aborted){
+                    throw normalizeAIRequestAbort(context.signal.reason);
+                }
+                if(busy){
+                    throw legacyAIProviderError(
+                        `The legacy ${role.toUpperCase()} provider still owns an active request.`,
+                        'ARCANE_AI_ROLE_BUSY'
+                    );
+                }
+                state='unloaded';
+                return statusLegacySpeechProvider();
+            },
+            dispose:function disposeLegacySpeechProvider(context={}){
+                if(context.signal?.aborted){
+                    throw normalizeAIRequestAbort(context.signal.reason);
+                }
+                if(busy){
+                    throw legacyAIProviderError(
+                        `The legacy ${role.toUpperCase()} provider still owns an active request.`,
+                        'ARCANE_AI_ROLE_BUSY'
+                    );
+                }
+                state='disposed';
+                return statusLegacySpeechProvider();
+            }
+        });
+    }
+
+    #ensureLegacyLLMProvider(providerId){
+        if(providerId!=='OPENAI'&&providerId!=='OLLAMA'){
+            return false;
+        }
+        if(this.#providerRuntime.hasProvider('llm',providerId)){
+            return false;
+        }
+        const provider=this.#createLegacyLLMProvider(providerId);
+        const unregister=this.#providerRuntime.register(provider);
+        this.#legacyLLMProviders.set(
+            providerId,
+            Object.freeze({provider,unregister})
+        );
+        return true;
+    }
+
+    #ensureLegacySpeechProvider(role,providerId){
+        if(!['stt','tts'].includes(role)
+            ||!['OPENAI','LOCAL_SPEACH'].includes(providerId)){
+            return false;
+        }
+        if(this.#providerRuntime.hasProvider(role,providerId)){
+            return false;
+        }
+        const provider=this.#createLegacySpeechProvider(role,providerId);
+        const unregister=this.#providerRuntime.register(provider);
+        this.#legacySpeechProviders.set(
+            this.#legacySpeechProviderKey(role,providerId),
+            Object.freeze({role,providerId,provider,unregister})
+        );
+        return true;
+    }
+
+    #releaseInactiveLegacyLLMProviders(activeProviderId){
+        for(const [providerId,record] of this.#legacyLLMProviders){
+            if(providerId===activeProviderId){
+                continue;
+            }
+            if(record.unregister()){
+                this.#legacyLLMProviders.delete(providerId);
+            }
+        }
+    }
+
+    #releaseInactiveLegacySpeechProviders(activeProviders){
+        for(const [key,record] of this.#legacySpeechProviders){
+            if(activeProviders[record.role]===record.providerId){
+                continue;
+            }
+            if(record.unregister()){
+                this.#legacySpeechProviders.delete(key);
+            }
+        }
+    }
+
+    #internalLegacyLLMSelection(localOnly=false){
+        const selection=this.#providerRuntime.selection(
+            'llm',
+            {localOnly}
+        );
+        if(!selection
+            ||!this.#legacyLLMProviders.has(selection.providerId)
+            ||selection.providerId!==this.llmService
+            ||selection.modelId!==this.model){
+            return null;
+        }
+        return selection;
+    }
+
+    #internalLegacySpeechSelection(role,localOnly=false){
+        const selection=this.#providerRuntime.selection(role,{localOnly});
+        if(!selection
+            ||!this.#legacySpeechProviders.has(
+                this.#legacySpeechProviderKey(role,selection.providerId)
+            )
+            ||selection.providerId!==this.#legacySpeechService(role)
+            ||selection.modelId!==this.#legacySpeechModel(role)){
+            return null;
+        }
+        return selection;
+    }
+
+    #retainLegacyLLMReadiness(operation){
+        this.#legacyLLMReadiness=Promise.resolve(operation).catch(
+            function retainLegacyLLMReadinessFailure(){
+                return null;
+            }
+        );
+        return this.#legacyLLMReadiness;
+    }
+
+    #retainLegacySpeechReadiness(operation){
+        this.#legacySpeechReadiness=Promise.resolve(operation).catch(
+            function retainLegacySpeechReadinessFailure(){
+                return null;
+            }
+        );
+        return this.#legacySpeechReadiness;
+    }
+
+    #reconcileLegacyLLMReadiness(){
+        const selection=this.#internalLegacyLLMSelection(false);
+        if(!selection){
+            return Promise.resolve(this.#providerRuntime.status('llm'));
+        }
+        const status=this.#providerRuntime.status('llm');
+        if(this.#legacyLLMCapability(selection.providerId)){
+            if(status.state==='ready'&&status.loaded===true){
+                return Promise.resolve(status);
+            }
+            return this.#providerRuntime.load('llm');
+        }
+        if(status.loaded===true
+            ||status.busy===true
+            ||status.state==='loading'
+            ||status.state==='unloading'){
+            return this.#providerRuntime.unload('llm');
+        }
+        return Promise.resolve(status);
+    }
+
+    #reconcileLegacySpeechReadiness(){
+        const runtime=this;
+        return Promise.all(['stt','tts'].map(function reconcileLegacySpeechRole(role){
+            const selection=runtime.#internalLegacySpeechSelection(role,false);
+            if(!selection){
+                return runtime.#providerRuntime.status(role);
+            }
+            const status=runtime.#providerRuntime.status(role);
+            if(runtime.#legacySpeechCapability(role,selection.providerId)){
+                return status;
+            }
+            if(status.loaded===true
+                ||status.busy===true
+                ||status.state==='loading'
+                ||status.state==='unloading'){
+                return runtime.#providerRuntime.unload(role);
+            }
+            return status;
+        }));
+    }
+
     get configured(){
         if(this.#usesProviderRuntime('llm',this.llmService)){
+            if(this.#internalLegacyLLMSelection(false)
+                &&!this.#legacyLLMCapability(this.llmService)){
+                return false;
+            }
             const state=this.#providerRuntime.status('llm');
             return state.state==='ready'&&state.loaded===true;
         }
@@ -259,6 +1065,26 @@ class AI {
 
     #assertServiceConfigured(service=this.llmService,role='llm'){
         if(this.#usesProviderRuntime(role,service)){
+            const internal=role==='llm'
+                ?this.#internalLegacyLLMSelection(false)
+                :this.#internalLegacySpeechSelection(role,false);
+            const internalAvailable=!internal
+                ||(role==='llm'
+                    ?this.#legacyLLMCapability(internal.providerId)
+                    :this.#legacySpeechCapability(role,internal.providerId));
+            if(!internalAvailable){
+                const inspection=role==='llm'
+                    ?this.#legacyLLMInspection(internal.providerId,internal)
+                    :this.#legacySpeechInspection(
+                        role,
+                        internal.providerId,
+                        internal
+                    );
+                throw legacyAIProviderError(
+                    inspection.message,
+                    inspection.code
+                );
+            }
             return true;
         }
         if(service==='OLLAMA'){
@@ -298,6 +1124,11 @@ class AI {
     }
 
     #shouldUseProviderRuntime(role,service,localOnly=false){
+        // Legacy adapters publish lifecycle without replacing established
+        // public transport callbacks or their cancellation behavior.
+        if(role==='llm'&&this.#internalLegacyLLMSelection(localOnly)){
+            return false;
+        }
         if(!localOnly){
             return this.#usesProviderRuntime(role,service);
         }
@@ -361,6 +1192,19 @@ class AI {
         }
     }
 
+    #normalizedLLMModel(service,model){
+        if(service==='OLLAMA'){
+            const mappedModel=model==='OPENAI'?null:this.#models[model];
+            return mappedModel
+                ||normalizeOllamaModelIdentifier(model)
+                ||model;
+        }
+        if(service==='OPENAI'){
+            return this.#models.OPENAI;
+        }
+        return model;
+    }
+
     #applyPreferenceTuple(tuple){
         const [
             llmService,
@@ -369,16 +1213,11 @@ class AI {
             model,
             modelTTS,
             modelSTT
-        ]=tuple;
-        let normalizedLLMModel=model;
-        if(llmService==='OLLAMA'){
-            const mappedModel=model==='OPENAI'?null:this.#models[model];
-            normalizedLLMModel=mappedModel
-                ||normalizeOllamaModelIdentifier(model)
-                ||model;
-        }else if(llmService==='OPENAI'){
-            normalizedLLMModel=this.#models.OPENAI;
-        }
+        ]=tuple;
+        const normalizedLLMModel=this.#normalizedLLMModel(
+            llmService,
+            model
+        );
         this.llmService=llmService;
         this.sttService=sttService;
         this.ttsService=ttsService;
@@ -405,9 +1244,12 @@ class AI {
 
     #routesFromPreferenceTuple(tuple){
         const roles={
-            llm:[tuple[0],tuple[3]],
-            stt:[tuple[1],tuple[5]],
-            tts:[tuple[2],tuple[4]]
+            llm:[
+                tuple[0],
+                this.#normalizedLLMModel(tuple[0],tuple[3])
+            ],
+            stt:[tuple[1],this.#sttModels[tuple[5]]||tuple[5]],
+            tts:[tuple[2],this.#ttsModels[tuple[4]]||tuple[4]]
         };
         const selections={};
         for(const role of ['llm','stt','tts']){
@@ -501,15 +1343,54 @@ class AI {
             modelSTT
         ]);
         this.#assertValidProviderTuple(tuple);
+        this.#ensureLegacyLLMProvider(tuple[0]);
+        this.#ensureLegacySpeechProvider('stt',tuple[1]);
+        this.#ensureLegacySpeechProvider('tts',tuple[2]);
         this.#providerRuntime.configure(this.#routesFromPreferenceTuple(tuple));
         this.#applyPreferenceTuple(tuple);
+        this.#releaseInactiveLegacyLLMProviders(tuple[0]);
+        this.#releaseInactiveLegacySpeechProviders({
+            stt:tuple[1],
+            tts:tuple[2]
+        });
+        this.#retainLegacyLLMReadiness(
+            this.#reconcileLegacyLLMReadiness()
+        );
+        this.#retainLegacySpeechReadiness(
+            this.#reconcileLegacySpeechReadiness()
+        );
         return true;
     }
 
     configureProviders(selections){
-        this.#assertRegisteredLegacyRoutes(selections);
-        const configured=this.#providerRuntime.configure(selections);
+        const prepared=this.#providerRuntime.validateConfiguration(selections);
+        this.#ensureLegacyLLMProvider(
+            prepared.llm.default?.providerId
+        );
+        this.#ensureLegacySpeechProvider(
+            'stt',
+            prepared.stt.default?.providerId
+        );
+        this.#ensureLegacySpeechProvider(
+            'tts',
+            prepared.tts.default?.providerId
+        );
+        this.#assertRegisteredLegacyRoutes(prepared);
+        const configured=this.#providerRuntime.configure(prepared);
         this.#applyPreferenceTuple(this.#tupleFromProviderRoutes(configured));
+        this.#releaseInactiveLegacyLLMProviders(
+            configured.llm.default?.providerId
+        );
+        this.#releaseInactiveLegacySpeechProviders({
+            stt:configured.stt.default?.providerId,
+            tts:configured.tts.default?.providerId
+        });
+        this.#retainLegacyLLMReadiness(
+            this.#reconcileLegacyLLMReadiness()
+        );
+        this.#retainLegacySpeechReadiness(
+            this.#reconcileLegacySpeechReadiness()
+        );
         return configured;
     }
 
@@ -532,18 +1413,48 @@ class AI {
         this.#assertValidProviderTuple(tuple);
         this.stopAudio();
         await this.#unloadProviderRolesForTransition();
+        this.#ensureLegacyLLMProvider(tuple[0]);
+        this.#ensureLegacySpeechProvider('stt',tuple[1]);
+        this.#ensureLegacySpeechProvider('tts',tuple[2]);
         this.#providerRuntime.configure(this.#routesFromPreferenceTuple(tuple));
         this.#applyPreferenceTuple(tuple);
+        this.#releaseInactiveLegacyLLMProviders(tuple[0]);
+        this.#releaseInactiveLegacySpeechProviders({
+            stt:tuple[1],
+            tts:tuple[2]
+        });
+        await this.#reconcileLegacyLLMReadiness();
+        await this.#reconcileLegacySpeechReadiness();
         return this.#providerRuntime.status();
     }
 
     async transitionProviders(selections){
-        this.#assertRegisteredLegacyRoutes(selections);
         const prepared=this.#providerRuntime.validateConfiguration(selections);
+        this.#ensureLegacyLLMProvider(
+            prepared.llm.default?.providerId
+        );
+        this.#ensureLegacySpeechProvider(
+            'stt',
+            prepared.stt.default?.providerId
+        );
+        this.#ensureLegacySpeechProvider(
+            'tts',
+            prepared.tts.default?.providerId
+        );
+        this.#assertRegisteredLegacyRoutes(prepared);
         this.stopAudio();
         await this.#unloadProviderRolesForTransition();
         const configured=this.#providerRuntime.configure(prepared);
         this.#applyPreferenceTuple(this.#tupleFromProviderRoutes(configured));
+        this.#releaseInactiveLegacyLLMProviders(
+            configured.llm.default?.providerId
+        );
+        this.#releaseInactiveLegacySpeechProviders({
+            stt:configured.stt.default?.providerId,
+            tts:configured.tts.default?.providerId
+        });
+        await this.#reconcileLegacyLLMReadiness();
+        await this.#reconcileLegacySpeechReadiness();
         return configured;
     }
 
@@ -632,6 +1543,127 @@ class AI {
         return null;
     }
 
+    async #requestLegacySpeechTranscription(payload={},signal=null){
+        const audio=payload?.audio;
+        if(!audio||typeof audio.arrayBuffer!=='function'){
+            throw new TypeError('Speech transcription requires an audio Blob or File.');
+        }
+        if(signal?.aborted){
+            throw normalizeAIRequestAbort(signal.reason);
+        }
+        const mimeType=String(payload.mimeType||audio.type||'audio/webm');
+        const model=String(payload.model||this.modelSTT);
+        const nativeSpeech=this.#nativeSpeech(this.sttService,'stt');
+        if(nativeSpeech){
+            const audioBytes=await audio.arrayBuffer();
+            if(signal?.aborted){
+                throw normalizeAIRequestAbort(signal.reason);
+            }
+            const response=await nativeSpeech.transcribe({
+                audioBase64:this.#arrayBufferToBase64(audioBytes),
+                mimeType,
+                model
+            });
+            if(signal?.aborted){
+                throw normalizeAIRequestAbort(signal.reason);
+            }
+            if(!response||typeof response.text!=='string'){
+                throw new TypeError('Arcane returned an invalid local speech transcription.');
+            }
+            return response.text;
+        }
+
+        await this.#assertAndroidSpeechBridge(this.sttService);
+        const formData=new FormData();
+        formData.append('file',audio);
+        formData.append('model',model);
+        formData.append('response_format','text');
+        const response=await fetch(
+            this.urlSTT,
+            {
+                method:'POST',
+                credentials,
+                headers:this.#sttHeaders[this.sttService],
+                body:formData,
+                signal
+            }
+        );
+        if(!response.ok){
+            throw new Error(`Speech transcription failed with status ${response.status}.`);
+        }
+        return response.text();
+    }
+
+    async #requestLegacySpeechSynthesis(payload={},signal=null){
+        const input=typeof payload?.input==='string'?payload.input:'';
+        if(!input){
+            throw new TypeError('Speech synthesis requires nonempty input.');
+        }
+        if(signal?.aborted){
+            throw normalizeAIRequestAbort(signal.reason);
+        }
+        const model=String(payload.model||this.modelTTS);
+        const voice=typeof payload.voice==='string'&&payload.voice.trim()
+            ?payload.voice.trim()
+            :this.#legacySpeechDefaultVoice('tts',this.ttsService);
+        if(!voice){
+            throw new TypeError('The selected speech provider requires a voice.');
+        }
+        const responseFormat=String(payload.responseFormat||this.audioFormat);
+        const speed=Number.isFinite(payload.speed)?payload.speed:this.voiceSpeed;
+        const nativeSpeech=this.#nativeSpeech(this.ttsService,'tts');
+        if(nativeSpeech){
+            const response=await nativeSpeech.synthesize({
+                model,
+                voice,
+                input,
+                responseFormat,
+                speed
+            });
+            if(signal?.aborted){
+                throw normalizeAIRequestAbort(signal.reason);
+            }
+            if(!response||typeof response.audioBase64!=='string'){
+                throw new TypeError('Arcane returned an invalid local speech response.');
+            }
+            return new Blob(
+                [this.#base64ToBytes(response.audioBase64)],
+                {
+                    type:typeof response.contentType==='string'
+                        ?response.contentType
+                        :this.audioType
+                }
+            );
+        }
+
+        await this.#assertAndroidSpeechBridge(this.ttsService);
+        const personality=await window.user?.personality
+            ||'A behavioral health technician with a slight veteran feel on occasion.';
+        const religion=await window.user?.religion||'caring';
+        const response=await fetch(
+            this.urlTTS,
+            {
+                method:'POST',
+                credentials,
+                headers:this.#ttsHeaders[this.ttsService],
+                body:JSON.stringify({
+                    model,
+                    voice,
+                    input,
+                    speed,
+                    instructions:`${personality} and sounding a bit ${religion}`,
+                    response_format:responseFormat
+                }),
+                signal
+            }
+        );
+        if(!response.ok){
+            throw new Error(`Speech synthesis failed with status ${response.status}.`);
+        }
+        const contentType=response.headers.get('content-type')||this.audioType;
+        return new Blob([await response.arrayBuffer()],{type:contentType});
+    }
+
     async #androidNativeHost(){
         if(typeof globalThis.arcaneAndroid?.postMessage==='function'){
             return true;
@@ -912,6 +1944,55 @@ class AI {
         return typeof content==='string'?content:completion;
     }
 
+    #requestLegacyLLMChat(payload={},signal=null){
+        return this.#fetchLegacy(
+            payload.messages??[],
+            function ignoreLegacyLLMProviderResponse(){},
+            payload.structuredOutput??false,
+            payload.tools??[],
+            payload.toolChoice??'auto',
+            payload.parallelToolCalls??true,
+            payload.id??Date.now(),
+            function ignoreLegacyLLMProviderRequest(){},
+            signal
+        );
+    }
+
+    #requestLegacyLLMStream(payload={},bridge){
+        function emitLegacyLLMStreamText(text,id,thinking){
+            if(typeof text!=='string'||!text){
+                return;
+            }
+            bridge.emit(
+                thinking
+                    ?{thinking:text}
+                    :{content:text}
+            );
+        }
+
+        function emitLegacyLLMStreamTool(name){
+            if(typeof name==='string'&&name){
+                bridge.emit({toolCalls:[{name}]});
+            }
+        }
+
+        return this.#streamLegacyMessage(
+            payload.messages??[],
+            emitLegacyLLMStreamText,
+            function ignoreLegacyLLMProviderCompletion(){},
+            payload.tools??[],
+            payload.toolChoice??'auto',
+            emitLegacyLLMStreamTool,
+            payload.parallelToolCalls??true,
+            payload.id??Date.now(),
+            payload.seeThinking??false,
+            bridge.signal,
+            function ignoreLegacyLLMProviderRequest(){},
+            payload.structuredOutput??false,
+            false
+        );
+    }
+
     #assertRequiredOllamaToolCall(toolCalls=[],toolChoice='auto'){
         const requiredName=toolChoice?.function?.name;
 
@@ -1152,6 +2233,38 @@ class AI {
                 signal
             });
         }
+
+        return this.#streamLegacyMessage(
+            messages,
+            streamHandler,
+            streamComplete,
+            tools,
+            tool_choice,
+            earlyFunctionTrigger,
+            parallel_tool_calls,
+            id,
+            seeThinking,
+            signal,
+            requestHandler,
+            structuredOutput
+        );
+    }
+
+    async #streamLegacyMessage(
+        messages=[],
+        streamHandler=function ignoreStreamChunk(){},
+        streamComplete=function finishIgnoredStream(){},
+        tools=[],
+        tool_choice='auto',
+        earlyFunctionTrigger=function ignoreEarlyFunction(){},
+        parallel_tool_calls=true,
+        id=Date.now(),
+        seeThinking=false,
+        signal=null,
+        requestHandler=function ignoreStreamRequest(){},
+        structuredOutput=false,
+        finishSpeech=true
+    ){
         let speechTurnCompleted=false;
 
         try{
@@ -1198,6 +2311,13 @@ class AI {
 
         const nativeOllama=this.#nativeOllama();
 
+        if(this.llmService==='OLLAMA'&&!nativeOllama){
+            throw legacyAIProviderError(
+                'Local AI requires the capability-gated Arcane API.',
+                'AI_NATIVE_LOCAL_REQUIRED'
+            );
+        }
+
         if(nativeOllama){
             let nativeContent='';
             const nativeToolCalls={};
@@ -1294,7 +2414,9 @@ class AI {
             if(Object.keys(nativeToolCalls).length&&!nativeContent){
                 streamHandler('',`M-${id}`,false);
             }
-            this.finishTTS();
+            if(finishSpeech){
+                this.finishTTS();
+            }
             await streamComplete(nativeResult,`M-${id}`,isThinking);
             speechTurnCompleted=true;
             return nativeResult;
@@ -1496,7 +2618,9 @@ class AI {
         if(Object.keys(tool_funcs).length&&!chunkString){
             streamHandler('',`M-${id}`,false);
         }
-        this.finishTTS();
+        if(finishSpeech){
+            this.finishTTS();
+        }
         await streamComplete(streamResult, `M-${id}`,isThinking);
 
         //sync
@@ -1609,6 +2733,31 @@ class AI {
                 onResponse:responseHandler
             });
         }
+
+        return this.#fetchLegacy(
+            messages,
+            responseHandler,
+            structuredOutput,
+            tools,
+            tool_choice,
+            parallel_tool_calls,
+            id,
+            requestHandler,
+            signal
+        );
+    }
+
+    async #fetchLegacy(
+        messages=[],
+        responseHandler=function ignoreFetchResponse(){},
+        structuredOutput=false,
+        tools=[],
+        tool_choice='auto',
+        parallel_tool_calls=true,
+        id=Date.now(),
+        requestHandler=function ignoreFetchRequest(){},
+        signal=null,
+    ){
         this.#assertServiceConfigured(this.llmService);
         if(signal&&(
             typeof signal.aborted!=='boolean'
@@ -1645,6 +2794,13 @@ class AI {
 
         const nativeOllama=this.#nativeOllama();
 
+        if(this.llmService==='OLLAMA'&&!nativeOllama){
+            throw legacyAIProviderError(
+                'Local AI requires the capability-gated Arcane API.',
+                'AI_NATIVE_LOCAL_REQUIRED'
+            );
+        }
+
         if(nativeOllama){
             const ollamaTools=this.#ollamaTools(tools,tool_choice);
             const ollamaMessages=this.#ollamaMessages(messages,tool_choice);
@@ -1931,15 +3087,17 @@ class AI {
     async #requestSpeechAudio(job){
         if(this.#usesProviderRuntime('tts',this.ttsService)){
             job.abortController=new AbortController();
+            const responseFormat=this.#providerSpeechResponseFormat();
+            const voice=this.#providerSpeechVoice();
             const response=await this.#providerRuntime.request(
                 'tts',
                 {
                     operation:'synthesize',
                     payload:{
                         model:this.#providerRuntime.selection('tts')?.modelId,
-                        voice:String(window.user?.AI_voice||'af_heart'),
                         input:job.text,
-                        responseFormat:this.audioFormat,
+                        responseFormat,
+                        ...(voice?{voice}:{}),
                         speed:this.voiceSpeed
                     },
                     localOnly:false,
@@ -1949,83 +3107,74 @@ class AI {
             return this.#normalizeProviderSpeechAudio(response);
         }
 
-        const nativeSpeech=this.#nativeSpeech(this.ttsService,'tts');
-
-        if(nativeSpeech){
-            const response=await nativeSpeech.synthesize({
+        job.abortController=new AbortController();
+        const response=await this.#requestLegacySpeechSynthesis(
+            {
                 model:this.modelTTS,
-                voice:String(window.user?.AI_voice||'af_heart'),
                 input:job.text,
                 responseFormat:this.audioFormat,
                 speed:this.voiceSpeed
-            });
-
-            if(!response||typeof response.audioBase64!=='string'){
-                throw new TypeError('Arcane returned an invalid local speech response.');
-            }
+            },
+            job.abortController.signal
+        );
+        return this.#normalizeProviderSpeechAudio(response);
+    }
 
-            return {
-                chunks:[this.#base64ToBytes(response.audioBase64)],
-                type:typeof response.contentType==='string'
-                    ?response.contentType
-                    :this.audioType
-            };
+    #providerSpeechVoice(){
+        const selection=this.#providerRuntime.selection('tts');
+        if(!selection){
+            return null;
         }
-
-        await this.#assertAndroidSpeechBridge(this.ttsService);
-
-        job.abortController=new AbortController();
-        const personality=await window.user?.personality
-            ||'A behavioral health technician with a slight veteran feel on occasion.';
-        const religion=await window.user?.religion||'caring';
-        const request={
-            model:this.modelTTS,
-            voice:window.user?.AI_voice,
-            input:job.text,
-            speed:this.voiceSpeed,
-            instructions:`${personality} and sounding a bit ${religion}`,
-            response_format:this.audioFormat
-        };
-        const response=await fetch(
-            this.urlTTS,
-            {
-                method:'POST',
-                credentials,
-                headers:this.#ttsHeaders[this.ttsService],
-                body:JSON.stringify(request),
-                signal:job.abortController.signal
-            }
+        const provider=this.#providerRuntime.catalog('tts').find(
+            entry=>entry.providerId===selection.providerId
         );
+        const model=provider?.models.find(entry=>entry?.id===selection.modelId);
+        return typeof model?.defaultVoice==='string'&&model.defaultVoice.trim()
+            ?model.defaultVoice.trim()
+            :null;
+    }
 
-        if(!response.ok){
-            throw new Error(`Speech synthesis failed with status ${response.status}.`);
+    #providerSpeechResponseFormat(){
+        const selection=this.#providerRuntime.selection('tts');
+        if(!selection){
+            return this.audioFormat;
         }
-
-        const reader=response.body?.getReader?.();
-
-        if(!reader){
-            throw new TypeError('Speech synthesis response body is not readable.');
+        const provider=this.#providerRuntime.catalog('tts').find(
+            entry=>entry.providerId===selection.providerId
+        );
+        const model=provider?.models.find(entry=>entry?.id===selection.modelId);
+        const speech=model?.speech;
+        if(speech===undefined){
+            return this.audioFormat;
         }
-
-        const chunks=[];
-
-        try{
-            while(true){
-                const {done,value}=await reader.read();
-
-                if(done){
-                    break;
-                }
-
-                if(value){
-                    chunks.push(value);
-                }
-            }
-        }finally{
-            reader.releaseLock?.();
+        const prototype=speech&&typeof speech==='object'
+            ?Object.getPrototypeOf(speech)
+            :null;
+        const descriptors=prototype===Object.prototype||prototype===null
+            ?Object.getOwnPropertyDescriptors(speech)
+            :null;
+        const formats=descriptors?.responseFormats?.value;
+        const defaultFormat=descriptors?.defaultResponseFormat?.value;
+        if(!Array.isArray(formats)
+            ||formats.length<1
+            ||!formats.every(format=>typeof format==='string'&&format.trim()===format&&format)
+            ||typeof defaultFormat!=='string'
+            ||!formats.includes(defaultFormat)){
+            throw legacyAIProviderError(
+                'The selected TTS provider returned an invalid speech format catalog.',
+                'ARCANE_AI_PROVIDER_RUNTIME_INVALID'
+            );
         }
-
-        return {chunks,type:this.audioType};
+        if(formats.includes(this.audioFormat)){
+            return this.audioFormat;
+        }
+        if(this.audioFormat===LEGACY_TTS_RESPONSE_FORMAT){
+            return defaultFormat;
+        }
+        throw legacyAIProviderError(
+            `The selected TTS provider does not support ${this.audioFormat}.`,
+            'ARCANE_AI_UNSUPPORTED_RESPONSE_FORMAT'
+        );
     }
 
     async #normalizeProviderSpeechAudio(response){
@@ -2148,55 +3297,15 @@ class AI {
             return text;
         }
 
-        const nativeSpeech=this.#nativeSpeech(this.sttService,'stt');
-
-        if(nativeSpeech){
-            if(!audioFile||typeof audioFile.arrayBuffer!=='function'){
-                throw new TypeError('Speech transcription requires an audio Blob or File.');
-            }
-
-            const response=await nativeSpeech.transcribe({
-                audioBase64:this.#arrayBufferToBase64(await audioFile.arrayBuffer()),
-                mimeType:String(audioFile.type||'audio/webm'),
-                model:this.modelSTT
-            });
-
-            if(!response||typeof response.text!=='string'){
-                throw new TypeError('Arcane returned an invalid local speech transcription.');
-            }
-
-            await responseHandler(response.text);
-            return response.text;
-        }
-
-        await this.#assertAndroidSpeechBridge(this.sttService);
-
-        const formData = new FormData();
-        formData.append('file', audioFile);
-        formData.append('model', this.modelSTT);
-        formData.append('response_format', 'text');
-
-        const response = await fetch(
-            this.urlSTT, 
+        const text=await this.#requestLegacySpeechTranscription(
             {
-                method: 'POST',
-                credentials: credentials,
-                headers: this.#sttHeaders[this.sttService],
-                body: formData,
-                signal
-            }
+                audio:audioFile,
+                mimeType:String(audioFile?.type||'audio/webm'),
+                model:this.modelSTT
+            },
+            signal
         );
-
-        if(!response.ok){
-            throw new Error(`Speech transcription failed with status ${response.status}.`);
-        }
-
-        const text = await response.text();
-        
-        //async
         await responseHandler(text);
-
-        //sync
         return text;
     }