@aleph-alpha/chat-kit 1.3.1 → 1.5.0

package/dist/index-BbTgIoYa.js

@@ -0,0 +1,1557 @@
+import { g as generateId } from "./generateId-BHf0W4Rq.js";
+import { ref, shallowRef, computed, readonly, toRaw, toValue, watch } 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 fetch2(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: fetch2,
+    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 now2 = /* @__PURE__ */ new Date();
+  return {
+    id: `pending-${generateId()}`,
+    title: title ?? "",
+    createdAt: now2,
+    updatedAt: now2
+  };
+}
+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
+  };
+}
+const defaultEndpoints = {
+  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`
+};
+class SdkError extends Error {
+  constructor(code, message, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "SdkError";
+  }
+}
+const DEFAULT_CONSTRAINTS = {
+  allowedMimeTypes: [
+    "application/pdf",
+    "text/plain",
+    "text/csv",
+    "application/msword",
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    "application/vnd.ms-excel",
+    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    "application/vnd.ms-powerpoint",
+    "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+    "image/png",
+    "image/jpeg",
+    "image/gif",
+    "image/webp"
+  ],
+  allowedExtensions: [
+    ".pdf",
+    ".txt",
+    ".csv",
+    ".doc",
+    ".docx",
+    ".xls",
+    ".xlsx",
+    ".ppt",
+    ".pptx",
+    ".png",
+    ".jpg",
+    ".jpeg",
+    ".gif",
+    ".webp"
+  ],
+  maxFileSizeBytes: 100 * 1024 * 1024,
+  maxFilesPerUpload: 20
+};
+const DEFAULT_RETRY_POLICY = {
+  maxRetries: 2,
+  delayMs: 1e3,
+  backoffMultiplier: 2,
+  retryableStatusCodes: [408, 429, 500, 502, 503]
+};
+const FILE_ICON_SVG = `data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='128' height='128' viewBox='0 0 24 24' fill='none' stroke='%2371717a' stroke-width='1.5' stroke-linecap='round' stroke-linejoin='round'%3E%3Cpath d='M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z'/%3E%3Cpath d='M14 2v4a2 2 0 0 0 2 2h4'/%3E%3C/svg%3E`;
+const FILE_ICONS = {
+  _default: FILE_ICON_SVG,
+  "application/pdf": `data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='128' height='128' viewBox='0 0 24 24' fill='none' stroke='%23ef4444' stroke-width='1.5' stroke-linecap='round' stroke-linejoin='round'%3E%3Cpath d='M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z'/%3E%3Cpath d='M14 2v4a2 2 0 0 0 2 2h4'/%3E%3Cpath d='M10 12h4'/%3E%3Cpath d='M10 16h4'/%3E%3C/svg%3E`,
+  "text/plain": `data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='128' height='128' viewBox='0 0 24 24' fill='none' stroke='%2371717a' stroke-width='1.5' stroke-linecap='round' stroke-linejoin='round'%3E%3Cpath d='M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z'/%3E%3Cpath d='M14 2v4a2 2 0 0 0 2 2h4'/%3E%3Cpath d='M10 12h4'/%3E%3Cpath d='M10 16h4'/%3E%3C/svg%3E`,
+  "text/csv": `data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='128' height='128' viewBox='0 0 24 24' fill='none' stroke='%2322c55e' stroke-width='1.5' stroke-linecap='round' stroke-linejoin='round'%3E%3Cpath d='M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z'/%3E%3Cpath d='M14 2v4a2 2 0 0 0 2 2h4'/%3E%3Cpath d='M8 15h2'/%3E%3Cpath d='M14 15h2'/%3E%3Cpath d='M8 11h2'/%3E%3Cpath d='M14 11h2'/%3E%3C/svg%3E`
+};
+const DB_VERSION = 1;
+const ACTIVE_UPLOAD_STATUSES = /* @__PURE__ */ new Set(["queued", "validating", "uploading"]);
+const ACTIVE_OR_PROCESSING = /* @__PURE__ */ new Set([
+  "queued",
+  "validating",
+  "uploading",
+  "processing"
+]);
+function now() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function extensionOf(name) {
+  const dot = name.lastIndexOf(".");
+  return dot === -1 ? "" : name.slice(dot).toLowerCase();
+}
+function debounce(fn, ms) {
+  let timer = null;
+  return () => {
+    if (timer) clearTimeout(timer);
+    timer = setTimeout(fn, ms);
+  };
+}
+class Semaphore {
+  permits;
+  queue = [];
+  constructor(permits) {
+    this.permits = permits;
+  }
+  acquire() {
+    if (this.permits > 0) {
+      this.permits--;
+      return Promise.resolve();
+    }
+    return new Promise((resolve) => {
+      this.queue.push(resolve);
+    });
+  }
+  release() {
+    if (this.queue.length > 0) {
+      this.queue.shift()();
+    } else {
+      this.permits++;
+    }
+  }
+}
+function iconFallback(file) {
+  const dataUrl = FILE_ICONS[file.type] || FILE_ICONS._default;
+  return {
+    dataUrl: dataUrl ?? "",
+    width: 128,
+    height: 128,
+    generatedAt: now(),
+    strategy: "icon-fallback"
+  };
+}
+function generateCanvasThumbnail(file, maxW = 128, maxH = 128) {
+  return new Promise((resolve, reject) => {
+    if (typeof document === "undefined") {
+      reject(new Error("Canvas is not available in this environment"));
+      return;
+    }
+    const url = URL.createObjectURL(file);
+    const img = new Image();
+    img.onload = () => {
+      let w = img.naturalWidth;
+      let h = img.naturalHeight;
+      const ratio = Math.min(maxW / w, maxH / h, 1);
+      w = Math.round(w * ratio);
+      h = Math.round(h * ratio);
+      const canvas = document.createElement("canvas");
+      canvas.width = w;
+      canvas.height = h;
+      const ctx = canvas.getContext("2d");
+      ctx.drawImage(img, 0, 0, w, h);
+      const dataUrl = canvas.toDataURL("image/png");
+      URL.revokeObjectURL(url);
+      resolve({
+        dataUrl,
+        width: w,
+        height: h,
+        generatedAt: now(),
+        strategy: "canvas"
+      });
+    };
+    img.onerror = () => {
+      URL.revokeObjectURL(url);
+      reject(new Error("Failed to load image for thumbnail generation"));
+    };
+    img.src = url;
+  });
+}
+async function generateThumbnail(file) {
+  if (file.type.startsWith("image/")) {
+    try {
+      return await generateCanvasThumbnail(file);
+    } catch {
+      return iconFallback(file);
+    }
+  }
+  return iconFallback(file);
+}
+function validateFileConstraints(file, constraints) {
+  const ext = extensionOf(file.name);
+  if (file.size > constraints.maxFileSizeBytes) {
+    return {
+      code: "FILE_TOO_LARGE",
+      message: `File "${file.name}" exceeds the maximum size of ${constraints.maxFileSizeBytes} bytes.`,
+      occurredAt: now()
+    };
+  }
+  if (constraints.allowedMimeTypes.length > 0 && !constraints.allowedMimeTypes.includes(file.type)) {
+    return {
+      code: "FILE_TYPE_NOT_ALLOWED",
+      message: `MIME type "${file.type}" is not allowed for file "${file.name}".`,
+      occurredAt: now()
+    };
+  }
+  if (constraints.allowedExtensions.length > 0 && ext !== "" && !constraints.allowedExtensions.includes(ext)) {
+    return {
+      code: "FILE_TYPE_NOT_ALLOWED",
+      message: `Extension "${ext}" is not allowed for file "${file.name}".`,
+      occurredAt: now()
+    };
+  }
+  return null;
+}
+async function runCustomValidators(file, constraints, validators) {
+  for (const validator of validators) {
+    const result = await validator(file, constraints);
+    if (!result.valid) {
+      return {
+        code: "VALIDATION_FAILED",
+        message: result.reason ?? `Validation failed for "${file.name}".`,
+        occurredAt: now()
+      };
+    }
+  }
+  return null;
+}
+function isRetryable(err, policy) {
+  if (!policy.retryableStatusCodes?.length) return true;
+  const status = err?.httpStatus ?? err?.status ?? err?.response?.status;
+  return status != null && policy.retryableStatusCodes.includes(status);
+}
+async function withRetry(fn, policy, signal) {
+  let lastError;
+  for (let attempt = 0; attempt <= policy.maxRetries; attempt++) {
+    if (signal.aborted)
+      throw new SdkError("UPLOAD_ABORTED", "Upload cancelled.");
+    try {
+      return await fn();
+    } catch (err) {
+      lastError = err;
+      if (signal.aborted) throw err;
+      if (attempt < policy.maxRetries && isRetryable(err, policy)) {
+        const delay = policy.delayMs * Math.pow(policy.backoffMultiplier ?? 2, attempt);
+        await new Promise((r) => setTimeout(r, delay));
+      }
+    }
+  }
+  throw lastError;
+}
+function openDB(dbName, storeName) {
+  return new Promise((resolve, reject) => {
+    const request = indexedDB.open(dbName, DB_VERSION);
+    request.onupgradeneeded = () => {
+      const db = request.result;
+      if (!db.objectStoreNames.contains(storeName)) {
+        db.createObjectStore(storeName, { keyPath: "id" });
+      }
+    };
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error);
+  });
+}
+function persistEntries(db, storeName, entries, filter) {
+  const filtered = filter ? entries.filter(filter) : entries;
+  const tx = db.transaction(storeName, "readwrite");
+  const store = tx.objectStore(storeName);
+  for (const entry of filtered) {
+    store.put(structuredClone(toRaw(entry)));
+  }
+  return new Promise((resolve, reject) => {
+    tx.oncomplete = () => resolve();
+    tx.onerror = () => reject(tx.error);
+  });
+}
+function deletePersistedEntry(db, storeName, id) {
+  const tx = db.transaction(storeName, "readwrite");
+  tx.objectStore(storeName).delete(id);
+  return new Promise((resolve, reject) => {
+    tx.oncomplete = () => resolve();
+    tx.onerror = () => reject(tx.error);
+  });
+}
+function restoreEntries(db, storeName, maxAge) {
+  const tx = db.transaction(storeName, "readonly");
+  const request = tx.objectStore(storeName).getAll();
+  return new Promise((resolve, reject) => {
+    request.onsuccess = () => {
+      let entries = request.result;
+      if (maxAge) {
+        const cutoff = Date.now() - maxAge;
+        entries = entries.filter(
+          (e) => new Date(e.queuedAt).getTime() > cutoff
+        );
+      }
+      resolve(entries.map(rehydrateEntry));
+    };
+    request.onerror = () => reject(request.error);
+  });
+}
+function purgeStore(db, storeName) {
+  const tx = db.transaction(storeName, "readwrite");
+  tx.objectStore(storeName).clear();
+  return new Promise((resolve, reject) => {
+    tx.oncomplete = () => resolve();
+    tx.onerror = () => reject(tx.error);
+  });
+}
+function rehydrateEntry(entry) {
+  if (entry.status === "uploading" || entry.status === "validating" || entry.status === "queued") {
+    return {
+      ...entry,
+      status: "failed",
+      error: {
+        code: "UPLOAD_INTERRUPTED",
+        message: "Upload was interrupted by a page reload or browser close.",
+        occurredAt: now()
+      }
+    };
+  }
+  if (entry.status === "processing") {
+    return {
+      ...entry,
+      status: "failed",
+      error: {
+        code: "PROCESSING_INTERRUPTED",
+        message: "Workflow processing was interrupted before completion.",
+        occurredAt: now()
+      }
+    };
+  }
+  if (entry.status === "removing") {
+    return {
+      ...entry,
+      status: "failed",
+      error: {
+        code: "REMOVE_INTERRUPTED",
+        message: "File removal was interrupted.",
+        occurredAt: now()
+      }
+    };
+  }
+  return entry;
+}
+function normalizePersistConfig(opt) {
+  if (!opt) return null;
+  if (opt === true) return {};
+  return opt;
+}
+function deriveStateKey(groupId, fileName, existingKeys) {
+  const base = `${groupId}::${fileName}`;
+  if (!existingKeys.has(base)) return base;
+  let suffix = 2;
+  while (existingKeys.has(`${base}::${suffix}`)) suffix++;
+  return `${base}::${suffix}`;
+}
+function useFileUpload(options) {
+  const { client, workflowId } = options;
+  let storeId = options.storeId ?? "";
+  const endpoints = options.endpoints ?? defaultEndpoints;
+  const retryPolicy = options.retryPolicy ?? DEFAULT_RETRY_POLICY;
+  const constraints = { ...DEFAULT_CONSTRAINTS };
+  const validators = options.validators ?? [];
+  const maxConcurrency = options.maxConcurrency ?? 3;
+  const files = ref(/* @__PURE__ */ new Map());
+  const workflowRun = ref(null);
+  const isRestoring = ref(false);
+  const uploadControllers = /* @__PURE__ */ new Map();
+  const semaphore = new Semaphore(maxConcurrency);
+  const persistConfig = normalizePersistConfig(options.persist);
+  let db = null;
+  const persistDbName = persistConfig?.dbName ?? "file-upload-sdk";
+  const persistStoreName = persistConfig?.storeName ?? "file-entries";
+  const persistDebounceMs = persistConfig?.debounceMs ?? 300;
+  const schedulePersist = debounce(async () => {
+    if (!db) return;
+    try {
+      const entries = [...files.value.values()];
+      await persistEntries(
+        db,
+        persistStoreName,
+        entries,
+        persistConfig?.filter
+      );
+      emit({ type: "state:persisted", entryCount: entries.length });
+    } catch (err) {
+      emit({ type: "state:persist-error", error: err });
+    }
+  }, persistDebounceMs);
+  function persistIfEnabled() {
+    if (persistConfig && db) schedulePersist();
+  }
+  function emit(event) {
+    options.onEvent?.(event);
+  }
+  function setEntry(entry) {
+    files.value.set(entry.id, entry);
+    persistIfEnabled();
+  }
+  function updateEntry(id, updates) {
+    const entry = files.value.get(id);
+    if (!entry) return;
+    Object.assign(entry, updates);
+    persistIfEnabled();
+  }
+  function getSupportedFileTypes() {
+    return { ...constraints };
+  }
+  async function validateAndQueueBatch(batch, groupId, mergedMeta) {
+    for (const { file, stateKey } of batch) {
+      const constraintErr = validateFileConstraints(file, constraints);
+      if (constraintErr) {
+        const entry2 = createEntry(stateKey, groupId, file, mergedMeta);
+        entry2.status = "failed";
+        entry2.error = constraintErr;
+        setEntry(entry2);
+        emit({ type: "file:failed", fileId: stateKey, error: constraintErr });
+        continue;
+      }
+      let thumbnail = null;
+      try {
+        thumbnail = await generateThumbnail(file);
+      } catch (err) {
+        emit({
+          type: "file:thumbnail-failed",
+          fileId: stateKey,
+          reason: err.message
+        });
+      }
+      const entry = createEntry(stateKey, groupId, file, mergedMeta, thumbnail);
+      setEntry(entry);
+      emit({ type: "file:queued", fileId: stateKey, entry });
+    }
+  }
+  async function runValidationPhase(validBatch) {
+    for (const { file, stateKey } of validBatch) {
+      updateEntry(stateKey, { status: "validating" });
+      emit({ type: "file:validating", fileId: stateKey });
+      const validationErr = await runCustomValidators(
+        file,
+        constraints,
+        validators
+      );
+      if (validationErr) {
+        updateEntry(stateKey, { status: "failed", error: validationErr });
+        emit({ type: "file:failed", fileId: stateKey, error: validationErr });
+      }
+    }
+  }
+  function handleUploadSuccess(uploadReady, response) {
+    const completedAt = now();
+    const results = Array.isArray(response) ? response : [];
+    for (let i = 0; i < uploadReady.length; i++) {
+      const { stateKey } = uploadReady[i];
+      const entry = files.value.get(stateKey);
+      const durationMs = new Date(completedAt).getTime() - new Date(entry.uploadStartedAt).getTime();
+      const remoteResult = results[i];
+      const remoteFileId = remoteResult?.id ?? null;
+      const documentId = remoteResult?.documentId ?? null;
+      if (remoteFileId) {
+        updateEntry(stateKey, {
+          status: "success",
+          progress: 100,
+          remoteFileId,
+          uploadCompletedAt: completedAt,
+          uploadDurationMs: durationMs
+        });
+        if (documentId) {
+          updateFileMetadata(stateKey, { documentId });
+        }
+        emit({
+          type: "file:success",
+          fileId: stateKey,
+          remoteFileId,
+          durationMs
+        });
+      } else {
+        const err = {
+          code: "UPLOAD_FAILED",
+          message: `No remote ID returned for "${entry.fileName}".`,
+          occurredAt: completedAt
+        };
+        updateEntry(stateKey, {
+          status: "failed",
+          error: err,
+          uploadCompletedAt: completedAt,
+          uploadDurationMs: durationMs
+        });
+        emit({ type: "file:failed", fileId: stateKey, error: err });
+      }
+    }
+  }
+  function handleUploadError(uploadReady, err, mergedSignal, batch, groupId) {
+    const completedAt = now();
+    if (mergedSignal.aborted) {
+      for (const { stateKey } of uploadReady) {
+        transitionToCancelled(stateKey);
+      }
+      uploadControllers.delete(groupId);
+      const result = buildUploadResult(groupId, batch);
+      emit({
+        type: "upload:complete",
+        groupId,
+        results: result.results
+      });
+      throw new SdkError(
+        "UPLOAD_ABORTED",
+        `Upload "${groupId}" was cancelled.`
+      );
+    }
+    const uploadErr = {
+      code: "UPLOAD_FAILED",
+      message: err.message ?? "Upload failed.",
+      httpStatus: err?.httpStatus ?? err?.status,
+      occurredAt: completedAt
+    };
+    for (const { stateKey } of uploadReady) {
+      const entry = files.value.get(stateKey);
+      const durationMs = entry.uploadStartedAt ? new Date(completedAt).getTime() - new Date(entry.uploadStartedAt).getTime() : null;
+      updateEntry(stateKey, {
+        status: "failed",
+        error: uploadErr,
+        uploadCompletedAt: completedAt,
+        uploadDurationMs: durationMs
+      });
+      emit({ type: "file:failed", fileId: stateKey, error: uploadErr });
+    }
+  }
+  async function upload(params) {
+    const fileList = Array.isArray(params.files) ? params.files : [params.files];
+    if (fileList.length > constraints.maxFilesPerUpload) {
+      throw new SdkError(
+        "MAX_FILES_EXCEEDED",
+        `Cannot upload ${fileList.length} files — maximum is ${constraints.maxFilesPerUpload}.`
+      );
+    }
+    const mergedMeta = {
+      ...params.metadata ?? {},
+      ...params.forwardedProps ?? {}
+    };
+    const existingKeys = new Set(files.value.keys());
+    const batch = [];
+    for (const file of fileList) {
+      const stateKey = deriveStateKey(params.id, file.name, existingKeys);
+      existingKeys.add(stateKey);
+      batch.push({ file, stateKey });
+    }
+    await validateAndQueueBatch(batch, params.id, mergedMeta);
+    const validBatch = batch.filter((b) => {
+      const entry = files.value.get(b.stateKey);
+      return entry && entry.status === "queued";
+    });
+    if (validBatch.length === 0) {
+      return buildUploadResult(params.id, batch);
+    }
+    await runValidationPhase(validBatch);
+    const uploadReady = validBatch.filter((b) => {
+      const entry = files.value.get(b.stateKey);
+      return entry && entry.status === "validating";
+    });
+    if (uploadReady.length === 0) {
+      return buildUploadResult(params.id, batch);
+    }
+    const formData = new FormData();
+    for (const { file } of uploadReady) {
+      formData.append("files", file, file.name);
+    }
+    const controller = new AbortController();
+    uploadControllers.set(params.id, controller);
+    const mergedSignal = params.signal ? AbortSignal.any([controller.signal, params.signal]) : controller.signal;
+    const uploadStarted = now();
+    for (const { stateKey } of uploadReady) {
+      updateEntry(stateKey, {
+        status: "uploading",
+        uploadStartedAt: uploadStarted,
+        attemptCount: (files.value.get(stateKey)?.attemptCount ?? 0) + 1,
+        lastAttemptAt: uploadStarted
+      });
+      emit({
+        type: "file:uploading",
+        fileId: stateKey,
+        attemptCount: files.value.get(stateKey).attemptCount
+      });
+    }
+    const totalBytes = uploadReady.reduce(
+      (sum, { file }) => sum + file.size,
+      0
+    );
+    const onUploadProgress = (event) => {
+      const ratio = event.total > 0 ? event.loaded / event.total : 0;
+      const loadedBytes = ratio * totalBytes;
+      for (const { file, stateKey } of uploadReady) {
+        const fileShare = totalBytes > 0 ? loadedBytes * (file.size / totalBytes) : 0;
+        const progress = Math.min(
+          100,
+          Math.round(fileShare / Math.max(file.size, 1) * 100)
+        );
+        updateEntry(stateKey, { progress });
+        emit({ type: "file:progress", fileId: stateKey, progress });
+      }
+    };
+    await semaphore.acquire();
+    try {
+      const response = await withRetry(
+        () => client.post(endpoints.files(storeId), formData, {
+          signal: mergedSignal,
+          onUploadProgress
+        }),
+        retryPolicy,
+        mergedSignal
+      );
+      handleUploadSuccess(uploadReady, response);
+    } catch (err) {
+      handleUploadError(uploadReady, err, mergedSignal, batch, params.id);
+    } finally {
+      semaphore.release();
+      uploadControllers.delete(params.id);
+    }
+    const result = buildUploadResult(params.id, batch);
+    emit({
+      type: "upload:complete",
+      groupId: params.id,
+      results: result.results
+    });
+    return result;
+  }
+  function createEntry(id, groupId, file, metadata, thumbnail = null) {
+    return {
+      id,
+      groupId,
+      fileName: file.name,
+      fileSize: file.size,
+      fileType: file.type,
+      status: "queued",
+      progress: 0,
+      queuedAt: now(),
+      uploadStartedAt: null,
+      uploadCompletedAt: null,
+      cancelledAt: null,
+      removedAt: null,
+      uploadDurationMs: null,
+      remoteFileId: null,
+      error: null,
+      attemptCount: 0,
+      lastAttemptAt: null,
+      thumbnail,
+      metadata: { ...metadata }
+    };
+  }
+  function buildUploadResult(groupId, batch) {
+    return {
+      id: groupId,
+      results: batch.map(({ stateKey }) => {
+        const entry = files.value.get(stateKey);
+        return {
+          fileId: stateKey,
+          success: entry.status === "success",
+          status: entry.status,
+          remoteFileId: entry.remoteFileId ?? void 0,
+          error: entry.error ?? void 0,
+          uploadDate: entry.uploadCompletedAt ?? entry.queuedAt,
+          metadata: entry.metadata
+        };
+      })
+    };
+  }
+  function cancel(groupId) {
+    const controller = uploadControllers.get(groupId);
+    if (controller) {
+      controller.abort();
+      uploadControllers.delete(groupId);
+    }
+    for (const [, entry] of files.value) {
+      if (entry.groupId === groupId) {
+        transitionToCancelled(entry.id);
+      }
+    }
+  }
+  function transitionToCancelled(id) {
+    const entry = files.value.get(id);
+    if (!entry || !ACTIVE_UPLOAD_STATUSES.has(entry.status)) return;
+    const ts = now();
+    updateEntry(id, {
+      status: "cancelled",
+      cancelledAt: ts,
+      error: {
+        code: "UPLOAD_ABORTED",
+        message: "Upload cancelled.",
+        occurredAt: ts
+      }
+    });
+    emit({ type: "file:cancelled", fileId: id });
+  }
+  async function removeFile(fileId, opts) {
+    const removeFromState = opts?.removeFromState ?? true;
+    const removeFromRemote = opts?.removeFromRemote ?? true;
+    const entry = files.value.get(fileId);
+    if (removeFromRemote && entry?.remoteFileId) {
+      updateEntry(fileId, { status: "removing" });
+      try {
+        await client.delete(endpoints.file(storeId, entry.remoteFileId));
+      } catch (err) {
+        const status = err?.httpStatus ?? err?.status ?? err?.response?.status;
+        if (status === 404) ;
+        else {
+          const removeErr = {
+            code: "REMOVE_FAILED",
+            message: err.message ?? "File removal failed.",
+            occurredAt: now()
+          };
+          updateEntry(fileId, { status: "failed", error: removeErr });
+          throw new SdkError("REMOVE_FAILED", removeErr.message);
+        }
+      }
+    }
+    if (removeFromState) {
+      files.value.delete(fileId);
+      if (db) {
+        try {
+          await deletePersistedEntry(db, persistStoreName, fileId);
+        } catch {
+        }
+      }
+      emit({ type: "file:removed", fileId });
+    } else if (entry) {
+      updateEntry(fileId, { status: "removed", removedAt: now() });
+      emit({ type: "file:removed", fileId });
+    }
+  }
+  function getFileState(id) {
+    return files.value.get(id);
+  }
+  function updateFileMetadata(id, meta) {
+    const entry = files.value.get(id);
+    if (!entry) return;
+    Object.assign(entry.metadata, meta);
+    persistIfEnabled();
+  }
+  function clearState() {
+    files.value.clear();
+    if (db) {
+      purgeStore(db, persistStoreName).catch(() => {
+      });
+    }
+  }
+  function scopeBy(metadataKey, value) {
+    const scopedFiles = computed(
+      () => [...files.value.values()].filter(
+        (f) => f.metadata[metadataKey] === value
+      )
+    );
+    const progress = computed(() => {
+      const active = scopedFiles.value.filter(
+        (f) => ACTIVE_OR_PROCESSING.has(f.status)
+      );
+      if (!active.length) return 100;
+      return Math.round(
+        active.reduce((sum, f) => sum + f.progress, 0) / active.length
+      );
+    });
+    const isUploading = computed(
+      () => scopedFiles.value.some((f) => ACTIVE_UPLOAD_STATUSES.has(f.status))
+    );
+    const hasErrors = computed(
+      () => scopedFiles.value.some((f) => f.status === "failed")
+    );
+    return {
+      files: scopedFiles,
+      count: computed(() => scopedFiles.value.length),
+      progress,
+      isUploading,
+      hasErrors,
+      clear: () => {
+        for (const entry of scopedFiles.value) {
+          files.value.delete(entry.id);
+          if (db) {
+            deletePersistedEntry(db, persistStoreName, entry.id).catch(
+              () => {
+              }
+            );
+          }
+        }
+      },
+      cancel: () => {
+        const groupIds = new Set(
+          scopedFiles.value.map((e) => e.groupId)
+        );
+        for (const gid of groupIds) cancel(gid);
+      },
+      retry: (fileId) => {
+        const entry = files.value.get(fileId);
+        if (entry && entry.status === "failed") {
+          updateEntry(fileId, { status: "queued", error: null, progress: 0 });
+        }
+      }
+    };
+  }
+  async function runWorkflow(fileIds) {
+    const source = fileIds.map((id) => `files://${id}`);
+    const input = { source };
+    const controller = new AbortController();
+    const involvedStateKeys = [...files.value.values()].filter((e) => e.remoteFileId && fileIds.includes(e.remoteFileId)).map((e) => e.id);
+    let sseEventCount = 0;
+    for (const key of involvedStateKeys) {
+      updateEntry(key, { status: "processing", progress: 0 });
+    }
+    const runResponse = await client.post(
+      endpoints.workflowRun(storeId, workflowId),
+      { input },
+      { signal: controller.signal }
+    );
+    const runId = runResponse.id;
+    workflowRun.value = {
+      runId,
+      workflowId,
+      storeId,
+      status: "connecting",
+      events: [],
+      error: null,
+      startedAt: now(),
+      completedAt: null
+    };
+    emit({ type: "workflow:started", runId });
+    const sseEndpoint = endpoints.workflowRunEventStream(
+      storeId,
+      workflowId,
+      runId
+    );
+    const sseStream = client.stream(sseEndpoint, {
+      signal: controller.signal
+    });
+    sseStream.subscribe((event) => {
+      if (!workflowRun.value) return;
+      let data;
+      try {
+        data = JSON.parse(event.data);
+      } catch {
+        data = {};
+      }
+      const runEvent = {
+        id: data.id ?? "",
+        status: data.status ?? event.event
+      };
+      workflowRun.value.events.push(runEvent);
+      emit({ type: "workflow:event", event: runEvent });
+      if (data.status === "completed") {
+        workflowRun.value.status = "completed";
+        workflowRun.value.completedAt = now();
+        for (const key of involvedStateKeys) {
+          updateEntry(key, { status: "success", progress: 100 });
+        }
+        emit({ type: "workflow:completed", runId });
+      } else if (data.status === "failed" || data.status === "error") {
+        workflowRun.value.status = "failed";
+        workflowRun.value.completedAt = now();
+        workflowRun.value.error = {
+          code: "WORKFLOW_RUN_FAILED",
+          message: `Workflow run ${runId} failed.`
+        };
+        const workflowErr = {
+          code: "UPLOAD_FAILED",
+          message: `Workflow run ${runId} failed.`,
+          occurredAt: now()
+        };
+        for (const key of involvedStateKeys) {
+          updateEntry(key, { status: "failed", error: workflowErr });
+        }
+        emit({
+          type: "workflow:failed",
+          runId,
+          error: workflowRun.value.error
+        });
+      } else {
+        workflowRun.value.status = "running";
+        sseEventCount++;
+        const estimated = Math.round(100 * (1 - 1 / (1 + sseEventCount * 0.3)));
+        for (const key of involvedStateKeys) {
+          updateEntry(key, { progress: estimated });
+          emit({ type: "file:progress", fileId: key, progress: estimated });
+        }
+      }
+    });
+    return {
+      close() {
+        controller.abort();
+        sseStream.close();
+        if (workflowRun.value && !["completed", "failed", "cancelled"].includes(
+          workflowRun.value.status
+        )) {
+          workflowRun.value.status = "cancelled";
+          workflowRun.value.completedAt = now();
+        }
+      }
+    };
+  }
+  async function restoreState() {
+    if (!persistConfig) return;
+    isRestoring.value = true;
+    try {
+      if (!db) db = await openDB(persistDbName, persistStoreName);
+      const entries = await restoreEntries(
+        db,
+        persistStoreName,
+        persistConfig.maxAge
+      );
+      for (const entry of entries) {
+        files.value.set(entry.id, entry);
+      }
+      emit({ type: "state:restored", entryCount: entries.length });
+    } catch (err) {
+      emit({ type: "state:persist-error", error: err });
+    } finally {
+      isRestoring.value = false;
+    }
+  }
+  async function purgePersistedState() {
+    if (!db) return;
+    try {
+      await purgeStore(db, persistStoreName);
+    } catch (err) {
+      emit({ type: "state:persist-error", error: err });
+    }
+  }
+  if (persistConfig) {
+    openDB(persistDbName, persistStoreName).then((database) => {
+      db = database;
+      return restoreState();
+    }).catch((err) => {
+      emit({ type: "state:persist-error", error: err });
+    });
+  }
+  function setStoreId(id) {
+    storeId = id;
+  }
+  async function getPublicUrl(fileId) {
+    const res = await client.post(
+      endpoints.filePublicUrl(storeId, fileId),
+      {}
+    );
+    return res.url;
+  }
+  return {
+    getSupportedFileTypes,
+    upload,
+    cancel,
+    removeFile,
+    files,
+    getFileState,
+    updateFileMetadata,
+    clearState,
+    setStoreId,
+    getPublicUrl,
+    scopeBy,
+    workflowRun,
+    runWorkflow,
+    isRestoring,
+    restoreState,
+    purgePersistedState
+  };
+}
+function buildHttpClient(baseUrl, defaultHeaders) {
+  return {
+    async get(url, config) {
+      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(url, body, config) {
+      const fullUrl = `${baseUrl}/${url}`;
+      const headers = { ...defaultHeaders };
+      let resolvedBody;
+      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(url, config) {
+      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, config) {
+      const controller = new AbortController();
+      const signal = config?.signal ? AbortSignal.any([controller.signal, config.signal]) : controller.signal;
+      const listeners = [];
+      let closed = false;
+      const fullUrl = `${baseUrl}/${url}`;
+      const headers = {
+        Accept: "text/event-stream",
+        ...defaultHeaders
+      };
+      function parseSseLines(lines, notify) {
+        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 {
+        }
+      })();
+      return {
+        subscribe(callback) {
+          listeners.push(callback);
+        },
+        close() {
+          closed = true;
+          controller.abort();
+        }
+      };
+    }
+  };
+}
+function createDocumentUploadProvider(config) {
+  const {
+    baseUrl,
+    userId,
+    workflowId,
+    searchStoreConfig,
+    workflowConfig,
+    persist = true,
+    maxConcurrency = 3
+  } = config;
+  const defaultHeaders = {
+    "x-user-id": userId,
+    ...config.headers ?? {}
+  };
+  const httpClient = buildHttpClient(baseUrl, defaultHeaders);
+  let resolvedStoreId = null;
+  let resolvePromise = null;
+  async function createSearchStoreWithWorkflow() {
+    const name = `${userId}-store-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}`;
+    const storeRes = await httpClient.post("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() {
+    if (resolvedStoreId) return resolvedStoreId;
+    if (resolvePromise) return resolvePromise;
+    resolvePromise = (async () => {
+      try {
+        const stores = await httpClient.get("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;
+  }
+  let instance = 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() {
+    if (!instance) {
+      const onEvent = (event) => {
+        config.onEvent?.(event);
+        if (event.type === "state:restored") {
+          purgeInterruptedFiles();
+        }
+      };
+      instance = useFileUpload({
+        client: httpClient,
+        workflowId,
+        persist,
+        maxConcurrency,
+        onEvent
+      });
+    }
+    return instance;
+  }
+  function useDocumentUpload(conversationIdRef) {
+    const fileInput = ref(null);
+    const upload = getUploadInstance();
+    const storeId = ref(resolvedStoreId ?? "");
+    const currentScope = shallowRef(
+      upload.scopeBy("conversationId", toValue(conversationIdRef))
+    );
+    watch(
+      () => toValue(conversationIdRef),
+      (newId, oldId) => {
+        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() {
+      return currentScope.value?.files.value ?? [];
+    }
+    async function uploadFiles(files) {
+      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) {
+      for (const entry of scopedFiles()) {
+        if (!entry.metadata.messageId && entry.status === "success") {
+          upload.updateFileMetadata(entry.id, { messageId });
+        }
+      }
+    }
+    function getFilesForMessage(messageId) {
+      return scopedFiles().filter(
+        (entry) => entry.metadata.messageId === messageId || entry.metadata.responseId && messageId === `user-${entry.metadata.responseId}-0`
+      );
+    }
+    function stampResponseId(responseId, localMessageId) {
+      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) {
+      const input = event.target;
+      const fileList = Array.from(input.files ?? []);
+      uploadFiles(fileList);
+      input.value = "";
+    }
+    return {
+      upload,
+      storeId,
+      fileInput,
+      uploadFiles,
+      unassignedFiles,
+      assignFilesToMessage,
+      getFilesForMessage,
+      stampResponseId,
+      purgeCompletedFiles,
+      handleFilesSelected
+    };
+  }
+  return { useDocumentUpload };
+}
+const WORKFLOW_ID = "my-doc-ai";
+const defaultDocumentUploadConfig = {
+  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: 1e4,
+          max_cols: 100,
+          include_empty_sheets: false
+        },
+        markdown_reader: { kind: "markdown", batch_size: 10 },
+        plaintext_reader: {
+          kind: "plaintext",
+          batch_size: 10,
+          max_content_size: 5e5,
+          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 {
+  useConversationSessions as a,
+  useConversations as b,
+  createDocumentUploadProvider as c,
+  defaultDocumentUploadConfig as d,
+  useDocumentUploadWithDefaultConfig as e,
+  useChat as u
+};