@aleph-alpha/chat-kit 1.3.1 → 1.5.0

package/src/composables/fileUpload/index.spec.ts

@@ -0,0 +1,213 @@
+import {
+  defaultDocumentUploadConfig,
+  createDocumentUploadProvider,
+} from './index';
+import type { DocumentUploadConfig } from './types';
+
+vi.mock('./useFileUploadWrapper', () => ({
+  createDocumentUploadProvider: vi.fn((config: DocumentUploadConfig) => ({
+    useDocumentUpload: vi.fn(() => ({
+      upload: {},
+      storeId: { value: '' },
+      fileInput: { value: null },
+      uploadFiles: vi.fn(),
+      unassignedFiles: { value: [] },
+      assignFilesToMessage: vi.fn(),
+      getFilesForMessage: vi.fn(() => []),
+      stampResponseId: vi.fn(),
+      purgeCompletedFiles: vi.fn(),
+      handleFilesSelected: vi.fn(),
+    })),
+    _config: config,
+  })),
+}));
+
+describe('fileUpload index', () => {
+  describe('defaultDocumentUploadConfig', () => {
+    it('uses the correct base URL', () => {
+      expect(defaultDocumentUploadConfig.baseUrl).toBe('/file-upload');
+    });
+
+    it('uses the correct userId', () => {
+      expect(defaultDocumentUploadConfig.userId).toBe('chat-user');
+    });
+
+    it('uses the correct workflowId', () => {
+      expect(defaultDocumentUploadConfig.workflowId).toBe('my-doc-ai');
+    });
+
+    it('configures searchStoreConfig with a dense model', () => {
+      const { searchStoreConfig } = defaultDocumentUploadConfig;
+      expect(searchStoreConfig.models).toHaveLength(1);
+      expect(searchStoreConfig.models[0]).toEqual({
+        type: 'dense',
+        dimension: 1024,
+        distance: 'cosine',
+        modality: 'text',
+        embedding_model: 'baai/bge-m3',
+      });
+    });
+
+    it('configures searchStoreConfig with rrf fusion strategy', () => {
+      expect(
+        defaultDocumentUploadConfig.searchStoreConfig.fusion_strategy,
+      ).toEqual({
+        type: 'rrf',
+      });
+    });
+
+    it('configures workflowConfig with the correct workflow name', () => {
+      const { workflowConfig } = defaultDocumentUploadConfig;
+      expect(workflowConfig.name).toBe('my-doc-ai');
+      expect(workflowConfig.workflow_name).toBe('DocumentAI');
+    });
+
+    it('configures workflowConfig definition', () => {
+      const { workflowConfig } = defaultDocumentUploadConfig;
+      expect(workflowConfig.definition).toEqual({
+        workflow_name: 'DocumentAI',
+      });
+    });
+
+    it('configures initialization parameters', () => {
+      const params = defaultDocumentUploadConfig.workflowConfig
+        .parameters as Record<string, unknown>;
+      expect(params.initialization).toEqual({
+        store: { batch_size: 10, pages_per_part: 25 },
+      });
+    });
+
+    it('configures all document extraction readers', () => {
+      const params = defaultDocumentUploadConfig.workflowConfig
+        .parameters as Record<string, unknown>;
+      const extraction = params.document_extraction as Record<string, unknown>;
+
+      expect(extraction.pdf_reader).toEqual({ kind: 'pypdf', batch_size: 10 });
+      expect(extraction.docx_reader).toEqual({
+        kind: 'docx',
+        batch_size: 10,
+        split_by_sections: false,
+      });
+      expect(extraction.pptx_reader).toEqual({
+        kind: 'pptx',
+        batch_size: 10,
+        include_notes: true,
+      });
+      expect(extraction.xlsx_reader).toEqual({
+        kind: 'xlsx',
+        batch_size: 10,
+        max_rows: 10000,
+        max_cols: 100,
+        include_empty_sheets: false,
+      });
+      expect(extraction.markdown_reader).toEqual({
+        kind: 'markdown',
+        batch_size: 10,
+      });
+      expect(extraction.plaintext_reader).toEqual({
+        kind: 'plaintext',
+        batch_size: 10,
+        max_content_size: 500000,
+        min_space_ratio: 0.02,
+      });
+    });
+
+    it('configures chunk extraction parameters', () => {
+      const params = defaultDocumentUploadConfig.workflowConfig
+        .parameters as Record<string, unknown>;
+      const chunkExtraction = params.chunk_extraction as Record<
+        string,
+        unknown
+      >;
+      expect(chunkExtraction.chunker).toEqual({
+        kind: 'naive',
+        batch_size: 1,
+        include_image_descriptions: false,
+        chunk_size: 200,
+      });
+    });
+
+    it('configures workflowConfig schema', () => {
+      const { workflowConfig } = defaultDocumentUploadConfig;
+      expect(workflowConfig.schema).toEqual({
+        type: 'object',
+        properties: {
+          source: {
+            description: 'Source path, connector URI, or list thereof',
+            anyOf: [
+              { type: 'string' },
+              { type: 'array', items: { type: 'string' } },
+            ],
+          },
+        },
+        additionalProperties: true,
+      });
+    });
+  });
+
+  describe('createDocumentUploadProvider', () => {
+    it('is re-exported from useFileUploadWrapper', () => {
+      expect(createDocumentUploadProvider).toBeDefined();
+      expect(typeof createDocumentUploadProvider).toBe('function');
+    });
+
+    it('returns a provider with useDocumentUpload', () => {
+      const provider = createDocumentUploadProvider(
+        defaultDocumentUploadConfig,
+      );
+      expect(provider).toHaveProperty('useDocumentUpload');
+      expect(typeof provider.useDocumentUpload).toBe('function');
+    });
+
+    it('passes the config to createDocumentUploadProvider', () => {
+      const customConfig: DocumentUploadConfig = {
+        baseUrl: '/custom-url',
+        userId: 'custom-user',
+        workflowId: 'custom-workflow',
+        searchStoreConfig: {
+          models: [
+            {
+              type: 'dense',
+              dimension: 512,
+              distance: 'euclidean',
+              modality: 'text',
+              embedding_model: 'custom-model',
+            },
+          ],
+          fusion_strategy: { type: 'custom' },
+        },
+        workflowConfig: { name: 'custom' },
+      };
+
+      const provider = createDocumentUploadProvider(
+        customConfig,
+      ) as unknown as {
+        useDocumentUpload: () => unknown;
+        _config: DocumentUploadConfig;
+      };
+      expect(provider._config).toBe(customConfig);
+    });
+  });
+
+  describe('useDocumentUploadWithDefaultConfig', () => {
+    it('is exported and callable', async () => {
+      const { useDocumentUploadWithDefaultConfig } = await import('./index');
+      expect(useDocumentUploadWithDefaultConfig).toBeDefined();
+      expect(typeof useDocumentUploadWithDefaultConfig).toBe('function');
+    });
+  });
+
+  describe('type exports', () => {
+    it('exports DocumentUploadConfig type', async () => {
+      const module = await import('./index');
+      expect('defaultDocumentUploadConfig' in module).toBe(true);
+    });
+
+    it('exports DocumentUploadProvider type via createDocumentUploadProvider', () => {
+      const provider = createDocumentUploadProvider(
+        defaultDocumentUploadConfig,
+      );
+      expect(provider).toBeDefined();
+    });
+  });
+});

package/src/composables/fileUpload/index.ts

@@ -0,0 +1,83 @@
+import type { DocumentUploadConfig, DocumentUploadProvider } from './types';
+import { createDocumentUploadProvider } from './useFileUploadWrapper';
+
+const WORKFLOW_ID = 'my-doc-ai';
+
+export const defaultDocumentUploadConfig: DocumentUploadConfig = {
+  baseUrl: '/file-upload',
+  userId: 'chat-user',
+  workflowId: WORKFLOW_ID,
+  searchStoreConfig: {
+    models: [
+      {
+        type: 'dense',
+        dimension: 1024,
+        distance: 'cosine',
+        modality: 'text',
+        embedding_model: 'baai/bge-m3',
+      },
+    ],
+    fusion_strategy: { type: 'rrf' },
+  },
+  workflowConfig: {
+    name: WORKFLOW_ID,
+    workflow_name: 'DocumentAI',
+    definition: { workflow_name: 'DocumentAI' },
+    parameters: {
+      initialization: {
+        store: { batch_size: 10, pages_per_part: 25 },
+      },
+      document_extraction: {
+        pdf_reader: { kind: 'pypdf', batch_size: 10 },
+        docx_reader: {
+          kind: 'docx',
+          batch_size: 10,
+          split_by_sections: false,
+        },
+        pptx_reader: { kind: 'pptx', batch_size: 10, include_notes: true },
+        xlsx_reader: {
+          kind: 'xlsx',
+          batch_size: 10,
+          max_rows: 10000,
+          max_cols: 100,
+          include_empty_sheets: false,
+        },
+        markdown_reader: { kind: 'markdown', batch_size: 10 },
+        plaintext_reader: {
+          kind: 'plaintext',
+          batch_size: 10,
+          max_content_size: 500000,
+          min_space_ratio: 0.02,
+        },
+      },
+      chunk_extraction: {
+        chunker: {
+          kind: 'naive',
+          batch_size: 1,
+          include_image_descriptions: false,
+          chunk_size: 200,
+        },
+      },
+    },
+    schema: {
+      type: 'object',
+      properties: {
+        source: {
+          description: 'Source path, connector URI, or list thereof',
+          anyOf: [
+            { type: 'string' },
+            { type: 'array', items: { type: 'string' } },
+          ],
+        },
+      },
+      additionalProperties: true,
+    },
+  },
+};
+
+const { useDocumentUpload: useDocumentUploadWithDefaultConfig } =
+  createDocumentUploadProvider(defaultDocumentUploadConfig);
+
+export { useDocumentUploadWithDefaultConfig, createDocumentUploadProvider };
+
+export type { DocumentUploadConfig, DocumentUploadProvider };

package/src/composables/fileUpload/types.ts

@@ -0,0 +1,409 @@
+import type { ComputedRef, MaybeRef, Ref } from 'vue';
+
+// ---------------------------------------------------------------------------
+//  HTTP Client
+// ---------------------------------------------------------------------------
+
+export interface RequestConfig {
+  signal?: AbortSignal;
+  onUploadProgress?: (event: { loaded: number; total: number }) => void;
+}
+
+export interface SseEvent {
+  event: string;
+  data: string;
+}
+
+export interface SseStream {
+  subscribe(callback: (event: SseEvent) => void): void;
+  close(): void;
+}
+
+export interface HttpClient {
+  get<T>(url: string, config?: RequestConfig): Promise<T>;
+  post<T>(url: string, body: unknown, config?: RequestConfig): Promise<T>;
+  delete<T>(url: string, config?: RequestConfig): Promise<T>;
+  stream(url: string, config?: RequestConfig): SseStream;
+}
+
+// ---------------------------------------------------------------------------
+//  Endpoint Resolver
+// ---------------------------------------------------------------------------
+
+export interface EndpointResolver {
+  files: (storeId: string) => string;
+  file: (storeId: string, fileId: string) => string;
+  filePublicUrl: (storeId: string, fileId: string) => string;
+  workflowRun: (storeId: string, workflowId: string) => string;
+  workflowRunEventStream: (
+    storeId: string,
+    workflowId: string,
+    runId: string,
+  ) => string;
+}
+
+export const defaultEndpoints: EndpointResolver = {
+  files: (storeId) => `search-stores/${storeId}/files`,
+  file: (storeId, fileId) => `search-stores/${storeId}/files/${fileId}`,
+  filePublicUrl: (storeId, fileId) =>
+    `search-stores/${storeId}/files/${fileId}/public-urls?ttl=1h`,
+  workflowRun: (storeId, workflowId) =>
+    `search-stores/${storeId}/workflows/${workflowId}/runs`,
+  workflowRunEventStream: (storeId, workflowId, runId) =>
+    `search-stores/${storeId}/workflows/${workflowId}/runs/${runId}/event-stream`,
+};
+
+// ---------------------------------------------------------------------------
+//  Domain Models
+// ---------------------------------------------------------------------------
+
+export interface RemoteFile {
+  id: string;
+  name: string;
+  size: number;
+  mime_type: string;
+  created_at: string;
+  updated_at: string;
+  metadata: Record<string, unknown>;
+}
+
+// ---------------------------------------------------------------------------
+//  File Constraints & Validation
+// ---------------------------------------------------------------------------
+
+export interface FileConstraints {
+  allowedMimeTypes: string[];
+  allowedExtensions: string[];
+  maxFileSizeBytes: number;
+  maxFilesPerUpload: number;
+}
+
+export type ValidatorFn = (
+  file: File,
+  constraints: FileConstraints,
+) => ValidationResult | Promise<ValidationResult>;
+
+export interface ValidationResult {
+  valid: boolean;
+  reason?: string;
+}
+
+// ---------------------------------------------------------------------------
+//  File State
+// ---------------------------------------------------------------------------
+
+export type FileStatus =
+  | 'queued'
+  | 'validating'
+  | 'uploading'
+  | 'processing'
+  | 'success'
+  | 'failed'
+  | 'cancelled'
+  | 'removing'
+  | 'removed';
+
+export type ThumbnailStrategy = 'canvas' | 'icon-fallback';
+
+export interface FileThumbnail {
+  dataUrl: string;
+  width: number;
+  height: number;
+  generatedAt: string;
+  strategy: ThumbnailStrategy;
+}
+
+export interface FileUploadError {
+  code: string;
+  message: string;
+  httpStatus?: number;
+  details?: unknown;
+  occurredAt: string;
+}
+
+export interface FileEntry {
+  id: string;
+  groupId: string;
+  fileName: string;
+  fileSize: number;
+  fileType: string;
+
+  status: FileStatus;
+  progress: number;
+
+  queuedAt: string;
+  uploadStartedAt: string | null;
+  uploadCompletedAt: string | null;
+  cancelledAt: string | null;
+  removedAt: string | null;
+
+  uploadDurationMs: number | null;
+  remoteFileId: string | null;
+  error: FileUploadError | null;
+
+  attemptCount: number;
+  lastAttemptAt: string | null;
+
+  thumbnail: FileThumbnail | null;
+  metadata: Record<string, unknown>;
+}
+
+export type FileStateMap = Map<string, FileEntry>;
+
+// ---------------------------------------------------------------------------
+//  Upload
+// ---------------------------------------------------------------------------
+
+export interface UploadParams {
+  id: string;
+  files: File | File[];
+  metadata?: Record<string, unknown>;
+  forwardedProps?: Record<string, unknown>;
+  signal?: AbortSignal;
+}
+
+export interface UploadResult {
+  id: string;
+  results: UploadFileResult[];
+}
+
+export interface UploadFileResult {
+  fileId: string;
+  success: boolean;
+  status: FileStatus;
+  remoteFileId?: string;
+  error?: FileUploadError;
+  uploadDate: string;
+  metadata?: Record<string, unknown>;
+}
+
+// ---------------------------------------------------------------------------
+//  File Removal
+// ---------------------------------------------------------------------------
+
+export interface RemoveFileOptions {
+  removeFromState?: boolean;
+  removeFromRemote?: boolean;
+}
+
+// ---------------------------------------------------------------------------
+//  Retry
+// ---------------------------------------------------------------------------
+
+export interface RetryPolicy {
+  maxRetries: number;
+  delayMs: number;
+  backoffMultiplier?: number;
+  retryableStatusCodes?: number[];
+}
+
+// ---------------------------------------------------------------------------
+//  Persistence
+// ---------------------------------------------------------------------------
+
+export interface PersistOptions {
+  dbName?: string;
+  storeName?: string;
+  debounceMs?: number;
+  maxAge?: number;
+  filter?: (entry: FileEntry) => boolean;
+}
+
+// ---------------------------------------------------------------------------
+//  Events
+// ---------------------------------------------------------------------------
+
+export type UploadEvent =
+  | { type: 'file:queued'; fileId: string; entry: FileEntry }
+  | { type: 'file:validating'; fileId: string }
+  | { type: 'file:uploading'; fileId: string; attemptCount: number }
+  | { type: 'file:progress'; fileId: string; progress: number }
+  | {
+      type: 'file:success';
+      fileId: string;
+      remoteFileId: string;
+      durationMs: number;
+    }
+  | { type: 'file:failed'; fileId: string; error: FileUploadError }
+  | { type: 'file:cancelled'; fileId: string }
+  | { type: 'file:removed'; fileId: string }
+  | { type: 'file:thumbnail-failed'; fileId: string; reason: string }
+  | { type: 'upload:complete'; groupId: string; results: UploadFileResult[] }
+  | { type: 'workflow:started'; runId: string }
+  | { type: 'workflow:event'; event: WorkflowRunEvent }
+  | { type: 'workflow:completed'; runId: string }
+  | {
+      type: 'workflow:failed';
+      runId: string;
+      error: { code: string; message: string };
+    }
+  | { type: 'state:restored'; entryCount: number }
+  | { type: 'state:persisted'; entryCount: number }
+  | { type: 'state:persist-error'; error: Error };
+
+// ---------------------------------------------------------------------------
+//  Scoped View
+// ---------------------------------------------------------------------------
+
+export interface ScopedFileView {
+  files: ComputedRef<FileEntry[]>;
+  count: ComputedRef<number>;
+  progress: ComputedRef<number>;
+  isUploading: ComputedRef<boolean>;
+  hasErrors: ComputedRef<boolean>;
+  clear: () => void;
+  cancel: () => void;
+  retry: (fileId: string) => void;
+}
+
+// ---------------------------------------------------------------------------
+//  Workflow
+// ---------------------------------------------------------------------------
+
+export interface WorkflowRunInput {
+  source: string;
+}
+
+export type WorkflowRunStatus =
+  | 'connecting'
+  | 'running'
+  | 'completed'
+  | 'failed'
+  | 'cancelled';
+
+export interface WorkflowRunEvent {
+  id: string;
+  status: string;
+}
+
+export interface WorkflowRun {
+  runId: string;
+  workflowId: string;
+  storeId: string;
+  status: WorkflowRunStatus;
+  events: WorkflowRunEvent[];
+  error: { code: string; message: string } | null;
+  startedAt: string;
+  completedAt: string | null;
+}
+
+export interface WorkflowStream {
+  close(): void;
+}
+
+// ---------------------------------------------------------------------------
+//  Error
+// ---------------------------------------------------------------------------
+
+export type ErrorCode =
+  | 'NO_ACTIVE_STORE'
+  | 'STORE_NOT_FOUND'
+  | 'FILE_TOO_LARGE'
+  | 'FILE_TYPE_NOT_ALLOWED'
+  | 'MAX_FILES_EXCEEDED'
+  | 'VALIDATION_FAILED'
+  | 'UPLOAD_FAILED'
+  | 'UPLOAD_ABORTED'
+  | 'REMOVE_FAILED'
+  | 'WORKFLOW_NOT_FOUND'
+  | 'WORKFLOW_RUN_FAILED'
+  | 'NETWORK_ERROR'
+  | 'UPLOAD_INTERRUPTED'
+  | 'REMOVE_INTERRUPTED';
+
+export class SdkError extends Error {
+  constructor(
+    public readonly code: ErrorCode,
+    message: string,
+    public readonly details?: unknown,
+  ) {
+    super(message);
+    this.name = 'SdkError';
+  }
+}
+
+// ---------------------------------------------------------------------------
+//  Document Upload Provider Config
+// ---------------------------------------------------------------------------
+
+export interface SearchStoreModel {
+  type: string;
+  dimension: number;
+  distance: string;
+  modality: string;
+  embedding_model: string;
+}
+
+export interface DocumentUploadConfig {
+  baseUrl: string;
+  userId: string;
+  workflowId: string;
+  searchStoreConfig: {
+    models: SearchStoreModel[];
+    fusion_strategy: Record<string, unknown>;
+  };
+  workflowConfig: Record<string, unknown>;
+  persist?: boolean;
+  maxConcurrency?: number;
+  headers?: Record<string, string>;
+  onEvent?: (event: UploadEvent) => void;
+}
+
+export interface DocumentUploadProvider {
+  useDocumentUpload: (
+    conversationIdRef: MaybeRef<string>,
+  ) => DocumentUploadReturn;
+}
+
+export interface DocumentUploadReturn {
+  upload: UseFileUploadReturn;
+  storeId: Ref<string>;
+  fileInput: Ref<HTMLInputElement | null>;
+  uploadFiles: (files: File[]) => Promise<UploadResult | undefined>;
+  unassignedFiles: ComputedRef<FileEntry[]>;
+  assignFilesToMessage: (messageId: string) => void;
+  getFilesForMessage: (messageId: string) => FileEntry[];
+  stampResponseId: (responseId: string, localMessageId: string) => void;
+  purgeCompletedFiles: () => void;
+  handleFilesSelected: (event: Event) => void;
+}
+
+// ---------------------------------------------------------------------------
+//  Composable Options & Return
+// ---------------------------------------------------------------------------
+
+export interface UseFileUploadOptions {
+  client: HttpClient;
+  storeId?: string;
+  workflowId: string;
+  endpoints?: EndpointResolver;
+  persist?: PersistOptions | boolean;
+  maxConcurrency?: number;
+  retryPolicy?: RetryPolicy;
+  validators?: ValidatorFn[];
+  onEvent?: (event: UploadEvent) => void;
+}
+
+export interface UseFileUploadReturn {
+  getSupportedFileTypes: () => FileConstraints;
+
+  upload: (params: UploadParams) => Promise<UploadResult>;
+  cancel: (groupId: string) => void;
+  removeFile: (fileId: string, options?: RemoveFileOptions) => Promise<void>;
+
+  files: Ref<FileStateMap>;
+  getFileState: (id: string) => FileEntry | undefined;
+  updateFileMetadata: (id: string, meta: Record<string, unknown>) => void;
+  clearState: () => void;
+  setStoreId: (id: string) => void;
+  getPublicUrl: (fileId: string) => Promise<string>;
+
+  scopeBy: (metadataKey: string, value: string) => ScopedFileView;
+
+  workflowRun: Ref<WorkflowRun | null>;
+  runWorkflow: (fileIds: string[]) => Promise<WorkflowStream>;
+
+  isRestoring: Ref<boolean>;
+  restoreState: () => Promise<void>;
+  purgePersistedState: () => Promise<void>;
+}