@aleph-alpha/chat-kit 1.4.0 → 1.5.1

package/src/composables/fileUpload/useFileUploadWrapper.ts

@@ -0,0 +1,382 @@
+import { ref, computed, shallowRef, watch, toValue, type MaybeRef } from 'vue';
+import type {
+  HttpClient,
+  RequestConfig,
+  SseStream,
+  SseEvent,
+  FileEntry,
+  ScopedFileView,
+  DocumentUploadConfig,
+  DocumentUploadProvider,
+  DocumentUploadReturn,
+  UploadEvent,
+} from './types';
+import { useFileUpload } from './useFileUpload';
+
+function buildHttpClient(
+  baseUrl: string,
+  defaultHeaders: Record<string, string>,
+): HttpClient {
+  return {
+    async get<T>(url: string, config?: RequestConfig): Promise<T> {
+      const fullUrl = `${baseUrl}/${url}`;
+      const res = await fetch(fullUrl, {
+        method: 'GET',
+        signal: config?.signal,
+        headers: defaultHeaders,
+        credentials: 'include',
+      });
+      if (!res.ok) throw new Error(`GET ${fullUrl} failed: ${res.status}`);
+      return res.json();
+    },
+
+    async post<T>(
+      url: string,
+      body: unknown,
+      config?: RequestConfig,
+    ): Promise<T> {
+      const fullUrl = `${baseUrl}/${url}`;
+      const headers: Record<string, string> = { ...defaultHeaders };
+      let resolvedBody: BodyInit | undefined;
+
+      if (body instanceof FormData) {
+        resolvedBody = body;
+      } else {
+        headers['Content-Type'] = 'application/json';
+        resolvedBody = JSON.stringify(body);
+      }
+
+      const res = await fetch(fullUrl, {
+        method: 'POST',
+        signal: config?.signal,
+        headers,
+        body: resolvedBody,
+        credentials: 'include',
+      });
+      if (!res.ok) throw new Error(`POST ${fullUrl} failed: ${res.status}`);
+      return res.json();
+    },
+
+    async delete<T>(url: string, config?: RequestConfig): Promise<T> {
+      const fullUrl = `${baseUrl}/${url}`;
+      const res = await fetch(fullUrl, {
+        method: 'DELETE',
+        signal: config?.signal,
+        headers: defaultHeaders,
+        credentials: 'include',
+      });
+      if (!res.ok) throw new Error(`DELETE ${fullUrl} failed: ${res.status}`);
+      return res.json();
+    },
+
+    stream(url: string, config?: RequestConfig): SseStream {
+      const controller = new AbortController();
+      const signal = config?.signal
+        ? AbortSignal.any([controller.signal, config.signal])
+        : controller.signal;
+
+      const listeners: Array<(event: SseEvent) => void> = [];
+      let closed = false;
+
+      const fullUrl = `${baseUrl}/${url}`;
+      const headers: Record<string, string> = {
+        Accept: 'text/event-stream',
+        ...defaultHeaders,
+      };
+
+      function parseSseLines(
+        lines: string[],
+        notify: (event: SseEvent) => void,
+      ): void {
+        let currentEvent = '';
+        let currentData = '';
+
+        for (const line of lines) {
+          if (line.startsWith('event:')) {
+            currentEvent = line.slice(6).trim();
+          } else if (line.startsWith('data:')) {
+            currentData = line.slice(5).trim();
+          } else if (line === '') {
+            if (currentData) {
+              notify({
+                event: currentEvent || 'message',
+                data: currentData,
+              });
+            }
+            currentEvent = '';
+            currentData = '';
+          }
+        }
+      }
+
+      (async () => {
+        try {
+          const response = await fetch(fullUrl, {
+            signal,
+            headers,
+            credentials: 'include',
+          });
+          if (!response.ok || !response.body) return;
+
+          const reader = response.body.getReader();
+          const decoder = new TextDecoder();
+          let buffer = '';
+
+          while (!closed) {
+            const { done, value } = await reader.read();
+            if (done) break;
+
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split('\n');
+            buffer = lines.pop() ?? '';
+
+            parseSseLines(lines, (event) => {
+              for (const cb of listeners) cb(event);
+            });
+          }
+        } catch {
+          // stream ended or aborted
+        }
+      })();
+
+      return {
+        subscribe(callback: (event: SseEvent) => void) {
+          listeners.push(callback);
+        },
+        close() {
+          closed = true;
+          controller.abort();
+        },
+      };
+    },
+  };
+}
+
+export function createDocumentUploadProvider(
+  config: DocumentUploadConfig,
+): DocumentUploadProvider {
+  const {
+    baseUrl,
+    userId,
+    workflowId,
+    searchStoreConfig,
+    workflowConfig,
+    persist = true,
+    maxConcurrency = 3,
+  } = config;
+
+  const defaultHeaders: Record<string, string> = {
+    'x-user-id': userId,
+    ...(config.headers ?? {}),
+  };
+
+  const httpClient = buildHttpClient(baseUrl, defaultHeaders);
+
+  // ---- Search store resolution (one per user) ----
+
+  let resolvedStoreId: string | null = null;
+  let resolvePromise: Promise<string> | null = null;
+
+  async function createSearchStoreWithWorkflow(): Promise<string> {
+    const name = `${userId}-store-${new Date().toISOString().replace(/[:.]/g, '-')}`;
+    const storeRes = await httpClient.post<{ id: string }>('search-stores', {
+      name,
+      ...searchStoreConfig,
+      metadata: { created_by: userId },
+    });
+    const newStoreId = storeRes.id;
+
+    await httpClient.post(
+      `search-stores/${newStoreId}/workflows`,
+      workflowConfig,
+    );
+
+    return newStoreId;
+  }
+
+  async function resolveSearchStore(): Promise<string> {
+    if (resolvedStoreId) return resolvedStoreId;
+    if (resolvePromise) return resolvePromise;
+
+    resolvePromise = (async () => {
+      try {
+        const stores = await httpClient.get<{ id: string }[]>('search-stores');
+
+        if (stores.length > 0 && stores[0]) {
+          resolvedStoreId = stores[0].id;
+          return resolvedStoreId;
+        }
+
+        resolvedStoreId = await createSearchStoreWithWorkflow();
+        return resolvedStoreId;
+      } catch (err) {
+        resolvePromise = null;
+        throw err;
+      }
+    })();
+
+    return resolvePromise;
+  }
+
+  // ---- Upload SDK singleton ----
+
+  let instance: ReturnType<typeof useFileUpload> | null = null;
+
+  function purgeInterruptedFiles() {
+    if (!instance) return;
+    const allFiles = [...instance.files.value.values()];
+    for (const entry of allFiles) {
+      if (entry.status === 'failed' && !entry.metadata.messageId) {
+        instance.removeFile(entry.id, { removeFromRemote: false });
+      }
+    }
+  }
+
+  function getUploadInstance(): ReturnType<typeof useFileUpload> {
+    if (!instance) {
+      const onEvent = (event: UploadEvent) => {
+        config.onEvent?.(event);
+        if (event.type === 'state:restored') {
+          purgeInterruptedFiles();
+        }
+      };
+
+      instance = useFileUpload({
+        client: httpClient,
+        workflowId,
+        persist,
+        maxConcurrency,
+        onEvent,
+      });
+    }
+    return instance;
+  }
+
+  // ---- Public composable ----
+
+  function useDocumentUpload(
+    conversationIdRef: MaybeRef<string>,
+  ): DocumentUploadReturn {
+    const fileInput = ref<HTMLInputElement | null>(null);
+    const upload = getUploadInstance();
+    const storeId = ref<string>(resolvedStoreId ?? '');
+
+    const currentScope = shallowRef<ScopedFileView | null>(
+      upload.scopeBy('conversationId', toValue(conversationIdRef)),
+    );
+
+    watch(
+      () => toValue(conversationIdRef),
+      (newId: string, oldId: string) => {
+        if (oldId && oldId !== newId) {
+          const oldScope = upload.scopeBy('conversationId', oldId);
+          for (const entry of oldScope.files.value) {
+            upload.updateFileMetadata(entry.id, { conversationId: newId });
+          }
+        }
+        currentScope.value = upload.scopeBy('conversationId', newId);
+      },
+    );
+
+    function scopedFiles(): FileEntry[] {
+      return currentScope.value?.files.value ?? [];
+    }
+
+    async function uploadFiles(files: File[]) {
+      if (!files.length) return;
+
+      const userStoreId = await resolveSearchStore();
+      upload.setStoreId(userStoreId);
+      storeId.value = userStoreId;
+
+      const conversationId = toValue(conversationIdRef);
+      const result = await upload.upload({
+        id: `${conversationId}::${Date.now()}`,
+        files,
+        forwardedProps: { conversationId },
+      });
+
+      for (const r of result.results) {
+        if (r.success && r.remoteFileId) {
+          upload.updateFileMetadata(r.fileId, {
+            data_platform_id: r.remoteFileId,
+            searchStoreId: storeId.value,
+          });
+        }
+      }
+
+      const successFileIds = result.results
+        .filter((r) => r.success && r.remoteFileId)
+        .map((r) => r.remoteFileId!);
+
+      if (successFileIds.length > 0) {
+        await upload.runWorkflow(successFileIds);
+        purgeCompletedFiles();
+      }
+
+      return result;
+    }
+
+    const unassignedFiles = computed(() =>
+      scopedFiles().filter((entry) => !entry.metadata.messageId),
+    );
+
+    function assignFilesToMessage(messageId: string) {
+      for (const entry of scopedFiles()) {
+        if (!entry.metadata.messageId && entry.status === 'success') {
+          upload.updateFileMetadata(entry.id, { messageId });
+        }
+      }
+    }
+
+    function getFilesForMessage(messageId: string): FileEntry[] {
+      return scopedFiles().filter(
+        (entry) =>
+          entry.metadata.messageId === messageId ||
+          (entry.metadata.responseId &&
+            messageId === `user-${entry.metadata.responseId}-0`),
+      );
+    }
+
+    function stampResponseId(responseId: string, localMessageId: string) {
+      for (const entry of scopedFiles()) {
+        if (entry.metadata.messageId === localMessageId) {
+          upload.updateFileMetadata(entry.id, { responseId });
+        }
+      }
+    }
+
+    function purgeCompletedFiles() {
+      const toPurge = scopedFiles().filter(
+        (entry) =>
+          entry.metadata.messageId &&
+          (entry.status === 'success' || entry.status === 'failed'),
+      );
+      for (const entry of toPurge) {
+        upload.removeFile(entry.id, { removeFromRemote: false });
+      }
+    }
+
+    function handleFilesSelected(event: Event) {
+      const input = event.target as HTMLInputElement;
+      const fileList = Array.from(input.files ?? []);
+      uploadFiles(fileList);
+      input.value = '';
+    }
+
+    return {
+      upload,
+      storeId,
+      fileInput,
+      uploadFiles,
+      unassignedFiles,
+      assignFilesToMessage,
+      getFilesForMessage,
+      stampResponseId,
+      purgeCompletedFiles,
+      handleFilesSelected,
+    };
+  }
+
+  return { useDocumentUpload };
+}

package/src/composables/index.ts

@@ -12,4 +12,5 @@ export type {
   MessageHandler,
   UseConversationSessionsReturn,
 } from './useConversationSessions';
-export type { ChatActions, ChatState, UseChatReturn } from './types';
+export * from './types';
+export * from './fileUpload';

package/src/index.ts

@@ -28,23 +28,7 @@ export {
 export type { ChatKitLabels } from './handlers';
 
 // Composables
-export {
-  useChat,
-  useConversationSessions,
-  useConversations,
-} from './composables';
-export type {
-  ChatActions,
-  ChatState,
-  ConversationSession,
-  CreateConversationInput,
-  MessageHandler,
-  MutationOptions,
-  UseChatReturn,
-  UseConversationSessionsReturn,
-  UseConversationsOptions,
-  UseConversationsReturn,
-} from './composables';
+export * from './composables';
 
 // Components
 export {

package/dist/useConversationSessions-GLZV_Ctr.js

@@ -1,259 +0,0 @@
-import { g as generateId } from "./generateId-BHf0W4Rq.js";
-import { ref, shallowRef, computed, readonly } from "vue";
-import { u as useMessageHandler } from "./useMessageHandler-ZRC-gIOJ.js";
-import "./purify.es-md74IFlY.js";
-function secondsToDate(seconds) {
-  return new Date(seconds * 1e3);
-}
-function toError(value) {
-  return value instanceof Error ? value : new Error(String(value));
-}
-function useChat() {
-}
-const DEFAULT_PAGE_SIZE = 20;
-function useConversations(options) {
-  const http = options.httpClient;
-  const path = options.path;
-  const pageSize = options.pageSize ?? DEFAULT_PAGE_SIZE;
-  const conversations = ref([]);
-  const inflightCount = shallowRef(0);
-  const isLoading = computed(() => inflightCount.value > 0);
-  const hasMore = shallowRef(false);
-  const error = shallowRef(null);
-  let nextCursor = null;
-  function beginRequest() {
-    inflightCount.value++;
-    error.value = null;
-  }
-  function endRequest() {
-    inflightCount.value--;
-  }
-  async function fetchPage(params) {
-    const query = {
-      limit: params.limit,
-      order: "desc"
-    };
-    if (params.cursor) query.after = params.cursor;
-    const raw = await http.get(path, { params: query });
-    return mapConversationList(raw);
-  }
-  async function fetch(opts) {
-    beginRequest();
-    try {
-      const page = await fetchPage({
-        limit: opts?.limit ?? pageSize,
-        cursor: null
-      });
-      conversations.value = page.items;
-      nextCursor = page.nextCursor;
-      hasMore.value = page.nextCursor !== null;
-    } catch (e) {
-      error.value = toError(e);
-      throw error.value;
-    } finally {
-      endRequest();
-    }
-  }
-  async function fetchMore() {
-    if (!hasMore.value || nextCursor === null) return;
-    beginRequest();
-    try {
-      const page = await fetchPage({ limit: pageSize, cursor: nextCursor });
-      conversations.value = [...conversations.value, ...page.items];
-      nextCursor = page.nextCursor;
-      hasMore.value = page.nextCursor !== null;
-    } catch (e) {
-      error.value = toError(e);
-      throw error.value;
-    } finally {
-      endRequest();
-    }
-  }
-  async function fetchById(id) {
-    beginRequest();
-    try {
-      const raw = await http.get(`${path}/${id}`);
-      return mapConversation(raw);
-    } catch (e) {
-      error.value = toError(e);
-      throw error.value;
-    } finally {
-      endRequest();
-    }
-  }
-  async function create(input, opts) {
-    const metadata = { ...input?.metadata ?? {} };
-    if (input?.title !== void 0) metadata.title = input.title;
-    const body = { metadata };
-    const previous = conversations.value;
-    let placeholder = null;
-    if (opts?.optimistic) {
-      placeholder = makePlaceholder(input?.title);
-      conversations.value = [placeholder, ...previous];
-    }
-    beginRequest();
-    try {
-      const raw = await http.post(path, body);
-      const created = mapConversation(raw);
-      conversations.value = placeholder ? conversations.value.map(
-        (c) => c.id === placeholder.id ? created : c
-      ) : [created, ...conversations.value];
-      return created;
-    } catch (e) {
-      if (placeholder) conversations.value = previous;
-      error.value = toError(e);
-      throw error.value;
-    } finally {
-      endRequest();
-    }
-  }
-  async function rename(id, title, opts) {
-    const previous = conversations.value;
-    if (opts?.optimistic) {
-      conversations.value = previous.map(
-        (c) => c.id === id ? { ...c, title, updatedAt: /* @__PURE__ */ new Date() } : c
-      );
-    }
-    beginRequest();
-    try {
-      const raw = await http.post(`${path}/${id}`, {
-        metadata: { title }
-      });
-      const updated = mapConversation(raw);
-      conversations.value = conversations.value.map(
-        (c) => c.id === id ? updated : c
-      );
-      return updated;
-    } catch (e) {
-      if (opts?.optimistic) conversations.value = previous;
-      error.value = toError(e);
-      throw error.value;
-    } finally {
-      endRequest();
-    }
-  }
-  async function remove(id, opts) {
-    const previous = conversations.value;
-    if (opts?.optimistic) {
-      conversations.value = previous.filter((c) => c.id !== id);
-    }
-    beginRequest();
-    try {
-      await http.delete(`${path}/${id}`);
-      if (!opts?.optimistic) {
-        conversations.value = previous.filter((c) => c.id !== id);
-      }
-    } catch (e) {
-      if (opts?.optimistic) conversations.value = previous;
-      error.value = toError(e);
-      throw error.value;
-    } finally {
-      endRequest();
-    }
-  }
-  function getById(id) {
-    return conversations.value.find((c) => c.id === id);
-  }
-  async function fetchResponses(id, opts) {
-    beginRequest();
-    try {
-      const raw = await http.get(`${path}/${id}/responses`, {
-        params: { order: opts?.order ?? "asc" }
-      });
-      return raw.data;
-    } catch (e) {
-      error.value = toError(e);
-      throw error.value;
-    } finally {
-      endRequest();
-    }
-  }
-  return {
-    conversations: readonly(conversations),
-    isLoading,
-    hasMore: readonly(hasMore),
-    error: readonly(error),
-    fetch,
-    fetchMore,
-    fetchById,
-    create,
-    rename,
-    remove,
-    getById,
-    fetchResponses
-  };
-}
-function mapConversation(raw) {
-  return {
-    id: raw.id,
-    title: raw.metadata?.title ?? "",
-    createdAt: secondsToDate(raw.created_at),
-    updatedAt: secondsToDate(raw.updated_at)
-  };
-}
-function mapConversationList(raw) {
-  return {
-    items: raw.data.map(mapConversation),
-    nextCursor: raw.has_more ? raw.last_id ?? null : null
-  };
-}
-function makePlaceholder(title) {
-  const now = /* @__PURE__ */ new Date();
-  return {
-    id: `pending-${generateId()}`,
-    title: title ?? "",
-    createdAt: now,
-    updatedAt: now
-  };
-}
-function useConversationSessions() {
-  const sessions = /* @__PURE__ */ new Map();
-  const focusedId = ref(null);
-  function createSession(conversationId) {
-    const existing = sessions.get(conversationId);
-    if (existing) return existing;
-    const session = {
-      id: conversationId,
-      messageHandler: useMessageHandler()
-    };
-    sessions.set(conversationId, session);
-    return session;
-  }
-  function getSession(conversationId) {
-    return sessions.get(conversationId);
-  }
-  function setActiveConversation(conversationId) {
-    if (conversationId === null) {
-      focusedId.value = null;
-      return;
-    }
-    createSession(conversationId);
-    focusedId.value = conversationId;
-  }
-  function removeSession(conversationId) {
-    sessions.delete(conversationId);
-    if (focusedId.value === conversationId) {
-      focusedId.value = null;
-    }
-  }
-  const activeSession = computed(() => {
-    const id = focusedId.value;
-    return id !== null ? sessions.get(id) ?? null : null;
-  });
-  const messageHandler = computed(
-    () => activeSession.value?.messageHandler ?? null
-  );
-  return {
-    activeSession,
-    messageHandler,
-    createSession,
-    getSession,
-    setActiveConversation,
-    removeSession
-  };
-}
-export {
-  useConversationSessions as a,
-  useConversations as b,
-  useChat as u
-};