@base44/superagent-native 0.0.1

package/src/useSuperagentConversation.ts

@@ -0,0 +1,242 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+
+import { AUTO_GREET_MESSAGE, MESSAGES_PAGE_SIZE } from './constants';
+import {
+  countAssistantResponses,
+  createErrorMessage,
+  createUserMessage,
+  getMessageCursor,
+  hasNewAssistantResponse,
+  isQueuedResponse,
+  isVisibleMessage,
+  mergeMessage,
+  normalizeMessages,
+  pollConversation,
+  refreshConversation,
+  sendWithFallback,
+} from './conversationRuntime';
+import type { QueuedSuperagentMessage, SuperagentConversation, SuperagentMessage, SuperagentNativeClient, SuperagentRealtimeClient, SuperagentReplyTo } from './types';
+
+type SendMessageHandler = (params: { agentId: string; fileUrls?: string[]; message: string; replyTo?: SuperagentReplyTo }) => Promise<SuperagentMessage | SuperagentMessage[] | void> | SuperagentMessage | SuperagentMessage[] | void;
+
+type UseConversationParams = {
+  agentId: string;
+  apiClient?: SuperagentNativeClient;
+  realtimeClient?: SuperagentRealtimeClient;
+  fallbackMessages: SuperagentMessage[];
+  fallbackSending: boolean;
+  onAgentMessageDone?: () => Promise<void> | void;
+  onConversationSettled?: () => Promise<void> | void;
+  onSendMessage?: SendMessageHandler;
+};
+
+export function useSuperagentConversation({
+  agentId,
+  apiClient,
+  realtimeClient,
+  fallbackMessages,
+  fallbackSending,
+  onAgentMessageDone,
+  onConversationSettled,
+  onSendMessage,
+}: UseConversationParams) {
+  const [conversationId, setConversationId] = useState<string | null>(null);
+  const [messages, setMessages] = useState<SuperagentMessage[]>(fallbackMessages);
+  const [queuedMessages, setQueuedMessages] = useState<QueuedSuperagentMessage[]>([]);
+  const [isLoading, setIsLoading] = useState(false);
+  const [isSending, setIsSending] = useState(false);
+  const [initError, setInitError] = useState<string | null>(null);
+  const [hasMoreMessages, setHasMoreMessages] = useState(false);
+  const sendGenerationRef = useRef(0);
+
+  useEffect(() => {
+    if (!apiClient) setMessages(fallbackMessages);
+  }, [apiClient, fallbackMessages]);
+
+  useEffect(() => {
+    if (!apiClient) return;
+    const client = apiClient;
+    let cancelled = false;
+
+    async function initConversation() {
+      setIsLoading(true);
+      setInitError(null);
+
+      try {
+        const conversations = await client.getConversations(1);
+        let conversation = conversations[0] ?? await client.createConversation({});
+        const page = await client.getMessages(conversation.id, { limit: MESSAGES_PAGE_SIZE });
+
+        if (cancelled) return;
+        conversation = { ...conversation, messages: page.messages };
+        setConversationId(conversation.id);
+        setMessages(normalizeMessages(conversation.messages ?? []));
+        setHasMoreMessages(Boolean(page.has_more ?? page.hasMore));
+
+        if ((conversation.messages ?? []).length === 0) {
+          await client.addMessage(conversation.id, createUserMessage(AUTO_GREET_MESSAGE));
+          if (cancelled) return;
+          await refreshConversation(client, conversation.id, setMessages);
+        }
+      } catch (error) {
+        if (!cancelled) setInitError(error instanceof Error ? error.message : 'Failed to load conversation');
+      } finally {
+        if (!cancelled) setIsLoading(false);
+      }
+    }
+
+    initConversation();
+    return () => { cancelled = true; };
+  }, [agentId, apiClient]);
+
+  useEffect(() => {
+    if (!realtimeClient || !conversationId) return undefined;
+
+    return realtimeClient.subscribeToConversation(conversationId, {
+      onMessage(message) {
+        setMessages((current) => mergeMessage(current, message));
+        if (message.role === 'assistant' && (message.content || message.toolCalls?.length || message.tool_calls?.length)) {
+          setIsSending(false);
+        }
+      },
+      onConversation(conversation) {
+        if (conversation.id !== conversationId) return;
+        setMessages(normalizeMessages(conversation.messages ?? []));
+      },
+      onAgentDone() {
+        setIsSending(false);
+        onAgentMessageDone?.();
+        if (apiClient) {
+          refreshConversation(apiClient, conversationId, setMessages)
+            .then(() => onConversationSettled?.())
+            .catch(() => {});
+        } else {
+          onConversationSettled?.();
+        }
+      },
+      onReconnect() {
+        if (apiClient) refreshConversation(apiClient, conversationId, setMessages).catch(() => {});
+      },
+      onError(error) {
+        setInitError(error instanceof Error ? error.message : 'Realtime connection failed');
+      },
+    });
+  }, [apiClient, conversationId, onAgentMessageDone, onConversationSettled, realtimeClient]);
+
+  const visibleMessages = useMemo(
+    () => messages.filter((message, index) => isVisibleMessage(message, index)),
+    [messages],
+  );
+
+  const sendMessage = useCallback(async (content: string, options: { fileUrls?: string[]; replyTo?: SuperagentReplyTo } = {}) => {
+    const trimmedContent = content.trim();
+    const fileUrls = options.fileUrls?.filter(Boolean) ?? [];
+    if (!trimmedContent && fileUrls.length === 0) return;
+
+    const assistantCountBefore = countAssistantResponses(messages);
+    const userMessage = createUserMessage(trimmedContent, { fileUrls, replyTo: options.replyTo });
+    setMessages((current) => [...current, userMessage]);
+
+    if (!apiClient || !conversationId) {
+      if (!onSendMessage) return;
+      const sendGeneration = sendGenerationRef.current + 1;
+      sendGenerationRef.current = sendGeneration;
+      const setSendingForCurrentSend = (value: boolean) => {
+        if (sendGenerationRef.current === sendGeneration) setIsSending(value);
+      };
+
+      setIsSending(true);
+      const hasAssistantResponse = await sendWithFallback(agentId, trimmedContent, fileUrls, options.replyTo, onSendMessage, setMessages, setSendingForCurrentSend);
+      if (hasAssistantResponse) onAgentMessageDone?.();
+      return;
+    }
+
+    const sendGeneration = sendGenerationRef.current + 1;
+    sendGenerationRef.current = sendGeneration;
+    const setSendingForCurrentSend = (value: boolean) => {
+      if (sendGenerationRef.current === sendGeneration) setIsSending(value);
+    };
+
+    setIsSending(true);
+    try {
+      const response = await apiClient.addMessage(conversationId, userMessage);
+      if (isQueuedResponse(response)) {
+        setQueuedMessages((current) => [...current, { id: userMessage.id!, content: userMessage.content, position: current.length }]);
+      } else {
+        const refreshedMessages = await refreshConversation(apiClient, conversationId, setMessages);
+        if (!realtimeClient) {
+          if (hasNewAssistantResponse(refreshedMessages, assistantCountBefore)) {
+            setSendingForCurrentSend(false);
+            onAgentMessageDone?.();
+            onConversationSettled?.();
+          } else {
+            pollConversation(apiClient, conversationId, setMessages, setSendingForCurrentSend, assistantCountBefore, onConversationSettled, onAgentMessageDone);
+          }
+        } else {
+          setTimeout(() => {
+            setSendingForCurrentSend(false);
+            onConversationSettled?.();
+          }, 5000);
+        }
+      }
+    } catch (error) {
+      const errorMessage = createErrorMessage(error);
+      setMessages((current) => [...current, errorMessage]);
+      setSendingForCurrentSend(false);
+    }
+  }, [agentId, apiClient, conversationId, messages, onAgentMessageDone, onConversationSettled, onSendMessage, realtimeClient]);
+
+  const deleteMessage = useCallback(async (messageId: string) => {
+    if (!messageId || messageId === 'welcome') return false;
+
+    if (!apiClient || !conversationId) {
+      setMessages((current) => current.filter((message) => message.id !== messageId));
+      return true;
+    }
+
+    try {
+      await apiClient.deleteMessage(conversationId, messageId);
+      await refreshConversation(apiClient, conversationId, setMessages);
+      return true;
+    } catch (error) {
+      setInitError(error instanceof Error ? error.message : 'Failed to delete message');
+      return false;
+    }
+  }, [apiClient, conversationId]);
+
+  const stop = useCallback(async () => {
+    sendGenerationRef.current += 1;
+
+    if (!apiClient || !conversationId) {
+      setIsSending(false);
+      return;
+    }
+
+    setIsSending(false);
+    setQueuedMessages([]);
+    await apiClient.stopConversation(conversationId);
+    await refreshConversation(apiClient, conversationId, setMessages);
+  }, [apiClient, conversationId]);
+
+  const loadPrevious = useCallback(async () => {
+    const before = getMessageCursor(messages[0]);
+    if (!apiClient || !conversationId || !before) return;
+    const page = await apiClient.getMessages(conversationId, { limit: MESSAGES_PAGE_SIZE, before });
+    setMessages((current) => [...normalizeMessages(page.messages), ...current]);
+    setHasMoreMessages(Boolean(page.has_more ?? page.hasMore));
+  }, [apiClient, conversationId, messages]);
+
+  const submitToolCallInput = useCallback(async (toolCallId: string, approve: boolean, extraUserInput?: unknown, originRequestId?: string): Promise<SuperagentConversation | null> => {
+    if (!apiClient || !conversationId) return null;
+    const updated = await apiClient.submitToolCallInput(conversationId, toolCallId, approve, extraUserInput, originRequestId);
+    if (updated.messages) setMessages(normalizeMessages(updated.messages));
+    onConversationSettled?.();
+    return updated;
+  }, [apiClient, conversationId, onConversationSettled]);
+
+  return {
+    conversationId, deleteMessage, hasMoreMessages, initError, isLoading,
+    isSending: isSending || fallbackSending,
+    loadPrevious, messages: visibleMessages, queuedMessages, sendMessage, submitToolCallInput, stop,
+  };
+}