@applica-software-guru/persona-sdk 0.1.84 → 0.1.86

package/src/runtime.tsx

@@ -1,80 +1,28 @@
-import { useState, useEffect, useCallback, PropsWithChildren, createContext, useContext, useMemo, useRef } from 'react';
+import { useState, useEffect, useCallback, PropsWithChildren, useMemo, useRef } from 'react';
 import {
   useExternalStoreRuntime,
-  AppendMessage,
   AssistantRuntimeProvider,
   CompositeAttachmentAdapter,
   SimpleImageAttachmentAdapter,
 } from '@assistant-ui/react';
-import {
-  PersonaConfig,
-  PersonaMessage,
-  PersonaPacket,
-  PersonaProtocol,
-  PersonaProtocolBaseConfig,
-  PersonaReasoning,
-  PersonaResponse,
-  PersonaTransaction,
-  ProtocolStatus,
-  Session,
-} from './types';
+import { PersonaConfig, PersonaMessage, PersonaResponse, ProtocolStatus, Session, ThreadData } from './types';
 import { parseMessages, convertMessage } from './messages';
-import {
-  PersonaRESTProtocol,
-  PersonaRESTProtocolConfig,
-  PersonaTransactionProtocol,
-  PersonaWebRTCProtocol,
-  PersonaWebRTCProtocolConfig,
-  PersonaWebSocketProtocol,
-  PersonaWebSocketProtocolConfig,
-} from './protocol';
-
-type PersonaRuntimeContextType = {
-  protocols: PersonaProtocol[];
-  protocolsStatus: Map<string, ProtocolStatus>;
-  getMessages: () => PersonaMessage[];
-};
-
-const PersonaRuntimeContext = createContext<PersonaRuntimeContextType | undefined>(undefined);
-
-function fileToBase64(file: File): Promise<string> {
-  return new Promise((resolve, reject) => {
-    const reader = new FileReader();
-    reader.readAsDataURL(file); // Converte il file in Data URL (base64)
-
-    reader.onload = () => {
-      //remove data url  using ;base64, to split
-      const base64 = reader.result as string;
-      const base64WithoutPrefix = base64.split(';base64,')[1];
-      resolve(base64WithoutPrefix);
-    };
+import { initializeProtocols } from './runtime/protocols';
+import { createPacketListener } from './runtime/listeners';
+import { createOnNewHandler, createOnEditHandler, createOnReloadHandler, createOnCancelHandler } from './runtime/handlers';
+import { PersonaRuntimeContext } from './runtime/context';
+import { createThreadListAdapter } from './runtime/threads';
+import { PersonaSessionStorage } from './storage';
 
-    reader.onerror = (error) => {
-      reject(error);
-    };
-  });
-}
+export {
+  usePersonaRuntime,
+  usePersonaRuntimeProtocol,
+  usePersonaRuntimeEndpoint,
+  usePersonaRuntimeWebRTCProtocol,
+  usePersonaRuntimeMessages,
+} from './runtime/context';
 
-function getFirstAvailableProtocolEndpoint(protocols: PersonaProtocol[]): string | null {
-  const extractors: { [key: string]: (protocol: PersonaProtocol) => string } = {
-    rest: (protocol) => (protocol as PersonaRESTProtocol).config.apiUrl,
-    webrtc: (protocol) =>
-      (protocol as PersonaWebRTCProtocol).config.webrtcUrl.replace('/webrtc', '').replace('ws://', 'http://').replace('wss://', 'https://'),
-    websocket: (protocol) =>
-      (protocol as PersonaWebSocketProtocol).config.webSocketUrl
-        .replace('/websocket', '')
-        .replace('ws://', 'http://')
-        .replace('wss://', 'https://'),
-  };
-
-  for (const protocol of protocols) {
-    const extractor = extractors[protocol.getName()];
-    if (extractor) {
-      return extractor(protocol);
-    }
-  }
-  return null;
-}
+export type { PersonaMessage, PersonaResponse, ThreadData };
 
 function PersonaRuntimeProviderInner({
   dev = false,
@@ -82,239 +30,264 @@ function PersonaRuntimeProviderInner({
   protocols: _protocols,
   logger,
   children,
-  session: defaultSession = 'new',
+  session: initialSession = 'new',
   transformMessages,
+  threads = false,
+  sessionStorage: _sessionStorage,
+  onThreadCreate,
+  onThreadSwitch,
+  onThreadRename,
+  onThreadArchive,
+  onThreadUnarchive,
+  onThreadDelete,
   ...config
 }: Readonly<PersonaConfig>) {
   const [isRunning, setIsRunning] = useState(false);
   const [messages, setMessages] = useState<PersonaMessage[]>([]);
-  const [session, setSession] = useState<Session>(defaultSession);
   const [protocolsStatus, setProtocolsStatus] = useState<Map<string, ProtocolStatus>>(new Map());
   const didMount = useRef(false);
+  const isSwitchingThread = useRef(false);
+
+  // Initialize message storage
+  const sessionStorage = useMemo(
+    () =>
+      _sessionStorage ||
+      new PersonaSessionStorage({
+        apiKey: config.apiKey!,
+        endpoint: baseUrl || 'https://persona.applica.guru/api',
+      }),
+    [_sessionStorage, baseUrl, config.apiKey],
+  );
 
-  const protocols = useMemo<PersonaProtocol[]>(() => {
-    if (Array.isArray(_protocols)) {
-      return _protocols;
-    }
+  // Thread management state
+  const [threadList, setThreadList] = useState<ThreadData[]>([]);
+  const [currentThreadId, setCurrentThreadId] = useState<string>('');
 
-    if (typeof _protocols === 'object' && _protocols !== null) {
-      const baseEndpoint = dev ? 'localhost:8000' : baseUrl || 'persona.applica.guru/api';
-      const baseEndpointProtocol = dev ? 'http' : 'https';
-      const baseWebSocketProtocol = dev ? 'ws' : 'wss';
-      let availableProtocols = Object.keys(_protocols)
-        .map((key) => {
-          switch (key) {
-            case 'rest':
-              const restConfig: PersonaProtocolBaseConfig | boolean | undefined = _protocols[key];
-              if (restConfig === true) {
-                return new PersonaRESTProtocol({
-                  apiUrl: `${baseEndpointProtocol}://${baseEndpoint}`,
-                  apiKey: config.apiKey,
-                  agentId: config.agentId,
-                  logger,
-                });
-              } else if (typeof restConfig === 'object' && restConfig !== null) {
-                return new PersonaRESTProtocol(restConfig as PersonaRESTProtocolConfig);
-              } else {
-                return null;
-              }
-            case 'webrtc':
-              const webrtcConfig: PersonaProtocolBaseConfig | boolean | undefined = _protocols[key];
-              if (webrtcConfig === true) {
-                return new PersonaWebRTCProtocol({
-                  webrtcUrl: `${baseWebSocketProtocol}://${baseEndpoint}/webrtc`,
-                  apiKey: config.apiKey,
-                  agentId: config.agentId,
-                  logger,
-                });
-              } else if (typeof webrtcConfig === 'object' && webrtcConfig !== null) {
-                return new PersonaWebRTCProtocol(webrtcConfig as PersonaWebRTCProtocolConfig);
-              } else {
-                return null;
-              }
-            case 'websocket':
-              const websocketConfig: PersonaProtocolBaseConfig | boolean | undefined = _protocols[key];
-              if (websocketConfig === true) {
-                return new PersonaWebSocketProtocol({
-                  webSocketUrl: `${baseWebSocketProtocol}://${baseEndpoint}/websocket`,
-                  apiKey: config.apiKey,
-                  agentId: config.agentId,
-                  logger,
-                });
-              } else if (typeof websocketConfig === 'object' && websocketConfig !== null) {
-                return new PersonaWebSocketProtocol(websocketConfig as PersonaWebSocketProtocolConfig);
-              } else {
-                return null;
-              }
-            default:
-              throw new Error(`Unknown protocol: ${key}`);
-          }
-        })
-        .filter((protocol) => protocol !== null) as PersonaProtocol[];
-
-      if (config.tools) {
-        availableProtocols.push(
-          new PersonaTransactionProtocol({
-            apiUrl: `${baseEndpointProtocol}://${baseEndpoint}`,
-            apiKey: config.apiKey,
-            agentId: config.agentId,
-            tools: config.tools, // Pass raw tools
-            logger,
-          }),
-        );
-      }
-      return availableProtocols;
-    }
-    throw new Error('Invalid protocols configuration');
-  }, []);
+  // Use refs to avoid re-renders and effect loops
+  const currentThreadRef = useRef<Session>(typeof initialSession === 'string' ? initialSession : 'new');
+  const hasInitialized = useRef(false);
 
+  // Load threads on mount (only once)
   useEffect(() => {
-    if (didMount.current) return;
+    if (!threads || hasInitialized.current) {
+      return;
+    }
+    hasInitialized.current = true;
+
+    sessionStorage
+      .list(config.agentId, config.userId)
+      .then((threads) => {
+        if (threads?.length > 0) {
+          setThreadList(threads);
+          setCurrentThreadId(threads[0].threadId);
+        }
+      })
+      .catch((error) => logger?.error('Failed to load threads:', error));
+  }, [threads, sessionStorage, config.agentId, config.userId, logger]);
+
+  // Initialize protocols
+  const protocols = useMemo(
+    () =>
+      initializeProtocols(_protocols, {
+        dev: dev || false,
+        baseUrl,
+        apiKey: config.apiKey,
+        agentId: config.agentId,
+        userId: config.userId,
+        tools: config.tools,
+        logger,
+      }),
+    [_protocols, dev, baseUrl, config.apiKey, config.agentId, config.userId, config.tools, logger],
+  );
 
+  // Setup protocol listeners (only once on mount)
+  useEffect(() => {
+    if (didMount.current) {
+      return;
+    }
     didMount.current = true;
     logger?.debug(
-      'Initializing protocols: ',
-      protocols.map((protocol) => protocol.getName()),
+      'Setting up protocols:',
+      protocols.map((p) => p.getName()),
     );
     protocols.forEach((protocol) => {
-      protocol.setSession(session);
+      protocol.setSession(currentThreadRef.current);
       protocol.clearListeners();
+
+      // Status change listener
       protocol.addStatusChangeListener((status: ProtocolStatus) => {
-        logger?.debug(`${protocol.getName()} has notified new status: ${status}`);
-        protocolsStatus.set(protocol.getName(), status);
-        if (status === 'connected') {
+        logger?.debug(`${protocol.getName()} status: ${status}`);
+        setProtocolsStatus((prev) => {
+          const next = new Map(prev);
+          next.set(protocol.getName(), status);
+          return next;
+        });
+
+        // Only send initial packets on first connection (not during thread switches)
+        if (status === 'connected' && !isSwitchingThread.current) {
           if (config.context) {
-            protocol.sendPacket({
-              type: 'command',
-              payload: {
-                command: 'set_initial_context',
-                arguments: config.context,
-              },
-            });
+            protocol
+              .sendPacket({
+                type: 'command',
+                payload: { command: 'set_initial_context', arguments: config.context },
+              })
+              .catch(() => {});
           }
+
           if (config.tools && Array.isArray(config.tools)) {
-            protocol.sendPacket({
-              type: 'command',
-              payload: {
-                command: 'set_local_tools',
-                arguments: {
-                  tools: config.tools.map((tool) => tool.schema),
-                },
-              },
-            });
+            protocol
+              .sendPacket({
+                type: 'command',
+                payload: { command: 'set_local_tools', arguments: { tools: config.tools.map((t) => t.schema) } },
+              })
+              .catch(() => {});
           }
         }
-        setProtocolsStatus(new Map(protocolsStatus));
       });
-      protocol.addPacketListener((message: PersonaPacket) => {
-        if (message.type === 'message') {
-          const personaMessage = message.payload as PersonaMessage;
-          if (personaMessage?.finishReason === 'stop' && !personaMessage?.functionResponse && !personaMessage?.thought) {
-            setIsRunning(false);
-          }
 
-          if (personaMessage.thought) {
-            personaMessage.type = 'reasoning';
-          }
+      // Packet listener
+      protocol.addPacketListener(createPacketListener(protocol, setMessages, setIsRunning, protocols, transformMessages));
 
-          setMessages((currentConversation) => {
-            const newMessages = parseMessages([...currentConversation, ...[{ ...personaMessage, protocol: protocol.getName() }]]);
-            return transformMessages ? transformMessages(newMessages) : newMessages;
-          });
-        } else if (message.type === 'reasoning') {
-          const reasoning = message.payload as PersonaReasoning;
-          const personaMessage: PersonaMessage = { type: 'reasoning', text: reasoning.thought, role: 'assistant', finishReason: 'stop' };
-
-          setMessages((currentConversation) => {
-            const newMessages = parseMessages([...currentConversation, ...[{ ...personaMessage, protocol: protocol.getName() }]]);
-            return transformMessages ? transformMessages(newMessages) : newMessages;
-          });
-        } else if (message.type === 'transaction') {
-          protocols.filter((p) => p !== protocol).forEach((p) => p.onTransaction(message.payload as PersonaTransaction));
-        }
-      });
+      // Auto-connect if configured
       if (protocol.autostart && protocol.status === 'disconnected') {
-        logger?.debug(`Connecting to protocol: ${protocol.getName()}`);
-        protocol.connect(session);
+        logger?.debug(`Auto-connecting protocol: ${protocol.getName()}`);
+        protocol.connect(currentThreadRef.current).catch(() => {});
         setIsRunning(false);
       }
     });
-  }, [session, protocols, logger, protocolsStatus, transformMessages]);
-
-  const onNew = async (message: AppendMessage) => {
-    if (message.content[0]?.type !== 'text') throw new Error('Only text messages are supported');
-    const ready = protocols.some((protocol) => protocol.getName() !== 'transaction' && protocol.status === 'connected');
-    if (!ready) {
-      setMessages((currentConversation) => {
-        const newMessages = [
-          ...currentConversation,
-          { role: 'assistant' as const, type: 'text' as const, text: 'No protocol is connected.' },
-        ];
-        return transformMessages ? transformMessages(newMessages) : newMessages;
-      });
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []); // Run only once
+
+  // Handle thread switching
+  useEffect(() => {
+    if (!threads || !currentThreadId) {
+      setMessages([]);
       return;
     }
 
-    const input = message.content[0].text;
-    setMessages((currentConversation) => {
-      const newMessages = [...currentConversation, { role: 'user' as const, type: 'text' as const, text: input }];
-      return transformMessages ? transformMessages(newMessages) : newMessages;
-    });
-    setIsRunning(true);
-
-    const protocol = protocols.sort((a, b) => b.getPriority() - a.getPriority()).find((protocol) => protocol.status === 'connected');
-    const content: Array<PersonaMessage> = [];
-    if (message.attachments) {
-      for (const attachment of message.attachments) {
-        if (attachment.contentType.startsWith('image/') && attachment.file) {
-          content.push({
-            role: 'user',
-            image: {
-              contentType: attachment.contentType,
-              content: await fileToBase64(attachment.file),
-            },
-            text: '',
-            type: 'text',
-          });
+    if (isSwitchingThread.current || currentThreadId === currentThreadRef.current) {
+      return;
+    }
+
+    // Mark as switching to prevent concurrent switches
+    isSwitchingThread.current = true;
+    logger?.info('Switching to thread:', currentThreadId);
+
+    const switchThread = async () => {
+      try {
+        // Disconnect active protocols in parallel
+        const connectedProtocols = protocols.filter((p) => p.status === 'connected');
+        if (connectedProtocols.length > 0) {
+          await Promise.allSettled(connectedProtocols.map((p) => p.disconnect()));
+        }
+
+        // Update thread reference
+        currentThreadRef.current = currentThreadId;
+
+        // Set new session on all protocols
+        await Promise.allSettled(protocols.map((p) => p.setSession(currentThreadId)));
+
+        // Load messages from storage
+        const loadedMessages = await sessionStorage.sync(currentThreadId);
+        const processed = parseMessages(loadedMessages);
+        setMessages(transformMessages ? transformMessages(processed) : processed);
+        logger?.debug(`Loaded ${loadedMessages.length} messages for thread ${currentThreadId}`);
+
+        // Reconnect autostart protocols
+        const autostartProtocols = protocols.filter((p) => p.autostart);
+        if (autostartProtocols.length > 0) {
+          await Promise.allSettled(autostartProtocols.map((p) => p.connect(currentThreadId)));
         }
+      } catch (error) {
+        logger?.error('Failed to switch thread:', error);
+        setMessages([]);
+      } finally {
+        isSwitchingThread.current = false;
       }
-    }
+    };
 
-    if (message.content) {
-      content.push({
-        role: 'user',
-        text: message.content[0].text,
-        type: 'text',
-      });
-    }
-    logger?.debug('Sending message:', content);
-    await protocol?.sendPacket({ type: 'request', payload: content });
-  };
+    switchThread();
+  }, [currentThreadId, threads, protocols, sessionStorage, transformMessages, logger]);
 
-  const onCancel = useCallback(() => {
-    setIsRunning(false);
-    setMessages([]);
-    setSession('new');
-    return Promise.resolve();
-  }, []);
+  // Message handlers
+  const onNew = useCallback(createOnNewHandler(protocols, setMessages, setIsRunning, transformMessages, logger), [
+    protocols,
+    transformMessages,
+    logger,
+  ]);
 
-  const onReload = useCallback(() => {
-    return Promise.resolve();
-  }, []);
+  const onEdit = useCallback(createOnEditHandler(protocols, messages, setMessages, setIsRunning, transformMessages, logger), [
+    protocols,
+    messages,
+    transformMessages,
+    logger,
+  ]);
 
-  const getMessages = useCallback(() => {
-    return messages;
-  }, [messages]);
+  const onReload = useCallback(createOnReloadHandler(protocols, messages, setMessages, setIsRunning, transformMessages, logger), [
+    protocols,
+    messages,
+    transformMessages,
+    logger,
+  ]);
+
+  const onCancel = useCallback(createOnCancelHandler(protocols, setMessages, setIsRunning, transformMessages), [
+    protocols,
+    transformMessages,
+  ]);
+
+  const handleSetMessages = useCallback(
+    (newMessages: readonly PersonaMessage[]) => {
+      const processed = parseMessages([...newMessages]);
+      setMessages(transformMessages ? transformMessages(processed) : processed);
+    },
+    [transformMessages],
+  );
 
+  const getMessages = useCallback(() => messages, [messages]);
+
+  // Thread list adapter
+  const threadListAdapter = useMemo(() => {
+    if (!threads) return undefined;
+
+    return createThreadListAdapter(
+      currentThreadId,
+      threadList,
+      setCurrentThreadId,
+      setThreadList,
+      sessionStorage,
+      onThreadCreate,
+      onThreadSwitch,
+      onThreadArchive,
+      onThreadUnarchive,
+      onThreadDelete,
+      logger,
+    );
+  }, [
+    threads,
+    currentThreadId,
+    threadList,
+    sessionStorage,
+    onThreadCreate,
+    onThreadSwitch,
+    onThreadArchive,
+    onThreadUnarchive,
+    onThreadDelete,
+    logger,
+  ]);
+
+  // Create runtime
   const runtime = useExternalStoreRuntime({
     isRunning,
     messages,
     convertMessage,
+    setMessages: handleSetMessages,
     onNew,
+    onEdit,
     onCancel,
     onReload,
     adapters: {
       attachments: new CompositeAttachmentAdapter([new SimpleImageAttachmentAdapter()]),
+      ...(threadListAdapter ? { threadList: threadListAdapter } : {}),
     },
   });
 
@@ -325,79 +298,6 @@ function PersonaRuntimeProviderInner({
   );
 }
 
-function PersonaRuntimeProvider({ children, ...config }: PropsWithChildren<PersonaConfig>) {
+export function PersonaRuntimeProvider({ children, ...config }: PropsWithChildren<PersonaConfig>) {
   return <PersonaRuntimeProviderInner {...config}>{children}</PersonaRuntimeProviderInner>;
 }
-
-function usePersonaRuntime(): PersonaRuntimeContextType {
-  const context = useContext(PersonaRuntimeContext);
-  if (!context) {
-    throw new Error('usePersonaRuntime must be used within a PersonaRuntimeProvider');
-  }
-  return context;
-}
-
-/**
- * Retrieves a specific protocol instance from the PersonaRuntimeContext.
- *
- * @param protocol - The name of the protocol to use.
- * @returns {PersonaProtocol | null} - The protocol instance or null if not found.
- * @throws {Error} - If the hook is used outside of a PersonaRuntimeProvider.
- */
-function usePersonaRuntimeProtocol(protocol: string): PersonaProtocol | null {
-  const context = useContext(PersonaRuntimeContext);
-  if (!context) {
-    throw new Error('usePersonaRuntimeProtocol must be used within a PersonaRuntimeProvider');
-  }
-
-  const protocolInstance = context.protocols.find((p) => p.getName() === protocol);
-  if (!protocolInstance) {
-    return null;
-  }
-
-  const status = context.protocolsStatus.get(protocolInstance.getName());
-
-  return {
-    ...protocolInstance,
-    connect: protocolInstance.connect.bind(protocolInstance),
-    disconnect: protocolInstance.disconnect.bind(protocolInstance),
-    sendPacket: protocolInstance.sendPacket.bind(protocolInstance),
-    setSession: protocolInstance.setSession.bind(protocolInstance),
-    addStatusChangeListener: protocolInstance.addStatusChangeListener.bind(protocolInstance),
-    addPacketListener: protocolInstance.addPacketListener.bind(protocolInstance),
-    getName: protocolInstance.getName.bind(protocolInstance),
-    getPriority: protocolInstance.getPriority.bind(protocolInstance),
-    status: status || protocolInstance.status,
-  };
-}
-
-function usePersonaRuntimeEndpoint(): string | null {
-  const context = useContext(PersonaRuntimeContext);
-  if (!context) {
-    throw new Error('usePersonaRuntimeEndpoint must be used within a PersonaRuntimeProvider');
-  }
-
-  return getFirstAvailableProtocolEndpoint(context.protocols);
-}
-
-function usePersonaRuntimeWebRTCProtocol(): PersonaWebRTCProtocol | null {
-  return usePersonaRuntimeProtocol('webrtc') as PersonaWebRTCProtocol;
-}
-
-function usePersonaRuntimeMessages(): PersonaMessage[] {
-  const context = useContext(PersonaRuntimeContext);
-  if (!context) {
-    throw new Error('usePersonaRuntimeMessages must be used within a PersonaRuntimeProvider');
-  }
-  return context.getMessages();
-}
-
-export {
-  PersonaRuntimeProvider,
-  usePersonaRuntimeEndpoint,
-  usePersonaRuntime,
-  usePersonaRuntimeProtocol,
-  usePersonaRuntimeWebRTCProtocol,
-  usePersonaRuntimeMessages,
-};
-export type { PersonaMessage, PersonaResponse };

package/src/storage/base.ts

@@ -0,0 +1,21 @@
+import type { PersonaMessage, Session, ThreadData } from '../types';
+
+/**
+ * Storage interface for messages with thread management support.
+ */
+export interface SessionStorage {
+  /**
+   * Sync messages for a specific session (load existing messages)
+   */
+  sync(sessionId: Session): Promise<PersonaMessage[]>;
+
+  /**
+   * Remove messages for a specific session (if supported)
+   */
+  remove(sessionId: Session): Promise<void>;
+
+  /**
+   * List all threads for a specific user
+   */
+  list(agentId: string, userId?: string): Promise<ThreadData[]>;
+}

package/src/storage/index.ts

@@ -0,0 +1,2 @@
+export * from './base';
+export * from './persona';