@adminforth/agent 1.37.0 → 1.38.0

package/custom/conversation_area/MessageRenderer.vue

@@ -8,11 +8,15 @@
     :key="part.type"
   > 
     <TextRenderer 
-      v-if="part.type === 'text'" 
+      v-if="part.type === 'text' && !checkIfMessageSystemMessage(part.text ?? '')" 
       :message="part.text" 
       :role="props.message.role" 
       :state="part.state ?? (props.message.role === 'user' ? 'done' : undefined)"
     />
+    <SystemMessageRenderer 
+      v-else
+      :message="part.text" 
+    />
   </template>
 
 </template>
@@ -25,9 +29,16 @@
   import type { IMessage } from '../types';
   import { getMessageParts } from '../utils';
   import ProcessingTimeline from './ProcessingTimeline.vue';
+  import SystemMessageRenderer from './SystemMessageRenderer.vue';
+  import { RESERVED_SYSTEM_MESSAGE_CONTENT } from '../composables/agentStore/constants';
 
   const props = defineProps<{ 
     message: IMessage 
     isLastMessageInChat: boolean
   }>();
+
+  function checkIfMessageSystemMessage(message: IMessage): boolean {
+    const isReserved = Object.values(RESERVED_SYSTEM_MESSAGE_CONTENT).includes(message as RESERVED_SYSTEM_MESSAGE_CONTENT);
+    return isReserved;
+  }
 </script>

package/custom/conversation_area/SystemMessageRenderer.vue

@@ -0,0 +1,28 @@
+<template>
+  <p :class="`${TEXT_CLASSES}`" v-if="message === RESERVED_SYSTEM_MESSAGE_CONTENT.START_AUDIO_CHAT">
+    <IconPhoneSolid class="inline-block w-4 h-4 mr-1" />
+    {{$t('Audio chat started')}}
+  </p>
+  <p :class="`${TEXT_CLASSES}`" v-else-if="message === RESERVED_SYSTEM_MESSAGE_CONTENT.END_AUDIO_CHAT">
+    <IconPhoneHangupSolid class="inline-block w-4 h-4 mr-1" />
+    {{$t('Audio chat ended')}}
+  </p>
+  <p :class="`${TEXT_CLASSES}`" v-else-if="message === RESERVED_SYSTEM_MESSAGE_CONTENT.AGENT_RESPONSE_ABORTED">
+    {{$t('Agent response aborted')}}
+  </p>
+
+</template>
+
+
+
+<script setup lang="ts">
+import { RESERVED_SYSTEM_MESSAGE_CONTENT } from '../composables/agentStore/constants';
+import { IconPhoneSolid, IconPhoneHangupSolid } from '@iconify-prerendered/vue-flowbite';
+
+const TEXT_CLASSES = 'text-center italic  text-lightListTableHeadingText dark:text-darkListTableHeadingText flex items-center justify-center';
+
+const props = defineProps<{ 
+  message: string
+}>();
+
+</script>

package/custom/conversation_area/TextRenderer.vue

@@ -16,9 +16,9 @@
       :components="incremarkComponents"
       :incremark-options="incremarkOptions"
     />
-    <p v-else class="text-red-500 py-2">
+    <!-- <p v-else class="text-red-500 py-2">
       {{ $t('No content to render') }}
-    </p>
+    </p> -->
   </div>
 </template>
 
@@ -28,11 +28,12 @@
   import { useRouter } from 'vue-router';
   import { useAgentStore } from '../composables/useAgentStore';
   import { useCoreStore } from '@/stores/core';
+  import type { IMessage } from '../types';
 
   const props = defineProps<{
     message: string | undefined,
     state: string | undefined,
-    role: 'user' | 'assistant'
+    role: IMessage['role']
   }>();
 
   const emit = defineEmits(['toggle-thoughts']);

package/custom/conversation_area/ToolRenderer.vue

@@ -109,7 +109,7 @@
   const hasToolSections = computed(() => toolSections.value.length > 0);
 
   onMounted(() => {
-    if (toolRendererRef.value) {
+    if (toolRendererRef.value && props.data.toolInfo) {
       toolRendererInitialWidth.value = toolRendererRef.value.offsetWidth;
     }
   });  

package/custom/package.json

@@ -22,6 +22,7 @@
     "dompurify": "^3.3.3",
     "katex": "^0.16.45",
     "marked": "^18.0.0",
-    "vega-embed": "^7.1.0"
+    "vega-embed": "^7.1.0",
+    "voice-activity-detection": "^0.0.5"
   }
 }

package/custom/pnpm-lock.yaml

@@ -44,6 +44,9 @@ importers:
       vega-embed:
         specifier: ^7.1.0
         version: 7.1.0(vega-lite@6.4.2(vega@6.2.0))(vega@6.2.0)
+      voice-activity-detection:
+        specifier: ^0.0.5
+        version: 0.0.5
 
 packages:
 
@@ -263,6 +266,9 @@ packages:
     peerDependencies:
       zod: ^3.25.76 || ^4.1.8
 
+  analyser-frequency-average@1.0.0:
+    resolution: {integrity: sha512-Y8HRgDfMWpefR286IAT7w9WsZ2r2dLOAkUNz8SQgsTAM0GsM9SAAqr1psqOr1scN76cL0pfuNZoQTnuvdoM0RA==}
+
   ansi-regex@6.2.2:
     resolution: {integrity: sha512-Bq3SmSpyFHaWjPk8If9yc6svM8c56dB5BAtW4Qbw5jHTwwXXcTLoRMkpDJp6VL0XzlWaCHTXrkFURMYmD0sLqg==}
     engines: {node: '>=12'}
@@ -271,6 +277,9 @@ packages:
     resolution: {integrity: sha512-4Dj6M28JB+oAH8kFkTLUo+a2jwOFkuqb3yucU0CANcRRUbxS0cP0nZYCGjcc3BNXwRIsUVmDGgzawme7zvJHvg==}
     engines: {node: '>=12'}
 
+  audio-frequency-to-index@2.0.0:
+    resolution: {integrity: sha512-7zqlDEAsEkPB0ORRhjBlsK7KBZQtdgLLQcmemFD2V2KHPH4flqzDOheWl+U69K0P/LA7J/H5YBNzNWaoS/7WAQ==}
+
   ccount@2.0.1:
     resolution: {integrity: sha512-eyrF0jiFpY+3drT6383f1qhkbGsLSifNAjA61IUjZjmLCWjItY6LB9ft9YhoDgwfmclB2zhu51Lc7+95b8NRAg==}
 
@@ -286,6 +295,9 @@ packages:
   character-reference-invalid@2.0.1:
     resolution: {integrity: sha512-iBZ4F4wRbyORVsu0jPV7gXkOsGYjGHPmAyv+HiHG8gi5PtC9KI2j1+v8/tlibRvjoWX027ypmG/n0HtO5t7unw==}
 
+  clamp@1.0.1:
+    resolution: {integrity: sha512-kgMuFyE78OC6Dyu3Dy7vcx4uy97EIbVxJB/B0eJ3bUNAkwdNcxYzgKltnyADiYwsR7SEqkkUPsEUT//OVS6XMA==}
+
   cliui@9.0.1:
     resolution: {integrity: sha512-k7ndgKhwoQveBL+/1tqGJYNz097I7WOvwbmmU2AR5+magtbjPWQTS1C5vzGkBC8Ym8UWRzfKUzUUqFLypY4Q+w==}
     engines: {node: '>=20'}
@@ -882,6 +894,9 @@ packages:
   vfile@6.0.3:
     resolution: {integrity: sha512-KzIbH/9tXat2u30jf+smMwFCsno4wHVdNmzFyL+T/L3UGqqk6JKfVqOFOZEpZSHADH1k40ab6NUIXZq422ov3Q==}
 
+  voice-activity-detection@0.0.5:
+    resolution: {integrity: sha512-Ezq+k0cICI67XR/R9KvTRhJ7/u6U0Zk9I+8VNs3hHTAvB6cA3glCa+cHgCRWSW/SV6cRrufSQsV1YxpNtsQb1g==}
+
   vue@3.5.32:
     resolution: {integrity: sha512-vM4z4Q9tTafVfMAK7IVzmxg34rSzTFMyIe0UUEijUCkn9+23lj0WRfA83dg7eQZIUlgOSGrkViIaCfqSAUXsMw==}
     peerDependencies:
@@ -1187,10 +1202,18 @@ snapshots:
       '@opentelemetry/api': 1.9.0
       zod: 4.3.6
 
+  analyser-frequency-average@1.0.0:
+    dependencies:
+      audio-frequency-to-index: 2.0.0
+
   ansi-regex@6.2.2: {}
 
   ansi-styles@6.2.3: {}
 
+  audio-frequency-to-index@2.0.0:
+    dependencies:
+      clamp: 1.0.1
+
   ccount@2.0.1: {}
 
   character-entities-html4@2.1.0: {}
@@ -1201,6 +1224,8 @@ snapshots:
 
   character-reference-invalid@2.0.1: {}
 
+  clamp@1.0.1: {}
+
   cliui@9.0.1:
     dependencies:
       string-width: 7.2.0
@@ -2143,6 +2168,10 @@ snapshots:
       '@types/unist': 3.0.3
       vfile-message: 4.0.3
 
+  voice-activity-detection@0.0.5:
+    dependencies:
+      analyser-frequency-average: 1.0.0
+
   vue@3.5.32:
     dependencies:
       '@vue/compiler-dom': 3.5.32

package/custom/speech_recognition_frontend/AudioLines.vue

@@ -0,0 +1,97 @@
+<template> 
+  <div 
+    class=" bg-white w-[0.2rem] rounded-sm transition-all duration-300 ease-in-out"
+    :class="{
+      'recordingAnimation1' : showAnimation,
+      'h-2': !isRecording,
+      'h-1': isRecording,
+    }"  
+  />
+  <div 
+    class=" bg-white w-[0.2rem] rounded-sm transition-all duration-300 ease-in-out"
+    :class="{
+      'recordingAnimation2' : showAnimation,
+      'h-4': !isRecording,
+      'h-1': isRecording,
+    }"  
+  />
+  <div 
+    class=" bg-white w-[0.2rem] rounded-sm transition-all duration-300 ease-in-out"
+    :class="{
+      'recordingAnimation3' : showAnimation,
+      'h-3': !isRecording,
+      'h-1': isRecording,
+    }"  
+  />
+  <div 
+    class=" bg-white w-[0.2rem] rounded-sm transition-all duration-300 ease-in-out"
+    :class="{
+      'recordingAnimation4' : showAnimation,
+      'h-2': !isRecording,
+      'h-1': isRecording,
+    }"  
+  />
+  <template v-if="isRecording">
+    <div 
+      class=" bg-white w-[0.2rem] rounded-sm h-1 transition-all duration-300 ease-in-out"
+      :class="{
+        'recordingAnimation5' : showAnimation,
+      }"  
+    />
+    <p class="text-white ml-2">End</p>
+  </template>
+</template>
+
+
+
+<script setup lang="ts">
+
+const props = defineProps<{
+  showAnimation: boolean;
+  isRecording: boolean;
+}>();
+
+</script>
+
+<style scoped lang="scss">
+  .recordingAnimation1 {
+    animation: recordingAnimation 1s infinite;
+    height: 0.3rem;
+  }
+
+  .recordingAnimation2 {
+    animation: recordingAnimation 1s infinite;
+    animation-delay: 0.2s;
+    height: 0.5rem;
+  }
+
+  .recordingAnimation3 {
+    animation: recordingAnimation 1s infinite;
+    animation-delay: 0.4s;
+    height: 0.4rem;
+  }
+  
+  .recordingAnimation4 {
+    animation: recordingAnimation 1s infinite;
+    animation-delay: 0.6s;
+    height: 0.5rem;
+  }
+
+  .recordingAnimation5 {
+    animation: recordingAnimation 1s infinite;
+    animation-delay: 0.8s;
+    height: 0.3rem;
+  }
+
+  @keyframes recordingAnimation {
+    0% {
+      transform: scaleY(1);
+    }
+    50% {
+      transform: scaleY(2);
+    }
+    100% {
+      transform: scaleY(1);
+    }
+  }
+</style>

package/custom/speech_recognition_frontend/MicrophoneButon.vue

@@ -0,0 +1,157 @@
+<template>
+  <button 
+    class="absolute bottom-2 h-9 bg-lightPrimary dark:bg-darkPrimary 
+      hover:opacity-90 rounded-full flex items-center justify-center
+      transition-all duration-300 ease-in-out overflow-hidden"
+    :class="[isAudioChatMode ? 'w-32 px-2': 'w-9', !agentStore.isAudioChatMode ? 'right-16': 'right-1/2 translate-x-1/2']" 
+    @click="toggleChatMode"
+  >
+    <div class="w-5 h-5 flex items-center justify-center">
+      <div v-if="microphoneButtonMode === 'listen' || microphoneButtonMode === 'off'" class="flex justify-evenly items-center gap-[0.1rem]">
+        <AudioLines :showAnimation="showAudioWavesAnimation" :isRecording="microphoneButtonMode === 'listen'" />
+      </div>
+      <div v-else-if="microphoneButtonMode === 'generating'" class="flex items-center justify-center gap-2 text-white text-sm">
+        <span class="w-3 h-3 bg-white rounded-sm" />
+        {{ $t('Stop') }}
+      </div>
+      <Spinner v-else class="w-4 h-4 text-lightButtonsText dark:text-darkButtonsText fill-lightButtonsBackground dark:fill-darkPrimary" />
+    </div>
+   
+  </button>
+</template>
+
+
+<script setup lang="ts">
+import { computed, onMounted, onBeforeUnmount, ref, watch } from 'vue';
+import debounce from 'lodash/debounce';
+import { requestMicAndStartVAD, stopUserMedia, getRecorder, CALIBRATION_DURATION } from './voiceActivityDetection';
+import { Spinner } from '@/afcl'
+import { storeToRefs } from 'pinia';
+import { useAgentStore } from '../composables/useAgentStore';
+import { useAgentAudio } from '../composables/useAgentAudio';
+import AudioLines from './AudioLines.vue';
+
+const agentStore = useAgentStore();
+const agentAudio = useAgentAudio();
+const { sendAudioToServerAndHandleResponse } = agentAudio;
+const { stopGenerationAndAudio } = agentAudio;
+const { stopCurrentAudioPlayback } = agentAudio;
+const { agentAudioMode } = storeToRefs(agentAudio);
+const microphoneButtonMode = ref<'off' | 'calibrating' | 'listen' | 'transcribing' | 'generating'>('off');
+const showAudioWavesAnimation = ref(false);
+const hideAnimationDebounced = debounce(() => {
+  showAudioWavesAnimation.value = false;
+}, 100);
+const sendUserRecordDebounced = debounce(() => {
+  sendRecordForTranscription();
+}, 500);
+
+const isAudioChatMode = computed(() => agentStore.isAudioChatMode);
+
+onMounted(() => {
+  agentStore.registerOnBeforeChatCloseCallback(async () => {
+    if(agentStore.isAudioChatMode) {
+      onStopRecording();
+      resetAll();
+      agentStore.setIsAudioChatMode(false);
+    }
+  });
+});
+
+watch(agentAudioMode, (newVal) => {
+  if(newVal === 'streaming') {
+    stopCurrentAudioPlayback(true);
+    microphoneButtonMode.value = 'generating';
+  } else if (newVal === 'transcribing') {
+    microphoneButtonMode.value = 'transcribing';
+  } else if (newVal === 'fetchingAudio') {
+    //Generation is done, waiting for audio to be ready
+  } else if (newVal === 'playingAgentResponse') {
+    // Audio is playing
+  } else {
+    if(isAudioChatMode.value) {
+      microphoneButtonMode.value = 'listen';
+    } else {
+      microphoneButtonMode.value = 'off';
+    }
+  }
+})
+
+function toggleChatMode() {
+  agentStore.setIsAudioChatMode(!isAudioChatMode.value);
+  if (isAudioChatMode.value) {
+    onStartRecording();
+  } else {
+    resetAll();
+    onStopRecording();
+  }
+}
+
+async function onStartRecording() {
+  microphoneButtonMode.value = 'calibrating';
+  await requestMicAndStartVAD(saidSomething, stopRecording, onAnySound);
+  setTimeout(() => {
+    microphoneButtonMode.value = 'listen';
+    agentAudio.playBeep(1000);
+  }, CALIBRATION_DURATION);
+}
+
+function onStopRecording() {
+  agentAudio.playBeep(600);
+  stopUserMedia();
+  showAudioWavesAnimation.value = false;
+}
+
+function resetAll() {
+  stopGenerationAndAudio();
+  microphoneButtonMode.value = 'off';
+  showAudioWavesAnimation.value = false;
+  hideAnimationDebounced.cancel();
+  sendUserRecordDebounced.cancel();
+}
+
+
+function saidSomething() {
+  showAudioWavesAnimation.value = true;
+  hideAnimationDebounced();
+  sendUserRecordDebounced();
+}
+
+function stopRecording() {
+  hideAnimationDebounced.cancel();
+  sendUserRecordDebounced.cancel();
+}
+
+function onAnySound(amplitude: number) {
+  if(amplitude < 0.01) {
+    showAudioWavesAnimation.value = false;
+    return;
+  }
+  showAudioWavesAnimation.value = true;
+  hideAnimationDebounced.cancel();
+}
+
+async function sendRecordForTranscription() {
+  showAudioWavesAnimation.value = false;
+  const recordBlob = await getRecorder();
+  if (recordBlob) {
+    onStopRecording();
+    await sendAudioToServerAndHandleResponse(recordBlob);
+    if (agentStore.isAudioChatMode) {
+      await requestMicAndStartVAD(saidSomething, stopRecording, onAnySound);
+    }
+  } else { 
+    console.error('No audio recorded');
+  }
+}
+
+onBeforeUnmount(() => {
+  stopUserMedia();
+  agentStore.setIsAudioChatMode(false);
+  onStopRecording();
+  hideAnimationDebounced.cancel();
+  sendUserRecordDebounced.cancel();
+});
+
+
+</script>

package/custom/speech_recognition_frontend/types/voice-activity-detection.d.ts

@@ -0,0 +1,22 @@
+declare module 'voice-activity-detection' {
+  type VADOptions = {
+    fftSize: number,
+    bufferLen: number,
+    smoothingTimeConstant: number,
+    minCaptureFreq: number,         // in Hz
+    maxCaptureFreq: number,        // in Hz
+    noiseCaptureDuration: number, // in ms
+    minNoiseLevel: number,         // from 0 to 1
+    maxNoiseLevel: number,         // from 0 to 1
+    avgNoiseMultiplier: number,     // from 0 to 1
+    onVoiceStart?: () => void;
+    onVoiceStop?: () => void;
+    onUpdate?: (value: number) => void;
+  };
+
+  export default function vad(
+    audioContext: AudioContext,
+    stream: MediaStream,
+    options: VADOptions,
+  ): void;
+}

package/custom/speech_recognition_frontend/voiceActivityDetection.ts

@@ -0,0 +1,151 @@
+import vad from 'voice-activity-detection';
+
+let currentStream: MediaStream | null = null;
+let vadInstance: any = null;
+let audioContext: AudioContext | null = null;
+let mediaRecorder: MediaRecorder | null = null;
+let recordedChunks: BlobPart[] = [];
+let wasVoiceStarted = false;
+
+export const CALIBRATION_DURATION = 1000; // in ms
+
+export async function requestMicAndStartVAD(
+  onVoiceStopCallback: () => void,
+  onVoiceStartCallback: () => void,
+  onUpdateCallback: (amplitude: number) => void
+) {
+  return new Promise<void>((resolve, reject) => {
+    try {
+      audioContext = new AudioContext();
+
+      navigator.mediaDevices
+        .getUserMedia({ audio: true })
+        .then((stream) => {
+          currentStream = stream;
+          startRecording(stream);
+          resolve();
+          startUserMedia(audioContext as AudioContext, stream, onVoiceStartCallback, onVoiceStopCallback, onUpdateCallback);
+        })
+        .catch((error) => {
+          handleMicConnectError();
+          reject(error);
+        });
+    } catch (e) {
+      handleUserMediaError();
+      reject(e);
+    }
+  });
+}
+
+function handleUserMediaError() {
+  console.error('Mic input is not supported by the browser.');
+}
+
+function handleMicConnectError() {
+  console.error('Could not connect microphone. Possible rejected by the user or is blocked by the browser.');
+}
+
+export async function stopUserMedia() {
+  wasVoiceStarted = false;
+  if (vadInstance && vadInstance.destroy) {
+    vadInstance.destroy();
+    vadInstance = null;
+  }
+
+  if (currentStream) {
+    currentStream.getTracks().forEach(track => track.stop());
+    currentStream = null;
+  }
+
+  if (audioContext) {
+    audioContext.close();
+    audioContext = null;
+  }
+
+  if (mediaRecorder) {
+    mediaRecorder.stop();
+    mediaRecorder = null;
+  }
+
+}
+
+function startRecording(stream: MediaStream) {
+  recordedChunks = [];
+  mediaRecorder = new MediaRecorder(stream);
+  mediaRecorder.ondataavailable = (event: BlobEvent) => {
+    if (event.data.size > 0) {
+      recordedChunks.push(event.data);
+    }
+  };
+  mediaRecorder.start();
+}
+
+export async function getRecorder(): Promise<Blob | null> {
+  if (!mediaRecorder) {
+    return Promise.resolve(null);
+  }
+
+  const recorder = mediaRecorder;
+  mediaRecorder = null;
+
+  const finalizeBlob = () => {
+    const blob = new Blob(recordedChunks, { type: recorder.mimeType || 'audio/webm' });
+    recordedChunks = [];
+    return blob;
+  };
+
+  if (recorder.state === 'inactive') {
+    return Promise.resolve(finalizeBlob());
+  }
+
+  return new Promise<Blob>((resolve, reject) => {
+    recorder.onstop = () => {
+      resolve(finalizeBlob());
+    };
+    recorder.onerror = () => {
+      recordedChunks = [];
+      reject(new Error('Failed to finalize audio recording.'));
+    };
+    recorder.stop();
+  });
+}
+
+function startUserMedia(
+  audioContext: AudioContext, 
+  stream: MediaStream, 
+  onVoiceStartCallback: () => void,
+  onVoiceStopCallback: () => void,
+  onUpdateCallback: (amplitude: number) => void
+) {
+  const options = {
+    fftSize: 1024,
+    bufferLen: 1024,
+    smoothingTimeConstant: 0.2,
+    minCaptureFreq: 85,         // in Hz
+    maxCaptureFreq: 255,        // in Hz
+    noiseCaptureDuration: CALIBRATION_DURATION, // in ms
+    minNoiseLevel: 0.5,         // from 0 to 1
+    maxNoiseLevel: 0.7,         // from 0 to 1
+    avgNoiseMultiplier: 1.2,
+    onVoiceStart() {
+      wasVoiceStarted = true;
+      if (!mediaRecorder || mediaRecorder.state === 'inactive') {
+        startRecording(currentStream as MediaStream);
+      }
+      console.log('👹👹👹voice start👹👹👹');
+      onVoiceStartCallback();
+    },
+    onVoiceStop() {
+      if (!wasVoiceStarted) {
+        return;
+      }
+      console.log('👿👿👿voice stop👿👿👿');
+      onVoiceStopCallback();
+    }, //Doesn't work properly, so we will handle it with onUpdate callback
+    onUpdate(val: number) {
+      onUpdateCallback(val);
+    }
+  };
+
+  vadInstance = vad(audioContext, stream, options);
+}

package/custom/types.ts

@@ -25,7 +25,7 @@ export interface IToolGroup {
 }
 
 export interface IMessage {
-  role: 'user' | 'assistant';
+  role: 'user' | 'assistant' | 'system';
   metadata?: any,
   parts: IPart[];
 }
@@ -41,4 +41,54 @@ export interface ISessionsListItem {
   sessionId: string;
   title: string;
   timestamp: string;
-}
+}
+
+export type SpeechStreamEvent =
+  | {
+      type: 'error';
+      error: string;
+    }
+  | {
+      type: 'transcript';
+      data: {
+        text: string;
+        language?: string;
+      };
+    }
+  | {
+      type: 'speech-response';
+      data: {
+        transcript: {
+          text: string;
+          language?: string;
+        };
+        response: {
+          text: string;
+        };
+        sessionId: string;
+        turnId: string;
+      };
+    }
+  | {
+      type: 'audio-start';
+      data: {
+        mimeType: string;
+        format: string;
+      };
+    }
+  | {
+      type: 'audio-delta';
+      data: {
+        base64: string;
+      };
+    }
+  | {
+      type: 'audio-done';
+    }
+  | {
+      type: 'data-tool-call';
+      data: any;
+    }
+  | {
+      type: 'finish';
+    };

package/dist/agent/languageDetect.js

@@ -27,12 +27,6 @@ const USER_LANGUAGE_OUTPUT_SCHEMA = {
         required: ["language", "code"],
     },
 };
-export function formatLanguagePrompt(language) {
-    if (!language) {
-        return "Respond in the user's language.";
-    }
-    return `Respond in ${language.language} (${language.code}).`;
-}
 function parseUserLanguage(content) {
     if (!content) {
         return null;