@aleph-alpha/chat-kit 1.3.1 → 1.5.0

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/composables/useConversations.spec.ts

@@ -1,3 +1,4 @@
+import type { ResponseList, StoredResponse } from '../adapters/responses-api';
 import type {
   HttpClient,
   RawConversation,
@@ -554,4 +555,121 @@ describe('useConversations', () => {
       expect(conv.getById('missing')).toBeUndefined();
     });
   });
+
+  describe('fetchResponses', () => {
+    function makeStoredResponse(
+      overrides: Partial<StoredResponse> & { id: string },
+    ): StoredResponse {
+      return {
+        object: 'response',
+        created_at: 1_777_456_700,
+        completed_at: 1_777_456_701,
+        status: 'completed',
+        model: 'pharia-1',
+        output: [],
+        request_input: [],
+        ...overrides,
+      };
+    }
+
+    function makeResponseList(data: StoredResponse[]): ResponseList {
+      return { object: 'list', data };
+    }
+
+    it('GETs /:id/responses with order=asc by default and returns the unwrapped list', async () => {
+      const http = makeFakeHttp();
+      http.get.mockResolvedValue(
+        makeResponseList([
+          makeStoredResponse({ id: 'resp_1' }),
+          makeStoredResponse({ id: 'resp_2' }),
+        ]),
+      );
+
+      const conv = useConversations({
+        httpClient: asHttp(http),
+        path: '/conversations',
+      });
+
+      const result = await conv.fetchResponses('conv_22');
+
+      expect(http.get).toHaveBeenCalledWith(
+        '/conversations/conv_22/responses',
+        {
+          params: { order: 'asc' },
+        },
+      );
+      expect(result.map((r) => r.id)).toEqual(['resp_1', 'resp_2']);
+    });
+
+    it('passes through the caller-supplied order', async () => {
+      const http = makeFakeHttp();
+      http.get.mockResolvedValue(makeResponseList([]));
+
+      const conv = useConversations({
+        httpClient: asHttp(http),
+        path: '/conversations',
+      });
+
+      await conv.fetchResponses('conv_22', { order: 'desc' });
+
+      expect(http.get).toHaveBeenCalledWith(
+        '/conversations/conv_22/responses',
+        {
+          params: { order: 'desc' },
+        },
+      );
+    });
+
+    it('does not modify the conversations list', async () => {
+      const http = makeFakeHttp();
+      http.get
+        .mockResolvedValueOnce(makeRawList([makeRawConversation({ id: 'a' })]))
+        .mockResolvedValueOnce(
+          makeResponseList([makeStoredResponse({ id: 'resp_1' })]),
+        );
+
+      const conv = useConversations({
+        httpClient: asHttp(http),
+        path: '/conversations',
+      });
+      await conv.fetch();
+      await conv.fetchResponses('a');
+
+      expect(conv.conversations.value.map((c) => c.id)).toEqual(['a']);
+    });
+
+    it('toggles isLoading around the call', async () => {
+      const http = makeFakeHttp();
+      let resolve!: (value: ResponseList) => void;
+      http.get.mockReturnValue(new Promise((r) => (resolve = r)));
+
+      const conv = useConversations({
+        httpClient: asHttp(http),
+        path: '/conversations',
+      });
+      const promise = conv.fetchResponses('a');
+
+      await nextTick();
+      expect(conv.isLoading.value).toBe(true);
+
+      resolve(makeResponseList([]));
+      await promise;
+
+      expect(conv.isLoading.value).toBe(false);
+    });
+
+    it('records and re-throws errors', async () => {
+      const http = makeFakeHttp();
+      http.get.mockRejectedValue(new Error('boom'));
+
+      const conv = useConversations({
+        httpClient: asHttp(http),
+        path: '/conversations',
+      });
+
+      await expect(conv.fetchResponses('a')).rejects.toThrow('boom');
+      expect(conv.error.value?.message).toBe('boom');
+      expect(conv.isLoading.value).toBe(false);
+    });
+  });
 });

package/src/composables/useConversations.ts

@@ -1,3 +1,4 @@
+import type { ResponseList, StoredResponse } from '../adapters/responses-api';
 import { generateId, secondsToDate, toError } from '../helpers';
 import type {
   ConversationSummary,
@@ -85,6 +86,18 @@ export interface UseConversationsReturn {
   remove(id: string, options?: MutationOptions): Promise<void>;
   /** Local lookup. Does not fetch — only checks the in-memory list. */
   getById(id: string): ConversationSummary | undefined;
+  /**
+   * List the OpenAI Responses-API records attached to a conversation. Pure
+   * fetch: it does not touch the conversations list. The endpoint is not
+   * paginated, so the returned array is the full timeline ordered by
+   * `created_at` (ascending by default). Pair with `responsesToTree` from
+   * `@aleph-alpha/chat-kit/adapters/responses-api` to hydrate a chat
+   * handler: `setTree(responsesToTree(await fetchResponses(id)))`.
+   */
+  fetchResponses(
+    id: string,
+    options?: { order?: 'asc' | 'desc' },
+  ): Promise<StoredResponse[]>;
 }
 
 const DEFAULT_PAGE_SIZE = 20;
@@ -277,6 +290,24 @@ export function useConversations(
     return conversations.value.find((c) => c.id === id);
   }
 
+  async function fetchResponses(
+    id: string,
+    opts?: { order?: 'asc' | 'desc' },
+  ): Promise<StoredResponse[]> {
+    beginRequest();
+    try {
+      const raw = await http.get<ResponseList>(`${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) as Readonly<
       Ref<readonly ConversationSummary[]>
@@ -291,6 +322,7 @@ export function useConversations(
     rename,
     remove,
     getById,
+    fetchResponses,
   };
 }
 

package/src/handlers/useChatKitLabels.spec.ts

@@ -261,7 +261,14 @@ describe('CkConversation uses injected labels', () => {
             {
               id: '1',
               role: 'assistant',
-              content: 'Hi',
+              content: [
+                {
+                  type: 'text',
+                  id: 'txt-1',
+                  text: 'Hi',
+                  status: 'completed',
+                },
+              ],
               createdAt: new Date(),
               status: 'completed',
             },
@@ -290,7 +297,14 @@ describe('CkConversation uses injected labels', () => {
                 {
                   id: '1',
                   role: 'assistant',
-                  content: 'Hi',
+                  content: [
+                    {
+                      type: 'text',
+                      id: 'txt-1',
+                      text: 'Hi',
+                      status: 'completed',
+                    },
+                  ],
                   createdAt: new Date(),
                   status: 'completed',
                 },