arcane-os 0.1.0-dev.5

package/runtime/arcane/modules/AIPreferenceRuntime.js

@@ -0,0 +1,32 @@
+const runtimeOverrides=new WeakMap();
+
+function requireUser(user){
+    if(!user||typeof user!=='object'){
+        throw new TypeError('An AI preference owner is required.');
+    }
+}
+
+/**
+ * Sets an in-memory preference tuple for the current page without writing it
+ * back to the user entity. Passing null removes the page-only override.
+ */
+export function setAIPreferenceRuntimeOverride(user,preferences){
+    requireUser(user);
+
+    if(preferences===null){
+        runtimeOverrides.delete(user);
+        return null;
+    }
+    if(!Array.isArray(preferences)||preferences.length!==6){
+        throw new TypeError('An AI runtime preference tuple must contain six entries.');
+    }
+
+    const snapshot=Object.freeze([...preferences]);
+    runtimeOverrides.set(user,snapshot);
+    return snapshot;
+}
+
+export function getAIPreferencesForRuntime(user){
+    requireUser(user);
+    return runtimeOverrides.get(user)||user.preferredModels;
+}

package/runtime/arcane/modules/AIPreferenceTuple.js

@@ -0,0 +1,92 @@
+export const AI_PREFERENCE_SLOT_KEYS=Object.freeze([
+    'llmProvider',
+    'sttProvider',
+    'ttsProvider',
+    'llmModel',
+    'ttsModel',
+    'sttModel'
+]);
+
+function preferenceToken(value){
+    return typeof value==='string'
+        ?value.trim()
+        :'';
+}
+
+function allowedTokensForSlot(allowedValues,index){
+    const supplied=allowedValues[index];
+
+    if(supplied===undefined||supplied===null){
+        return null;
+    }
+
+    if(!Array.isArray(supplied)&&!(supplied instanceof Set)){
+        throw new TypeError(
+            `Allowed AI preference values for ${AI_PREFERENCE_SLOT_KEYS[index]} must be an array or Set.`
+        );
+    }
+
+    return new Set(
+        Array.from(supplied,preferenceToken).filter(Boolean)
+    );
+}
+
+/**
+ * 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.
+ *
+ * Slot order:
+ * [LLM provider, STT provider, TTS provider, LLM model, TTS model, STT model]
+ */
+export function normalizeAIPreferenceTuple(
+    value,
+    {
+        defaults,
+        allowedValues=[],
+        aliases=[]
+    }={}
+){
+    if(!Array.isArray(defaults)||defaults.length!==AI_PREFERENCE_SLOT_KEYS.length){
+        throw new TypeError(
+            `AI preference defaults must contain exactly ${AI_PREFERENCE_SLOT_KEYS.length} slots.`
+        );
+    }
+
+    const source=Array.isArray(value)?value:[];
+
+    return AI_PREFERENCE_SLOT_KEYS.map((slot,index)=>{
+        const fallback=preferenceToken(defaults[index]);
+
+        if(!fallback){
+            throw new TypeError(`The default AI preference for ${slot} must be a non-empty string.`);
+        }
+
+        const slotAliases=aliases[index]||{};
+        let candidate=preferenceToken(source[index]);
+
+        if(candidate&&Object.prototype.hasOwnProperty.call(slotAliases,candidate)){
+            candidate=preferenceToken(slotAliases[candidate]);
+        }
+
+        const allowed=allowedTokensForSlot(allowedValues,index);
+
+        if(allowed&&!allowed.has(fallback)){
+            throw new TypeError(`The default AI preference for ${slot} must be allowed.`);
+        }
+
+        if(!candidate||(allowed&&!allowed.has(candidate))){
+            return fallback;
+        }
+
+        return candidate;
+    });
+}
+
+export function aiPreferenceTuplesEqual(left,right){
+    return Array.isArray(left)
+        &&Array.isArray(right)
+        &&left.length===AI_PREFERENCE_SLOT_KEYS.length
+        &&right.length===AI_PREFERENCE_SLOT_KEYS.length
+        &&left.every((value,index)=>value===right[index]);
+}

package/runtime/arcane/modules/AIResponseLength.js

@@ -0,0 +1,42 @@
+const RESPONSE_LENGTH_HEADING='## Application-selected response length';
+
+export const AI_RESPONSE_LENGTH_DEFAULT='medium';
+
+export const AI_RESPONSE_LENGTH_OPTIONS=Object.freeze([
+    Object.freeze({value:'low',label:'Low (1–5 sentences)',minSentences:1,maxSentences:5}),
+    Object.freeze({value:'medium',label:'Medium (6–10 sentences)',minSentences:6,maxSentences:10}),
+    Object.freeze({value:'high',label:'High (11–20 sentences)',minSentences:11,maxSentences:20})
+]);
+
+const RESPONSE_LENGTH_BY_VALUE=new Map(
+    AI_RESPONSE_LENGTH_OPTIONS.map(option=>[option.value,option])
+);
+
+export function normalizeAIResponseLength(value){
+    const normalized=typeof value==='string'?value.trim().toLowerCase():'';
+    return RESPONSE_LENGTH_BY_VALUE.has(normalized)
+        ?normalized
+        :AI_RESPONSE_LENGTH_DEFAULT;
+}
+
+export function aiResponseLengthInstruction(value){
+    const option=RESPONSE_LENGTH_BY_VALUE.get(normalizeAIResponseLength(value));
+    const sentenceTarget=`Aim for ${option.minSentences} to ${option.maxSentences} sentences.`;
+
+    return `${RESPONSE_LENGTH_HEADING}
+${sentenceTarget} A more specific response-length request in the current user message overrides this saved target. Application requirements, tool or function calls, structured response schemas, safety or crisis requirements, evidence and source attribution, uncertainty, warnings, and next steps override the sentence target. Do not omit required information, invent information, or pad the response merely to reach the target.`;
+}
+
+export function applyAIResponseLength(systemPrompt,value){
+    if(typeof systemPrompt!=='string'){
+        throw new TypeError('systemPrompt must be a string');
+    }
+
+    const prompt=systemPrompt.trimEnd();
+    if(prompt.includes(RESPONSE_LENGTH_HEADING)){
+        return prompt;
+    }
+
+    const instruction=aiResponseLengthInstruction(value);
+    return prompt?`${prompt}\n\n${instruction}`:instruction;
+}