Function useAttachmentQueue

packages/kilo-chat-hooks/src/use-attachment-queue.ts:243–420

(
  client: KiloChatClient,
  conversationId: string,
  options: UseAttachmentQueueOptions
)

}

export function useAttachmentQueue(
  client: KiloChatClient,
  conversationId: string,
  options: UseAttachmentQueueOptions
): UseAttachmentQueueResult {
  const [state, dispatch] = useReducer(attachmentQueueReducer, { rows: [] });
  const { performUpload, maxBytes, generateTempId, onSizeRejected } = options;
  const generate = generateTempId ?? defaultTempId;

  type Pending = {
    abort: AbortController;
    putUrl?: string;
    putHeaders?: Record<string, string>;
    putUrlExpiresAtMs?: number;
  };
  const pendingRef = useRef<Map<string, Pending>>(new Map());
  // Blobs are tracked separately so previews keep working after the upload
  // completes — pendingRef releases its entry on setReady to free upload
  // bookkeeping, but the local bytes are still useful for the preview chip
  // until the user sends or removes the attachment.
  const blobsRef = useRef<Map<string, Blob>>(new Map());

  type UploadArgs = { tempId: string; filename: string; mimeType: string; size: number };

  const startUpload = useCallback(
    async (args: UploadArgs) => {
      const { tempId, filename, mimeType, size } = args;
      const pending = pendingRef.current.get(tempId);
      const blob = blobsRef.current.get(tempId);
      if (!pending || !blob) return;

      try {
        let putUrl = pending.putUrl;
        let putHeaders = pending.putHeaders;
        const expiresAtMs = pending.putUrlExpiresAtMs ?? 0;
        // Treat the URL as expired a minute early to avoid racing R2 at the boundary.
        const putUrlExpired = Date.now() > expiresAtMs - 60 * 1000;

        if (!putUrl || !putHeaders || putUrlExpired) {
          const res = await client.initAttachment({
            conversationId,
            mimeType,
            size,
            filename,
            idempotencyKey: tempId,
          });
          if (pending.abort.signal.aborted) return;
          pending.putUrl = res.putUrl;
          pending.putHeaders = res.putHeaders;
          pending.putUrlExpiresAtMs = res.putUrlExpiresAt * 1000;
          putUrl = res.putUrl;
          putHeaders = res.putHeaders;
          dispatch({ type: 'setInited', tempId, attachmentId: res.attachmentId });
        }

        await performUpload(blob, putUrl, putHeaders, {
          signal: pending.abort.signal,
          onProgress: fraction => dispatch({ type: 'setProgress', tempId, progress: fraction }),