@applica-software-guru/persona-chat-sdk 0.1.102

package/src/runtime/utils.ts

@@ -0,0 +1,46 @@
+import type { PersonaProtocol } from '../types';
+import { PersonaRESTProtocol, PersonaWebRTCProtocol, PersonaWebSocketProtocol } from '../protocol';
+
+/**
+ * Converts a File object to a base64 string
+ */
+export function fileToBase64(file: File): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.readAsDataURL(file);
+
+    reader.onload = () => {
+      const base64 = reader.result as string;
+      const base64WithoutPrefix = base64.split(';base64,')[1];
+      resolve(base64WithoutPrefix);
+    };
+
+    reader.onerror = (error) => {
+      reject(error);
+    };
+  });
+}
+
+/**
+ * Extracts the first available protocol endpoint URL
+ */
+export 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;
+}

package/src/runtime.tsx

@@ -0,0 +1,334 @@
+import { useState, useEffect, useCallback, PropsWithChildren, useMemo, useRef } from 'react';
+import {
+  useExternalStoreRuntime,
+  AssistantRuntimeProvider,
+  CompositeAttachmentAdapter,
+  SimpleImageAttachmentAdapter,
+  SimpleTextAttachmentAdapter,
+} from '@assistant-ui/react';
+import { SimpleFileAttachmentAdapter } from './runtime/file-attachment-adapter';
+import { PersonaConfig, PersonaMessage, PersonaResponse, ProtocolStatus, Session, ThreadData } from './types';
+import { parseMessages, convertMessage } from './messages';
+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';
+
+export {
+  usePersonaRuntime,
+  usePersonaRuntimeProtocol,
+  usePersonaRuntimeEndpoint,
+  usePersonaRuntimeWebRTCProtocol,
+  usePersonaRuntimeMessages,
+} from './runtime/context';
+
+export type { PersonaMessage, PersonaResponse, ThreadData };
+
+function PersonaRuntimeProviderInner({
+  dev = false,
+  baseUrl,
+  protocols: _protocols,
+  logger,
+  children,
+  session: initialSession = 'new',
+  transformMessages,
+  threads = false,
+  sessionStorage: _sessionStorage,
+  onThreadCreate,
+  onThreadSwitch,
+  onThreadRename,
+  onThreadArchive,
+  onThreadUnarchive,
+  onThreadDelete,
+  enableAttachments = false,
+  ...config
+}: Readonly<PersonaConfig>) {
+  const [isRunning, setIsRunning] = useState(false);
+  const [messages, setMessages] = useState<PersonaMessage[]>([]);
+  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],
+  );
+
+  // Thread management state
+  const [threadList, setThreadList] = useState<ThreadData[]>([]);
+  const [currentThreadId, setCurrentThreadId] = useState<string>('');
+
+  // 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 (!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(
+      'Setting up protocols:',
+      protocols.map((p) => p.getName()),
+    );
+    protocols.forEach((protocol) => {
+      protocol.setSession(currentThreadRef.current);
+      protocol.clearListeners();
+
+      // Status change listener
+      protocol.addStatusChangeListener((status: ProtocolStatus) => {
+        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 },
+              })
+              .catch(() => {});
+          }
+
+          if (config.tools && Array.isArray(config.tools)) {
+            protocol
+              .sendPacket({
+                type: 'command',
+                payload: { command: 'set_local_tools', arguments: { tools: config.tools.map((t) => t.schema) } },
+              })
+              .catch(() => {});
+          }
+        }
+      });
+
+      // Packet listener
+      protocol.addPacketListener(createPacketListener(protocol, setMessages, setIsRunning, protocols, transformMessages));
+
+      // Auto-connect if configured
+      if (protocol.autostart && protocol.status === 'disconnected') {
+        logger?.debug(`Auto-connecting protocol: ${protocol.getName()}`);
+        protocol.connect(currentThreadRef.current).catch(() => {});
+        setIsRunning(false);
+      }
+    });
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []); // Run only once
+
+  // Load messages for an existing session on mount (without threads)
+  useEffect(() => {
+    if (threads || !initialSession || initialSession === 'new') {
+      return;
+    }
+
+    sessionStorage
+      .sync(initialSession)
+      .then((loadedMessages) => {
+        if (loadedMessages.length > 0) {
+          const processed = parseMessages(loadedMessages);
+          setMessages(transformMessages ? transformMessages(processed) : processed);
+          logger?.debug(`Loaded ${loadedMessages.length} messages for session ${initialSession}`);
+        }
+      })
+      .catch((error) => {
+        logger?.error('Failed to load session messages:', error);
+      });
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []); // Run only once on mount
+
+  // Handle thread switching
+  useEffect(() => {
+    if (!threads || !currentThreadId) {
+      setMessages([]);
+      return;
+    }
+
+    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;
+      }
+    };
+
+    switchThread();
+  }, [currentThreadId, threads, protocols, sessionStorage, transformMessages, logger]);
+
+  // Message handlers
+  const onNew = useCallback(createOnNewHandler(protocols, setMessages, setIsRunning, transformMessages, logger), [
+    protocols,
+    transformMessages,
+    logger,
+  ]);
+
+  const onEdit = useCallback(createOnEditHandler(protocols, messages, setMessages, setIsRunning, transformMessages, logger), [
+    protocols,
+    messages,
+    transformMessages,
+    logger,
+  ]);
+
+  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,
+    );
+  }, [
+    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: {
+      ...(enableAttachments
+        ? {
+            attachments: new CompositeAttachmentAdapter([
+              new SimpleImageAttachmentAdapter(),
+              new SimpleTextAttachmentAdapter(),
+              new SimpleFileAttachmentAdapter(),
+            ]),
+          }
+        : {}),
+      ...(threadListAdapter ? { threadList: threadListAdapter } : {}),
+    },
+  });
+
+  return (
+    <PersonaRuntimeContext.Provider value={{ protocols, protocolsStatus, getMessages }}>
+      <AssistantRuntimeProvider runtime={runtime}>{children}</AssistantRuntimeProvider>
+    </PersonaRuntimeContext.Provider>
+  );
+}
+
+export function PersonaRuntimeProvider({ children, ...config }: PropsWithChildren<PersonaConfig>) {
+  return <PersonaRuntimeProviderInner {...config}>{children}</PersonaRuntimeProviderInner>;
+}

package/src/storage/base.ts

@@ -0,0 +1,13 @@
+import type { PersonaMessage, Session, ThreadData } from '../types';
+
+export interface SessionStorage {
+  sync(sessionId: Session): Promise<PersonaMessage[]>;
+
+  archive(sessionId: Session): Promise<void>;
+
+  unarchive(sessionId: Session): Promise<void>;
+
+  delete(sessionId: Session): Promise<void>;
+
+  list(agentId: string, userId?: string): Promise<ThreadData[]>;
+}

package/src/storage/index.ts

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

package/src/storage/persona.ts

@@ -0,0 +1,138 @@
+import type { PersonaMessage, Session, ThreadData } from '../types';
+import type { SessionStorage } from './base';
+import type { PersonaLogger } from '../logging';
+
+type PersonaSessionStorageOptions = {
+  endpoint: string;
+  apiKey?: string;
+  pageSize?: number;
+  logger?: PersonaLogger;
+};
+
+export class PersonaSessionStorage implements SessionStorage {
+  private endpoint: string;
+  private apiKey?: string;
+  private pageSize: number;
+  private logger?: PersonaLogger;
+
+  constructor(opts: PersonaSessionStorageOptions) {
+    this.endpoint = opts.endpoint.replace(/\/$/, '');
+    this.apiKey = opts.apiKey;
+    this.pageSize = opts.pageSize ?? 200;
+    this.logger = opts.logger;
+  }
+
+  private buildHeaders() {
+    const headers: Record<string, string> = { 'Content-Type': 'application/json' };
+    if (this.apiKey) headers['x-persona-apikey'] = this.apiKey;
+    return headers;
+  }
+
+  /**
+   * Fetch messages for a session from the Persona REST API
+   */
+  async sync(sessionId: Session): Promise<PersonaMessage[]> {
+    if (!sessionId) return [];
+    const url = `${this.endpoint}/sessions/${encodeURIComponent(String(sessionId))}/messages?page=1&size=${this.pageSize}`;
+
+    try {
+      const res = await fetch(url, { method: 'GET', headers: this.buildHeaders() });
+      if (!res.ok) {
+        // Log and return empty list on error
+        this.logger?.warn('PersonaSessionStorage: failed to fetch messages', res.status, await res.text());
+        return [];
+      }
+
+      const data = await res.json();
+      if (!Array.isArray(data.items)) return [];
+
+      // Try to normalize createdAt strings to Date objects
+      const messages: PersonaMessage[] = data.items.map((m: any) => {
+        const msg: PersonaMessage = {
+          id: m.id ?? m.messageId ?? undefined,
+          protocol: m.protocol,
+          thought: m.thought,
+          text: m.text ?? '',
+          image: m.image,
+          type: m.type ?? 'text',
+          role: m.role ?? 'assistant',
+          file: m.file,
+          sources: m.sources,
+          sessionId: m.sessionId ?? sessionId,
+          finishReason: m.finishReason,
+          functionCalls: m.functionCalls,
+          functionResponse: m.functionResponse,
+          status: m.status,
+          createdAt: m.createdAt ? new Date(m.createdAt) : undefined,
+          metadata: m.metadata,
+        };
+        return msg;
+      });
+
+      return messages;
+    } catch (err) {
+      // Network or parsing error
+      this.logger?.warn('PersonaSessionStorage: error fetching messages', err);
+      return [];
+    }
+  }
+
+  async archive(sessionId: Session): Promise<void> {
+    return this._visiblility(sessionId, 'archived');
+  }
+
+  async unarchive(sessionId: Session): Promise<void> {
+    return this._visiblility(sessionId, 'active');
+  }
+
+  async delete(sessionId: Session): Promise<void> {
+    return this._visiblility(sessionId, 'deleted');
+  }
+
+  async _visiblility(sessionId: Session, visibility: 'active' | 'deleted' | 'archived'): Promise<void> {
+    if (!sessionId) return;
+    const url = `${this.endpoint}/sessions/${encodeURIComponent(String(sessionId))}/visibility`;
+    try {
+      const body = JSON.stringify({ visibility });
+      const res = await fetch(url, { method: 'PUT', headers: this.buildHeaders(), body });
+      if (!res.ok) {
+        const text = await res.text();
+        this.logger?.warn('PersonaSessionStorage: failed to set session visibility', res.status, text);
+        throw new Error(`Failed to set session visibility: ${res.status}`);
+      }
+      return;
+    } catch (err) {
+      throw err;
+    }
+  }
+
+  async clearAll(): Promise<void> {
+    return Promise.reject(new Error('PersonaAPIMessageStorage: clearAll not supported'));
+  }
+
+  async list(agentId: string, userId?: string): Promise<ThreadData[]> {
+    const params = new URLSearchParams({ page: '1', size: '100', visibility: 'active' });
+    if (userId) params.set('userId', userId);
+    if (agentId) params.set('agentId', agentId);
+
+    const url = `${this.endpoint}/sessions?${params.toString()}`;
+    try {
+      const res = await fetch(url, { method: 'GET', headers: this.buildHeaders() });
+      if (!res.ok) {
+        return [];
+      }
+
+      const data = await res.json();
+      if (!Array.isArray(data.items)) return [];
+      const threads: ThreadData[] = data.items.map((item: any) => ({
+        threadId: item.code || item.id,
+        title: item.title || `Session ${item.code || item.id}`,
+        status: item.status === 'archived' ? 'archived' : 'regular',
+      }));
+
+      return threads;
+    } catch (err) {
+      return [];
+    }
+  }
+}