arcane-os 0.5.7 → 0.5.9

package/runtime/arcane/modules/AIPreferenceTuple.js

@@ -34,7 +34,7 @@ function allowedTokensForSlot(allowedValues,index){
 /**
  * Normalizes the shared six-slot AI preference contract without choosing any
  * provider or model policy. Applications supply their own defaults, allowed
- * values, and legacy aliases.
+ * values, and provider aliases.
  *
  * Slot order:
  * [LLM provider, STT provider, TTS provider, LLM model, TTS model, STT model]

package/runtime/arcane/modules/AIProviderRuntime.js

@@ -1336,6 +1336,16 @@ function validateProvider(provider) {
     if (typeof provider.localOnly !== 'boolean') {
         fail('AI provider.localOnly must be a boolean.');
     }
+    const maxConcurrentRequests = provider.maxConcurrentRequests === undefined
+        ? 1
+        : provider.maxConcurrentRequests;
+    if (!Number.isSafeInteger(maxConcurrentRequests)
+        || maxConcurrentRequests < 1) {
+        fail('AI provider.maxConcurrentRequests must be a positive safe integer.');
+    }
+    if (provider.role !== 'tts' && maxConcurrentRequests !== 1) {
+        fail('Only TTS providers may process more than one concurrent request.');
+    }
     for (const method of PROVIDER_METHODS) {
         if (typeof provider[method] !== 'function') {
             fail(`AI provider.${method} must be a function.`);
@@ -1345,7 +1355,8 @@ function validateProvider(provider) {
         protocol: AI_PROVIDER_PROTOCOL,
         role: provider.role,
         id: provider.id,
-        localOnly: provider.localOnly
+        localOnly: provider.localOnly,
+        maxConcurrentRequests
     };
     for (const method of PROVIDER_METHODS) {
         record[method] = provider[method].bind(provider);
@@ -1650,7 +1661,7 @@ function createRoleSlot(role) {
         unloadPromise: null,
         disposePromise: null,
         requestQueue: [],
-        request: null,
+        activeRequests: new Map(),
         disposed: false,
         ready: false
     };
@@ -2591,7 +2602,7 @@ export class AIProviderRuntime {
                 )
             );
         }
-        if (slot.request || slot.requestQueue.length) {
+        if (slot.activeRequests.size || slot.requestQueue.length) {
             return Promise.reject(
                 operationError(
                     `AI role ${role} cannot load during active request ownership.`,
@@ -2831,10 +2842,11 @@ export class AIProviderRuntime {
             return Promise.resolve(before);
         }
         const providerOwned = slot.ready
+            || slot.activeRequests.size > 0
             || providerStatus?.loaded === true
             || providerStatus?.busy === true;
         if (!slot.loadPromise
-            && !slot.request
+            && slot.activeRequests.size === 0
             && slot.requestQueue.length === 0
             && !providerOwned
             && (!provider || providerStatus)) {
@@ -2858,10 +2870,16 @@ export class AIProviderRuntime {
             'ARCANE_AI_REQUEST_ABORTED'
         );
         this.#rejectQueuedRoleRequests(slot, requestCancellation);
-        slot.request?.controller.abort(requestCancellation);
+        const capturedRequestRecords = [...slot.activeRequests.values()];
+        for (const requestRecord of capturedRequestRecords) {
+            requestRecord.controller.abort(requestCancellation);
+        }
         const capturedLoad = slot.loadPromise;
-        const capturedRequestRecord = slot.request;
-        const capturedRequest = capturedRequestRecord?.promise ?? null;
+        const capturedRequests = capturedRequestRecords.map(
+            function selectAIProviderRequestPromise(requestRecord) {
+                return requestRecord.promise;
+            }
+        ).filter(Boolean);
         const unloadOperationId = providerOwned
             ? this.#nextOperationId(slot, 'unload')
             : null;
@@ -2871,15 +2889,22 @@ export class AIProviderRuntime {
                 if (signal?.aborted) {
                     throw normalizedAbort();
                 }
-                if (capturedRequestRecord?.cancel) {
-                    try {
-                        await capturedRequestRecord.cancel(requestCancellation);
-                    } catch {
-                        // Provider unload below remains the authoritative cleanup.
-                    }
-                }
                 await Promise.allSettled(
-                    [capturedLoad, capturedRequest].filter(Boolean)
+                    capturedRequestRecords.map(
+                        function cancelActiveAIProviderRequest(requestRecord) {
+                            if (!requestRecord.cancel) {
+                                return undefined;
+                            }
+                            return Promise.resolve().then(
+                                function invokeActiveAIProviderRequestCancellation() {
+                                    return requestRecord.cancel(requestCancellation);
+                                }
+                            );
+                        }
+                    )
+                );
+                await Promise.allSettled(
+                    [capturedLoad, ...capturedRequests].filter(Boolean)
                 );
                 if (signal?.aborted) {
                     throw normalizedAbort();
@@ -2926,6 +2951,7 @@ export class AIProviderRuntime {
                     {
                         state: 'unloading',
                         loaded: true,
+                        busy: capturedRequestRecords.length > 0,
                         operationId: unloadOperationId
                     }
                 )
@@ -3105,7 +3131,7 @@ export class AIProviderRuntime {
                 slot.unloadPromise = null;
                 slot.disposePromise = null;
                 slot.requestQueue = [];
-                slot.request = null;
+                slot.activeRequests.clear();
                 slot.ready = false;
                 slot.disposed = true;
             }
@@ -3136,6 +3162,10 @@ export class AIProviderRuntime {
     }
 
     request(role, options = {}) {
+        return this.#requestRole(role, options, false);
+    }
+
+    #requestRole(role, options, queued) {
         this.#assertOpen();
         this.#assertNotConfiguring();
         assertRole(role);
@@ -3234,13 +3264,16 @@ export class AIProviderRuntime {
                 )
             );
         }
-        if (slot.request) {
+        const maxConcurrentRequests = this.#providerRequestCapacity(provider);
+        if ((!queued && slot.requestQueue.length)
+            || slot.activeRequests.size >= maxConcurrentRequests) {
             return this.#enqueueRoleRequest(slot, options);
         }
         if (!slot.ready
             || providerStatus.state !== 'ready'
             || providerStatus.loaded !== true
-            || providerStatus.busy !== false) {
+            || (providerStatus.busy !== false
+                && slot.activeRequests.size === 0)) {
             slot.ready = false;
             return Promise.reject(
                 operationError(
@@ -3258,31 +3291,24 @@ export class AIProviderRuntime {
         const runtime = this;
         const requestRecord = {
             controller,
+            operationId,
             requestSequence,
             promise: null,
             cancel: null
         };
-        slot.request = requestRecord;
-        publishAIRuntimeRoleState(
-            role,
-            roleRecord(
-                role,
-                slot.selection,
-                {
-                    state: 'ready',
-                    loaded: true,
-                    busy: true,
-                    operationId
-                }
-            )
-        );
+        slot.activeRequests.set(requestSequence, requestRecord);
+        this.#publishRoleRequestState(slot);
 
         function restoreAIProviderRoleAfterRequest(error) {
             if (slot.generation !== generation
-                || slot.requestSequence !== requestSequence
                 || slot.unloadPromise) {
                 return;
             }
+            if (slot.activeRequests.size || slot.requestQueue.length) {
+                slot.ready = true;
+                runtime.#publishRoleRequestState(slot);
+                return;
+            }
             let providerState = null;
             try {
                 providerState = validateProviderStatus(provider.status());
@@ -3398,8 +3424,8 @@ export class AIProviderRuntime {
                     cancelAbortedAIProviderStream
                 );
                 detachSignal();
-                if (slot.request === requestRecord) {
-                    slot.request = null;
+                if (slot.activeRequests.get(requestSequence) === requestRecord) {
+                    slot.activeRequests.delete(requestSequence);
                 }
                 runtime.#drainRoleRequestQueue(slot);
                 if (error) {
@@ -3592,6 +3618,7 @@ export class AIProviderRuntime {
                         slot,
                         generation,
                         requestSequence,
+                        requestRecord,
                         controller.signal
                     );
                     privateStreamObservation = (
@@ -3603,6 +3630,7 @@ export class AIProviderRuntime {
                                         slot,
                                         generation,
                                         requestSequence,
+                                        requestRecord,
                                         controller.signal
                                     );
                                     if (result.done) {
@@ -3643,6 +3671,7 @@ export class AIProviderRuntime {
                                     slot,
                                     generation,
                                     requestSequence,
+                                    requestRecord,
                                     controller.signal
                                 );
                                 const terminalValue = role === 'llm'
@@ -3773,6 +3802,7 @@ export class AIProviderRuntime {
                     slot,
                     generation,
                     requestSequence,
+                    requestRecord,
                     controller.signal
                 );
                 return role === 'llm'
@@ -3786,18 +3816,15 @@ export class AIProviderRuntime {
                     ? normalizedAbort(error)
                     : error;
                 requestError = normalized;
-                restoreAIProviderRoleAfterRequest(normalized);
                 throw normalized;
             } finally {
                 detachSignal();
-                if (slot.request === requestRecord) {
-                    slot.request = null;
+                if (slot.activeRequests.get(requestSequence) === requestRecord) {
+                    slot.activeRequests.delete(requestSequence);
                 }
                 runtime.#drainRoleRequestQueue(slot);
-                if (!requestError
-                    && slot.generation === generation
-                    && !slot.unloadPromise) {
-                    restoreAIProviderRoleAfterRequest(null);
+                if (slot.generation === generation && !slot.unloadPromise) {
+                    restoreAIProviderRoleAfterRequest(requestError);
                 }
             }
         })();
@@ -3823,10 +3850,10 @@ export class AIProviderRuntime {
     cancel(role) {
         assertRole(role);
         const slot = this.#slots[role];
-        if (!slot.request) {
+        const requestRecord = slot.activeRequests.values().next().value ?? null;
+        if (!requestRecord) {
             return false;
         }
-        const requestRecord = slot.request;
         const reason = operationError(
             `AI role ${role} request was cancelled.`,
             'ARCANE_AI_REQUEST_ABORTED'
@@ -3958,39 +3985,37 @@ export class AIProviderRuntime {
                 };
             }
             slot.requestQueue.push(entry);
+            runtime.#publishRoleRequestState(slot);
             runtime.#drainRoleRequestQueue(slot);
         });
     }
 
     #drainRoleRequestQueue(slot) {
-        if (slot.request
-            || slot.unloadPromise
+        if (slot.unloadPromise
             || slot.disposePromise
             || slot.disposed) {
             return;
         }
-        const entry = slot.requestQueue.shift();
-        if (!entry) {
-            return;
-        }
-        entry.detachSignal?.();
-        if (entry.options.signal?.aborted) {
-            entry.reject(normalizedAbort(entry.options.signal.reason));
-            this.#drainRoleRequestQueue(slot);
-            return;
-        }
+        const provider = this.#providerFor(slot);
+        const maxConcurrentRequests = this.#providerRequestCapacity(provider);
         const runtime = this;
-        Promise.resolve().then(
-            function runQueuedAIProviderRoleRequest() {
-                return runtime.request(slot.role, entry.options);
+        while (slot.requestQueue.length
+            && slot.activeRequests.size < maxConcurrentRequests) {
+            const entry = slot.requestQueue.shift();
+            entry.detachSignal?.();
+            if (entry.options.signal?.aborted) {
+                entry.reject(normalizedAbort(entry.options.signal.reason));
+                continue;
             }
-        ).then(entry.resolve, entry.reject).finally(
-            function continueAIProviderRoleRequestQueue() {
-                if (!slot.request) {
-                    runtime.#drainRoleRequestQueue(slot);
-                }
+            let operation;
+            try {
+                operation = runtime.#requestRole(slot.role, entry.options, true);
+            } catch (error) {
+                entry.reject(error);
+                continue;
             }
-        );
+            Promise.resolve(operation).then(entry.resolve, entry.reject);
+        }
     }
 
     #rejectQueuedRoleRequests(slot, error) {
@@ -4039,7 +4064,7 @@ export class AIProviderRuntime {
             slot.loadPromise
             || slot.unloadPromise
             || slot.disposePromise
-            || slot.request
+            || slot.activeRequests.size > 0
             || slot.requestQueue.length > 0
             || slot.ready
         );
@@ -4086,9 +4111,15 @@ export class AIProviderRuntime {
         }
     }
 
-    #assertCurrentRequest(slot, generation, requestSequence, signal) {
+    #assertCurrentRequest(
+        slot,
+        generation,
+        requestSequence,
+        requestRecord,
+        signal
+    ) {
         this.#assertCurrentOperation(slot, generation, signal);
-        if (slot.requestSequence !== requestSequence) {
+        if (slot.activeRequests.get(requestSequence) !== requestRecord) {
             throw operationError(
                 `AI role ${slot.role} no longer owns the active provider request.`,
                 'ARCANE_AI_REQUEST_STALE'
@@ -4096,6 +4127,33 @@ export class AIProviderRuntime {
         }
     }
 
+    #providerRequestCapacity(provider) {
+        return provider?.role === 'tts'
+            ? provider.maxConcurrentRequests
+            : 1;
+    }
+
+    #publishRoleRequestState(slot) {
+        const requestRecord = slot.activeRequests.values().next().value ?? null;
+        if (!requestRecord && slot.requestQueue.length === 0) {
+            return false;
+        }
+        publishAIRuntimeRoleState(
+            slot.role,
+            roleRecord(
+                slot.role,
+                slot.selection,
+                {
+                    state: 'ready',
+                    loaded: true,
+                    busy: true,
+                    operationId: requestRecord?.operationId ?? null
+                }
+            )
+        );
+        return true;
+    }
+
     #forwardAbort(signal, controller) {
         if (!signal) {
             return function detachAbsentAIProviderAbort() {};
@@ -4133,6 +4191,7 @@ export class AIProviderRuntime {
     }
 
     #publishRoleError(slot, error, loaded) {
+        const requestRecord = slot.activeRequests.values().next().value ?? null;
         publishAIRuntimeRoleState(
             slot.role,
             roleRecord(
@@ -4141,6 +4200,8 @@ export class AIProviderRuntime {
                 {
                     state: 'error',
                     loaded,
+                    busy: Boolean(requestRecord || slot.requestQueue.length),
+                    operationId: requestRecord?.operationId ?? null,
                     error: stateError(
                         error,
                         'ARCANE_AI_PROVIDER_OPERATION_FAILED'

package/runtime/arcane/modules/AIRuntimeState.js

@@ -82,24 +82,9 @@ const STARTUP_TERMINAL_STATES = new Set([
     'disposed'
 ]);
 
-/**
- * @deprecated Subscribe through the focused runtime helpers or arcaneEvents.
- * This state-free EventTarget compatibility view delegates to the module's
- * canonical source; it does not own a second listener registry or event bus.
- */
-const aiRuntimeEventCompatibilityView = {
-    addEventListener(type, listener, options) {
-        return aiRuntimeEventSource.addEventListener(type, listener, options);
-    },
-    removeEventListener(type, listener, options) {
-        return aiRuntimeEventSource.removeEventListener(type, listener, options);
-    },
-    dispatchEvent(event) {
-        return aiRuntimeEventSource.dispatchEvent(event);
-    }
-};
+const aiRuntimeEventOwner = {};
 const aiRuntimeEventSource = createArcaneEventSource(
-    aiRuntimeEventCompatibilityView,
+    aiRuntimeEventOwner,
     {
         source: 'ai-runtime-state',
         eventTypes: completeValue([
@@ -109,7 +94,6 @@ const aiRuntimeEventSource = createArcaneEventSource(
         ])
     }
 );
-export const aiRuntimeEvents = completeValue(aiRuntimeEventCompatibilityView);
 
 function fail(message) {
     throw new TypeError(`ARCANE_AI_RUNTIME_STATE_INVALID: ${message}`);

package/runtime/arcane/modules/BrowserTestSuite.js

@@ -12,14 +12,11 @@ export const BROWSER_TEST_SUITE_EVENT_TYPES={
 export const BROWSER_TEST_SUITE_ERROR_CODES={
     assertion:'BROWSER_TEST_ASSERTION',
     busy:'BROWSER_TEST_BUSY',
-    callbackRejectedLegacy:'BROWSER_TEST_ERROR',
+    callbackRejected:'BROWSER_TEST_ERROR',
     clockInvalid:'BROWSER_TEST_INVALID_CLOCK',
     descriptorCaseCollision:'BROWSER_TEST_CASE_COLLISION',
-    descriptorDuplicate:'BROWSER_TEST_CASE_COLLISION',
     descriptorInvalid:'BROWSER_TEST_INVALID_DESCRIPTOR',
     disposed:'BROWSER_TEST_SUITE_DISPOSED',
-    limitExceeded:'BROWSER_TEST_LIMIT',
-    limitInvalid:'BROWSER_TEST_INVALID_LIMIT',
     optionsInvalid:'BROWSER_TEST_INVALID_OPTIONS',
     resultInvalid:'BROWSER_TEST_INVALID_RESULT',
     runAborted:'BROWSER_TEST_ABORTED',
@@ -230,7 +227,7 @@ function browserTestResultReason(result){
     if(result.code===BROWSER_TEST_SUITE_ERROR_CODES.timedOut){
         return BROWSER_TEST_SUITE_REASONS.testTimedOut;
     }
-    if(result.code===BROWSER_TEST_SUITE_ERROR_CODES.callbackRejectedLegacy){
+    if(result.code===BROWSER_TEST_SUITE_ERROR_CODES.callbackRejected){
         return BROWSER_TEST_SUITE_REASONS.testCallbackRejected;
     }
     if(result.status==='pass')return BROWSER_TEST_SUITE_REASONS.testPassed;

package/runtime/arcane/modules/CalculatorEngine.js

@@ -50,10 +50,6 @@ export default class CalculatorEngine{
     #events;
     #operationSequence=0;
     constructor(){this.#events=createArcaneEventSource(this,{source:'calculator-engine',eventTypes:['calculator-result','calculator-error']});}
-    addEventListener(type,listener,options){return this.#events.addEventListener(type,listener,options);}
-    removeEventListener(type,listener,options){return this.#events.removeEventListener(type,listener,options);}
-    on(type,listener,options){return this.#events.on(type,listener,options);}
-    dispatchEvent(value){return this.#events.dispatchEvent(value);}
     calculate(expression){
         if(this.#disposed)throw disposedError();
         const operationId=`${this.#events.instanceId}:calculate:${(++this.#operationSequence).toString(36)}`;

package/runtime/arcane/modules/ChatRecords.js

@@ -21,7 +21,175 @@ function hasConversationEntry(chat=[]){
     );
 }
 
+function plainRecord(value){
+    if(!value||typeof value!=='object'||Array.isArray(value))return false;
+    const prototype=Object.getPrototypeOf(value);
+    return prototype===Object.prototype||prototype===null;
+}
+
+function coded(error,code){
+    if(!error.code)error.code=code;
+    return error;
+}
+
+function copyCompleteValue(value,seen=new Map()){
+    if(value===null||typeof value!=='object')return value;
+    if(seen.has(value))return seen.get(value);
+    if(Array.isArray(value)){
+        const result=[];
+        seen.set(value,result);
+        for(const item of value)result.push(copyCompleteValue(item,seen));
+        return result;
+    }
+    const result={};
+    seen.set(value,result);
+    for(const [key,descriptor] of Object.entries(
+        Object.getOwnPropertyDescriptors(value)
+    )){
+        if(Object.hasOwn(descriptor,'value')){
+            result[key]=copyCompleteValue(descriptor.value,seen);
+        }
+    }
+    return result;
+}
+
+function providerMessageCopy(message){
+    const copy=copyCompleteValue(message);
+    if(copy.role==='tool'){
+        delete copy.message;
+        delete copy.name;
+        delete copy.status;
+    }
+    delete copy.memory_excluded;
+    delete copy.persistence_excluded;
+    delete copy.persistence_message;
+    delete copy.persistence_name;
+    delete copy.persistence_status;
+    delete copy.timestamp;
+    delete copy.ui_hidden;
+    return copy;
+}
+
+function structuralToolMessage(call,label){
+    const argumentValue=call?.function?.arguments;
+    if(typeof argumentValue!=='string'){
+        throw coded(
+            new TypeError(`${label}.function.arguments must be a JSON string.`),
+            'AI_CHAT_INVALID_TOOL_CALL'
+        );
+    }
+    let argumentsRecord;
+    try{
+        argumentsRecord=JSON.parse(argumentValue);
+    }catch(cause){
+        throw coded(
+            new TypeError(`${label}.function.arguments must encode a JSON object.`,{cause}),
+            'AI_CHAT_INVALID_TOOL_CALL'
+        );
+    }
+    if(!plainRecord(argumentsRecord)){
+        throw coded(
+            new TypeError(`${label}.function.arguments must encode a JSON object.`),
+            'AI_CHAT_INVALID_TOOL_CALL'
+        );
+    }
+    if(typeof argumentsRecord.message!=='string'||!argumentsRecord.message.trim()){
+        throw coded(
+            new TypeError(`${label}.function.arguments.message must contain user-facing text.`),
+            'AI_CHAT_TOOL_MESSAGE_REQUIRED'
+        );
+    }
+    return argumentsRecord.message;
+}
+
+function activeToolProtocolState(messages){
+    const pending=new Set();
+    let start=-1;
+    for(let index=0;index<messages.length;index++){
+        const message=messages[index];
+        if(message?.role==='assistant'){
+            if(start>=0&&!pending.size)start=-1;
+            if(Array.isArray(message.tool_calls)){
+                if(!pending.size&&message.tool_calls.length)start=index;
+                for(const call of message.tool_calls){
+                    if(typeof call?.id==='string'&&call.id)pending.add(call.id);
+                }
+            }
+        }
+        if(message?.role==='tool'&&typeof message.tool_call_id==='string'){
+            pending.delete(message.tool_call_id);
+        }
+    }
+    return {pending:pending.size,start};
+}
+
+function appendOrdinaryMessages(result,message,index){
+    if(!plainRecord(message))return;
+    if(['system','user'].includes(message.role)){
+        if(Object.hasOwn(message,'content')){
+            result.push({role:message.role,content:message.content});
+        }
+        return;
+    }
+    if(message.role==='assistant'){
+        if(message.content!==undefined&&message.content!==null&&String(message.content)){
+            result.push({role:'assistant',content:String(message.content)});
+        }
+        if(message.tool_calls===undefined)return;
+        if(!Array.isArray(message.tool_calls)){
+            throw coded(
+                new TypeError(`Chat message ${index+1}.tool_calls must be an array.`),
+                'AI_CHAT_INVALID_TOOL_CALL'
+            );
+        }
+        for(let callIndex=0;callIndex<message.tool_calls.length;callIndex++){
+            result.push({
+                role:'assistant',
+                content:structuralToolMessage(
+                    message.tool_calls[callIndex],
+                    `Chat message ${index+1}.tool_calls[${callIndex}]`
+                )
+            });
+        }
+        return;
+    }
+    if(message.role!=='tool')return;
+    const content=typeof message.tool_call_id==='string'
+        ?message.persistence_message??message.message
+        :message.content;
+    if(typeof content==='string'&&content.trim()){
+        result.push({role:'assistant',content});
+    }
+}
+
+/**
+ * Projects retained chat state into recurring provider context. Raw structural
+ * protocol is preserved only for the one unresolved continuation at the tail.
+ * Settled exchanges become complete ordinary visible conversation messages.
+ */
+function recurringChatMessages(chat=[],{settleCompleteToolTail=false}={}){
+    const messages=Array.isArray(chat)
+        ?chat
+        :chat?.messages||[];
+    const active=activeToolProtocolState(messages);
+    const activeStart=settleCompleteToolTail&&!active.pending
+        ?-1
+        :active.start;
+    const settledEnd=activeStart<0?messages.length:activeStart;
+    const result=[];
+    for(let index=0;index<settledEnd;index++){
+        appendOrdinaryMessages(result,messages[index],index);
+    }
+    if(activeStart>=0){
+        for(let index=activeStart;index<messages.length;index++){
+            result.push(providerMessageCopy(messages[index]));
+        }
+    }
+    return result;
+}
+
 export {
     hasConversationEntry,
-    hasUserEntry
+    hasUserEntry,
+    recurringChatMessages
 };