arcane-os 0.63.0 → 0.65.0

package/runtime/arcane/components/voice-transcription.html

@@ -135,7 +135,7 @@
     const [
         {default:MD},
         {appendTranscription,createSTTActivationController,normalizeVoiceOptions},
-        {requestAIRuntimeIntent,subscribeAIRuntimeState},
+        {continuesAIRuntimeOperation,requestAIRuntimeIntent,subscribeAIRuntimeState},
         {default:ContinuousVoiceCapture},
         {getAIProviderRuntime}
     ]=await Promise.all([
@@ -165,6 +165,7 @@
     let recorder=null;
     let state='idle';
     let stateMessage='';
+    let transcriptionRuntimeOperationId=null;
     let sttRole=unavailableRole('stt');
     let transcript='';
     let sessionGeneration=0;
@@ -1121,7 +1122,17 @@
             error.code='ARCANE_VOICE_TRANSCRIPTION_STT_RUNTIME_METHOD_UNAVAILABLE';
             throw error;
         }
-        return globalThis.ai.fetchSTT(file,signal);
+        const previousOperationId=providerRuntime.status('stt').operationId;
+        const pending=globalThis.ai.fetchSTT(file,signal);
+        const activeRole=providerRuntime.status('stt');
+        const operationId=activeRole.busy&&activeRole.operationId!==previousOperationId
+            ?activeRole.operationId:null;
+        transcriptionRuntimeOperationId=operationId;
+        try{
+            return await pending;
+        }finally{
+            if(transcriptionRuntimeOperationId===operationId)transcriptionRuntimeOperationId=null;
+        }
     }
 
     function isTranscriptionCancellation(error,controller){
@@ -1417,6 +1428,9 @@
     function synchronizeAIRuntimeState(snapshot){
         const previousRole=sttRole;
         sttRole=snapshot.roles.stt;
+        const continuingTranscription=continuesAIRuntimeOperation(
+            previousRole,sttRole,transcriptionRuntimeOperationId
+        );
         if(sttRole.state==='error'&&previousRole.state!=='error'){
             arcaneLogging.error('Arcane transcription runtime failed.',sttRole.error);
         }
@@ -1438,6 +1452,7 @@
                 return;
             }
             if(session.processing==='transcribing'
+                &&!continuingTranscription
                 &&(sttRole.state!=='ready'
                     ||previousRole.providerId!==sttRole.providerId
                     ||previousRole.modelId!==sttRole.modelId)){
@@ -1447,7 +1462,8 @@
             renderContinuousState(session);
             return;
         }
-        if(previousRole.state==='ready'&&sttRole.state!=='ready'){
+        if(['ready','recovering'].includes(previousRole.state)
+            &&sttRole.state!=='ready'&&!continuingTranscription){
             if(cancelSTTOperation('runtime-unready')){
                 return;
             }

package/runtime/arcane/modules/AI.js

@@ -15,7 +15,7 @@ import {
     AI_PROVIDER_PROTOCOL,
     getAIProviderRuntime
 } from './AIProviderRuntime.js';
-import {normalizeOllamaModelIdentifier} from './OllamaModelIdentifier.js';
+import {normalizeOllamaModelIdentifier,sameOllamaModelIdentifier} from './OllamaModelIdentifier.js';
 import {arcaneLogging} from 'arcane-os/logging';
 import {
     fetchHTTPResponse,
@@ -1371,11 +1371,115 @@ class AI {
         const localOnly=providerId==='OLLAMA';
         let state='unloaded';
         let busy=false;
+        let nativeWatch=null;
+
+        function nativeOllamaReady(){
+            if(!nativeWatch
+                ||nativeWatch.ollama!==runtime.#nativeOllama()
+                ||nativeWatch.modelId!==runtime.model
+                ||nativeWatch.error){
+                return false;
+            }
+            const snapshot=nativeWatch.snapshot;
+            return snapshot?.available===true
+                &&(snapshot.models??[]).some(function selectedResident(model){
+                    return sameOllamaModelIdentifier(model.id??model.model??model.name,nativeWatch.modelId)
+                        &&model.loaded===true;
+                });
+        }
+
+        function stopNativeOllamaWatch(){
+            const previous=nativeWatch;
+            nativeWatch=null;
+            previous?.unsubscribe?.();
+            return previous;
+        }
+
+        function observeNativeOllama(watch,snapshot,error=null){
+            if(nativeWatch!==watch){
+                return;
+            }
+            watch.snapshot=snapshot;
+            watch.error=error;
+            if(state==='ready'&&!nativeOllamaReady()){
+                state='unloaded';
+                runtime.#retainBuiltInLLMReadiness(
+                    runtime.#reconcileBuiltInLLMReadiness()
+                );
+            }
+        }
+
+        async function inspectNativeOllama(watch,signal){
+            if(signal?.aborted){
+                throw normalizeAIRequestAbort(signal.reason);
+            }
+            const revision=watch.revision;
+            try{
+                const running=await watch.ollama.running({signal});
+                if(signal?.aborted){
+                    throw normalizeAIRequestAbort(signal.reason);
+                }
+                if(nativeWatch===watch&&watch.revision===revision){
+                    observeNativeOllama(watch,{
+                        available:true,
+                        models:(running.models??[]).map(function residentModel(model){
+                            return {...model,loaded:true};
+                        })
+                    });
+                }
+            }catch(error){
+                if(!signal?.aborted&&watch.revision===revision){
+                    observeNativeOllama(watch,null,error);
+                }
+                throw error;
+            }
+            if(nativeWatch!==watch||!nativeOllamaReady()){
+                throw watch.error??aiProviderError(
+                    'The selected Ollama model is not loaded.',
+                    'ARCANE_AI_ROLE_NOT_READY'
+                );
+            }
+        }
+
+        async function loadNativeOllama(context){
+            stopNativeOllamaWatch();
+            const ollama=runtime.#nativeOllama();
+            if(!is.function(ollama?.generate)||!is.function(ollama?.running)){
+                throw aiProviderError(
+                    'The native Ollama API does not expose model loading and resident status.',
+                    'AI_NATIVE_LOCAL_REQUIRED'
+                );
+            }
+            const watch={
+                ollama,modelId:context.selection.modelId,
+                snapshot:null,error:null,revision:0,unsubscribe:null
+            };
+            nativeWatch=watch;
+            if(is.function(globalThis.Arcane?.events?.on)){
+                watch.unsubscribe=globalThis.Arcane.events.on(
+                    'localai.state',
+                    function observeNativeOllamaState(snapshot){
+                        watch.revision+=1;
+                        const engine=snapshot.ollama??snapshot.runtimes?.find(function ollamaEngine(record){
+                            return record.id==='ollama';
+                        });
+                        observeNativeOllama(watch,engine??null,engine?.error??null);
+                    }
+                );
+            }
+            // Empty generation is Ollama's public preload operation. Residency
+            // is established separately; a successful response alone is insufficient.
+            await ollama.generate(
+                {model:watch.modelId,prompt:'',stream:false},
+                {signal:context.signal}
+            );
+            await inspectNativeOllama(watch,context.signal);
+        }
 
         function statusBuiltInLLMProvider(){
             if(state==='ready'
-                &&!busy
-                &&!runtime.#builtInLLMCapability(providerId)){
+                &&((localOnly&&!nativeOllamaReady())
+                    ||(!busy&&!runtime.#builtInLLMCapability(providerId)))){
                 state='unloaded';
             }
             return completeValue({
@@ -1423,7 +1527,7 @@ class AI {
                 return runtime.#builtInLLMInspection(providerId,selection);
             },
             status:statusBuiltInLLMProvider,
-            load:function loadBuiltInLLMProvider(context={}){
+            load:async function loadBuiltInLLMProvider(context={}){
                 if(context.signal?.aborted){
                     throw normalizeAIRequestAbort(context.signal.reason);
                 }
@@ -1447,7 +1551,7 @@ class AI {
                 const inspection=assertBuiltInLLMSelection(context.selection);
                 state='loading';
                 context.progress({
-                    phase:'capability',
+                    phase:localOnly?'loading':'capability',
                     completed:0,
                     total:1,
                     unit:'items',
@@ -1457,9 +1561,18 @@ class AI {
                     state='unloaded';
                     throw normalizeAIRequestAbort(context.signal.reason);
                 }
+                if(localOnly){
+                    try{
+                        await loadNativeOllama(context);
+                    }catch(error){
+                        state='unloaded';
+                        stopNativeOllamaWatch();
+                        throw error;
+                    }
+                }
                 state='ready';
                 context.progress({
-                    phase:'capability',
+                    phase:localOnly?'loading':'capability',
                     completed:1,
                     total:1,
                     unit:'items',
@@ -1489,24 +1602,39 @@ class AI {
                     );
                 }
                 busy=true;
+                const watch=nativeWatch;
                 if(context.operation==='chat'){
-                    return Promise.resolve(
-                        runtime.#requestBuiltInLLMChat(
+                    return (async function requestLoadedBuiltInLLM(){
+                        if(localOnly){
+                            await inspectNativeOllama(watch,context.signal);
+                        }
+                        const result=await runtime.#requestBuiltInLLMChat(
                             context.payload,
                             context.signal,
                             controls.onRetry
-                        )
-                    ).finally(releaseBuiltInLLMRequest);
+                        );
+                        if(localOnly){
+                            await inspectNativeOllama(watch,context.signal);
+                        }
+                        return result;
+                    })().finally(releaseBuiltInLLMRequest);
                 }
                 if(context.operation==='stream'){
                     const handle=createBuiltInAIStreamBridge(
-                        function executeBuiltInLLMProviderStream(bridge){
-                            return runtime.#requestBuiltInLLMStream(
+                        async function executeBuiltInLLMProviderStream(bridge){
+                            if(localOnly){
+                                await inspectNativeOllama(watch,bridge.signal);
+                            }
+                            const result=await runtime.#requestBuiltInLLMStream(
                                 context.payload,
                                 bridge,
                                 controls.observeToolText,
                                 controls.onRetry
                             );
+                            if(localOnly){
+                                await inspectNativeOllama(watch,bridge.signal);
+                            }
+                            return result;
                         },
                         context.signal
                     );
@@ -1522,18 +1650,27 @@ class AI {
                     'ARCANE_AI_PROVIDER_RUNTIME_INVALID'
                 );
             },
-            unload:function unloadBuiltInLLMProvider(context={}){
+            unload:async function unloadBuiltInLLMProvider(context={}){
                 if(context.signal?.aborted){
                     throw normalizeAIRequestAbort(context.signal.reason);
                 }
+                const watch=stopNativeOllamaWatch();
+                const release=localOnly&&state==='ready';
                 state='unloaded';
                 busy=false;
+                if(release&&watch){
+                    await watch.ollama.generate(
+                        {model:watch.modelId,prompt:'',keep_alive:0,stream:false},
+                        {signal:context.signal}
+                    );
+                }
                 return statusBuiltInLLMProvider();
             },
             dispose:function disposeBuiltInLLMProvider(context={}){
                 if(context.signal?.aborted){
                     throw normalizeAIRequestAbort(context.signal.reason);
                 }
+                stopNativeOllamaWatch();
                 state='disposed';
                 busy=false;
                 return statusBuiltInLLMProvider();
@@ -1615,17 +1752,205 @@ class AI {
         const expectedOperation=role==='stt'?'transcribe':'synthesize';
         let state='unloaded';
         let busy=false;
+        let nativeWatch=null;
+        let nativeRequest=null;
+
+        function continuingNativeSpeechRequest(){
+            const selected=nativeWatch?.snapshot?.roles?.[role];
+            return role==='stt'&&busy&&nativeRequest?.requestId
+                &&nativeRequest.watch===nativeWatch&&!nativeRequest.signal?.aborted
+                &&nativeWatch.speech===runtime.#nativeSpeech(providerId,role)
+                &&nativeWatch.modelId===runtime.#builtInSpeechModel(role)
+                &&nativeWatch.snapshot.status==='ok'&&!nativeWatch.snapshot.closed
+                &&selected?.modelId===nativeWatch.modelId
+                &&selected.providerId===nativeWatch.engineId
+                &&selected.requestId===nativeRequest.requestId
+                &&selected.loaded===false
+                &&((selected.state==='recovering'&&selected.busy===true)
+                    ||selected.state==='error');
+        }
+
+        function nativeSpeechReady(){
+            if(!nativeWatch
+                ||nativeWatch.speech!==runtime.#nativeSpeech(providerId,role)
+                ||nativeWatch.modelId!==runtime.#builtInSpeechModel(role)){
+                return false;
+            }
+            const snapshot=nativeWatch.snapshot;
+            const selected=snapshot?.roles?.[role];
+            if(selected){
+                return selected.modelId===nativeWatch.modelId
+                    &&selected.providerId===nativeWatch.engineId
+                    &&selected.loaded===true
+                    &&selected.available===true
+                    &&['ready','running'].includes(selected.state);
+            }
+            // Older fixed-model hosts expose independent health, not engine lifecycle.
+            return snapshot?.status==='ok'
+                &&nativeWatch.modelId===(role==='stt'?'whisper-small':'kokoro')
+                &&snapshot[role==='stt'?'sttEngine':'ttsEngine']
+                    ===(role==='stt'?'whisper.cpp':'kokoro-onnx')
+                &&snapshot[role==='stt'?'transcriptionAvailable':'synthesisAvailable']===true;
+        }
+
+        function nativeSpeechReadinessError(){
+            const snapshot=nativeWatch?.snapshot;
+            if(nativeWatch?.error){
+                return nativeWatch.error;
+            }
+            if(!snapshot){
+                return aiProviderError(
+                    'The native speech API returned no readiness status.',
+                    'AI_NATIVE_LOCAL_REQUIRED'
+                );
+            }
+            const selected=snapshot.roles?.[role];
+            if(selected?.modelId&&selected.modelId!==nativeWatch.modelId){
+                return aiProviderError(
+                    `The native ${role.toUpperCase()} model differs from the selected AI model.`,
+                    'ARCANE_AI_MODEL_AUTHORITY_REQUIRED'
+                );
+            }
+            if(selected?.providerId&&selected.providerId!==nativeWatch.engineId){
+                return aiProviderError(
+                    `The native ${role.toUpperCase()} engine was replaced.`,
+                    'ARCANE_AI_MODEL_AUTHORITY_REQUIRED'
+                );
+            }
+            if(snapshot.closed===true
+                ||['closing','closed'].includes(snapshot.status)
+                ||['error','unavailable','closed','disposed'].includes(selected?.state)
+                ||(!selected&&!nativeSpeechReady())){
+                return aiProviderError(
+                    `The native ${role.toUpperCase()} model is not ready.`,
+                    'ARCANE_AI_ROLE_NOT_READY',
+                    selected?.error
+                );
+            }
+            return null;
+        }
+
+        function stopNativeSpeechWatch(){
+            const previous=nativeWatch;
+            nativeWatch=null;
+            previous?.unsubscribe?.();
+        }
+
+        function waitForNativeSpeech(context){
+            stopNativeSpeechWatch();
+            const watch={
+                speech:runtime.#nativeSpeech(providerId,role),
+                modelId:context.selection.modelId,
+                engineId:null,
+                snapshot:null,
+                error:null,
+                revision:0,
+                unsubscribe:null
+            };
+            nativeWatch=watch;
+            return new Promise(function waitForNativeSpeechState(resolve,reject){
+                let settled=false;
+                function finish(error){
+                    if(settled){
+                        return;
+                    }
+                    settled=true;
+                    context.signal?.removeEventListener('abort',cancel);
+                    if(error){
+                        reject(error);
+                    }else{
+                        resolve();
+                    }
+                }
+                function cancel(){
+                    finish(normalizeAIRequestAbort(context.signal.reason));
+                }
+                function reportObservationFailure(error){
+                    finish(error);
+                    arcaneLogging.error('Native speech readiness observation failed.',error);
+                }
+                function observe(snapshot,error=null){
+                    if(nativeWatch!==watch){
+                        return;
+                    }
+                    watch.snapshot=snapshot;
+                    watch.error=error;
+                    watch.engineId??=snapshot?.roles?.[role]?.providerId??null;
+                    if(context.signal?.aborted&&!settled){
+                        cancel();
+                    }else if(nativeSpeechReady()){
+                        finish();
+                        nativeRequest?.refreshState?.();
+                    }else if(continuingNativeSpeechRequest()){
+                        nativeRequest.refreshState?.();
+                    }else{
+                        const failure=nativeSpeechReadinessError();
+                        if(failure){
+                            finish(failure);
+                        }
+                        if(state==='ready'){
+                            state='unloaded';
+                            runtime.#retainBuiltInSpeechReadiness(
+                                runtime.#reconcileBuiltInSpeechReadiness()
+                            );
+                        }
+                    }
+                }
+                context.signal?.addEventListener('abort',cancel,{once:true});
+                try{
+                    if(context.signal?.aborted){
+                        cancel();
+                        return;
+                    }
+                    if(!is.function(watch.speech?.status)){
+                        throw aiProviderError(
+                            'The native speech API does not expose readiness status.',
+                            'AI_NATIVE_LOCAL_REQUIRED'
+                        );
+                    }
+                    if(is.function(globalThis.Arcane?.events?.on)){
+                        watch.unsubscribe=globalThis.Arcane.events.on(
+                            'speech.state',
+                            function observeNativeSpeechState(snapshot){
+                                watch.revision+=1;
+                                try{
+                                    observe(snapshot);
+                                }catch(error){
+                                    reportObservationFailure(error);
+                                }
+                            }
+                        );
+                    }
+                    const revision=watch.revision;
+                    Promise.resolve(watch.speech.status()).then(
+                        function receiveNativeSpeechStatus(snapshot){
+                            if(watch.revision===revision){
+                                observe(snapshot);
+                            }
+                        },
+                        function rejectNativeSpeechStatus(error){
+                            if(watch.revision===revision){
+                                observe(null,error);
+                            }
+                        }
+                    ).catch(reportObservationFailure);
+                }catch(error){
+                    finish(error);
+                }
+            });
+        }
 
         function statusBuiltInSpeechProvider(){
-            if(state==='ready'
-                &&!busy
-                &&!runtime.#builtInSpeechCapability(role,providerId)){
-                state='unloaded';
-            }
+            const requestPending=Boolean(continuingNativeSpeechRequest());
+            const selected=nativeWatch?.snapshot?.roles?.[role];
+            const current=state==='ready'&&!nativeSpeechReady()
+                ?requestPending?selected.state:'unloaded':state;
             return completeValue({
-                state,
-                loaded:state==='ready',
-                busy
+                state:current,
+                loaded:current==='ready',
+                busy,
+                requestPending,
+                ...(current==='error'?{error:selected.error}:{})
             });
         }
 
@@ -1646,6 +1971,11 @@ class AI {
 
         function releaseBuiltInSpeechRequest(){
             busy=false;
+            nativeRequest=null;
+            if(state==='ready'&&!nativeSpeechReady()){
+                state='unloaded';
+                stopNativeSpeechWatch();
+            }
         }
 
         return completeValue({
@@ -1676,7 +2006,7 @@ class AI {
                 return runtime.#builtInSpeechInspection(role,providerId,selection);
             },
             status:statusBuiltInSpeechProvider,
-            load:function loadBuiltInSpeechProvider(context={}){
+            load:async function loadBuiltInSpeechProvider(context={}){
                 if(context.signal?.aborted){
                     throw normalizeAIRequestAbort(context.signal.reason);
                 }
@@ -1706,22 +2036,35 @@ class AI {
                     unit:'items',
                     heartbeat:false
                 });
-                if(context.signal?.aborted){
+                try{
+                    await waitForNativeSpeech(context);
+                    if(context.signal?.aborted){
+                        throw normalizeAIRequestAbort(context.signal.reason);
+                    }
+                    assertBuiltInSpeechSelection(context.selection);
+                    if(!nativeSpeechReady()){
+                        throw nativeSpeechReadinessError()??aiProviderError(
+                            `The native ${role.toUpperCase()} model lost readiness.`,
+                            'ARCANE_AI_ROLE_NOT_READY'
+                        );
+                    }
+                    state='ready';
+                    context.progress({
+                        phase:'capability',
+                        completed:1,
+                        total:1,
+                        unit:'items',
+                        heartbeat:false
+                    });
+                    return completeValue({
+                        authority:inspection.authority,
+                        status:statusBuiltInSpeechProvider()
+                    });
+                }catch(error){
                     state='unloaded';
-                    throw normalizeAIRequestAbort(context.signal.reason);
+                    stopNativeSpeechWatch();
+                    throw error;
                 }
-                state='ready';
-                context.progress({
-                    phase:'capability',
-                    completed:1,
-                    total:1,
-                    unit:'items',
-                    heartbeat:false
-                });
-                return completeValue({
-                    authority:inspection.authority,
-                    status:statusBuiltInSpeechProvider()
-                });
             },
             request:function requestBuiltInSpeechProvider(context={}){
                 if(context.signal?.aborted){
@@ -1748,10 +2091,18 @@ class AI {
                     );
                 }
                 busy=true;
+                const operation=role==='stt'?{
+                    requestId:null,watch:nativeWatch,signal:context.signal,
+                    refreshState:context.refreshState
+                }:null;
+                nativeRequest=operation;
                 const request=role==='stt'
                     ?runtime.#requestBuiltInSpeechTranscription(
                         context.payload,
-                        context.signal
+                        context.signal,
+                        function ownNativeSpeechRequest({requestId}){
+                            if(nativeRequest===operation)operation.requestId=requestId;
+                        }
                     )
                     :runtime.#requestBuiltInSpeechSynthesis(
                         context.payload,
@@ -1770,6 +2121,7 @@ class AI {
                     );
                 }
                 state='unloaded';
+                stopNativeSpeechWatch();
                 return statusBuiltInSpeechProvider();
             },
             dispose:function disposeBuiltInSpeechProvider(context={}){
@@ -1783,6 +2135,7 @@ class AI {
                     );
                 }
                 state='disposed';
+                stopNativeSpeechWatch();
                 return statusBuiltInSpeechProvider();
             }
         });
@@ -1837,6 +2190,7 @@ class AI {
                 continue;
             }
             if(record.unregister()){
+                record.provider.dispose();
                 this.#builtInSpeechProviders.delete(key);
             }
         }
@@ -1893,6 +2247,12 @@ class AI {
             return Promise.resolve(this.#providerRuntime.status('llm'));
         }
         const status=this.#providerRuntime.status('llm');
+        const provider=this.#builtInLLMProviders.get(selection.providerId)?.provider;
+        if(selection.providerId==='OLLAMA'
+            &&provider?.status().loaded!==true
+            &&(status.loaded===true||status.busy===true)){
+            return this.#providerRuntime.unload('llm');
+        }
         if(this.#builtInLLMCapability(selection.providerId)){
             if(status.state==='ready'&&status.loaded===true){
                 return Promise.resolve(status);
@@ -1916,7 +2276,13 @@ class AI {
                 return runtime.#providerRuntime.status(role);
             }
             const status=runtime.#providerRuntime.status(role);
-            if(runtime.#builtInSpeechCapability(role,selection.providerId)){
+            const record=runtime.#builtInSpeechProviders.get(
+                runtime.#builtInSpeechProviderKey(role,selection.providerId)
+            );
+            const providerStatus=record?.provider.status();
+            if(runtime.#builtInSpeechCapability(role,selection.providerId)
+                &&(!(status.loaded===true||status.busy===true)
+                    ||providerStatus?.loaded===true||providerStatus?.requestPending===true)){
                 return status;
             }
             if(status.loaded===true
@@ -4068,7 +4434,7 @@ class AI {
         return null;
     }
 
-    async #requestBuiltInSpeechTranscription(payload={},signal=null){
+    async #requestBuiltInSpeechTranscription(payload={},signal=null,onRequest=undefined){
         const audio=payload?.audio;
         if(!audio||!is.function(audio.arrayBuffer)){
             throw new TypeError('Speech transcription requires an audio Blob or File.');
@@ -4090,7 +4456,7 @@ class AI {
                     audioBase64:this.#arrayBufferToBase64(audioBytes),
                     mimeType,
                     model
-                },{signal});
+                },{signal,onRequest});
             }catch(error){
                 if(isAIRequestAbort(error,signal)){
                     throw normalizeAIRequestAbort(error);