@athenaintel/react 0.57.2 → 0.59.0

package/dist/composer/folder-upload.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Uploading files into a folder. agora's quick upload (`POST /api/upload/`) files what it takes at
+ * the workspace's root; its async upload (`POST /api/upload/async`) takes a destination,
+ * `parent_folder_id`, and authorizes EDIT on that folder before it stages a byte
+ * (`_require_upload_destination`: the folder's permission check, then its ABAC edit gate), so a
+ * folder the person may only view, or may not open, refuses the whole upload. The task it starts is
+ * then read through GraphQL (`asyncUploadTask`, answered only for the caller's current workspace)
+ * until it ends, at most `FOLDER_UPLOAD_DEADLINE_MS`.
+ */
+import { type MentionAuthContext } from '../chat-ui/mentions/suggestions/data/api-client';
+import type { UploadedAsset } from './useFileUpload';
+/** agora's async upload route, under the API base. */
+export declare const FOLDER_UPLOAD_PATH = "/api/upload/async";
+/** How long an upload's task is read before the upload gives up on it (it may still finish). */
+export declare const FOLDER_UPLOAD_DEADLINE_MS: number;
+export declare const ASYNC_UPLOAD_TASK_QUERY = "\n  query AthenaAsyncUploadTask($taskId: String!) {\n    asyncUploadTask(taskId: $taskId) {\n      taskId\n      status\n      requestedCount\n      processedCount\n      uploadedCount\n      failedCount\n      message\n      results {\n        fileIndex\n        filename\n        status\n        message\n        assetId\n      }\n    }\n  }\n";
+export interface FolderUploadTask {
+    taskId: string;
+    status: string;
+    requestedCount: number;
+    processedCount: number;
+    uploadedCount: number;
+    failedCount: number;
+    message: string | null;
+    results: Array<{
+        fileIndex: number;
+        filename: string;
+        status: string;
+        message: string;
+        assetId: string | null;
+    }>;
+}
+/** What an upload into a folder made, and what it could not. */
+export interface FolderUploadResult {
+    uploaded: UploadedAsset[];
+    failed: Array<{
+        fileName: string;
+        error: string;
+    }>;
+}
+/** The wait before the `attempt`th read of the task (0-indexed), doubling to its cap. */
+export declare function folderUploadPollDelayMs(attempt: number): number;
+/** The upload's form: every file, and the folder they go into. */
+export declare function folderUploadForm({ files, parentFolderId, }: {
+    files: readonly File[];
+    parentFolderId: string;
+}): FormData;
+/**
+ * What the task made, file by file: each uploaded file as the asset it became (named and sized
+ * from the file sent), each failed one with agora's reason, and a task that ended without a result
+ * for a file (cancelled, or failed as a whole) with the task's message.
+ */
+export declare function folderUploadResultOf({ task, files, }: {
+    task: FolderUploadTask;
+    files: readonly File[];
+}): FolderUploadResult;
+/**
+ * Reads the task until it ends: at once, then after waits that double from 250 ms to 2 s. A task
+ * agora no longer names (another workspace, or gone) and one that has not ended by the deadline
+ * fail the upload; what the task did by then stays done.
+ */
+export declare function waitForFolderUploadTask({ auth, taskId, signal, deadlineMs, now, sleep, }: {
+    auth: MentionAuthContext;
+    taskId: string;
+    signal?: AbortSignal;
+    deadlineMs?: number;
+    now?: () => number;
+    sleep?: (ms: number) => Promise<void>;
+}): Promise<FolderUploadTask>;
+/**
+ * Starts an upload of `files` into `parentFolderId` (agora's async upload, which refuses a folder
+ * the caller may not edit before it takes any file), as `send` posts it, and answers its task id.
+ */
+export declare function startFolderUpload({ send, files, parentFolderId, }: {
+    /** Posts the form to `FOLDER_UPLOAD_PATH` with the credential (and the byte progress). */
+    send: (form: FormData) => Promise<Response>;
+    files: readonly File[];
+    parentFolderId: string;
+}): Promise<string>;

package/dist/composer/folder-upload.js

@@ -0,0 +1,149 @@
+import { fetchGraphQL } from "../chat-ui/mentions/suggestions/data/api-client.js";
+const FOLDER_UPLOAD_PATH = "/api/upload/async";
+const FOLDER_UPLOAD_DEADLINE_MS = 15 * 60 * 1e3;
+const FOLDER_UPLOAD_POLL_MIN_MS = 250;
+const FOLDER_UPLOAD_POLL_MAX_MS = 2e3;
+const ASYNC_UPLOAD_TASK_QUERY = `
+  query AthenaAsyncUploadTask($taskId: String!) {
+    asyncUploadTask(taskId: $taskId) {
+      taskId
+      status
+      requestedCount
+      processedCount
+      uploadedCount
+      failedCount
+      message
+      results {
+        fileIndex
+        filename
+        status
+        message
+        assetId
+      }
+    }
+  }
+`;
+const ENDED = /* @__PURE__ */ new Set(["completed", "failed", "cancelled"]);
+function folderUploadPollDelayMs(attempt) {
+  return Math.min(FOLDER_UPLOAD_POLL_MIN_MS * 2 ** attempt, FOLDER_UPLOAD_POLL_MAX_MS);
+}
+function folderUploadForm({
+  files,
+  parentFolderId
+}) {
+  const form = new FormData();
+  for (const file of files) form.append("files", file, file.name);
+  form.append("parent_folder_id", parentFolderId);
+  return form;
+}
+function taskIdOf(body) {
+  const camel = Reflect.get(Object(body), "taskId");
+  if (typeof camel === "string" && camel) return camel;
+  const snake = Reflect.get(Object(body), "task_id");
+  return typeof snake === "string" && snake ? snake : null;
+}
+async function refusalDetail(response) {
+  const body = await response.json().catch(() => null);
+  const detail = Reflect.get(Object(body), "detail");
+  return typeof detail === "string" && detail ? detail : null;
+}
+function folderUploadResultOf({
+  task,
+  files
+}) {
+  const uploaded = [];
+  const failed = [];
+  const answered = /* @__PURE__ */ new Set();
+  for (const result of task.results) {
+    answered.add(result.fileIndex);
+    const file = files[result.fileIndex];
+    if (result.status === "uploaded" && result.assetId) {
+      uploaded.push({
+        id: result.assetId,
+        title: result.filename,
+        fileName: result.filename,
+        fileSize: (file == null ? void 0 : file.size) ?? 0,
+        mediaType: (file == null ? void 0 : file.type) || "application/octet-stream",
+        fileIndex: result.fileIndex
+      });
+    } else {
+      failed.push({ fileName: result.filename, error: result.message || "Upload failed" });
+    }
+  }
+  files.forEach((file, index) => {
+    if (answered.has(index)) return;
+    failed.push({ fileName: file.name, error: task.message || `Upload ${task.status}` });
+  });
+  return { uploaded, failed };
+}
+function wait(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal == null ? void 0 : signal.aborted) {
+      reject(new DOMException("Upload cancelled", "AbortError"));
+      return;
+    }
+    const timer = setTimeout(() => {
+      signal == null ? void 0 : signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(new DOMException("Upload cancelled", "AbortError"));
+    };
+    signal == null ? void 0 : signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+async function waitForFolderUploadTask({
+  auth,
+  taskId,
+  signal,
+  deadlineMs = FOLDER_UPLOAD_DEADLINE_MS,
+  now = Date.now,
+  sleep = (ms) => wait(ms, signal)
+}) {
+  const startedAt = now();
+  for (let attempt = 0; ; attempt += 1) {
+    const data = await fetchGraphQL(
+      auth,
+      ASYNC_UPLOAD_TASK_QUERY,
+      { taskId },
+      { signal }
+    );
+    const task = data.asyncUploadTask;
+    if (!task) throw new Error("Athena no longer knows this upload.");
+    if (ENDED.has(task.status)) return task;
+    if (now() - startedAt >= deadlineMs) {
+      throw new Error("The upload is taking too long; it may still finish in Athena.");
+    }
+    await sleep(folderUploadPollDelayMs(attempt));
+  }
+}
+async function startFolderUpload({
+  send,
+  files,
+  parentFolderId
+}) {
+  const response = await send(folderUploadForm({ files, parentFolderId }));
+  if (!response.ok) {
+    const detail = await refusalDetail(response);
+    if (response.status === 401 || response.status === 403) {
+      throw new Error(detail ?? "You can’t add files to this folder.");
+    }
+    if (response.status === 404) throw new Error(detail ?? "That folder is no longer there.");
+    throw new Error(detail ?? `Upload failed with status ${response.status}`);
+  }
+  const taskId = taskIdOf(await response.json().catch(() => null));
+  if (!taskId) throw new Error("Athena did not start the upload.");
+  return taskId;
+}
+export {
+  ASYNC_UPLOAD_TASK_QUERY,
+  FOLDER_UPLOAD_DEADLINE_MS,
+  FOLDER_UPLOAD_PATH,
+  folderUploadForm,
+  folderUploadPollDelayMs,
+  folderUploadResultOf,
+  startFolderUpload,
+  waitForFolderUploadTask
+};
+//# sourceMappingURL=folder-upload.js.map

package/dist/composer/folder-upload.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"folder-upload.js","sources":["../../src/composer/folder-upload.ts"],"sourcesContent":["/**\n * Uploading files into a folder. agora's quick upload (`POST /api/upload/`) files what it takes at\n * the workspace's root; its async upload (`POST /api/upload/async`) takes a destination,\n * `parent_folder_id`, and authorizes EDIT on that folder before it stages a byte\n * (`_require_upload_destination`: the folder's permission check, then its ABAC edit gate), so a\n * folder the person may only view, or may not open, refuses the whole upload. The task it starts is\n * then read through GraphQL (`asyncUploadTask`, answered only for the caller's current workspace)\n * until it ends, at most `FOLDER_UPLOAD_DEADLINE_MS`.\n */\nimport {\n  fetchGraphQL,\n  type MentionAuthContext,\n} from '../chat-ui/mentions/suggestions/data/api-client';\nimport type { UploadedAsset } from './useFileUpload';\n\n/** agora's async upload route, under the API base. */\nexport const FOLDER_UPLOAD_PATH = '/api/upload/async';\n\n/** How long an upload's task is read before the upload gives up on it (it may still finish). */\nexport const FOLDER_UPLOAD_DEADLINE_MS = 15 * 60 * 1000;\n/** The first wait before the task is read again, doubling to `FOLDER_UPLOAD_POLL_MAX_MS`. */\nconst FOLDER_UPLOAD_POLL_MIN_MS = 250;\nconst FOLDER_UPLOAD_POLL_MAX_MS = 2_000;\n\nexport const ASYNC_UPLOAD_TASK_QUERY = `\n  query AthenaAsyncUploadTask($taskId: String!) {\n    asyncUploadTask(taskId: $taskId) {\n      taskId\n      status\n      requestedCount\n      processedCount\n      uploadedCount\n      failedCount\n      message\n      results {\n        fileIndex\n        filename\n        status\n        message\n        assetId\n      }\n    }\n  }\n`;\n\n/** The states an upload task ends in. */\nconst ENDED: ReadonlySet<string> = new Set(['completed', 'failed', 'cancelled']);\n\nexport interface FolderUploadTask {\n  taskId: string;\n  status: string;\n  requestedCount: number;\n  processedCount: number;\n  uploadedCount: number;\n  failedCount: number;\n  message: string | null;\n  results: Array<{\n    fileIndex: number;\n    filename: string;\n    status: string;\n    message: string;\n    assetId: string | null;\n  }>;\n}\n\n/** What an upload into a folder made, and what it could not. */\nexport interface FolderUploadResult {\n  uploaded: UploadedAsset[];\n  failed: Array<{ fileName: string; error: string }>;\n}\n\n/** The wait before the `attempt`th read of the task (0-indexed), doubling to its cap. */\nexport function folderUploadPollDelayMs(attempt: number): number {\n  return Math.min(FOLDER_UPLOAD_POLL_MIN_MS * 2 ** attempt, FOLDER_UPLOAD_POLL_MAX_MS);\n}\n\n/** The upload's form: every file, and the folder they go into. */\nexport function folderUploadForm({\n  files,\n  parentFolderId,\n}: {\n  files: readonly File[];\n  parentFolderId: string;\n}): FormData {\n  const form = new FormData();\n  for (const file of files) form.append('files', file, file.name);\n  form.append('parent_folder_id', parentFolderId);\n  return form;\n}\n\n/** The task id agora's answer names (`taskId`; `task_id` from an agora that answers snake_case). */\nfunction taskIdOf(body: unknown): string | null {\n  const camel: unknown = Reflect.get(Object(body), 'taskId');\n  if (typeof camel === 'string' && camel) return camel;\n  const snake: unknown = Reflect.get(Object(body), 'task_id');\n  return typeof snake === 'string' && snake ? snake : null;\n}\n\n/** agora's `detail` for a refused upload, when it gave one. */\nasync function refusalDetail(response: Response): Promise<string | null> {\n  const body: unknown = await response.json().catch(() => null);\n  const detail: unknown = Reflect.get(Object(body), 'detail');\n  return typeof detail === 'string' && detail ? detail : null;\n}\n\n/**\n * What the task made, file by file: each uploaded file as the asset it became (named and sized\n * from the file sent), each failed one with agora's reason, and a task that ended without a result\n * for a file (cancelled, or failed as a whole) with the task's message.\n */\nexport function folderUploadResultOf({\n  task,\n  files,\n}: {\n  task: FolderUploadTask;\n  files: readonly File[];\n}): FolderUploadResult {\n  const uploaded: UploadedAsset[] = [];\n  const failed: FolderUploadResult['failed'] = [];\n  const answered = new Set<number>();\n  for (const result of task.results) {\n    answered.add(result.fileIndex);\n    const file = files[result.fileIndex];\n    if (result.status === 'uploaded' && result.assetId) {\n      uploaded.push({\n        id: result.assetId,\n        title: result.filename,\n        fileName: result.filename,\n        fileSize: file?.size ?? 0,\n        mediaType: file?.type || 'application/octet-stream',\n        fileIndex: result.fileIndex,\n      });\n    } else {\n      failed.push({ fileName: result.filename, error: result.message || 'Upload failed' });\n    }\n  }\n  files.forEach((file, index) => {\n    if (answered.has(index)) return;\n    failed.push({ fileName: file.name, error: task.message || `Upload ${task.status}` });\n  });\n  return { uploaded, failed };\n}\n\n/** Waits `ms`, or rejects at once when `signal` aborts. */\nfunction wait(ms: number, signal: AbortSignal | undefined): Promise<void> {\n  return new Promise((resolve, reject) => {\n    if (signal?.aborted) {\n      reject(new DOMException('Upload cancelled', 'AbortError'));\n      return;\n    }\n    const timer = setTimeout(() => {\n      signal?.removeEventListener('abort', onAbort);\n      resolve();\n    }, ms);\n    const onAbort = () => {\n      clearTimeout(timer);\n      reject(new DOMException('Upload cancelled', 'AbortError'));\n    };\n    signal?.addEventListener('abort', onAbort, { once: true });\n  });\n}\n\n/**\n * Reads the task until it ends: at once, then after waits that double from 250 ms to 2 s. A task\n * agora no longer names (another workspace, or gone) and one that has not ended by the deadline\n * fail the upload; what the task did by then stays done.\n */\nexport async function waitForFolderUploadTask({\n  auth,\n  taskId,\n  signal,\n  deadlineMs = FOLDER_UPLOAD_DEADLINE_MS,\n  now = Date.now,\n  sleep = (ms) => wait(ms, signal),\n}: {\n  auth: MentionAuthContext;\n  taskId: string;\n  signal?: AbortSignal;\n  deadlineMs?: number;\n  now?: () => number;\n  sleep?: (ms: number) => Promise<void>;\n}): Promise<FolderUploadTask> {\n  const startedAt = now();\n  for (let attempt = 0; ; attempt += 1) {\n    const data = await fetchGraphQL<{ asyncUploadTask: FolderUploadTask | null }>(\n      auth,\n      ASYNC_UPLOAD_TASK_QUERY,\n      { taskId },\n      { signal },\n    );\n    const task = data.asyncUploadTask;\n    if (!task) throw new Error('Athena no longer knows this upload.');\n    if (ENDED.has(task.status)) return task;\n    if (now() - startedAt >= deadlineMs) {\n      throw new Error('The upload is taking too long; it may still finish in Athena.');\n    }\n    await sleep(folderUploadPollDelayMs(attempt));\n  }\n}\n\n/**\n * Starts an upload of `files` into `parentFolderId` (agora's async upload, which refuses a folder\n * the caller may not edit before it takes any file), as `send` posts it, and answers its task id.\n */\nexport async function startFolderUpload({\n  send,\n  files,\n  parentFolderId,\n}: {\n  /** Posts the form to `FOLDER_UPLOAD_PATH` with the credential (and the byte progress). */\n  send: (form: FormData) => Promise<Response>;\n  files: readonly File[];\n  parentFolderId: string;\n}): Promise<string> {\n  const response = await send(folderUploadForm({ files, parentFolderId }));\n  if (!response.ok) {\n    const detail = await refusalDetail(response);\n    if (response.status === 401 || response.status === 403) {\n      throw new Error(detail ?? 'You can’t add files to this folder.');\n    }\n    if (response.status === 404) throw new Error(detail ?? 'That folder is no longer there.');\n    throw new Error(detail ?? `Upload failed with status ${response.status}`);\n  }\n  const taskId = taskIdOf(await response.json().catch(() => null));\n  if (!taskId) throw new Error('Athena did not start the upload.');\n  return taskId;\n}\n"],"names":[],"mappings":"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"}

package/dist/composer/index.d.ts

@@ -6,7 +6,7 @@ export { useComposerReady, useFocusComposer } from './composer-handoff';
 export { useReadComposerDraft, useTryReadComposerDraft } from './useReadComposerDraft';
 export { useComposerAttachment } from './useComposerAttachment';
 export { useFileUpload } from './useFileUpload';
-export type { UploadedAsset, UploadProgress, UseFileUploadReturn } from './useFileUpload';
+export type { UploadedAsset, UploadOptions, UploadProgress, UploadRefusal, UseFileUploadReturn, } from './useFileUpload';
 export { FileUploadButton } from './FileUploadButton';
 export type { FileUploadButtonProps } from './FileUploadButton';
 export { ComposerQuotePreview } from './ComposerQuotePreview';

package/dist/composer/useAttachToChat.cjs

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require$$0 = require("react");
+const threadIdContext = require("../threads/thread-id-context.cjs");
+const attachedReferences = require("./attached-references.cjs");
+const composerHandoff = require("./composer-handoff.cjs");
+const useAppendToComposer = require("./useAppendToComposer.cjs");
+function useAttachToChat() {
+  const threadId = require$$0.useContext(threadIdContext.AthenaStatewireThreadIdContext);
+  const references = attachedReferences.usePendingAttachedReferences(threadId);
+  const appendToComposer = useAppendToComposer.useAppendToComposer();
+  const focusComposer = composerHandoff.useFocusComposer();
+  const attach = require$$0.useCallback(
+    (reference, options) => {
+      const result = attachedReferences.attachReferenceToThread({ threadId, reference });
+      if (!result.attached) return result;
+      const prompt = options == null ? void 0 : options.prompt;
+      if (prompt) appendToComposer(prompt, { focus: (options == null ? void 0 : options.open) ?? false });
+      else if (options == null ? void 0 : options.open) focusComposer();
+      return result;
+    },
+    [appendToComposer, focusComposer, threadId]
+  );
+  const detach = require$$0.useCallback(
+    (reference) => attachedReferences.detachReferenceFromThread({ threadId, reference }),
+    [threadId]
+  );
+  const clear = require$$0.useCallback(() => attachedReferences.clearAttachedReferences(threadId), [threadId]);
+  return require$$0.useMemo(
+    () => ({ attach, detach, clear, references }),
+    [attach, clear, detach, references]
+  );
+}
+exports.useAttachToChat = useAttachToChat;
+//# sourceMappingURL=useAttachToChat.cjs.map

package/dist/composer/useAttachToChat.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAttachToChat.cjs","sources":["../../src/composer/useAttachToChat.ts"],"sourcesContent":["import type { AttachableReference } from '@athenaintel/references/attachable';\nimport { useCallback, useContext, useMemo } from 'react';\nimport { AthenaStatewireThreadIdContext } from '../threads/thread-id-context';\nimport {\n  type AttachReferenceResult,\n  attachReferenceToThread,\n  clearAttachedReferences,\n  detachReferenceFromThread,\n  usePendingAttachedReferences,\n} from './attached-references';\nimport { useFocusComposer } from './composer-handoff';\nimport { useAppendToComposer } from './useAppendToComposer';\n\n/**\n * Something an app can attach to the next chat message: an Athena asset (optionally narrowed to a\n * place inside it with an `anchor`, as the reference standard writes it), an ontology object, or a\n * web page. `meta.title` is what the chip shows; the agent is told it is the app's label, never the\n * object's content.\n *\n * ```ts\n * { referenced: 'asset', id: 'asset_…', anchor?: { type: 'page', page: 5 }, meta?: { title: 'Q4 deck' } }\n * { referenced: 'ontology_object', id: 'asset_…', meta?: { title: 'Sequoia Capital', objectType: 'Investor' } }\n * { referenced: 'external_url', url: 'https://…', meta?: { title: 'Blog post' } }\n * ```\n */\nexport type AthenaReference = AttachableReference;\n\nexport interface AttachToChatOptions {\n  /**\n   * Text put in the composer after what the person has typed, for them to finish and send. Nothing\n   * is sent.\n   */\n  prompt?: string;\n  /** Focus the composer, caret at the end of the draft, so the person can type and send. */\n  open?: boolean;\n}\n\nexport interface UseAttachToChatResult {\n  /**\n   * Attach `reference` to the next message: the composer shows it as a removable chip, and it\n   * travels with that message as structured data, never as text. Athena resolves it on the server\n   * with the signed-in person's own permission; the agent is told about anything it can't open\n   * instead of seeing it. Returns why it was not attached when it was not.\n   */\n  attach: (reference: AthenaReference, options?: AttachToChatOptions) => AttachReferenceResult;\n  /** Take `reference` (matched by kind and id, an asset's anchor included) off the next message. */\n  detach: (reference: AthenaReference) => void;\n  /** Take every reference off the next message. */\n  clear: () => void;\n  /** What the next message carries, in the order attached. */\n  references: readonly AthenaReference[];\n}\n\n/**\n * Attach objects on screen to the conversation's next message (\"Discuss this with the agent\").\n * Use it anywhere under `<AthenaProvider>`: it attaches to the chat's active conversation, whose\n * composer (`AthenaChat`) shows the chips. A message carries at most\n * `MAX_ATTACHED_REFERENCES` (10).\n *\n * ```tsx\n * const { attach } = useAttachToChat();\n * <button onClick={() => attach(\n *   { referenced: 'ontology_object', id: investor.id, meta: { title: investor.name } },\n *   { prompt: 'Draft an intro email to ', open: true },\n * )}>Discuss</button>\n * ```\n */\nexport function useAttachToChat(): UseAttachToChatResult {\n  const threadId = useContext(AthenaStatewireThreadIdContext);\n  const references = usePendingAttachedReferences(threadId);\n  const appendToComposer = useAppendToComposer();\n  const focusComposer = useFocusComposer();\n\n  const attach = useCallback(\n    (reference: AthenaReference, options?: AttachToChatOptions): AttachReferenceResult => {\n      const result = attachReferenceToThread({ threadId, reference });\n      if (!result.attached) return result;\n      const prompt = options?.prompt;\n      if (prompt) appendToComposer(prompt, { focus: options?.open ?? false });\n      else if (options?.open) focusComposer();\n      return result;\n    },\n    [appendToComposer, focusComposer, threadId],\n  );\n  const detach = useCallback(\n    (reference: AthenaReference) => detachReferenceFromThread({ threadId, reference }),\n    [threadId],\n  );\n  const clear = useCallback(() => clearAttachedReferences(threadId), [threadId]);\n\n  return useMemo(\n    () => ({ attach, detach, clear, references }),\n    [attach, clear, detach, references],\n  );\n}\n"],"names":["useContext","AthenaStatewireThreadIdContext","usePendingAttachedReferences","useAppendToComposer","useFocusComposer","useCallback","attachReferenceToThread","detachReferenceFromThread","clearAttachedReferences","useMemo"],"mappings":";;;;;;;AAmEO,SAAS,kBAAyC;AACvD,QAAM,WAAWA,WAAAA,WAAWC,8CAA8B;AAC1D,QAAM,aAAaC,mBAAAA,6BAA6B,QAAQ;AACxD,QAAM,mBAAmBC,oBAAAA,oBAAA;AACzB,QAAM,gBAAgBC,gBAAAA,iBAAA;AAEtB,QAAM,SAASC,WAAAA;AAAAA,IACb,CAAC,WAA4B,YAAyD;AACpF,YAAM,SAASC,mBAAAA,wBAAwB,EAAE,UAAU,WAAW;AAC9D,UAAI,CAAC,OAAO,SAAU,QAAO;AAC7B,YAAM,SAAS,mCAAS;AACxB,UAAI,yBAAyB,QAAQ,EAAE,QAAO,mCAAS,SAAQ,OAAO;AAAA,eAC7D,mCAAS,KAAM,eAAA;AACxB,aAAO;AAAA,IACT;AAAA,IACA,CAAC,kBAAkB,eAAe,QAAQ;AAAA,EAAA;AAE5C,QAAM,SAASD,WAAAA;AAAAA,IACb,CAAC,cAA+BE,mBAAAA,0BAA0B,EAAE,UAAU,WAAW;AAAA,IACjF,CAAC,QAAQ;AAAA,EAAA;AAEX,QAAM,QAAQF,WAAAA,YAAY,MAAMG,mBAAAA,wBAAwB,QAAQ,GAAG,CAAC,QAAQ,CAAC;AAE7E,SAAOC,WAAAA;AAAAA,IACL,OAAO,EAAE,QAAQ,QAAQ,OAAO,WAAA;AAAA,IAChC,CAAC,QAAQ,OAAO,QAAQ,UAAU;AAAA,EAAA;AAEtC;;"}

package/dist/composer/useAttachToChat.d.ts

@@ -0,0 +1,54 @@
+import type { AttachableReference } from '../references/src/attachable';
+import { type AttachReferenceResult } from './attached-references';
+/**
+ * Something an app can attach to the next chat message: an Athena asset (optionally narrowed to a
+ * place inside it with an `anchor`, as the reference standard writes it), an ontology object, or a
+ * web page. `meta.title` is what the chip shows; the agent is told it is the app's label, never the
+ * object's content.
+ *
+ * ```ts
+ * { referenced: 'asset', id: 'asset_…', anchor?: { type: 'page', page: 5 }, meta?: { title: 'Q4 deck' } }
+ * { referenced: 'ontology_object', id: 'asset_…', meta?: { title: 'Sequoia Capital', objectType: 'Investor' } }
+ * { referenced: 'external_url', url: 'https://…', meta?: { title: 'Blog post' } }
+ * ```
+ */
+export type AthenaReference = AttachableReference;
+export interface AttachToChatOptions {
+    /**
+     * Text put in the composer after what the person has typed, for them to finish and send. Nothing
+     * is sent.
+     */
+    prompt?: string;
+    /** Focus the composer, caret at the end of the draft, so the person can type and send. */
+    open?: boolean;
+}
+export interface UseAttachToChatResult {
+    /**
+     * Attach `reference` to the next message: the composer shows it as a removable chip, and it
+     * travels with that message as structured data, never as text. Athena resolves it on the server
+     * with the signed-in person's own permission; the agent is told about anything it can't open
+     * instead of seeing it. Returns why it was not attached when it was not.
+     */
+    attach: (reference: AthenaReference, options?: AttachToChatOptions) => AttachReferenceResult;
+    /** Take `reference` (matched by kind and id, an asset's anchor included) off the next message. */
+    detach: (reference: AthenaReference) => void;
+    /** Take every reference off the next message. */
+    clear: () => void;
+    /** What the next message carries, in the order attached. */
+    references: readonly AthenaReference[];
+}
+/**
+ * Attach objects on screen to the conversation's next message ("Discuss this with the agent").
+ * Use it anywhere under `<AthenaProvider>`: it attaches to the chat's active conversation, whose
+ * composer (`AthenaChat`) shows the chips. A message carries at most
+ * `MAX_ATTACHED_REFERENCES` (10).
+ *
+ * ```tsx
+ * const { attach } = useAttachToChat();
+ * <button onClick={() => attach(
+ *   { referenced: 'ontology_object', id: investor.id, meta: { title: investor.name } },
+ *   { prompt: 'Draft an intro email to ', open: true },
+ * )}>Discuss</button>
+ * ```
+ */
+export declare function useAttachToChat(): UseAttachToChatResult;

package/dist/composer/useAttachToChat.js

@@ -0,0 +1,35 @@
+import { useContext, useCallback, useMemo } from "react";
+import { AthenaStatewireThreadIdContext } from "../threads/thread-id-context.js";
+import { usePendingAttachedReferences, attachReferenceToThread, detachReferenceFromThread, clearAttachedReferences } from "./attached-references.js";
+import { useFocusComposer } from "./composer-handoff.js";
+import { useAppendToComposer } from "./useAppendToComposer.js";
+function useAttachToChat() {
+  const threadId = useContext(AthenaStatewireThreadIdContext);
+  const references = usePendingAttachedReferences(threadId);
+  const appendToComposer = useAppendToComposer();
+  const focusComposer = useFocusComposer();
+  const attach = useCallback(
+    (reference, options) => {
+      const result = attachReferenceToThread({ threadId, reference });
+      if (!result.attached) return result;
+      const prompt = options == null ? void 0 : options.prompt;
+      if (prompt) appendToComposer(prompt, { focus: (options == null ? void 0 : options.open) ?? false });
+      else if (options == null ? void 0 : options.open) focusComposer();
+      return result;
+    },
+    [appendToComposer, focusComposer, threadId]
+  );
+  const detach = useCallback(
+    (reference) => detachReferenceFromThread({ threadId, reference }),
+    [threadId]
+  );
+  const clear = useCallback(() => clearAttachedReferences(threadId), [threadId]);
+  return useMemo(
+    () => ({ attach, detach, clear, references }),
+    [attach, clear, detach, references]
+  );
+}
+export {
+  useAttachToChat
+};
+//# sourceMappingURL=useAttachToChat.js.map

package/dist/composer/useAttachToChat.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAttachToChat.js","sources":["../../src/composer/useAttachToChat.ts"],"sourcesContent":["import type { AttachableReference } from '@athenaintel/references/attachable';\nimport { useCallback, useContext, useMemo } from 'react';\nimport { AthenaStatewireThreadIdContext } from '../threads/thread-id-context';\nimport {\n  type AttachReferenceResult,\n  attachReferenceToThread,\n  clearAttachedReferences,\n  detachReferenceFromThread,\n  usePendingAttachedReferences,\n} from './attached-references';\nimport { useFocusComposer } from './composer-handoff';\nimport { useAppendToComposer } from './useAppendToComposer';\n\n/**\n * Something an app can attach to the next chat message: an Athena asset (optionally narrowed to a\n * place inside it with an `anchor`, as the reference standard writes it), an ontology object, or a\n * web page. `meta.title` is what the chip shows; the agent is told it is the app's label, never the\n * object's content.\n *\n * ```ts\n * { referenced: 'asset', id: 'asset_…', anchor?: { type: 'page', page: 5 }, meta?: { title: 'Q4 deck' } }\n * { referenced: 'ontology_object', id: 'asset_…', meta?: { title: 'Sequoia Capital', objectType: 'Investor' } }\n * { referenced: 'external_url', url: 'https://…', meta?: { title: 'Blog post' } }\n * ```\n */\nexport type AthenaReference = AttachableReference;\n\nexport interface AttachToChatOptions {\n  /**\n   * Text put in the composer after what the person has typed, for them to finish and send. Nothing\n   * is sent.\n   */\n  prompt?: string;\n  /** Focus the composer, caret at the end of the draft, so the person can type and send. */\n  open?: boolean;\n}\n\nexport interface UseAttachToChatResult {\n  /**\n   * Attach `reference` to the next message: the composer shows it as a removable chip, and it\n   * travels with that message as structured data, never as text. Athena resolves it on the server\n   * with the signed-in person's own permission; the agent is told about anything it can't open\n   * instead of seeing it. Returns why it was not attached when it was not.\n   */\n  attach: (reference: AthenaReference, options?: AttachToChatOptions) => AttachReferenceResult;\n  /** Take `reference` (matched by kind and id, an asset's anchor included) off the next message. */\n  detach: (reference: AthenaReference) => void;\n  /** Take every reference off the next message. */\n  clear: () => void;\n  /** What the next message carries, in the order attached. */\n  references: readonly AthenaReference[];\n}\n\n/**\n * Attach objects on screen to the conversation's next message (\"Discuss this with the agent\").\n * Use it anywhere under `<AthenaProvider>`: it attaches to the chat's active conversation, whose\n * composer (`AthenaChat`) shows the chips. A message carries at most\n * `MAX_ATTACHED_REFERENCES` (10).\n *\n * ```tsx\n * const { attach } = useAttachToChat();\n * <button onClick={() => attach(\n *   { referenced: 'ontology_object', id: investor.id, meta: { title: investor.name } },\n *   { prompt: 'Draft an intro email to ', open: true },\n * )}>Discuss</button>\n * ```\n */\nexport function useAttachToChat(): UseAttachToChatResult {\n  const threadId = useContext(AthenaStatewireThreadIdContext);\n  const references = usePendingAttachedReferences(threadId);\n  const appendToComposer = useAppendToComposer();\n  const focusComposer = useFocusComposer();\n\n  const attach = useCallback(\n    (reference: AthenaReference, options?: AttachToChatOptions): AttachReferenceResult => {\n      const result = attachReferenceToThread({ threadId, reference });\n      if (!result.attached) return result;\n      const prompt = options?.prompt;\n      if (prompt) appendToComposer(prompt, { focus: options?.open ?? false });\n      else if (options?.open) focusComposer();\n      return result;\n    },\n    [appendToComposer, focusComposer, threadId],\n  );\n  const detach = useCallback(\n    (reference: AthenaReference) => detachReferenceFromThread({ threadId, reference }),\n    [threadId],\n  );\n  const clear = useCallback(() => clearAttachedReferences(threadId), [threadId]);\n\n  return useMemo(\n    () => ({ attach, detach, clear, references }),\n    [attach, clear, detach, references],\n  );\n}\n"],"names":[],"mappings":";;;;;AAmEO,SAAS,kBAAyC;AACvD,QAAM,WAAW,WAAW,8BAA8B;AAC1D,QAAM,aAAa,6BAA6B,QAAQ;AACxD,QAAM,mBAAmB,oBAAA;AACzB,QAAM,gBAAgB,iBAAA;AAEtB,QAAM,SAAS;AAAA,IACb,CAAC,WAA4B,YAAyD;AACpF,YAAM,SAAS,wBAAwB,EAAE,UAAU,WAAW;AAC9D,UAAI,CAAC,OAAO,SAAU,QAAO;AAC7B,YAAM,SAAS,mCAAS;AACxB,UAAI,yBAAyB,QAAQ,EAAE,QAAO,mCAAS,SAAQ,OAAO;AAAA,eAC7D,mCAAS,KAAM,eAAA;AACxB,aAAO;AAAA,IACT;AAAA,IACA,CAAC,kBAAkB,eAAe,QAAQ;AAAA,EAAA;AAE5C,QAAM,SAAS;AAAA,IACb,CAAC,cAA+B,0BAA0B,EAAE,UAAU,WAAW;AAAA,IACjF,CAAC,QAAQ;AAAA,EAAA;AAEX,QAAM,QAAQ,YAAY,MAAM,wBAAwB,QAAQ,GAAG,CAAC,QAAQ,CAAC;AAE7E,SAAO;AAAA,IACL,OAAO,EAAE,QAAQ,QAAQ,OAAO,WAAA;AAAA,IAChC,CAAC,QAAQ,OAAO,QAAQ,UAAU;AAAA,EAAA;AAEtC;"}

package/dist/composer/useAttachedReferencesComposerProps.cjs

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require$$0 = require("react");
+const attachedReferences = require("./attached-references.cjs");
+function useAttachedReferencesComposerProps(threadId) {
+  const prepareSend = require$$0.useCallback(
+    ({ text }) => ({
+      queue: attachedReferences.stageThreadAttachedReferencesForSend({ threadId, text }).length > 0
+    }),
+    [threadId]
+  );
+  const onSendReturned = require$$0.useCallback(
+    ({ text }) => attachedReferences.restoreSentAttachedReferences({ threadId, text }),
+    [threadId]
+  );
+  return require$$0.useMemo(() => ({ prepareSend, onSendReturned }), [onSendReturned, prepareSend]);
+}
+exports.useAttachedReferencesComposerProps = useAttachedReferencesComposerProps;
+//# sourceMappingURL=useAttachedReferencesComposerProps.cjs.map

package/dist/composer/useAttachedReferencesComposerProps.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAttachedReferencesComposerProps.cjs","sources":["../../src/composer/useAttachedReferencesComposerProps.ts"],"sourcesContent":["import { useCallback, useMemo } from 'react';\nimport type { TiptapComposerProps } from '../chat-ui/composer/tiptap-composer';\nimport {\n  restoreSentAttachedReferences,\n  stageThreadAttachedReferencesForSend,\n} from './attached-references';\n\n/** The `TiptapComposer` props that send what an app attached to the message. */\nexport type AttachedReferencesComposerProps = Required<\n  Pick<TiptapComposerProps, 'prepareSend' | 'onSendReturned'>\n>;\n\n/**\n * Wire a `TiptapComposer` to the references an app attached to `threadId`'s next message\n * (`useAttachToChat`): spread the result on the composer. Each send the composer makes itself\n * carries them in its metadata (and waits for its own run rather than joining a live one), and a\n * send statewire hands back brings their chips back. `AthenaChat` does this for its own composer;\n * a host mounting `TiptapComposer` directly (with `ComposerAttachedReferences` above it) opts in\n * here, and one that doesn't never sends attachments or loads this code.\n */\nexport function useAttachedReferencesComposerProps(\n  threadId: string,\n): AttachedReferencesComposerProps {\n  const prepareSend = useCallback(\n    ({ text }: { text: string }) => ({\n      queue: stageThreadAttachedReferencesForSend({ threadId, text }).length > 0,\n    }),\n    [threadId],\n  );\n  const onSendReturned = useCallback(\n    ({ text }: { text: string }) => restoreSentAttachedReferences({ threadId, text }),\n    [threadId],\n  );\n  return useMemo(() => ({ prepareSend, onSendReturned }), [onSendReturned, prepareSend]);\n}\n"],"names":["useCallback","stageThreadAttachedReferencesForSend","restoreSentAttachedReferences","useMemo"],"mappings":";;;;AAoBO,SAAS,mCACd,UACiC;AACjC,QAAM,cAAcA,WAAAA;AAAAA,IAClB,CAAC,EAAE,KAAA,OAA8B;AAAA,MAC/B,OAAOC,mBAAAA,qCAAqC,EAAE,UAAU,KAAA,CAAM,EAAE,SAAS;AAAA,IAAA;AAAA,IAE3E,CAAC,QAAQ;AAAA,EAAA;AAEX,QAAM,iBAAiBD,WAAAA;AAAAA,IACrB,CAAC,EAAE,KAAA,MAA6BE,mBAAAA,8BAA8B,EAAE,UAAU,MAAM;AAAA,IAChF,CAAC,QAAQ;AAAA,EAAA;AAEX,SAAOC,WAAAA,QAAQ,OAAO,EAAE,aAAa,mBAAmB,CAAC,gBAAgB,WAAW,CAAC;AACvF;;"}

package/dist/composer/useAttachedReferencesComposerProps.d.ts

@@ -0,0 +1,12 @@
+import type { TiptapComposerProps } from '../chat-ui/composer/tiptap-composer';
+/** The `TiptapComposer` props that send what an app attached to the message. */
+export type AttachedReferencesComposerProps = Required<Pick<TiptapComposerProps, 'prepareSend' | 'onSendReturned'>>;
+/**
+ * Wire a `TiptapComposer` to the references an app attached to `threadId`'s next message
+ * (`useAttachToChat`): spread the result on the composer. Each send the composer makes itself
+ * carries them in its metadata (and waits for its own run rather than joining a live one), and a
+ * send statewire hands back brings their chips back. `AthenaChat` does this for its own composer;
+ * a host mounting `TiptapComposer` directly (with `ComposerAttachedReferences` above it) opts in
+ * here, and one that doesn't never sends attachments or loads this code.
+ */
+export declare function useAttachedReferencesComposerProps(threadId: string): AttachedReferencesComposerProps;

package/dist/composer/useAttachedReferencesComposerProps.js

@@ -0,0 +1,19 @@
+import { useCallback, useMemo } from "react";
+import { stageThreadAttachedReferencesForSend, restoreSentAttachedReferences } from "./attached-references.js";
+function useAttachedReferencesComposerProps(threadId) {
+  const prepareSend = useCallback(
+    ({ text }) => ({
+      queue: stageThreadAttachedReferencesForSend({ threadId, text }).length > 0
+    }),
+    [threadId]
+  );
+  const onSendReturned = useCallback(
+    ({ text }) => restoreSentAttachedReferences({ threadId, text }),
+    [threadId]
+  );
+  return useMemo(() => ({ prepareSend, onSendReturned }), [onSendReturned, prepareSend]);
+}
+export {
+  useAttachedReferencesComposerProps
+};
+//# sourceMappingURL=useAttachedReferencesComposerProps.js.map

package/dist/composer/useAttachedReferencesComposerProps.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAttachedReferencesComposerProps.js","sources":["../../src/composer/useAttachedReferencesComposerProps.ts"],"sourcesContent":["import { useCallback, useMemo } from 'react';\nimport type { TiptapComposerProps } from '../chat-ui/composer/tiptap-composer';\nimport {\n  restoreSentAttachedReferences,\n  stageThreadAttachedReferencesForSend,\n} from './attached-references';\n\n/** The `TiptapComposer` props that send what an app attached to the message. */\nexport type AttachedReferencesComposerProps = Required<\n  Pick<TiptapComposerProps, 'prepareSend' | 'onSendReturned'>\n>;\n\n/**\n * Wire a `TiptapComposer` to the references an app attached to `threadId`'s next message\n * (`useAttachToChat`): spread the result on the composer. Each send the composer makes itself\n * carries them in its metadata (and waits for its own run rather than joining a live one), and a\n * send statewire hands back brings their chips back. `AthenaChat` does this for its own composer;\n * a host mounting `TiptapComposer` directly (with `ComposerAttachedReferences` above it) opts in\n * here, and one that doesn't never sends attachments or loads this code.\n */\nexport function useAttachedReferencesComposerProps(\n  threadId: string,\n): AttachedReferencesComposerProps {\n  const prepareSend = useCallback(\n    ({ text }: { text: string }) => ({\n      queue: stageThreadAttachedReferencesForSend({ threadId, text }).length > 0,\n    }),\n    [threadId],\n  );\n  const onSendReturned = useCallback(\n    ({ text }: { text: string }) => restoreSentAttachedReferences({ threadId, text }),\n    [threadId],\n  );\n  return useMemo(() => ({ prepareSend, onSendReturned }), [onSendReturned, prepareSend]);\n}\n"],"names":[],"mappings":";;AAoBO,SAAS,mCACd,UACiC;AACjC,QAAM,cAAc;AAAA,IAClB,CAAC,EAAE,KAAA,OAA8B;AAAA,MAC/B,OAAO,qCAAqC,EAAE,UAAU,KAAA,CAAM,EAAE,SAAS;AAAA,IAAA;AAAA,IAE3E,CAAC,QAAQ;AAAA,EAAA;AAEX,QAAM,iBAAiB;AAAA,IACrB,CAAC,EAAE,KAAA,MAA6B,8BAA8B,EAAE,UAAU,MAAM;AAAA,IAChF,CAAC,QAAQ;AAAA,EAAA;AAEX,SAAO,QAAQ,OAAO,EAAE,aAAa,mBAAmB,CAAC,gBAAgB,WAAW,CAAC;AACvF;"}

package/dist/composer/useFileUpload.cjs

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require$$0 = require("react");
 const AthenaContext = require("../provider/AthenaContext.cjs");
+const folderUpload = require("./folder-upload.cjs");
 const MAX_FILE_SIZE = 5 * 1024 * 1024 * 1024;
 function useFileUpload() {
   const config = AthenaContext.useAthenaConfig();
@@ -12,15 +13,87 @@ function useFileUpload() {
   const [progress, setProgress] = require$$0.useState(null);
   const [error, setError] = require$$0.useState(null);
   const xhrRef = require$$0.useRef(null);
+  const taskWaitRef = require$$0.useRef(null);
   require$$0.useEffect(() => {
     return () => {
-      var _a;
+      var _a, _b;
       (_a = xhrRef.current) == null ? void 0 : _a.abort();
+      (_b = taskWaitRef.current) == null ? void 0 : _b.abort();
     };
   }, []);
   const clearError = require$$0.useCallback(() => setError(null), []);
+  const uploadIntoFolder = require$$0.useCallback(
+    async ({
+      files,
+      parentFolderId,
+      baseUrl,
+      headers,
+      currentToken
+    }) => {
+      const send = (form) => new Promise((resolve, reject) => {
+        const xhr = new XMLHttpRequest();
+        xhrRef.current = xhr;
+        xhr.upload.addEventListener("progress", (e) => {
+          var _a;
+          if (!e.lengthComputable) return;
+          const percent = e.loaded / e.total;
+          const fileIndex = Math.min(Math.floor(percent * files.length), files.length - 1);
+          setProgress({
+            current: fileIndex + 1,
+            total: files.length,
+            fileName: ((_a = files[fileIndex]) == null ? void 0 : _a.name) ?? "",
+            percent
+          });
+        });
+        xhr.addEventListener(
+          "load",
+          () => resolve(new Response(xhr.responseText, { status: xhr.status }))
+        );
+        xhr.addEventListener("error", () => reject(new Error("Network error during upload")));
+        xhr.addEventListener("abort", () => reject(new Error("Upload was cancelled")));
+        xhr.open("POST", `${baseUrl}${folderUpload.FOLDER_UPLOAD_PATH}`);
+        for (const [key, value] of Object.entries(headers)) xhr.setRequestHeader(key, value);
+        xhr.withCredentials = !currentToken && !configRef.current.apiKey;
+        xhr.send(form);
+      });
+      const taskId = await folderUpload.startFolderUpload({ send, files, parentFolderId });
+      const config2 = configRef.current;
+      const auth = {
+        backendUrl: baseUrl,
+        appUrl: config2.appUrl,
+        apiKey: config2.apiKey,
+        credentials: "include",
+        get accessToken() {
+          return configRef.current.token ?? void 0;
+        },
+        getAccessToken: async () => {
+          var _a, _b;
+          return await ((_b = (_a = configRef.current).getToken) == null ? void 0 : _b.call(_a)) ?? void 0;
+        },
+        renewAccessToken: async () => {
+          var _a, _b;
+          return await ((_b = (_a = configRef.current).getToken) == null ? void 0 : _b.call(_a, { force: true })) ?? void 0;
+        }
+      };
+      const waiting = new AbortController();
+      taskWaitRef.current = waiting;
+      try {
+        const task = await folderUpload.waitForFolderUploadTask({ auth, taskId, signal: waiting.signal });
+        const { uploaded, failed } = folderUpload.folderUploadResultOf({ task, files });
+        if (failed.length > 0) {
+          const errMsg = failed.map((entry) => `${entry.fileName}: ${entry.error}`).join("; ");
+          setError(errMsg);
+          if (uploaded.length === 0) throw new Error(errMsg);
+        }
+        return { uploaded, refused: failed };
+      } finally {
+        if (taskWaitRef.current === waiting) taskWaitRef.current = null;
+      }
+    },
+    []
+  );
   const upload = require$$0.useCallback(
-    async (files) => {
+    async (files, options = {}) => {
       var _a;
       if (files.length === 0) return [];
       for (const file of files) {
@@ -34,10 +107,6 @@ function useFileUpload() {
       setError(null);
       setProgress({ current: 0, total: files.length, fileName: ((_a = files[0]) == null ? void 0 : _a.name) ?? "", percent: 0 });
       try {
-        const formData = new FormData();
-        for (const file of files) {
-          formData.append("files", file, file.name);
-        }
         const baseUrl = backendUrl.replace(/\/api\/assistant-ui\/?$/, "");
         const uploadUrl = `${baseUrl}/api/upload/`;
         const currentToken = configRef.current.token;
@@ -47,6 +116,22 @@ function useFileUpload() {
         } else if (apiKey) {
           headers["X-API-KEY"] = apiKey;
         }
+        const { parentFolderId, onFilesRefused } = options;
+        if (parentFolderId) {
+          const { uploaded, refused } = await uploadIntoFolder({
+            files,
+            parentFolderId,
+            baseUrl,
+            headers,
+            currentToken
+          });
+          if (refused.length > 0) onFilesRefused == null ? void 0 : onFilesRefused(refused);
+          return uploaded;
+        }
+        const formData = new FormData();
+        for (const file of files) {
+          formData.append("files", file, file.name);
+        }
         const xhr = new XMLHttpRequest();
         xhrRef.current = xhr;
         const result = await new Promise((resolve, reject) => {
@@ -108,6 +193,9 @@ function useFileUpload() {
             throw new Error(errMsg);
           }
           setError(errMsg);
+          onFilesRefused == null ? void 0 : onFilesRefused(
+            result.errors.map((e) => ({ fileName: e.file.filename, error: e.error }))
+          );
         }
         return result.success;
       } catch (err) {
@@ -120,7 +208,7 @@ function useFileUpload() {
         setProgress(null);
       }
     },
-    [backendUrl, apiKey]
+    [backendUrl, apiKey, uploadIntoFolder]
   );
   return { upload, isUploading, progress, error, clearError };
 }