@sveda-ai/vue 0.1.0

package/src/index.ts

@@ -0,0 +1,141 @@
+export * from '@sveda-ai/core';
+
+export {
+  default,
+  createSveda,
+  useSvedaClient,
+  useSvedaConfig,
+  SvedaClientKey,
+  SvedaConfigKey,
+  SvedaHostEmbedKey,
+  SvedaFillHostKey,
+  SvedaHideLauncherKey,
+} from './plugin';
+export type {
+  SvedaPluginOptions,
+  SvedaPlugin,
+  SvedaConfig,
+  SvedaBrand,
+  SvedaModelOption,
+  SvedaQuickPrompt,
+} from './plugin';
+
+export {
+  applySvedaAppearance,
+  buildAppearanceCss,
+  formatRadiusPx,
+  hexToHsl,
+  hslToHex,
+  isSvedaHsl,
+  parseRadiusPx,
+  resolveSvedaAppearance,
+  sanitizeSvedaLauncher,
+  sanitizeSvedaLauncherImage,
+  sanitizeSvedaRadius,
+  sanitizeSvedaTheme,
+  useSvedaLauncher,
+  svedaLauncher,
+  SVEDA_APPEARANCE_PRESET_IDS,
+  SVEDA_APPEARANCE_PRESETS,
+  SVEDA_APPEARANCE_STYLE_ID,
+  SVEDA_DEFAULT_LAUNCHER_ICON,
+  SVEDA_LAUNCHER_ICON_IDS,
+  SVEDA_LAUNCHER_IMAGE_MAX_BYTES,
+  SVEDA_LAUNCHER_IMAGE_MAX_CHARS,
+  SVEDA_TOKEN_KEYS,
+} from './appearance';
+export type {
+  SvedaAppearance,
+  SvedaAppearanceLauncher,
+  SvedaAppearancePresetId,
+  SvedaAppearanceTheme,
+  SvedaAppearanceTokens,
+  SvedaLauncherIconId,
+  SvedaTokenKey,
+} from './appearance';
+export { svedaLauncherIconComponent, svedaLauncherIconMap } from './launcherIcons';
+
+export { createSvedaI18n, installSvedaI18n, useSvedaT, SvedaI18nKey } from './i18n/index';
+export type { SvedaI18n, SvedaI18nOptions, SvedaMessages } from './i18n/index';
+
+export { default as SvedaChat } from './components/shell/SvedaChat.vue';
+export { default as Toaster } from './ui/toast/Toaster.vue';
+export { default as SvedaToolbar } from './components/shell/SvedaToolbar.vue';
+export { default as SvedaTabs } from './components/shell/SvedaTabs.vue';
+export { default as SvedaLandingView } from './components/shell/SvedaLandingView.vue';
+export { default as SvedaInputSection } from './components/shell/SvedaInputSection.vue';
+export { default as SvedaModelControls } from './components/shell/SvedaModelControls.vue';
+export { default as SvedaModelSelect } from './components/shell/SvedaModelSelect.vue';
+export { default as SvedaQuickPrompts } from './components/shell/SvedaQuickPrompts.vue';
+export { default as SvedaHistorySheet } from './components/shell/SvedaHistorySheet.vue';
+export { default as SvedaHistorySidebar } from './components/shell/SvedaHistorySidebar.vue';
+export { default as SvedaAgentTasksPanel } from './components/shell/SvedaAgentTasksPanel.vue';
+export { default as SvedaAgentCompletedNotice } from './components/shell/SvedaAgentCompletedNotice.vue';
+export { default as SvedaMaxStepsNotice } from './components/shell/SvedaMaxStepsNotice.vue';
+export { default as SvedaContextUsageBar } from './components/shell/SvedaContextUsageBar.vue';
+export { default as SvedaResizeHandles } from './components/shell/SvedaResizeHandles.vue';
+export { default as SvedaMinimizedTrigger } from './components/shell/SvedaMinimizedTrigger.vue';
+
+export { useSvedaChat } from './composables/useSvedaChat';
+export type { SvedaChatHistory, SvedaChatState } from './composables/useSvedaChat';
+export { useSvedaStreaming } from './composables/useSvedaStreaming';
+export type {
+  SvedaStreamingStore,
+  SvedaStreamingOptions,
+  SvedaSendPayload,
+} from './composables/useSvedaStreaming';
+export {
+  useSvedaChatLayout,
+  SVEDA_CHAT_LAYOUT_MIN_WIDTH,
+  SVEDA_CHAT_LAYOUT_MIN_HEIGHT,
+  SVEDA_CHAT_LAYOUT_MAX_WIDTH,
+  SVEDA_CHAT_LAYOUT_MAX_HEIGHT,
+  SVEDA_CHAT_MAIN_CONTENT_MIN_WIDTH,
+} from './composables/useSvedaChatLayout';
+export type { SvedaChatViewMode } from './composables/useSvedaChatLayout';
+export { useSvedaAgentTasks } from './composables/useSvedaAgentTasks';
+export type {
+  SvedaAgentTaskItem,
+  SvedaAgentTasksState,
+  SvedaAgentTasksPayload,
+} from './composables/useSvedaAgentTasks';
+export { useSvedaChatPage } from './composables/useSvedaChatPage';
+export type { SvedaChatPageOptions, SvedaChatPageRefs } from './composables/useSvedaChatPage';
+export { useSvedaMessaging } from './composables/useSvedaMessaging';
+export { useSvedaDocuments } from './composables/useSvedaDocuments';
+export type { SvedaExtractedDocumentItem } from './composables/useSvedaDocuments';
+export { useSvedaModel } from './composables/useSvedaModel';
+export type { SvedaChatModelOption } from './composables/useSvedaModel';
+export { useSvedaMaxStepsContinue } from './composables/useSvedaMaxStepsContinue';
+export type { SvedaMaxStepsReachedData } from './composables/useSvedaMaxStepsContinue';
+export { useSvedaPrompts } from './composables/useSvedaPrompts';
+export type { SvedaQuickPromptItem } from './composables/useSvedaPrompts';
+export { useSvedaScroll } from './composables/useSvedaScroll';
+export type { SvedaScrollContainer } from './composables/useSvedaScroll';
+export { useSvedaShell } from './composables/useSvedaShell';
+export type { SvedaBrandInfo } from './composables/useSvedaShell';
+export { useSvedaContextWindow, SVEDA_CHAT_MAX_CONTEXT_TOKENS } from './composables/useSvedaContextWindow';
+export { useSvedaBootstrap } from './composables/useSvedaBootstrap';
+export { useSvedaReadable } from './composables/useSvedaReadable';
+export { useSvedaTool } from './composables/useSvedaTool';
+export type { UseSvedaToolOptions } from './composables/useSvedaTool';
+
+export { isNewChatPlaceholder, buildChatTabTitleMap } from './lib/chatTabs';
+export type { SvedaTabChat } from './lib/chatTabs';
+export { isChatTitlePlaceholder, deriveProvisionalChatTitle } from './lib/chatTitle';
+export {
+  SVEDA_CHAT_MINIMIZED_STORAGE_KEY,
+  readPersistedMinimized,
+  writePersistedMinimized,
+} from './lib/chatUiStorage';
+export { humanizeModelId, getSvedaModelDisplayName } from './lib/modelLabels';
+export { finalizeMessagesForDisplay } from './lib/finalizeMessages';
+export type { SvedaFinalizableMessage } from './lib/finalizeMessages';
+export {
+  getUserMessageText,
+  getUserMessageAttachmentNames,
+  userMessageHasVisibleContent,
+} from './lib/userMessage';
+export type { SvedaUserMessageLike } from './lib/userMessage';
+
+export const SVEDA_VUE_VERSION = '0.1.0';

package/src/launcherIcons.ts

@@ -0,0 +1,39 @@
+import {
+  Bot,
+  BotMessageSquare,
+  Brain,
+  CircleHelp,
+  Gem,
+  Heart,
+  MessageCircle,
+  MessageSquare,
+  Rocket,
+  Sparkles,
+  Star,
+  Zap,
+  type LucideIcon,
+} from 'lucide-vue-next';
+import { SVEDA_DEFAULT_LAUNCHER_ICON, SVEDA_LAUNCHER_ICON_IDS, type SvedaLauncherIconId } from './appearance';
+
+export const svedaLauncherIconMap: Record<SvedaLauncherIconId, LucideIcon> = {
+  sparkles: Sparkles,
+  'message-circle': MessageCircle,
+  'message-square': MessageSquare,
+  bot: Bot,
+  'bot-message-square': BotMessageSquare,
+  brain: Brain,
+  zap: Zap,
+  star: Star,
+  heart: Heart,
+  'circle-help': CircleHelp,
+  rocket: Rocket,
+  gem: Gem,
+};
+
+export const svedaLauncherIconComponent = (icon: string): LucideIcon => {
+  if ((SVEDA_LAUNCHER_ICON_IDS as readonly string[]).includes(icon)) {
+    return svedaLauncherIconMap[icon as SvedaLauncherIconId];
+  }
+
+  return svedaLauncherIconMap[SVEDA_DEFAULT_LAUNCHER_ICON];
+};

package/src/lib/assistantMessage.ts

@@ -0,0 +1,437 @@
+export interface SvedaResourceLink {
+  label: string;
+  url: string;
+  icon?: string;
+  kind?: 'created' | 'reference';
+}
+
+export type SvedaAssistantMessagePart = {
+  type?: string;
+  text?: string;
+  state?: string;
+  toolName?: string;
+  toolCallId?: string;
+  target?: string;
+  output?: unknown;
+  result?: unknown;
+  input?: unknown;
+  args?: unknown;
+  errorText?: string;
+  renderHint?: string;
+  renderData?: Record<string, unknown>;
+};
+
+export type SvedaLegacyActivity = {
+  phase?: string;
+  steps?: Array<{
+    id: string;
+    label: string;
+    status: string;
+    detail?: string;
+    kind?: string;
+    activityGroupKey?: string;
+    activityGroupLabel?: string;
+    display?: { name?: string; link?: string };
+  }>;
+};
+
+export type SvedaChatMessageLike = {
+  id?: string;
+  role?: string;
+  content?: string;
+  parts?: SvedaAssistantMessagePart[];
+  reasoningStream?: string;
+  activity?: SvedaLegacyActivity;
+  toolInvocations?: SvedaAssistantMessagePart[];
+  resources?: SvedaResourceLink[];
+  streaming?: boolean;
+  isError?: boolean;
+  attachmentNames?: string[];
+  metadata?: {
+    attachmentNames?: string[];
+  };
+};
+
+export type AssistantMessageSegment =
+  | {
+      kind: 'activity';
+      id: string;
+      invocations: SvedaAssistantMessagePart[];
+      legacyActivity?: SvedaLegacyActivity;
+    }
+  | {
+      kind: 'comment';
+      id: string;
+      text: string;
+      streaming: boolean;
+    }
+  | {
+      kind: 'answer';
+      id: string;
+      text: string;
+      streaming: boolean;
+    }
+  | {
+      kind: 'reasoning';
+      id: string;
+      text: string;
+      streaming: boolean;
+    };
+
+export function isAssistantToolPart(part: SvedaAssistantMessagePart | null | undefined): boolean {
+  if (!part || typeof part.type !== 'string') {
+    return false;
+  }
+  if (part.type === 'tool-call' || part.type === 'tool-result') {
+    return false;
+  }
+  return part.type === 'dynamic-tool' || part.type.startsWith('tool-');
+}
+
+function svedaToolPartToInvocation(
+  call: SvedaAssistantMessagePart | undefined,
+  result: SvedaAssistantMessagePart | undefined
+): SvedaAssistantMessagePart {
+  return {
+    type: 'dynamic-tool',
+    toolCallId: call?.toolCallId ?? result?.toolCallId ?? '',
+    toolName: call?.toolName ?? result?.toolName ?? '',
+    input: call?.input,
+    output: result?.output,
+    renderHint: result?.renderHint,
+    renderData: result?.renderData,
+    state: result ? 'result' : 'call',
+  };
+}
+
+export function buildAssistantMessageSegments(
+  message: SvedaChatMessageLike
+): AssistantMessageSegment[] {
+  const parts = Array.isArray(message.parts) ? message.parts : [];
+
+  if (parts.length === 0) {
+    const segments: AssistantMessageSegment[] = [];
+
+    const legacyInvocations = Array.isArray(message.toolInvocations) ? message.toolInvocations : [];
+    if (legacyInvocations.length > 0) {
+      segments.push({
+        kind: 'activity',
+        id: 'activity-legacy-tools',
+        invocations: legacyInvocations,
+      });
+    } else if (message.activity?.steps?.length) {
+      segments.push({
+        kind: 'activity',
+        id: 'activity-legacy',
+        invocations: [],
+        legacyActivity: message.activity,
+      });
+    }
+
+    if (message.reasoningStream?.trim()) {
+      segments.push({
+        kind: 'reasoning',
+        id: 'reasoning-legacy',
+        text: message.reasoningStream.trim(),
+        streaming: false,
+      });
+    }
+
+    if (message.content?.trim()) {
+      segments.push({
+        kind: 'answer',
+        id: 'answer-legacy',
+        text: message.content.trim(),
+        streaming: false,
+      });
+    }
+
+    return segments;
+  }
+
+  const resultsByCallId = new Map<string, SvedaAssistantMessagePart>();
+  for (const part of parts) {
+    if (part.type === 'tool-result' && part.toolCallId) {
+      resultsByCallId.set(part.toolCallId, part);
+    }
+  }
+  const consumedResultIds = new Set<string>();
+
+  const segments: AssistantMessageSegment[] = [];
+  let toolBuffer: SvedaAssistantMessagePart[] = [];
+  const textBuffer: Array<{ part: SvedaAssistantMessagePart; index: number }> = [];
+
+  const lastTextPartIndex = parts.reduce((lastIndex, part, index) => {
+    if (part.type === 'text' && part.text?.trim()) {
+      return index;
+    }
+    return lastIndex;
+  }, -1);
+
+  const flushTools = () => {
+    if (toolBuffer.length === 0) {
+      return;
+    }
+    segments.push({
+      kind: 'activity',
+      id: `activity-${segments.length}`,
+      invocations: [...toolBuffer],
+    });
+    toolBuffer = [];
+  };
+
+  const flushText = () => {
+    const buffered = textBuffer.filter(
+      entry => entry.part.type === 'text' && entry.part.text?.trim()
+    );
+    textBuffer.length = 0;
+    if (buffered.length === 0) {
+      return;
+    }
+
+    const text = buffered.map(entry => String(entry.part.text).trim()).join('\n\n');
+    const streaming = buffered.some(entry => entry.part.state === 'streaming');
+    const maxTextIndex = Math.max(...buffered.map(entry => entry.index));
+    const isAnswer = lastTextPartIndex >= 0 && maxTextIndex === lastTextPartIndex;
+
+    segments.push({
+      kind: isAnswer ? 'answer' : 'comment',
+      id: `text-${segments.length}`,
+      text,
+      streaming,
+    });
+  };
+
+  for (let index = 0; index < parts.length; index += 1) {
+    const part = parts[index];
+
+    if (part.type === 'tool-call') {
+      if (textBuffer.length > 0) {
+        flushText();
+      }
+      const result = part.toolCallId ? resultsByCallId.get(part.toolCallId) : undefined;
+      if (result && part.toolCallId) {
+        consumedResultIds.add(part.toolCallId);
+      }
+      toolBuffer.push(svedaToolPartToInvocation(part, result));
+      continue;
+    }
+
+    if (part.type === 'tool-result') {
+      if (part.toolCallId && consumedResultIds.has(part.toolCallId)) {
+        continue;
+      }
+      if (textBuffer.length > 0) {
+        flushText();
+      }
+      toolBuffer.push(svedaToolPartToInvocation(undefined, part));
+      continue;
+    }
+
+    if (isAssistantToolPart(part)) {
+      if (textBuffer.length > 0) {
+        flushText();
+      }
+      toolBuffer.push(part);
+      continue;
+    }
+
+    if (part.type === 'reasoning' && part.text?.trim()) {
+      flushTools();
+      if (textBuffer.length > 0) {
+        flushText();
+      }
+      segments.push({
+        kind: 'reasoning',
+        id: `reasoning-${segments.length}`,
+        text: part.text.trim(),
+        streaming: part.state === 'streaming',
+      });
+      continue;
+    }
+
+    if (part.type === 'text') {
+      if (toolBuffer.length > 0) {
+        flushTools();
+      }
+      textBuffer.push({ part, index });
+      continue;
+    }
+  }
+
+  flushText();
+  flushTools();
+
+  let hasAnswer = segments.some(segment => segment.kind === 'answer');
+  if (!hasAnswer) {
+    for (let i = segments.length - 1; i >= 0; i -= 1) {
+      if (segments[i].kind === 'comment') {
+        segments[i] = { ...segments[i], kind: 'answer' } as AssistantMessageSegment;
+        hasAnswer = true;
+        break;
+      }
+    }
+  }
+
+  if (!hasAnswer && message.content?.trim()) {
+    segments.push({
+      kind: 'answer',
+      id: 'answer-content-fallback',
+      text: message.content.trim(),
+      streaming: false,
+    });
+  }
+
+  return segments;
+}
+
+const READ_ONLY_TOOL_PREFIXES = ['get_', 'list_', 'search_', 'read_'];
+
+export function getToolNameFromPart(part: { toolName?: string; type?: string }): string {
+  if (part.toolName) {
+    return part.toolName;
+  }
+  if (
+    typeof part.type === 'string' &&
+    part.type.startsWith('tool-') &&
+    part.type !== 'tool-call' &&
+    part.type !== 'tool-result'
+  ) {
+    return part.type.slice('tool-'.length);
+  }
+  return '';
+}
+
+export function parseToolResultOutput(output: unknown): Record<string, unknown> | null {
+  if (output === undefined || output === null) {
+    return null;
+  }
+  if (typeof output === 'object') {
+    return output as Record<string, unknown>;
+  }
+  if (typeof output !== 'string' || output.trim() === '') {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(output) as unknown;
+    return typeof parsed === 'object' && parsed !== null
+      ? (parsed as Record<string, unknown>)
+      : null;
+  } catch {
+    return null;
+  }
+}
+
+export function getActivityGroupKey(toolName: string): string {
+  if (!toolName) {
+    return '';
+  }
+  if (READ_ONLY_TOOL_PREFIXES.some(prefix => toolName.startsWith(prefix))) {
+    return `reader:${toolName}`;
+  }
+  return '';
+}
+
+export function getActivityGroupLabel(_toolName: string, translatedToolName: string): string {
+  return translatedToolName;
+}
+
+function normalizeResourceLink(raw: unknown): SvedaResourceLink | null {
+  if (!raw || typeof raw !== 'object') {
+    return null;
+  }
+  const record = raw as Record<string, unknown>;
+  const label = record.label ?? record.name;
+  const url = record.url ?? record.link;
+  if (typeof label !== 'string' || label.trim() === '') {
+    return null;
+  }
+  if (typeof url !== 'string' || url.trim() === '') {
+    return null;
+  }
+  const icon = typeof record.icon === 'string' && record.icon.trim() !== '' ? record.icon.trim() : undefined;
+  return { label: label.trim(), url: url.trim(), ...(icon ? { icon } : {}) };
+}
+
+function pushResourceLink(resources: SvedaResourceLink[], resource: SvedaResourceLink): void {
+  if (!resource.label || !resource.url) {
+    return;
+  }
+  if (resources.some(existing => existing.url === resource.url)) {
+    return;
+  }
+  resources.push(resource);
+}
+
+export function collectResourceLinks(message: SvedaChatMessageLike): SvedaResourceLink[] {
+  const collected: SvedaResourceLink[] = [];
+  const parts = [
+    ...(Array.isArray(message.toolInvocations) ? message.toolInvocations : []),
+    ...(Array.isArray(message.parts) ? message.parts : []),
+  ];
+
+  for (const part of parts) {
+    if (!part || typeof part !== 'object') {
+      continue;
+    }
+
+    if (part.type === 'tool-result' && part.renderHint === 'resource_links') {
+      const links = part.renderData?.links;
+      if (Array.isArray(links)) {
+        for (const raw of links) {
+          const link = normalizeResourceLink(raw);
+          if (link) {
+            pushResourceLink(collected, { ...link, kind: link.kind ?? 'reference' });
+          }
+        }
+      }
+      continue;
+    }
+
+    if (part.type === 'tool-result' || isAssistantToolPart(part)) {
+      const resultData = parseToolResultOutput(part.output !== undefined ? part.output : part.result);
+      if (!resultData || resultData.success === false) {
+        continue;
+      }
+
+      const display = resultData.display as { name?: unknown; link?: unknown } | undefined;
+      if (display?.name && display?.link) {
+        pushResourceLink(collected, {
+          label: String(display.name),
+          url: String(display.link),
+          kind: 'created',
+        });
+      }
+
+      const links = resultData.links;
+      if (Array.isArray(links)) {
+        for (const raw of links) {
+          const link = normalizeResourceLink(raw);
+          if (link) {
+            pushResourceLink(collected, { ...link, kind: link.kind ?? 'reference' });
+          }
+        }
+      }
+    }
+  }
+
+  return collected;
+}
+
+export function enrichMessagesWithResourceLinks<
+  T extends { role?: string; resources?: SvedaResourceLink[] },
+>(messages: T[]): T[] {
+  return messages.map(message => {
+    if (message.role !== 'assistant') {
+      return message;
+    }
+    const resources = collectResourceLinks(message);
+    if (resources.length === 0) {
+      return message;
+    }
+    return {
+      ...message,
+      resources,
+    };
+  });
+}

package/src/lib/chatHistoryMerge.ts

@@ -0,0 +1,93 @@
+export type SvedaMergeableChatHistory<TMessage> = {
+  id: string;
+  title: string;
+  preview?: string;
+  messages: TMessage[];
+  tokensUsed: number;
+  contextWindowTokens: number;
+  createdAt: number;
+  updatedAt: number;
+  messagesLoaded: boolean;
+};
+
+export const mergeServerChatHistories = <T extends SvedaMergeableChatHistory<unknown>>(
+  serverHistories: T[],
+  currentChat: T | null
+): T[] => {
+  if (!currentChat) {
+    return serverHistories;
+  }
+
+  const index = serverHistories.findIndex(chat => chat.id === currentChat.id);
+  if (index === -1) {
+    return [currentChat, ...serverHistories];
+  }
+
+  if (currentChat.messagesLoaded && !serverHistories[index].messagesLoaded) {
+    const next = [...serverHistories];
+    next[index] = {
+      ...serverHistories[index],
+      messages: currentChat.messages,
+      messagesLoaded: true,
+    };
+    return next;
+  }
+
+  return serverHistories;
+};
+
+export const resolveMergedCurrentChat = <T extends { id: string }>(
+  histories: T[],
+  currentChat: T | null
+): T | null => {
+  if (!currentChat) {
+    return null;
+  }
+
+  return histories.find(chat => chat.id === currentChat.id) ?? currentChat;
+};
+
+export const upsertChatHistoryMessages = <T extends SvedaMergeableChatHistory<unknown>>(
+  histories: T[],
+  currentChat: T | null,
+  chatId: string,
+  messages: T['messages'],
+  now: number = Date.now()
+): { histories: T[]; current: T | null } => {
+  const index = histories.findIndex(chat => chat.id === chatId);
+  if (index !== -1) {
+    const next = [...histories];
+    next[index] = {
+      ...histories[index],
+      messages,
+      messagesLoaded: true,
+      updatedAt: now,
+    };
+
+    return {
+      histories: next,
+      current: currentChat?.id === chatId ? next[index] : currentChat,
+    };
+  }
+
+  const base = currentChat?.id === chatId ? currentChat : null;
+  const upserted = {
+    ...(base ?? {
+      id: chatId,
+      title: '',
+      preview: '',
+      tokensUsed: 0,
+      contextWindowTokens: 0,
+      createdAt: now,
+    }),
+    id: chatId,
+    messages,
+    messagesLoaded: true,
+    updatedAt: now,
+  } as T;
+
+  return {
+    histories: [upserted, ...histories],
+    current: currentChat === null || currentChat.id === chatId ? upserted : currentChat,
+  };
+};