arcane-os 0.62.0 → 0.64.0

package/runtime/arcane/modules/AI.js

@@ -1615,17 +1615,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 +1834,11 @@ class AI {
 
         function releaseBuiltInSpeechRequest(){
             busy=false;
+            nativeRequest=null;
+            if(state==='ready'&&!nativeSpeechReady()){
+                state='unloaded';
+                stopNativeSpeechWatch();
+            }
         }
 
         return completeValue({
@@ -1676,7 +1869,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 +1899,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 +1954,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 +1984,7 @@ class AI {
                     );
                 }
                 state='unloaded';
+                stopNativeSpeechWatch();
                 return statusBuiltInSpeechProvider();
             },
             dispose:function disposeBuiltInSpeechProvider(context={}){
@@ -1783,6 +1998,7 @@ class AI {
                     );
                 }
                 state='disposed';
+                stopNativeSpeechWatch();
                 return statusBuiltInSpeechProvider();
             }
         });
@@ -1837,6 +2053,7 @@ class AI {
                 continue;
             }
             if(record.unregister()){
+                record.provider.dispose();
                 this.#builtInSpeechProviders.delete(key);
             }
         }
@@ -1916,7 +2133,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 +4291,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 +4313,7 @@ class AI {
                     audioBase64:this.#arrayBufferToBase64(audioBytes),
                     mimeType,
                     model
-                },{signal});
+                },{signal,onRequest});
             }catch(error){
                 if(isAIRequestAbort(error,signal)){
                     throw normalizeAIRequestAbort(error);

package/runtime/arcane/modules/AIProviderRuntime.js

@@ -4037,6 +4037,15 @@ export class AIProviderRuntime {
                     payload: options.payload,
                     signal: controller.signal
                 };
+                if (role === 'stt') {
+                    providerRequest.refreshState = function refreshActiveProviderState() {
+                        if (slot.generation === generation && !slot.unloadPromise
+                            && !slot.disposePromise && !controller.signal.aborted
+                            && slot.activeRequests.get(requestSequence) === requestRecord) {
+                            runtime.#publishRoleRequestState(slot);
+                        }
+                    };
+                }
                 if (SPEECH_ROLES.includes(role)) {
                     arcaneLogging.debug('[Arcane speech runtime] provider.request', {generation, requestSequence, operationId}, providerRequest);
                 }
@@ -4579,16 +4588,24 @@ export class AIProviderRuntime {
         if (!requestRecord && slot.requestQueue.length === 0) {
             return false;
         }
+        const provider = this.#providerFor(slot);
+        const providerState = slot.role === 'stt' && provider
+            ? validateProviderStatus(provider.status()) : null;
+        const pendingRecovery = requestRecord && providerState?.loaded === false
+            && ['recovering', 'error'].includes(providerState.state);
         publishAIRuntimeRoleState(
             slot.role,
             roleRecord(
                 slot.role,
                 slot.selection,
                 {
-                    state: 'ready',
-                    loaded: true,
+                    state: pendingRecovery ? providerState.state : 'ready',
+                    loaded: !pendingRecovery,
                     busy: true,
-                    operationId: requestRecord?.operationId ?? null
+                    operationId: requestRecord?.operationId ?? null,
+                    ...(pendingRecovery && providerState.state === 'error'
+                        ? {error: stateError(providerState.error, 'ARCANE_AI_PROVIDER_REQUEST_FAILED')}
+                        : {})
                 }
             )
         );

package/runtime/arcane/modules/AIRuntimeState.js

@@ -21,12 +21,22 @@ export const AI_RUNTIME_STATES = completeValue([
     'unavailable',
     'unloaded',
     'loading',
+    'recovering',
     'ready',
     'unloading',
     'error',
     'disposed'
 ]);
 
+/** Keep only an already-owned operation through its truthful recovery/error state. */
+export function continuesAIRuntimeOperation(previous, current, operationId) {
+    return is.string(operationId) && operationId.length > 0
+        && previous?.operationId === operationId && current?.operationId === operationId
+        && previous.providerId === current.providerId && previous.modelId === current.modelId
+        && current.loaded === false && current.busy === true
+        && ['recovering', 'error'].includes(current.state);
+}
+
 const ROLE_KEYS = completeValue([
     'role',
     'state',
@@ -77,6 +87,7 @@ const MUST_BE_UNLOADED = new Set([
     'unavailable',
     'unloaded',
     'loading',
+    'recovering',
     'disposed'
 ]);
 const STARTUP_TERMINAL_STATES = new Set([
@@ -291,8 +302,10 @@ function copyRoleRecord(role, record) {
         && (record.providerId === null || record.modelId === null)) {
         fail('a loaded role must identify its provider and model.');
     }
-    if (record.busy && (record.state !== 'ready' || !record.loaded)) {
-        fail('a busy role must be ready and loaded.');
+    const pendingRecovery = ['recovering', 'error'].includes(record.state)
+        && record.operationId !== null;
+    if (record.busy && !pendingRecovery && (record.state !== 'ready' || !record.loaded)) {
+        fail('a busy role must be ready and loaded or retain its recovering/error operation.');
     }
     if (record.state === 'error' && error === null) {
         fail('an error role state must include error details.');

package/runtime/arcane/modules/ComponentContracts.js

@@ -607,6 +607,9 @@ function createSTTActivationController({
         if(role?.state==='loading'){
             return `Transcription ${formatAIRuntimeProgress(role.progress,'loading')}; Cancel is available.`;
         }
+        if(role?.state==='recovering'){
+            return 'Transcription is recovering the current request.';
+        }
         if(role?.state==='unloading'){
             return `Transcription ${formatAIRuntimeProgress(role.progress,'releasing')}.`;
         }

package/schemas/arcane-app.schema.json

@@ -262,7 +262,7 @@
           "type": "array",
           "items": {
             "oneOf": [
-              { "enum": ["llama.cpp", "ollama", "onnx", "stable-diffusion.cpp"] },
+              { "enum": ["llama.cpp", "ollama", "onnx", "stable-diffusion.cpp", "whisper.cpp"] },
               {
                 "type": "object",
                 "required": ["id"],
@@ -271,7 +271,8 @@
                   "version": { "type": "string" },
                   "url": { "type": "string" }
                 }
-              }
+              },
+              { "$ref": "#/$defs/whisperRuntime" }
             ]
           }
         },
@@ -294,6 +295,56 @@
         }
       }
     },
+    "whisperRuntime": {
+      "type": "object",
+      "required": ["id"],
+      "description": "Native Whisper transcription. Models are explicitly selected; describing a runtime acquires nothing. Automatic Windows x64 preparation selects intact CUDA and CPU distributions, an SDK helper, and FFmpeg. Other hosts supply their selected complete runtime and decoder trees.",
+      "properties": {
+        "id": { "const": "whisper.cpp" },
+        "version": { "type": "string", "default": "1.9.4" },
+        "backend": { "enum": ["auto", "cuda", "metal", "cpu"], "default": "auto" },
+        "helperRoot": { "type": "string", "description": "Complete helper directory copied into the native runtime, including its app-local libraries. Defaults to the directory containing helperExecutable." },
+        "helperExecutable": { "type": "string" },
+        "helperUrl": { "type": "string" },
+        "helperVersion": { "type": "string" },
+        "decoderRoot": { "type": "string" },
+        "decoderExecutable": { "type": "string" },
+        "decoderUrl": { "type": "string" },
+        "modelId": { "type": "string" },
+        "variants": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "required": ["backend"],
+            "properties": {
+              "backend": { "enum": ["cuda", "metal", "cpu"] },
+              "root": { "type": "string" },
+              "url": { "type": "string" },
+              "libraryDirectory": { "type": "string" }
+            }
+          }
+        },
+        "models": {
+          "type": "array",
+          "default": [],
+          "items": {
+            "oneOf": [
+              { "const": "whisper-small" },
+              {
+                "type": "object",
+                "required": ["id"],
+                "properties": {
+                  "id": { "type": "string" },
+                  "path": { "type": "string" },
+                  "url": { "type": "string" },
+                  "filename": { "type": "string" }
+                }
+              }
+            ]
+          }
+        }
+      }
+    },
     "pwa": {
       "type": "object",
       "additionalProperties": false,

package/schemas/arcane-package.schema.json

@@ -156,7 +156,7 @@
           "type": "array",
           "items": {
             "oneOf": [
-              { "enum": ["llama.cpp", "ollama", "onnx", "stable-diffusion.cpp"] },
+              { "enum": ["llama.cpp", "ollama", "onnx", "stable-diffusion.cpp", "whisper.cpp"] },
               {
                 "type": "object",
                 "required": ["id"],
@@ -165,7 +165,8 @@
                   "version": { "type": "string" },
                   "url": { "type": "string" }
                 }
-              }
+              },
+              { "$ref": "#/$defs/whisperRuntime" }
             ]
           }
         },
@@ -188,6 +189,56 @@
         }
       }
     },
+    "whisperRuntime": {
+      "type": "object",
+      "required": ["id"],
+      "description": "Native Whisper transcription. Models are explicitly selected; describing a runtime acquires nothing. Automatic Windows x64 preparation selects intact CUDA and CPU distributions, an SDK helper, and FFmpeg. Other hosts supply their selected complete runtime and decoder trees.",
+      "properties": {
+        "id": { "const": "whisper.cpp" },
+        "version": { "type": "string", "default": "1.9.4" },
+        "backend": { "enum": ["auto", "cuda", "metal", "cpu"], "default": "auto" },
+        "helperRoot": { "type": "string", "description": "Complete helper directory copied into the native runtime, including its app-local libraries. Defaults to the directory containing helperExecutable." },
+        "helperExecutable": { "type": "string" },
+        "helperUrl": { "type": "string" },
+        "helperVersion": { "type": "string" },
+        "decoderRoot": { "type": "string" },
+        "decoderExecutable": { "type": "string" },
+        "decoderUrl": { "type": "string" },
+        "modelId": { "type": "string" },
+        "variants": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "required": ["backend"],
+            "properties": {
+              "backend": { "enum": ["cuda", "metal", "cpu"] },
+              "root": { "type": "string" },
+              "url": { "type": "string" },
+              "libraryDirectory": { "type": "string" }
+            }
+          }
+        },
+        "models": {
+          "type": "array",
+          "default": [],
+          "items": {
+            "oneOf": [
+              { "const": "whisper-small" },
+              {
+                "type": "object",
+                "required": ["id"],
+                "properties": {
+                  "id": { "type": "string" },
+                  "path": { "type": "string" },
+                  "url": { "type": "string" },
+                  "filename": { "type": "string" }
+                }
+              }
+            ]
+          }
+        }
+      }
+    },
     "pwa": {
       "type": "object",
       "additionalProperties": false,