@adminforth/agent 2.0.10 → 2.2.0

package/custom/composables/agentStore/useAgentSessions.ts

@@ -1,350 +0,0 @@
-import type { ComputedRef, Ref, ShallowRef } from 'vue';
-import { callAdminForthApi } from '@/utils';
-import type { Chat } from '../../chat';
-import type { IAgentSession, ISessionsListItem, IPart } from '../../types';
-import { PRE_SESSION_ID } from './constants';
-import { i18nInstance } from '@/i18n';
-
-type AdminforthLike = {
-  confirm(options: { title?: string; message?: string; yes?: string; no?: string; dangerous?: boolean }): Promise<boolean>;
-};
-
-type CreateAgentSessionManagerOptions = {
-  activeSessionId: Ref<string | null>;
-  currentSession: Ref<IAgentSession | null>;
-  sessionList: Ref<ISessionsListItem[]>;
-  sessions: Ref<Record<string, IAgentSession>>;
-  currentChat: ShallowRef<Chat<any> | null | undefined>;
-  trimmedUserMessage: ComputedRef<string>;
-  isResponseInProgress: ComputedRef<boolean>;
-  isMessageInputBlocked: ComputedRef<boolean>;
-  userMessageInput: Ref<any>;
-  lastMessage: Ref<string>;
-  blockCloseOfChat: Ref<boolean>;
-  adminforth: AdminforthLike;
-  setCurrentChat: (sessionId: string) => void;
-};
-
-export function createAgentSessionManager({
-  activeSessionId,
-  currentSession,
-  sessionList,
-  sessions,
-  currentChat,
-  trimmedUserMessage,
-  isResponseInProgress,
-  isMessageInputBlocked,
-  userMessageInput,
-  lastMessage,
-  blockCloseOfChat,
-  adminforth,
-  setCurrentChat,
-}: CreateAgentSessionManagerOptions) {
-  function sortSessionsListByTimestamp(sessionsListToSort: ISessionsListItem[]) {
-    return [...sessionsListToSort].sort((a: ISessionsListItem, b: ISessionsListItem) => b.timestamp.localeCompare(a.timestamp));
-  }
-
-  function t(key: string) {
-    return i18nInstance?.global.t(key) ?? key;
-  }
-
-  function saveCurrentSessionInCache() {
-    if (currentSession.value) {
-      currentSession.value.messages = currentChat.value?.messages.map((m: any) => ({
-        role: m.role,
-        text: m.parts.map((p: IPart) => p.type === 'text' ? p.text : '').join(''),
-      })) || [];
-      sessions.value[currentSession.value.sessionId] = currentSession.value;
-    }
-  }
-
-  async function fetchSession(sessionId: string) {
-    try {
-      const res = await callAdminForthApi({
-        method: 'POST',
-        path: '/agent/get-session-info',
-        body: { sessionId },
-      });
-      if (res.error) {
-        console.error('Error fetching session:', res.error);
-        return;
-      }
-      sessions.value[sessionId] = res.session;
-      setCurrentChat(sessionId);
-    } catch (error) {
-      console.error('Error fetching session', error);
-    }
-  }
-
-  async function setActiveSession(sessionId: string) {
-    activeSessionId.value = sessionId;
-    saveCurrentSessionInCache();
-    if (!sessions.value[sessionId]) {
-      await fetchSession(sessionId);
-    }
-    currentSession.value = sessions.value[sessionId];
-    setCurrentChat(sessionId);
-    if (currentChat.value.messages.length === 0) {
-      currentChat.value.messages = currentSession.value?.messages.map((m: any) => ({
-        role: m.role,
-        parts:[{
-          type: 'text',
-          text: m.text,
-          state: 'done',
-        }]
-      }));
-    }
-  }
-
-  async function deletePreSession() {
-    sessionList.value = sessionList.value.filter((s: ISessionsListItem) => s.sessionId !== PRE_SESSION_ID);
-    if (activeSessionId.value === PRE_SESSION_ID) {
-      activeSessionId.value = null;
-      currentSession.value = null;
-    }
-  }
-
-  async function createNewSession(triggerMessage?: string) {
-    try {
-      const res = await callAdminForthApi({
-        method: 'POST',
-        path: '/agent/create-session',
-        body: {
-          triggerMessage
-        },
-      });
-      if (res.error) {
-        console.error('Error creating new session:', res.error);
-        return;
-      }
-      deletePreSession();
-      sessions.value[res.sessionId] = res;
-      sessionList.value.unshift({
-        sessionId: res.sessionId,
-        title: res.title,
-        timestamp: new Date().toISOString(),
-      });
-      setActiveSession(res.sessionId);
-    } catch (error) {
-      console.error('Error creating new session', error);
-    }
-  }
-
-  async function sendMessage() {
-    const message = trimmedUserMessage.value;
-    if (!message || isMessageInputBlocked.value) {
-      return;
-    }
-    if (!currentSession.value || currentSession.value.sessionId === PRE_SESSION_ID) {
-      await createNewSession(message);
-    }
-    currentSession.value!.timestamp = new Date().toISOString();
-    sessionList.value = sortSessionsListByTimestamp(sessionList.value.map((s: ISessionsListItem) => s.sessionId === currentSession.value?.sessionId ? {
-      ...s,
-      timestamp: currentSession.value?.timestamp || s.timestamp,
-    } : s));
-    lastMessage.value = message;
-    currentChat.value?.sendMessage({
-      text: message,
-    });
-    userMessageInput.value = '';
-  }
-
-  async function createPreSession() {
-    saveCurrentSessionInCache();
-    if (!sessionList.value.some((s: ISessionsListItem) => s.sessionId === PRE_SESSION_ID)) {
-      sessionList.value.unshift({
-        sessionId: PRE_SESSION_ID,
-        title: 'New Session',
-        timestamp: new Date().toISOString(),
-      });
-    }
-
-    activeSessionId.value = PRE_SESSION_ID;
-    currentSession.value = {
-      sessionId: PRE_SESSION_ID,
-      title: 'New Session',
-      timestamp: new Date().toISOString(),
-      messages: [],
-    };
-    sessions.value[PRE_SESSION_ID] = currentSession.value;
-    setCurrentChat(PRE_SESSION_ID);
-  }
-
-  async function deleteSession(sessionId: string) {
-    if (sessionId === PRE_SESSION_ID) {
-      deletePreSession();
-      return;
-    }
-    blockCloseOfChat.value = true;
-    const isConfirmed = await adminforth.confirm({title: t('Are you sure, that you want to delete this session?'), message: t('This process is irreversible.'), yes: 'Yes', no: 'No', dangerous: true});
-    blockCloseOfChat.value = false;
-    if (!isConfirmed) {
-      return;
-    }
-    try {
-      const res = await callAdminForthApi({
-        method: 'POST',
-        path: '/agent/delete-session',
-        body: { sessionId },
-      });
-      if (res.error) {
-        console.error('Error deleting session:', res.error);
-        return;
-      }
-      delete sessions.value[sessionId];
-      sessionList.value = sessionList.value.filter((s: ISessionsListItem) => s.sessionId !== sessionId);
-      if (activeSessionId.value === sessionId) {
-        activeSessionId.value = null;
-        currentSession.value = null;
-      }
-    } catch (error) {
-      console.error('Error deleting session', error);
-    }
-    if(sessionId === activeSessionId.value) {
-      activeSessionId.value = sessionList.value.length > 0 ? sessionList.value[0].sessionId : null;
-      if (activeSessionId.value) {
-        currentSession.value = sessions.value[activeSessionId.value] || null;
-      } else {
-        currentSession.value = null;
-      }
-    }
-    createPreSession();
-  }
-
-  async function fetchSessionsList() {
-    try {
-      const res = await callAdminForthApi({
-        method: 'POST',
-        path: '/agent/get-sessions',
-        body: {
-          limit: 100,
-        },
-      });
-      if (res.error) {
-        console.error('Error fetching sessions list:', res.error);
-        return;
-      }
-      sessionList.value = res.sessions;
-    } catch (error) {
-      console.error('Error fetching sessions list', error);
-    }
-  }
-
-  function addDebugMessage(message: string) {
-    const debugMessage = {
-      role: 'assistant',
-      parts: [{
-        type: 'text',
-        text: message,
-        state: 'done',
-      }]
-    };
-    currentChat.value?.messages.push(debugMessage);
-  }
-
-  async function addSystemMessage(message: string) {
-    if (!currentSession.value || currentSession.value.sessionId === PRE_SESSION_ID) {
-      await createNewSession('Audio chat');
-    }
-    const systemMessage = {
-      role: 'system',
-      parts: [{
-        type: 'text',
-        text: message,
-        state: 'done',
-      }]
-    };
-    currentChat.value?.messages.push(systemMessage);
-    try {
-      const res = await callAdminForthApi({
-        method: 'POST',
-        path: '/agent/add-system-message-to-turns',
-        body: {
-          sessionId: activeSessionId.value,
-          systemMessage: message,
-        },
-      });
-    } catch (error) {
-      console.error('Error adding system message', error);
-    }
-  }
-
-  function addAgentMessage(message: string) {
-    const agentMessage = {
-      role: 'assistant',
-      parts: [{
-        type: 'text',
-        text: message,
-        state: 'done',
-      }]
-    };
-    currentChat.value?.messages.push(agentMessage);
-  }
-
-  function updateLastAgentMessage(message: string) {
-    const lastMsg = currentChat.value?.lastMessage;
-    if (lastMsg && lastMsg.role === 'assistant') {
-      lastMsg.parts = [{
-        type: 'text',
-        text: message,
-        state: 'done',
-      }];
-      currentChat.value?.messages.splice(currentChat.value.messages.length - 1, 1, lastMsg);
-    } else {
-      addAgentMessage(message);
-    }
-  }
-
-  function addUserMessage(message: string) {
-    const userMessage = {
-      role: 'user',
-      parts: [{
-        type: 'text',
-        text: message,
-        state: 'done',
-      }]
-    };
-    currentChat.value?.messages.push(userMessage);
-  }
-
-
-  function addDataToolCallMessage(data: any) {
-    const lastMessage = currentChat.value?.lastMessage;
-    if (lastMessage.role === 'assistant') {
-      lastMessage.parts.push({
-        type: 'data-tool-call',
-        data,
-      });
-      currentChat.value?.messages.splice(currentChat.value.messages.length - 1, 1, lastMessage);
-    } else {
-      const toolCallMessage = {
-        role: 'assistant',
-        parts: [{
-          type: 'data-tool-call',
-          data,
-        }]
-      };
-      currentChat.value?.messages.push(toolCallMessage);
-    }
-  }
-
-  function setCurrentChatStatus(status: any) { // ChatStatus type
-    (currentChat.value as any)?.setStatus({status});
-  }
-
-  return {
-    sendMessage,
-    createPreSession,
-    setActiveSession,
-    fetchSessionsList,
-    deleteSession,
-    addDebugMessage,
-    addSystemMessage,
-    addAgentMessage,
-    addUserMessage,
-    addDataToolCallMessage,
-    setCurrentChatStatus,
-    updateLastAgentMessage
-  };
-}

package/custom/composables/useAgentAudio.ts

@@ -1,272 +0,0 @@
-import adminforth from "@/adminforth";
-import { useAgentStore } from "./useAgentStore";
-import { defineStore } from 'pinia';
-import type { SpeechStreamEvent } from '../types';
-import { ref } from 'vue';
-import { getCurrentPageContext } from './agentStore/pageContext';
-import {
-  createChatResponseAudioPlayback,
-  endStandByAudio,
-  finishChatResponseAudio,
-  playChatResponseCurrentChunks,
-  startStandByAudio,
-  stopChatResponseAudio,
-  unlockAudio,
-} from './agentAudio/utils';
-import type { ChatResponseAudioPlayback } from './agentAudio/utils';
-
-let isStandByAudioPlaying = false;
-async function playStandByAudio() {
-  isStandByAudioPlaying = true;
-  await startStandByAudio();
-}
-
-function stopStandByAudio() {
-  endStandByAudio();
-  isStandByAudioPlaying = false;
-}
-
-export const useAgentAudio = defineStore('agentAudio', () => {
-  const agentStore = useAgentStore();
-  const agentAudioMode = ref<'transcribing' | 'streaming' | 'fetchingAudio' | 'playingAgentResponse' | 'readyToRespond' >('readyToRespond');
-  const isStreamingResponse = ref(false);
-    
-  let currentAbortController: AbortController | null = null;
-  let currentStreamingAudio: ChatResponseAudioPlayback | null = null;
-  let wasAudioResponseReceived = false;
-
-  function stopGenerationAndAudio() {
-    setAudioModeReadyToRespond();
-    stopCurrentAudioPlayback();
-    currentAbortController?.abort();
-  }
-
-  function setAudioModeReadyToRespond() {
-    agentAudioMode.value = 'readyToRespond';
-  }
-
-  async function sendAudioToServerAndHandleResponse(blob: Blob) {
-    currentAbortController = new AbortController();
-    wasAudioResponseReceived = false;
-    const formData = new FormData();
-    formData.append('file', blob, 'user_prompt.wav');
-    formData.append('sessionId', agentStore.activeSessionId);
-    formData.append('mode', agentStore.activeModeName ?? '');
-    formData.append('timeZone', Intl.DateTimeFormat().resolvedOptions().timeZone);
-    formData.append('currentPage', JSON.stringify(getCurrentPageContext()));
-    const fullPath = `${import.meta.env.VITE_ADMINFORTH_PUBLIC_PATH || ''}/adminapi/v1/agent/speech-response`;
-    try {
-      agentAudioMode.value = 'transcribing';
-      console.log('Sending audio to server for transcription and response generation');
-      const res = await fetch(fullPath, {
-        method: 'POST',
-        body: formData,
-        headers: {
-          Accept: 'text/event-stream',
-        },
-        signal: currentAbortController!.signal,
-      });
-      isStreamingResponse.value = true;
-      if (res.ok) {
-        agentAudioMode.value = 'streaming';
-        await readSpeechResponseStream(res);
-      } else {
-        console.error('Failed to transcribe audio:', res.statusText);
-        adminforth.alert({message: 'Failed to transcribe audio', variant: 'danger'});
-      }
-    } catch (error) {
-      if (error instanceof DOMException && error.name === 'AbortError') {
-        //
-      } else {
-        console.error('Error sending audio to server:', error);
-      }
-    } finally {
-      isStreamingResponse.value = false;
-      if (!wasAudioResponseReceived) {
-        setAudioModeReadyToRespond();
-      }
-    }
-  }
-
-  async function readSpeechResponseStream(res: Response) {
-    const reader = res.body?.getReader();
-    if (!reader) {
-      adminforth.alert({message: 'Speech response stream is not available', variant: 'danger'});
-      return;
-    }
-
-    const decoder = new TextDecoder();
-    let buffer = '';
-
-    agentStore.setCurrentChatStatus('streaming');
-    try {
-      while (true) {
-        const { value, done } = await reader.read();
-
-        if (done) {
-          break;
-        }
-
-        buffer += decoder.decode(value, { stream: true });
-        const eventBlocks = buffer.split('\n\n');
-        buffer = eventBlocks.pop() ?? '';
-
-        for (const eventBlock of eventBlocks) {
-          await handleSpeechStreamEvent(eventBlock);
-        }
-      }
-
-      buffer += decoder.decode();
-
-      if (buffer.trim()) {
-        await handleSpeechStreamEvent(buffer);
-      }
-
-      finishAudioStream();
-    } finally {
-      reader.releaseLock();
-      agentStore.setCurrentChatStatus('ready');
-    }
-  }
-
-  async function handleSpeechStreamEvent(eventBlock: string) {
-    if (currentAbortController?.signal.aborted) {
-      return;
-    }
-    const data = eventBlock
-      .split('\n')
-      .filter((line) => line.startsWith('data:'))
-      .map((line) => line.slice(5).trimStart())
-      .join('\n');
-    if (!data || data === '[DONE]') {
-      return;
-    }
-
-    const event = JSON.parse(data) as SpeechStreamEvent;
-    console.log('Received speech stream event type:', event.type);
-
-    if (event.type === 'error') {
-
-      return;
-    }
-
-    if (event.type === 'transcript') {
-      agentStore.addUserMessage(event.data.text);
-      agentStore.updateLastAgentMessage('');
-      return;
-    }
-
-    if (event.type === 'speech-response') {
-      stopStandByAudio();
-      agentStore.setCurrentChatStatus('ready');
-      agentStore.addAgentMessage(event.data.response.text);
-      return;
-    }
-
-    if (event.type === 'audio-start') {
-      wasAudioResponseReceived = true;
-      isStreamingResponse.value = false;
-      agentAudioMode.value = 'fetchingAudio';
-      initializeAudioStream(event.data);
-      agentAudioMode.value = 'playingAgentResponse';
-      return;
-    }
-
-    if (event.type === 'audio-delta') {
-      appendAudioChunk(event.data.base64);
-      return;
-    }
-
-    if (event.type === 'audio-done') {
-      finishAudioStream();
-      return;
-    }
-
-    if (event.type === 'data-tool-call') {
-      if (!isStandByAudioPlaying) {
-        playStandByAudio();
-      }
-      agentStore.addDataToolCallMessage(event.data);
-      return;
-    }
-
-    if (event.type === 'open-page') {
-      agentStore.openAgentPage(event.data.targetPath);
-    }
-  }
-
-  function initializeAudioStream(audioData: Extract<SpeechStreamEvent, { type: 'audio-start' }>['data']) {
-    stopCurrentAudioPlayback();
-    currentStreamingAudio = createChatResponseAudioPlayback({
-      sampleRate: audioData.sampleRate,
-      channelCount: audioData.channelCount,
-      bitsPerSample: audioData.bitsPerSample,
-      onEnded: handleAudioEnded,
-    });
-  }
-
-  function appendAudioChunk(base64: string) {
-    playChatResponseCurrentChunks({
-      playback: currentStreamingAudio!,
-      chunks: [base64ToArrayBuffer(base64)],
-    });
-  }
-
-  function finishAudioStream() {
-    finishChatResponseAudio(currentStreamingAudio);
-  }
-
-  function stopCurrentAudioPlayback(dontResetMode = false) {
-    stopStandByAudio();
-    stopChatResponseAudio(currentStreamingAudio);
-    currentStreamingAudio = null;
-    if (!dontResetMode) {
-      setAudioModeReadyToRespond();
-    }
-  }
-
-  function handleAudioEnded() {
-    currentStreamingAudio = null;
-    setAudioModeReadyToRespond();
-  }
-
-  function base64ToArrayBuffer(base64: string) {
-    const binary = atob(base64);
-    const bytes = new Uint8Array(binary.length);
-
-    for (let i = 0; i < binary.length; i += 1) {
-      bytes[i] = binary.charCodeAt(i);
-    }
-
-    return bytes.buffer;
-  }
-
-  function playBeep(freq = 800, duration = 0.05) {
-    const ctx = new AudioContext();
-    const osc = ctx.createOscillator();
-    const gain = ctx.createGain();
-
-    osc.frequency.value = freq;
-    osc.type = 'sine';
-
-    osc.connect(gain);
-    gain.connect(ctx.destination);
-
-    osc.start();
-
-    gain.gain.setValueAtTime(1, ctx.currentTime);
-    gain.gain.exponentialRampToValueAtTime(0.001, ctx.currentTime + duration);
-
-    osc.stop(ctx.currentTime + duration);
-  }
-
-  return {
-    sendAudioToServerAndHandleResponse,
-    stopGenerationAndAudio,
-    stopCurrentAudioPlayback,
-    playBeep,
-    agentAudioMode,
-    unlockAudio,
-  };
-
-});