@copilotz/chat-adapter 0.3.3 → 0.3.4

package/dist/index.d.ts

@@ -44,6 +44,15 @@ type RestMessage = {
     createdAt?: string;
     updatedAt?: string;
 };
+type RestMessagePageInfo = {
+    hasMoreBefore: boolean;
+    oldestMessageId: string | null;
+    newestMessageId: string | null;
+};
+type RestMessagePage = {
+    data: RestMessage[];
+    pageInfo: RestMessagePageInfo;
+};
 type StreamCallbacks = {
     onToken?: (token: string, isComplete: boolean, raw?: any, options?: {
         isReasoning?: boolean;
@@ -95,6 +104,10 @@ declare class CopilotzRequestError extends Error {
 declare function runCopilotzStream(options: RunOptions): Promise<CopilotzStreamResult>;
 declare function fetchThreads(userId: string, getRequestHeaders?: RequestHeadersProvider): Promise<RestThread[]>;
 declare function fetchThreadMessages(threadId: string, getRequestHeaders?: RequestHeadersProvider): Promise<RestMessage[]>;
+declare function fetchThreadMessagesPage(threadId: string, options?: {
+    limit?: number;
+    before?: string | null;
+}, getRequestHeaders?: RequestHeadersProvider): Promise<RestMessagePage>;
 declare function updateThread(threadId: string, updates: Partial<RestThread>, getRequestHeaders?: RequestHeadersProvider): Promise<any>;
 declare function deleteThread(threadId: string, getRequestHeaders?: RequestHeadersProvider): Promise<boolean>;
 declare const copilotzService: {
@@ -187,6 +200,8 @@ interface UseCopilotzOptions {
 declare function useCopilotz({ userId, initialContext, bootstrap, defaultThreadName, onToolOutput, preferredAgentName, participants, targetAgentName, getRequestHeaders, eventInterceptor, runErrorInterceptor, }: UseCopilotzOptions): {
     messages: ChatMessage[];
     isMessagesLoading: boolean;
+    isLoadingOlderMessages: boolean;
+    messagePageInfo: RestMessagePageInfo;
     threads: ChatThread[];
     currentThreadId: string | null;
     isStreaming: boolean;
@@ -202,6 +217,7 @@ declare function useCopilotz({ userId, initialContext, bootstrap, defaultThreadN
     stopGeneration: () => void;
     fetchAndSetThreadsState: (uid: string, preferredExternalId?: string | null) => Promise<string | null | undefined>;
     loadThreadMessages: (threadId: string) => Promise<void>;
+    loadOlderMessages: () => Promise<void>;
     reset: () => void;
 };
 
@@ -281,4 +297,4 @@ type WithMetadata = {
 };
 declare function resolveAssetsInMessages<T extends WithMetadata>(messages: T[]): Promise<T[]>;
 
-export { CopilotzChat, CopilotzRequestError, type CopilotzStreamResult, type EventInterceptor, type EventInterceptorResult, type RenderSpecialState, type RequestHeadersProvider, type RunErrorInterceptor, type SpecialChatState, type SpecialStateControls, type UrlParamsConfig, type UrlState, type UseUrlStateReturn, copilotzService, deleteThread, fetchThreadMessages, fetchThreads, getAssetDataUrl, resolveAssetsInMessages, runCopilotzStream, updateThread, useCopilotz, useUrlState };
+export { CopilotzChat, CopilotzRequestError, type CopilotzStreamResult, type EventInterceptor, type EventInterceptorResult, type RenderSpecialState, type RequestHeadersProvider, type RestMessagePage, type RestMessagePageInfo, type RunErrorInterceptor, type SpecialChatState, type SpecialStateControls, type UrlParamsConfig, type UrlState, type UseUrlStateReturn, copilotzService, deleteThread, fetchThreadMessages, fetchThreadMessagesPage, fetchThreads, getAssetDataUrl, resolveAssetsInMessages, runCopilotzStream, updateThread, useCopilotz, useUrlState };

package/dist/index.js

@@ -130,6 +130,11 @@ var withAuthHeaders = async (headers = {}, getRequestHeaders) => {
   }
   return headers;
 };
+var buildFallbackPageInfo = (data) => ({
+  hasMoreBefore: false,
+  oldestMessageId: data[0]?.id ?? null,
+  newestMessageId: data[data.length - 1]?.id ?? null
+});
 var CopilotzRequestError = class extends Error {
   status;
   code;
@@ -549,8 +554,15 @@ async function fetchThreads(userId, getRequestHeaders) {
   return data;
 }
 async function fetchThreadMessages(threadId, getRequestHeaders) {
+  const page = await fetchThreadMessagesPage(threadId, void 0, getRequestHeaders);
+  return page.data;
+}
+async function fetchThreadMessagesPage(threadId, options, getRequestHeaders) {
   const params = new URLSearchParams();
-  params.set("limit", "500");
+  params.set("limit", String(options?.limit ?? 50));
+  if (options?.before) {
+    params.set("before", options.before);
+  }
   const res = await fetch(
     apiUrl(`/v1/threads/${threadId}/messages?${params.toString()}`),
     {
@@ -566,14 +578,33 @@ async function fetchThreadMessages(threadId, getRequestHeaders) {
       errorText || `Failed to load thread messages (${res.status})`
     );
   }
-  const data = await res.json();
-  if (Array.isArray(data)) {
-    return data;
+  const payload = await res.json();
+  if (Array.isArray(payload)) {
+    return {
+      data: payload,
+      pageInfo: buildFallbackPageInfo(payload)
+    };
   }
-  if (Array.isArray(data?.data)) {
-    return data.data;
+  if (Array.isArray(payload?.data)) {
+    const data = payload.data;
+    const rawPageInfo = payload?.pageInfo;
+    return {
+      data,
+      pageInfo: {
+        hasMoreBefore: rawPageInfo?.hasMoreBefore === true,
+        oldestMessageId: typeof rawPageInfo?.oldestMessageId === "string" ? rawPageInfo.oldestMessageId : data[0]?.id ?? null,
+        newestMessageId: typeof rawPageInfo?.newestMessageId === "string" ? rawPageInfo.newestMessageId : data[data.length - 1]?.id ?? null
+      }
+    };
   }
-  return [];
+  return {
+    data: [],
+    pageInfo: {
+      hasMoreBefore: false,
+      oldestMessageId: null,
+      newestMessageId: null
+    }
+  };
 }
 async function updateThread(threadId, updates, getRequestHeaders) {
   const res = await fetch(apiUrl(`/v1/threads/${threadId}`), {
@@ -800,6 +831,12 @@ var messageAgentKey = (message) => {
   if (message.role !== "assistant") return null;
   return message.senderAgentId ?? message.senderName ?? null;
 };
+var THREAD_MESSAGES_PAGE_SIZE = 50;
+var createEmptyMessagePageInfo = () => ({
+  hasMoreBefore: false,
+  oldestMessageId: null,
+  newestMessageId: null
+});
 var normalizeToolStatus = (status) => {
   if (status === "pending") return "pending";
   if (status === "running" || status === "processing") return "running";
@@ -917,6 +954,18 @@ var mergePersistedToolResults = (messages, updates) => {
   }
   return nextMessages;
 };
+var prependUniqueMessages = (olderMessages, currentMessages) => {
+  if (olderMessages.length === 0) return currentMessages;
+  if (currentMessages.length === 0) return olderMessages;
+  const seen = /* @__PURE__ */ new Set();
+  const combined = [];
+  for (const message of [...olderMessages, ...currentMessages]) {
+    if (seen.has(message.id)) continue;
+    seen.add(message.id);
+    combined.push(message);
+  }
+  return combined;
+};
 var convertServerMessage = (msg) => {
   const timestamp = msg.createdAt ? new Date(msg.createdAt).getTime() : nowTs();
   const metadata = msg.metadata ?? void 0;
@@ -1004,6 +1053,8 @@ function useCopilotz({
   const [currentThreadExternalId, setCurrentThreadExternalId] = useState2(null);
   const [messages, setMessages] = useState2([]);
   const [isMessagesLoading, setIsMessagesLoading] = useState2(false);
+  const [isLoadingOlderMessages, setIsLoadingOlderMessages] = useState2(false);
+  const [messagePageInfo, setMessagePageInfo] = useState2(createEmptyMessagePageInfo);
   const [isStreaming, setIsStreaming] = useState2(false);
   const [specialState, setSpecialState] = useState2(null);
   const [userContextSeed, setUserContextSeed] = useState2(initialContext || {});
@@ -1016,12 +1067,17 @@ function useCopilotz({
   const currentThreadIdRef = useRef2(currentThreadId);
   const currentThreadExternalIdRef = useRef2(currentThreadExternalId);
   const userContextSeedRef = useRef2(userContextSeed);
+  const messagePageInfoRef = useRef2(messagePageInfo);
+  const isLoadingOlderMessagesRef = useRef2(isLoadingOlderMessages);
+  const persistedToolUpdatesRef = useRef2([]);
   threadsRef.current = threads;
   threadMetadataMapRef.current = threadMetadataMap;
   threadExternalIdMapRef.current = threadExternalIdMap;
   currentThreadIdRef.current = currentThreadId;
   currentThreadExternalIdRef.current = currentThreadExternalId;
   userContextSeedRef.current = userContextSeed;
+  messagePageInfoRef.current = messagePageInfo;
+  isLoadingOlderMessagesRef.current = isLoadingOlderMessages;
   preferredAgentRef.current = preferredAgentName ?? null;
   participantsRef.current = participants ?? null;
   targetAgentNameRef.current = targetAgentName ?? null;
@@ -1210,50 +1266,105 @@ function useCopilotz({
       return null;
     }
   }, [updateThreadsState, getRequestHeaders]);
+  const prepareThreadMessages = useCallback2(async (rawMessages) => {
+    const resolvedMessages = await resolveAssetsInMessages(rawMessages);
+    resolvedMessages.forEach((msg) => {
+      if (msg.senderType === "tool") {
+        const metadata = msg.metadata;
+        const output = metadata?.output ?? metadata;
+        if (output) processToolOutput(output);
+      }
+    });
+    const toolResultUpdates = resolvedMessages.map((msg) => extractToolResultUpdateFromMessage(msg)).filter((update) => update !== null);
+    const viewMessages = resolvedMessages.filter((msg) => {
+      const meta = msg.metadata ?? {};
+      if (isInternalMessageMetadata(meta)) {
+        return false;
+      }
+      const text = (typeof msg.content === "string" ? msg.content : "").trim();
+      const hasText = text.length > 0;
+      const hasToolCalls = extractToolCallsFromServerMessage(msg).length > 0;
+      const hasAttachments = Array.isArray(meta.attachments) && meta.attachments.length > 0;
+      if (msg.senderType === "tool") {
+        return hasAttachments;
+      }
+      return hasText || hasToolCalls || hasAttachments;
+    }).map(convertServerMessage);
+    return {
+      viewMessages,
+      toolResultUpdates
+    };
+  }, [processToolOutput]);
   const loadThreadMessages = useCallback2(async (threadId) => {
     const requestId = messagesRequestRef.current + 1;
     messagesRequestRef.current = requestId;
     setIsMessagesLoading(true);
+    setIsLoadingOlderMessages(false);
+    setMessagePageInfo(createEmptyMessagePageInfo());
+    persistedToolUpdatesRef.current = [];
     try {
-      const rawMessages = await fetchThreadMessages(threadId, getRequestHeaders);
-      const resolvedMessages = await resolveAssetsInMessages(rawMessages);
+      const page = await fetchThreadMessagesPage(
+        threadId,
+        { limit: THREAD_MESSAGES_PAGE_SIZE },
+        getRequestHeaders
+      );
+      const { viewMessages, toolResultUpdates } = await prepareThreadMessages(page.data);
       if (messagesRequestRef.current !== requestId) return;
-      resolvedMessages.forEach((msg) => {
-        if (msg.senderType === "tool") {
-          const metadata = msg.metadata;
-          const output = metadata?.output ?? metadata;
-          if (output) processToolOutput(output);
-        }
-      });
-      const toolResultUpdates = resolvedMessages.map((msg) => extractToolResultUpdateFromMessage(msg)).filter((update) => update !== null);
-      const viewMessages = resolvedMessages.filter((msg) => {
-        const meta = msg.metadata ?? {};
-        if (isInternalMessageMetadata(meta)) {
-          return false;
-        }
-        const text = (typeof msg.content === "string" ? msg.content : "").trim();
-        const hasText = text.length > 0;
-        const hasToolCalls = extractToolCallsFromServerMessage(msg).length > 0;
-        const hasAttachments = Array.isArray(meta.attachments) && meta.attachments.length > 0;
-        if (msg.senderType === "tool") {
-          return hasAttachments;
-        }
-        return hasText || hasToolCalls || hasAttachments;
-      }).map(convertServerMessage);
-      const hydratedMessages = mergePersistedToolResults(viewMessages, toolResultUpdates);
+      persistedToolUpdatesRef.current = toolResultUpdates;
+      const hydratedMessages = mergePersistedToolResults(viewMessages, persistedToolUpdatesRef.current);
       setMessages(hydratedMessages);
+      setMessagePageInfo(page.pageInfo);
     } catch (error) {
       if (isAbortError(error)) return;
       console.error(`Error loading messages for thread ${threadId}`, error);
+      persistedToolUpdatesRef.current = [];
+      setMessagePageInfo(createEmptyMessagePageInfo());
     } finally {
       if (messagesRequestRef.current === requestId) {
         setIsMessagesLoading(false);
       }
     }
-  }, [processToolOutput, getRequestHeaders]);
+  }, [getRequestHeaders, prepareThreadMessages]);
+  const loadOlderMessages = useCallback2(async () => {
+    const threadId = currentThreadIdRef.current;
+    const pageInfo = messagePageInfoRef.current;
+    const before = pageInfo.oldestMessageId;
+    if (!threadId || !before || !pageInfo.hasMoreBefore || isLoadingOlderMessagesRef.current) {
+      return;
+    }
+    const requestId = messagesRequestRef.current;
+    setIsLoadingOlderMessages(true);
+    try {
+      const page = await fetchThreadMessagesPage(
+        threadId,
+        { limit: THREAD_MESSAGES_PAGE_SIZE, before },
+        getRequestHeaders
+      );
+      const { viewMessages, toolResultUpdates } = await prepareThreadMessages(page.data);
+      if (messagesRequestRef.current !== requestId) return;
+      persistedToolUpdatesRef.current = [
+        ...toolResultUpdates,
+        ...persistedToolUpdatesRef.current
+      ];
+      setMessages((prev) => mergePersistedToolResults(
+        prependUniqueMessages(viewMessages, prev),
+        persistedToolUpdatesRef.current
+      ));
+      setMessagePageInfo(page.pageInfo);
+    } catch (error) {
+      if (isAbortError(error)) return;
+      console.error(`Error loading older messages for thread ${threadId}`, error);
+    } finally {
+      if (messagesRequestRef.current === requestId) {
+        setIsLoadingOlderMessages(false);
+      }
+    }
+  }, [getRequestHeaders, prepareThreadMessages]);
   const handleSelectThread = useCallback2(async (threadId) => {
     setCurrentThreadId(threadId);
     setMessages([]);
+    setMessagePageInfo(createEmptyMessagePageInfo());
+    persistedToolUpdatesRef.current = [];
     const extMap = threadExternalIdMapRef.current;
     setCurrentThreadExternalId(extMap[threadId] ?? null);
     await loadThreadMessages(threadId);
@@ -1261,6 +1372,7 @@ function useCopilotz({
   const handleCreateThread = useCallback2((title) => {
     messagesRequestRef.current += 1;
     setIsMessagesLoading(false);
+    setIsLoadingOlderMessages(false);
     const id = generateId();
     const now = nowTs();
     const newThread = {
@@ -1277,6 +1389,8 @@ function useCopilotz({
     setCurrentThreadId(id);
     setCurrentThreadExternalId(id);
     setMessages([]);
+    setMessagePageInfo(createEmptyMessagePageInfo());
+    persistedToolUpdatesRef.current = [];
   }, []);
   const handleRenameThread = useCallback2(async (threadId, newTitle) => {
     const trimmedTitle = newTitle.trim();
@@ -1346,6 +1460,8 @@ function useCopilotz({
         setCurrentThreadId(null);
         setCurrentThreadExternalId(null);
         setMessages([]);
+        setMessagePageInfo(createEmptyMessagePageInfo());
+        persistedToolUpdatesRef.current = [];
       }
     }
     if (!isPlaceholder) {
@@ -1898,6 +2014,8 @@ function useCopilotz({
     setThreadExternalIdMap((prev) => ({ ...prev, [bootstrapThreadExternalId]: bootstrapThreadExternalId }));
     setThreadMetadataMap((prev) => ({ ...prev, [bootstrapThreadExternalId]: {} }));
     setMessages([]);
+    setMessagePageInfo(createEmptyMessagePageInfo());
+    persistedToolUpdatesRef.current = [];
     setSpecialState(null);
     try {
       await sendCopilotzMessage({
@@ -1943,7 +2061,10 @@ function useCopilotz({
     setMessages([]);
     setUserContextSeed({});
     setIsMessagesLoading(false);
+    setIsLoadingOlderMessages(false);
     setIsStreaming(false);
+    setMessagePageInfo(createEmptyMessagePageInfo());
+    persistedToolUpdatesRef.current = [];
     setSpecialState(null);
     abortControllerRef.current?.abort();
   }, []);
@@ -1984,6 +2105,8 @@ function useCopilotz({
   return {
     messages,
     isMessagesLoading,
+    isLoadingOlderMessages,
+    messagePageInfo,
     threads,
     currentThreadId,
     isStreaming,
@@ -1999,6 +2122,7 @@ function useCopilotz({
     stopGeneration: handleStop,
     fetchAndSetThreadsState,
     loadThreadMessages,
+    loadOlderMessages,
     reset
   };
 }
@@ -2047,6 +2171,8 @@ var CopilotzChat = ({
   const {
     messages,
     isMessagesLoading,
+    isLoadingOlderMessages,
+    messagePageInfo,
     threads,
     currentThreadId,
     isStreaming,
@@ -2059,7 +2185,8 @@ var CopilotzChat = ({
     renameThread,
     archiveThread,
     deleteThread: deleteThread2,
-    stopGeneration
+    stopGeneration,
+    loadOlderMessages
   } = useCopilotz({
     userId,
     initialContext,
@@ -2160,6 +2287,9 @@ var CopilotzChat = ({
     {
       messages,
       isMessagesLoading,
+      isLoadingOlderMessages,
+      hasMoreMessagesBefore: messagePageInfo.hasMoreBefore,
+      onLoadOlderMessages: loadOlderMessages,
       threads,
       currentThreadId,
       config: mergedConfig,
@@ -2188,6 +2318,7 @@ export {
   copilotzService,
   deleteThread,
   fetchThreadMessages,
+  fetchThreadMessagesPage,
   fetchThreads,
   getAssetDataUrl,
   resolveAssetsInMessages,