@sveda-ai/vue 0.1.0

package/src/composables/useSvedaStreaming.ts

@@ -0,0 +1,408 @@
+import type {
+  SvedaChatSession,
+  SvedaClient,
+  SvedaDisplayMessage,
+  SvedaMessagePart,
+  SvedaSendOptions,
+  SvedaSessionStatus,
+} from '@sveda-ai/core';
+import type { SvedaContextUsageEvent, SvedaMaxStepsEvent, SvedaToolProgressEvent } from '@sveda-ai/protocol';
+import { computed, inject, nextTick, onUnmounted, ref, watch, type Ref } from 'vue';
+import { useSvedaT } from '../i18n/index';
+import { deriveProvisionalChatTitle, isChatTitlePlaceholder } from '../lib/chatTitle';
+import { SvedaClientKey } from '../plugin';
+
+export interface SvedaStreamingStore {
+  currentChat: Ref<{
+    id: string;
+    title?: string;
+    messages?: SvedaDisplayMessage[];
+  } | null>;
+  setChatMessages: (chatId: string, messages: SvedaDisplayMessage[]) => void;
+  setChatTitle: (chatId: string, title: string) => void;
+  refreshChatTitleFromServer: (chatId: string) => Promise<string | null>;
+  incrementChatTokens: (chatId: string, tokens: number) => void;
+  setChatContextWindowTokens: (chatId: string, tokens: number) => void;
+}
+
+export interface SvedaStreamingOptions {
+  newChatLabel?: () => string;
+  resolveSendOptions?: () => Pick<SvedaSendOptions, 'model' | 'provider' | 'options'>;
+  onMaxStepsReached?: (chatId: string, data: { maxSteps: number }) => void;
+  onToolProgress?: (chatId: string, event: SvedaToolProgressEvent) => void;
+  onContextUsage?: (chatId: string, event: SvedaContextUsageEvent) => void;
+  onError?: (chatId: string, error: unknown) => void;
+  onDone?: (chatId: string) => void;
+}
+
+export type SvedaSendPayload =
+  | string
+  | {
+      displayText: string;
+      promptText: string;
+      attachmentNames?: string[];
+    };
+
+export function useSvedaStreaming(
+  store: SvedaStreamingStore,
+  scrollToBottom: (options?: { behavior?: string; onlyIfNearBottom?: boolean }) => void,
+  options: SvedaStreamingOptions = {}
+) {
+  const t = useSvedaT();
+  const client = inject(SvedaClientKey, null) as SvedaClient | null;
+  if (!client) {
+    throw new Error('[sveda] useSvedaStreaming requires the Sveda plugin to be installed.');
+  }
+
+  const isThinking = ref(false);
+  const thinkingMessage = ref('');
+  const streamingChatIds = ref(new Set<string>());
+  const unreadChatIds = ref(new Set<string>());
+  const statusByChatId = ref<Record<string, SvedaSessionStatus>>({});
+
+  const subscriptions = new Map<string, Array<() => void>>();
+  const displayTextOverrides = new Map<string, Map<string, string>>();
+
+  const setChatStreaming = (chatId: string, streaming: boolean) => {
+    const next = new Set(streamingChatIds.value);
+    if (streaming) {
+      next.add(chatId);
+    } else {
+      next.delete(chatId);
+    }
+    streamingChatIds.value = next;
+  };
+
+  const clearChatUnread = (chatId?: string | null) => {
+    if (!chatId) {
+      return;
+    }
+    const next = new Set(unreadChatIds.value);
+    next.delete(chatId);
+    unreadChatIds.value = next;
+  };
+
+  const resolveNewChatLabel = () => {
+    if (typeof options.newChatLabel === 'function') {
+      return options.newChatLabel();
+    }
+    return t('newChat');
+  };
+
+  const applyProvisionalChatTitle = (chatId: string, userRequest: string) => {
+    if (!store.currentChat.value || store.currentChat.value.id !== chatId) {
+      return;
+    }
+
+    const newChatLabel = resolveNewChatLabel();
+    if (!isChatTitlePlaceholder((store.currentChat.value.title || '').trim(), newChatLabel)) {
+      return;
+    }
+
+    const provisionalTitle = deriveProvisionalChatTitle(userRequest);
+    if (provisionalTitle) {
+      store.setChatTitle(chatId, provisionalTitle);
+    }
+  };
+
+  const scheduleChatTitleRefresh = (chatId: string) => {
+    const newChatLabel = resolveNewChatLabel();
+    const delays = [800, 2500, 6000];
+
+    delays.forEach(delay => {
+      setTimeout(async () => {
+        const title = await store.refreshChatTitleFromServer(chatId);
+        if (!title || isChatTitlePlaceholder(title, newChatLabel)) {
+          return;
+        }
+        store.setChatTitle(chatId, title);
+      }, delay);
+    });
+  };
+
+  const setChatStatus = (chatId: string, status: SvedaSessionStatus) => {
+    const previous = statusByChatId.value[chatId];
+    statusByChatId.value = {
+      ...statusByChatId.value,
+      [chatId]: status,
+    };
+
+    const wasStreaming = previous === 'streaming' || previous === 'submitted';
+    const isStreamingNow = status === 'streaming' || status === 'submitted';
+    setChatStreaming(chatId, isStreamingNow);
+
+    if (wasStreaming && !isStreamingNow && store.currentChat.value?.id !== chatId) {
+      const next = new Set(unreadChatIds.value);
+      next.add(chatId);
+      unreadChatIds.value = next;
+    }
+
+    if (isStreamingNow) {
+      clearChatUnread(chatId);
+    }
+  };
+
+  const applyDisplayOverrides = (
+    chatId: string,
+    messages: SvedaDisplayMessage[]
+  ): SvedaDisplayMessage[] => {
+    const overrides = displayTextOverrides.get(chatId);
+    if (!overrides || overrides.size === 0) {
+      return messages;
+    }
+
+    return messages.map(message => {
+      const override = overrides.get(message.id);
+      if (override === undefined || message.role !== 'user') {
+        return message;
+      }
+
+      const fileParts = message.parts.filter(part => part.type === 'file');
+      const parts: SvedaMessagePart[] = [
+        ...(override ? [{ type: 'text', text: override } as SvedaMessagePart] : []),
+        ...fileParts,
+      ];
+
+      return { ...message, parts };
+    });
+  };
+
+  const ensureSession = (chatId: string): SvedaChatSession => {
+    const session = client.session(chatId);
+    if (subscriptions.has(chatId)) {
+      return session;
+    }
+
+    const offMessages = session.on('messages', () => {
+      store.setChatMessages(chatId, applyDisplayOverrides(chatId, session.messages));
+    });
+
+    const offStatus = session.on('status', payload => {
+      setChatStatus(chatId, payload as SvedaSessionStatus);
+    });
+
+    const offTitle = session.on('title', payload => {
+      if (typeof payload === 'string' && payload.trim()) {
+        store.setChatTitle(chatId, payload);
+      }
+    });
+
+    const offMaxSteps = session.on('maxSteps', payload => {
+      const event = payload as SvedaMaxStepsEvent | undefined;
+      options.onMaxStepsReached?.(chatId, {
+        maxSteps: typeof event?.maxSteps === 'number' ? event.maxSteps : 0,
+      });
+    });
+
+    const offContextUsage = session.on('contextUsage', payload => {
+      const event = payload as SvedaContextUsageEvent | undefined;
+      if (event && typeof event.usedTokens === 'number') {
+        store.setChatContextWindowTokens(chatId, event.usedTokens);
+      }
+      if (event) {
+        options.onContextUsage?.(chatId, event);
+      }
+    });
+
+    const offToolProgress = session.on('toolProgress', payload => {
+      options.onToolProgress?.(chatId, payload as SvedaToolProgressEvent);
+    });
+
+    const offFinish = session.on('finish', payload => {
+      const event = payload as
+        | { usage?: { totalTokens?: number; promptTokens?: number } }
+        | undefined;
+      if (event?.usage) {
+        if (typeof event.usage.totalTokens === 'number') {
+          store.incrementChatTokens(chatId, event.usage.totalTokens);
+        }
+        if (typeof event.usage.promptTokens === 'number') {
+          store.setChatContextWindowTokens(chatId, event.usage.promptTokens);
+        }
+      }
+      void nextTick(() => {
+        options.onDone?.(chatId);
+        scheduleChatTitleRefresh(chatId);
+        if (store.currentChat.value?.id === chatId) {
+          scrollToBottom();
+        }
+      });
+    });
+
+    const offError = session.on('error', payload => {
+      options.onError?.(chatId, payload);
+      void nextTick(() => {
+        options.onDone?.(chatId);
+        if (store.currentChat.value?.id === chatId) {
+          scrollToBottom();
+        }
+      });
+    });
+
+    subscriptions.set(chatId, [
+      offMessages,
+      offStatus,
+      offTitle,
+      offMaxSteps,
+      offContextUsage,
+      offToolProgress,
+      offFinish,
+      offError,
+    ]);
+    setChatStatus(chatId, session.status);
+
+    return session;
+  };
+
+  watch(
+    () => store.currentChat.value?.id,
+    (newId, oldId) => {
+      if (!newId || newId === oldId || !subscriptions.has(newId)) {
+        return;
+      }
+
+      const session = client.session(newId);
+      if (session.isStreaming) {
+        return;
+      }
+
+      session.setMessages(store.currentChat.value?.messages ?? []);
+    }
+  );
+
+  watch(
+    () => statusByChatId.value[store.currentChat.value?.id ?? ''],
+    status => {
+      if (status === 'streaming' || status === 'submitted') {
+        isThinking.value = true;
+        thinkingMessage.value = t('analyzingRequest');
+      } else {
+        isThinking.value = false;
+        thinkingMessage.value = '';
+      }
+    },
+    { immediate: true }
+  );
+
+  const isStreaming = computed(() =>
+    streamingChatIds.value.has(store.currentChat.value?.id ?? '')
+  );
+
+  const stopStreaming = (chatId: string | null | undefined = store.currentChat.value?.id) => {
+    if (!chatId || !subscriptions.has(chatId)) {
+      return;
+    }
+    client.session(chatId).stop();
+    setChatStreaming(chatId, false);
+    isThinking.value = false;
+    thinkingMessage.value = '';
+  };
+
+  const resolveSendOptions = (): SvedaSendOptions => ({
+    ...(options.resolveSendOptions?.() ?? {}),
+  });
+
+  const sendMessage = async (
+    userPayload: SvedaSendPayload,
+    pageContext: Record<string, unknown> = {}
+  ) => {
+    let displayText = '';
+    let promptText = '';
+    let attachmentNames: string[] = [];
+
+    if (typeof userPayload === 'string') {
+      displayText = userPayload.trim();
+      promptText = displayText;
+    } else if (userPayload && typeof userPayload === 'object') {
+      displayText = String(userPayload.displayText ?? '').trim();
+      promptText = String(userPayload.promptText ?? '').trim();
+      attachmentNames = Array.isArray(userPayload.attachmentNames)
+        ? userPayload.attachmentNames.map(name => String(name).trim()).filter(Boolean)
+        : [];
+    } else {
+      return;
+    }
+
+    if (!promptText || !store.currentChat.value) {
+      return;
+    }
+
+    const chatId = store.currentChat.value.id;
+    applyProvisionalChatTitle(chatId, promptText || displayText);
+    const session = ensureSession(chatId);
+    session.setMessages(store.currentChat.value.messages ?? []);
+
+    const sendOptions: SvedaSendOptions = {
+      ...resolveSendOptions(),
+      context: { ...pageContext },
+      ...(attachmentNames.length > 0
+        ? { files: attachmentNames.map(name => ({ name })) }
+        : {}),
+    };
+
+    const sendPromise = session.send(promptText, sendOptions);
+
+    if (displayText !== promptText) {
+      const userMessage = [...session.messages].reverse().find(message => message.role === 'user');
+      if (userMessage) {
+        if (!displayTextOverrides.has(chatId)) {
+          displayTextOverrides.set(chatId, new Map());
+        }
+        displayTextOverrides.get(chatId)!.set(userMessage.id, displayText);
+        store.setChatMessages(chatId, applyDisplayOverrides(chatId, session.messages));
+      }
+    }
+
+    try {
+      await sendPromise;
+    } catch {
+      return;
+    }
+
+    scrollToBottom();
+  };
+
+  const continueAfterMaxSteps = async (pageContext: Record<string, unknown> = {}) => {
+    const chatId = store.currentChat.value?.id;
+    if (!chatId) {
+      return;
+    }
+
+    const session = ensureSession(chatId);
+    if (session.messages.length === 0) {
+      session.setMessages(store.currentChat.value?.messages ?? []);
+    }
+
+    try {
+      await session.continueAfterMaxSteps({
+        ...resolveSendOptions(),
+        context: { ...pageContext },
+      });
+    } catch {
+      return;
+    }
+
+    scrollToBottom();
+  };
+
+  onUnmounted(() => {
+    for (const [chatId, unsubscribes] of subscriptions.entries()) {
+      client.session(chatId).stop();
+      unsubscribes.forEach(off => off());
+    }
+    subscriptions.clear();
+    displayTextOverrides.clear();
+  });
+
+  return {
+    sendMessage,
+    continueAfterMaxSteps,
+    isStreaming,
+    isThinking,
+    thinkingMessage,
+    stopStreaming,
+    streamingChatIds,
+    unreadChatIds,
+    clearChatUnread,
+  };
+}

package/src/composables/useSvedaTool.ts

@@ -0,0 +1,18 @@
+import type { SvedaFrontendTool } from '@sveda-ai/core';
+import { inject, onUnmounted } from 'vue';
+import { SvedaClientKey } from '../plugin';
+
+export type UseSvedaToolOptions = SvedaFrontendTool;
+
+export function useSvedaTool(tool: UseSvedaToolOptions): void {
+  const client = inject(SvedaClientKey, null);
+  if (!client) {
+    return;
+  }
+
+  const unregister = client.toolRegistry.register(tool);
+
+  onUnmounted(() => {
+    unregister();
+  });
+}

package/src/i18n/index.ts

@@ -0,0 +1,72 @@
+import { inject, reactive, type App, type InjectionKey } from 'vue';
+
+export type SvedaMessages = Record<string, string>;
+
+export interface SvedaI18n {
+  readonly locale: string;
+  t(key: string, params?: Record<string, unknown>): string;
+  setLocale(locale: string): void;
+  extend(locale: string, messages: SvedaMessages): void;
+}
+
+export interface SvedaI18nOptions {
+  locale?: string;
+  fallbackLocale?: string;
+  messages?: Record<string, SvedaMessages>;
+}
+
+export const SvedaI18nKey: InjectionKey<SvedaI18n> = Symbol('sveda-i18n');
+
+export function createSvedaI18n(options: SvedaI18nOptions = {}): SvedaI18n {
+  const state = reactive({
+    locale: options.locale ?? 'en',
+    fallbackLocale: options.fallbackLocale ?? 'en',
+    messages: { ...(options.messages ?? {}) } as Record<string, SvedaMessages>,
+  });
+
+  const interpolate = (template: string, params?: Record<string, unknown>): string => {
+    if (!params) {
+      return template;
+    }
+
+    return template.replace(/\{(\w+)\}/g, (match, name: string) =>
+      params[name] === undefined || params[name] === null ? match : String(params[name])
+    );
+  };
+
+  return {
+    get locale() {
+      return state.locale;
+    },
+    t(key: string, params?: Record<string, unknown>): string {
+      const message =
+        state.messages[state.locale]?.[key] ?? state.messages[state.fallbackLocale]?.[key];
+
+      if (message === undefined) {
+        return key;
+      }
+
+      return interpolate(message, params);
+    },
+    setLocale(locale: string): void {
+      state.locale = locale;
+    },
+    extend(locale: string, messages: SvedaMessages): void {
+      state.messages[locale] = { ...(state.messages[locale] ?? {}), ...messages };
+    },
+  };
+}
+
+export function installSvedaI18n(app: App, i18n: SvedaI18n): void {
+  app.provide(SvedaI18nKey, i18n);
+}
+
+export function useSvedaT(): (key: string, params?: Record<string, unknown>) => string {
+  const i18n = inject(SvedaI18nKey);
+
+  if (!i18n) {
+    return (key: string) => key;
+  }
+
+  return (key, params) => i18n.t(key, params);
+}

package/src/i18n/locales/en.ts

@@ -0,0 +1,58 @@
+import type { SvedaMessages } from '../index';
+
+const en: SvedaMessages = {
+  chatTitle: 'AI Assistant',
+  welcomeMessage: "Hi! I'm your AI assistant. How can I help you today?",
+  newChat: 'New Chat',
+  newChatNumbered: 'New Chat {number}',
+  chatHistory: 'Chat History',
+  closeChatTab: 'Close chat tab',
+  chatTabRunning: 'Agent is working',
+  chatTabUnread: 'New response ready',
+  quickPromptsTitle: 'Ask me anything',
+  confirmDeleteChat: 'Are you sure you want to delete this chat?',
+  renameChat: 'Rename chat',
+  renameChatPlaceholder: 'Enter chat name',
+  analyzingRequest: 'Analyzing your request...',
+  errorSendingMessage: 'Failed to send message. Please try again.',
+  agentFinishedNotice: 'Agent finished',
+  maxStepsReachedNotice:
+    'The agent reached the step limit for this request ({limit}). Press Continue to resume in this chat.',
+  maxStepsContinue: 'Continue',
+  maxStepsContinuePrompt:
+    'Continue from where you stopped. Briefly summarize what you already found, then keep working on the task.',
+  viewModeFixed: 'Switch to fixed view',
+  viewModeFloating: 'Switch to floating view',
+  immersiveModeEnter: 'Immersive mode',
+  immersiveModeExit: 'Exit immersive mode',
+  toolbarMinimize: 'Minimize',
+  modelSelectPlaceholder: 'Model',
+  thinkingTooltip:
+    'Chain-of-thought reasoning before the answer. Improves accuracy; responses may take longer.',
+  assistantLogoAlt: 'AI assistant',
+  contextWindowUsage: 'Context window usage',
+  contextWindowPercent: 'Used: {percent}%',
+  chatDocumentsExtracting: 'Extracting text from documents…',
+  chatDocumentsHeader: 'Attached document content:',
+  chatDocumentTruncatedNotice: '[Truncated: reached extracted-text limit for this message.]',
+  chatDocumentErrorReadFailed: 'Could not read the file.',
+  chatDocumentErrorEmpty: 'Could not extract text from the file.',
+  chatDocumentErrorQuotaExceeded: '[Skipped: overall extracted-text limit reached.]',
+  chatDocumentErrorUnknown: 'Could not extract text from this file.',
+  chatDocumentsExtractFailed: 'Could not process attachments. Please try again.',
+  chatAttachmentOnlyPlaceholder: 'Documents: {names}',
+  agentTasksTitle: 'Parallel agents',
+  agentTasksSpawnPhase: 'Batch agent run',
+  phaseSearchSubagents: 'Search scouts',
+  phaseToolCalling: 'Using tools',
+  agentTaskStatusPending: 'Pending',
+  agentTaskStatusRunning: 'Running',
+  agentTaskStatusCompleted: 'Done',
+  agentTaskStatusFailed: 'Error',
+  commonDelete: 'Delete',
+  commonCancel: 'Cancel',
+  commonSave: 'Save',
+  commonError: 'Error',
+};
+
+export default en;

package/src/i18n/locales/ru.ts

@@ -0,0 +1,59 @@
+import type { SvedaMessages } from '../index';
+
+const ru: SvedaMessages = {
+  chatTitle: 'AI Ассистент',
+  welcomeMessage: 'Привет! Я ваш AI-ассистент. Чем могу помочь?',
+  newChat: 'Новый чат',
+  newChatNumbered: 'Новый чат {number}',
+  chatHistory: 'История чатов',
+  closeChatTab: 'Закрыть вкладку чата',
+  chatTabRunning: 'Агент работает',
+  chatTabUnread: 'Есть новый ответ',
+  quickPromptsTitle: 'Спросите меня о чём угодно',
+  confirmDeleteChat: 'Вы уверены, что хотите удалить этот чат?',
+  renameChat: 'Переименовать чат',
+  renameChatPlaceholder: 'Введите название чата',
+  analyzingRequest: 'Анализирую ваш запрос...',
+  errorSendingMessage: 'Не удалось отправить сообщение. Попробуйте ещё раз.',
+  agentFinishedNotice: 'Агент закончил работу',
+  maxStepsReachedNotice:
+    'Агент достиг лимита шагов за этот запрос ({limit}). Нажмите «Продолжить», чтобы продолжить в этом чате.',
+  maxStepsContinue: 'Продолжить',
+  maxStepsContinuePrompt:
+    'Продолжи с того места, где остановился. Кратко резюмируй, что уже выяснил, и продолжай задачу.',
+  viewModeFixed: 'Переключить на фиксированный вид',
+  viewModeFloating: 'Переключить на плавающий вид',
+  immersiveModeEnter: 'Иммерсивный режим',
+  immersiveModeExit: 'Выйти из иммерсивного режима',
+  toolbarMinimize: 'Свернуть',
+  modelSelectPlaceholder: 'Модель',
+  thinkingTooltip:
+    'Пошаговое рассуждение перед ответом. Повышает точность, но ответ может занять больше времени.',
+  assistantLogoAlt: 'AI ассистент',
+  contextWindowUsage: 'Использование контекстного окна',
+  contextWindowPercent: 'Использовано: {percent}%',
+  chatDocumentsExtracting: 'Извлекаем текст из документов…',
+  chatDocumentsHeader: 'Содержимое вложённых документов:',
+  chatDocumentTruncatedNotice: '[Текст усечён: достигнут лимит символов для сообщения.]',
+  chatDocumentErrorReadFailed: 'Не удалось прочитать файл.',
+  chatDocumentErrorEmpty: 'Текст из файла извлечь не удалось.',
+  chatDocumentErrorQuotaExceeded:
+    '[Файл пропущен: превышен общий лимит объёма извлекаемого текста.]',
+  chatDocumentErrorUnknown: 'Не удалось извлечь текст из файла.',
+  chatDocumentsExtractFailed: 'Не удалось распознать вложения. Попробуйте ещё раз.',
+  chatAttachmentOnlyPlaceholder: 'Документы: {names}',
+  agentTasksTitle: 'Параллельные агенты',
+  agentTasksSpawnPhase: 'Пакетный запуск агентов',
+  phaseSearchSubagents: 'Поисковые скауты',
+  phaseToolCalling: 'Вызов инструментов',
+  agentTaskStatusPending: 'Ожидание',
+  agentTaskStatusRunning: 'Выполняется',
+  agentTaskStatusCompleted: 'Готово',
+  agentTaskStatusFailed: 'Ошибка',
+  commonDelete: 'Удалить',
+  commonCancel: 'Отмена',
+  commonSave: 'Сохранить',
+  commonError: 'Ошибка',
+};
+
+export default ru;