Add low level access

src/ts/process/triggers.ts

@@ -6,6 +6,10 @@ import { get } from "svelte/store";
 import { CurrentCharacter, CurrentChat, selectedCharID } from "../stores";
 import { processMultiCommand } from "./command";
 import { parseKeyValue } from "../util";
+import { alertError, alertInput, alertNormal, alertSelect } from "../alert";
+import type { OpenAIChat } from ".";
+import { HypaProcesser } from "./memory/hypamemory";
+import { requestChatData } from "./request";
 
 export interface triggerscript{
     comment: string;
@@ -16,7 +20,7 @@ export interface triggerscript{
 
 export type triggerCondition = triggerConditionsVar|triggerConditionsExists|triggerConditionsChatIndex
 
-export type triggerEffect = triggerEffectSetvar|triggerEffectSystemPrompt|triggerEffectImpersonate|triggerEffectCommand|triggerEffectStop|triggerEffectRunTrigger
+export type triggerEffect = triggerEffectRunLLM|triggerEffectCheckSimilarity|triggerEffectSendAIprompt|triggerEffectShowAlert|triggerEffectSetvar|triggerEffectSystemPrompt|triggerEffectImpersonate|triggerEffectCommand|triggerEffectStop|triggerEffectRunTrigger
 
 export type triggerConditionsVar = {
     type:'var'|'value'
@@ -62,6 +66,13 @@ export interface triggerEffectCommand{
     value: string
 }
 
+export interface triggerEffectShowAlert{
+    type: 'showAlert',
+    alertType: string
+    value: string
+    inputVar: string
+}
+
 export interface triggerEffectRunTrigger{
     type: 'runtrigger',
     value: string
@@ -71,6 +82,23 @@ export interface triggerEffectStop{
     type: 'stop'
 }
 
+export interface triggerEffectSendAIprompt{
+    type: 'sendAIprompt'
+}
+
+export interface triggerEffectCheckSimilarity{
+    type: 'checkSimilarity',
+    source: string,
+    value: string,
+    inputVar: string
+}
+
+export interface triggerEffectRunLLM{
+    type: 'runLLM',
+    value: string,
+    inputVar: string
+}
+
 export type additonalSysPrompt = {
     start:string,
     historyend: string,
@@ -88,6 +116,8 @@ export async function runTrigger(char:character,mode:triggerMode, arg:{
     char = structuredClone(char)
     let varChanged = false
     let stopSending = arg.stopSending ?? false
+    let lowLevelAccess = char.lowLevelAccess ?? false
+    let sendAIprompt = false
     const currentChat = get(CurrentChat)
     let additonalSysPrompt:additonalSysPrompt = arg.additonalSysPrompt ?? {
         start:'',
@@ -269,7 +299,7 @@ export async function runTrigger(char:character,mode:triggerMode, arg:{
                     break
                 }
                 case 'runtrigger':{
-                    if(arg.recursiveCount < 10){
+                    if(arg.recursiveCount < 10 || lowLevelAccess){
                         arg.recursiveCount++
                         const r = await runTrigger(char,'manual',{
                             chat,
@@ -286,6 +316,116 @@ export async function runTrigger(char:character,mode:triggerMode, arg:{
                     }
                     break
                 }
+
+                // low level access only
+                case 'showAlert':{
+                    if(!lowLevelAccess){
+                        break
+                    }
+
+                    const effectValue = risuChatParser(effect.value,{chara:char})
+                    const inputVar = risuChatParser(effect.inputVar,{chara:char})
+
+                    switch(effect.alertType){
+                        case 'normal':{
+                            alertNormal(effectValue)
+                            break
+                        }
+                        case 'error':{
+                            alertError(effectValue)
+                            break
+                        }
+                        case 'input':{
+                            const val = await alertInput(effectValue)
+                            setVar(inputVar, val)
+                        }
+                        case 'select':{
+                            const val = await alertSelect(effectValue.split('§'))
+                            setVar(inputVar, val)
+                        }
+                    }
+                    break
+                }
+
+                case 'sendAIprompt':{
+                    if(!lowLevelAccess){
+                        break
+                    }
+                    sendAIprompt = true
+                    break
+                }
+
+                case 'runLLM':{
+                    if(!lowLevelAccess){
+                        break
+                    }
+                    const effectValue = risuChatParser(effect.value,{chara:char})
+                    const varName = effect.inputVar
+                    let promptbody:OpenAIChat[] = []
+                    let currentRole:'user'|'assistant'|'system'
+                    
+                    const splited = effectValue.split('\n')
+
+                    for(let i = 0; i < splited.length; i++){
+                        const line = splited[i]
+                        if(line.startsWith('@@role ')){
+                            const role = line.split(' ')[1]
+                            switch(role){
+                                case 'user':
+                                case 'assistant':
+                                case 'system':
+                                    currentRole = role
+                                    break
+                                default:
+                                    currentRole = 'system'
+                                    break
+                            }
+                            promptbody.push({role: currentRole, content: ''})
+                            continue
+                        }
+                        else if(promptbody.length === 0){
+                            promptbody.push({role: 'system', content: line})
+                        }
+                        else{
+                            promptbody[promptbody.length - 1].content += line
+                        }
+                    }
+
+                    promptbody = promptbody.map((e) => {
+                        e.content = e.content.trim()
+                        return e
+                    }).filter((e) => e.content.length > 0)
+
+                    const result = await requestChatData({
+                        formated: promptbody,
+                        bias: {},
+                        useStreaming: false,
+                        noMultiGen: true,
+                    }, 'model')
+
+                    if(result.type === 'fail' || result.type === 'streaming' || result.type === 'multiline'){
+                        setVar(varName, 'Error: ' + result.result)
+                    }
+                    else{
+                        setVar(varName, result.result)
+                    }
+
+                    break
+                }
+
+                case 'checkSimilarity':{
+                    if(!lowLevelAccess){
+                        break
+                    }
+
+                    const processer = new HypaProcesser('MiniLM')
+                    const effectValue = risuChatParser(effect.value,{chara:char})
+                    const source = risuChatParser(effect.source,{chara:char})
+                    await processer.addText(effectValue.split('§'))
+                    const val = await processer.similaritySearch(source)
+                    setVar(effect.inputVar, val.join('§'))
+                    break
+                }
             }
         }
     }
@@ -305,6 +445,6 @@ export async function runTrigger(char:character,mode:triggerMode, arg:{
         currentChat.scriptstate = chat.scriptstate
     }
 
-    return {additonalSysPrompt, chat, tokens:caculatedTokens, stopSending}
+    return {additonalSysPrompt, chat, tokens:caculatedTokens, stopSending, sendAIprompt}
 
 }