@applica-software-guru/persona-sdk 0.1.83 → 0.1.85

package/src/runtime/listeners.ts

@@ -0,0 +1,79 @@
+import { PersonaPacket, PersonaMessage, PersonaReasoning, PersonaTransaction, PersonaProtocol, TransformMessages } from '../types';
+import { parseMessages } from '../messages';
+
+/**
+ * Creates packet listener for a protocol
+ */
+export function createPacketListener(
+  protocol: PersonaProtocol,
+  setMessages: React.Dispatch<React.SetStateAction<PersonaMessage[]>>,
+  setIsRunning: React.Dispatch<React.SetStateAction<boolean>>,
+  protocols: PersonaProtocol[],
+  transformMessages?: TransformMessages,
+) {
+  return (message: PersonaPacket) => {
+    if (message.type === 'message') {
+      handleMessagePacket(message.payload as PersonaMessage, protocol, setMessages, setIsRunning, transformMessages);
+    } else if (message.type === 'reasoning') {
+      handleReasoningPacket(message.payload as PersonaReasoning, protocol, setMessages, transformMessages);
+    } else if (message.type === 'transaction') {
+      handleTransactionPacket(message.payload as PersonaTransaction, protocol, protocols);
+    }
+  };
+}
+
+function handleMessagePacket(
+  personaMessage: PersonaMessage,
+  protocol: PersonaProtocol,
+  setMessages: React.Dispatch<React.SetStateAction<PersonaMessage[]>>,
+  setIsRunning: React.Dispatch<React.SetStateAction<boolean>>,
+  transformMessages?: TransformMessages,
+) {
+  // Ensure message has proper timestamp
+  if (!personaMessage.createdAt) {
+    personaMessage.createdAt = new Date();
+  }
+
+  // Handle finish reason and update isRunning state
+  if (personaMessage?.finishReason === 'stop' && !personaMessage?.functionResponse && !personaMessage?.thought) {
+    setIsRunning(false);
+  }
+
+  // Convert thought to reasoning type
+  if (personaMessage.thought) {
+    personaMessage.type = 'reasoning';
+  }
+
+  // Add protocol information
+  personaMessage.protocol = protocol.getName();
+
+  setMessages((currentConversation) => {
+    const newMessages = parseMessages([...currentConversation, personaMessage]);
+    return transformMessages ? transformMessages(newMessages) : newMessages;
+  });
+}
+
+function handleReasoningPacket(
+  reasoning: PersonaReasoning,
+  protocol: PersonaProtocol,
+  setMessages: React.Dispatch<React.SetStateAction<PersonaMessage[]>>,
+  transformMessages?: TransformMessages,
+) {
+  const personaMessage: PersonaMessage = {
+    type: 'reasoning',
+    text: reasoning.thought,
+    role: 'assistant',
+    finishReason: 'stop',
+    protocol: protocol.getName(),
+    createdAt: new Date(),
+  };
+
+  setMessages((currentConversation) => {
+    const newMessages = parseMessages([...currentConversation, personaMessage]);
+    return transformMessages ? transformMessages(newMessages) : newMessages;
+  });
+}
+
+function handleTransactionPacket(transaction: PersonaTransaction, currentProtocol: PersonaProtocol, protocols: PersonaProtocol[]) {
+  protocols.filter((p) => p !== currentProtocol).forEach((p) => p.onTransaction(transaction));
+}

package/src/runtime/protocols.ts

@@ -0,0 +1,169 @@
+import { PersonaProtocol, PersonaProtocolBaseConfig, PersonaConfig } from '../types';
+import type { PersonaLogger } from '../logging';
+import {
+  PersonaRESTProtocol,
+  PersonaRESTProtocolConfig,
+  PersonaTransactionProtocol,
+  PersonaWebRTCProtocol,
+  PersonaWebRTCProtocolConfig,
+  PersonaWebSocketProtocol,
+  PersonaWebSocketProtocolConfig,
+} from '../protocol';
+
+type ProtocolsConfig = PersonaConfig['protocols'];
+
+/**
+ * Initializes protocols based on configuration
+ */
+export function initializeProtocols(
+  _protocols: ProtocolsConfig,
+  config: {
+    dev: boolean;
+    baseUrl?: string;
+    apiKey: string;
+    agentId: string;
+    userId?: string;
+    tools?: PersonaConfig['tools'];
+    logger?: PersonaLogger;
+  },
+): PersonaProtocol[] {
+  if (Array.isArray(_protocols)) {
+    return _protocols;
+  }
+
+  if (typeof _protocols === 'object' && _protocols !== null) {
+    const baseEndpoint = config.dev ? 'localhost:8000' : config.baseUrl || 'persona.applica.guru/api';
+    const baseEndpointProtocol = config.dev ? 'http' : 'https';
+    const baseWebSocketProtocol = config.dev ? 'ws' : 'wss';
+
+    let availableProtocols = Object.keys(_protocols)
+      .map((key) => {
+        switch (key) {
+          case 'rest':
+            return createRESTProtocol(_protocols[key], {
+              baseEndpointProtocol,
+              baseEndpoint,
+              apiKey: config.apiKey,
+              agentId: config.agentId,
+              userId: config.userId,
+              logger: config.logger,
+            });
+
+          case 'webrtc':
+            return createWebRTCProtocol(_protocols[key], {
+              baseWebSocketProtocol,
+              baseEndpoint,
+              apiKey: config.apiKey,
+              agentId: config.agentId,
+              userId: config.userId,
+              logger: config.logger,
+            });
+
+          case 'websocket':
+            return createWebSocketProtocol(_protocols[key], {
+              baseWebSocketProtocol,
+              baseEndpoint,
+              apiKey: config.apiKey,
+              agentId: config.agentId,
+              userId: config.userId,
+              logger: config.logger,
+            });
+
+          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,
+          logger: config.logger,
+        }),
+      );
+    }
+
+    return availableProtocols;
+  }
+
+  throw new Error('Invalid protocols configuration');
+}
+
+function createRESTProtocol(
+  config: PersonaProtocolBaseConfig | boolean | undefined,
+  baseConfig: {
+    baseEndpointProtocol: string;
+    baseEndpoint: string;
+    apiKey: string;
+    agentId: string;
+    userId?: string;
+    logger?: PersonaLogger;
+  },
+): PersonaRESTProtocol | null {
+  if (config === true) {
+    return new PersonaRESTProtocol({
+      apiUrl: `${baseConfig.baseEndpointProtocol}://${baseConfig.baseEndpoint}`,
+      apiKey: baseConfig.apiKey,
+      agentId: baseConfig.agentId,
+      userId: baseConfig.userId,
+      logger: baseConfig.logger,
+    });
+  } else if (typeof config === 'object' && config !== null) {
+    return new PersonaRESTProtocol(config as PersonaRESTProtocolConfig);
+  }
+  return null;
+}
+
+function createWebRTCProtocol(
+  config: PersonaProtocolBaseConfig | boolean | undefined,
+  baseConfig: {
+    baseWebSocketProtocol: string;
+    baseEndpoint: string;
+    apiKey: string;
+    agentId: string;
+    userId?: string;
+    logger?: PersonaLogger;
+  },
+): PersonaWebRTCProtocol | null {
+  if (config === true) {
+    return new PersonaWebRTCProtocol({
+      webrtcUrl: `${baseConfig.baseWebSocketProtocol}://${baseConfig.baseEndpoint}/webrtc`,
+      apiKey: baseConfig.apiKey,
+      agentId: baseConfig.agentId,
+      userId: baseConfig.userId,
+      logger: baseConfig.logger,
+    });
+  } else if (typeof config === 'object' && config !== null) {
+    return new PersonaWebRTCProtocol(config as PersonaWebRTCProtocolConfig);
+  }
+  return null;
+}
+
+function createWebSocketProtocol(
+  config: PersonaProtocolBaseConfig | boolean | undefined,
+  baseConfig: {
+    baseWebSocketProtocol: string;
+    baseEndpoint: string;
+    apiKey: string;
+    agentId: string;
+    userId?: string;
+    logger?: PersonaLogger;
+  },
+): PersonaWebSocketProtocol | null {
+  if (config === true) {
+    return new PersonaWebSocketProtocol({
+      webSocketUrl: `${baseConfig.baseWebSocketProtocol}://${baseConfig.baseEndpoint}/websocket`,
+      apiKey: baseConfig.apiKey,
+      agentId: baseConfig.agentId,
+      userId: baseConfig.userId,
+      logger: baseConfig.logger,
+    });
+  } else if (typeof config === 'object' && config !== null) {
+    return new PersonaWebSocketProtocol(config as PersonaWebSocketProtocolConfig);
+  }
+  return null;
+}

package/src/runtime/threads.ts

@@ -0,0 +1,120 @@
+import { ThreadData } from '../types';
+import type { PersonaLogger } from '../logging';
+import type { SessionStorage } from '../storage';
+
+/**
+ * Generates a new session ID
+ */
+export function generateSessionId(): string {
+  const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+  let sid = '';
+  for (let i = 0; i < 16; i++) {
+    sid += chars.charAt(Math.floor(Math.random() * chars.length));
+  }
+  return sid;
+}
+
+/**
+ * Creates the thread list adapter for multi-thread support
+ */
+export function createThreadListAdapter(
+  currentThreadId: string,
+  threadList: ThreadData[],
+  setCurrentThreadId: (id: string) => void,
+  setThreadList: React.Dispatch<React.SetStateAction<ThreadData[]>>,
+  storage: SessionStorage,
+  onThreadCreate?: (threadId: string) => void,
+  onThreadSwitch?: (threadId: string) => void,
+  onThreadArchive?: (threadId: string) => void,
+  onThreadUnarchive?: (threadId: string) => void,
+  onThreadDelete?: (threadId: string) => void,
+  logger?: PersonaLogger,
+) {
+  return {
+    threadId: currentThreadId,
+    threads: threadList
+      .filter((t) => t.status === 'regular')
+      .map((t) => ({
+        id: t.threadId,
+        threadId: t.threadId,
+        title: t.title || `Chat ${t.threadId}`,
+        status: t.status as 'regular',
+      })),
+    archivedThreads: threadList
+      .filter((t) => t.status === 'archived')
+      .map((t) => ({
+        id: t.threadId,
+        threadId: t.threadId,
+        title: t.title || `Archived Chat ${t.threadId}`,
+        status: t.status as 'archived',
+      })),
+
+    onSwitchToNewThread: () => {
+      const newId = generateSessionId();
+      logger?.debug('Creating new thread:', newId);
+
+      const newThread = {
+        threadId: newId,
+        status: 'regular' as const,
+        title: 'New Chat',
+      };
+
+      setThreadList((prev) => [newThread, ...prev]);
+      setCurrentThreadId(newId);
+
+      onThreadCreate?.(newId);
+    },
+
+    onSwitchToThread: (threadId: string) => {
+      logger?.debug('Switching to thread:', threadId);
+      setCurrentThreadId(threadId);
+      // Messages will be synced by the useEffect in runtime.tsx
+
+      onThreadSwitch?.(threadId);
+    },
+
+    onArchive: (threadId: string) => {
+      logger?.debug('Archiving thread:', threadId);
+      setThreadList((prev) => prev.map((t) => (t.threadId === threadId ? { ...t, status: 'archived' as const } : t)));
+
+      onThreadArchive?.(threadId);
+    },
+
+    onUnarchive: (threadId: string) => {
+      logger?.debug('Unarchiving thread:', threadId);
+      setThreadList((prev) => prev.map((t) => (t.threadId === threadId ? { ...t, status: 'regular' as const } : t)));
+
+      onThreadUnarchive?.(threadId);
+    },
+
+    onDelete: async (threadId: string) => {
+      logger?.debug('Deleting thread:', threadId);
+
+      // Remove from list
+      setThreadList((prev) => prev.filter((t) => t.threadId !== threadId));
+
+      // Switch to another thread if deleting current
+      if (currentThreadId === threadId) {
+        const remaining = threadList.filter((t) => t.threadId !== threadId && t.status === 'regular');
+        if (remaining.length > 0) {
+          setCurrentThreadId(remaining[0].threadId);
+        }
+      }
+
+      // Delete from backend (threadId = sessionId)
+      storage
+        .remove(threadId)
+        .then(() => logger?.debug('Thread deleted from backend'))
+        .catch((error) => logger?.error('Failed to delete thread:', error));
+
+      onThreadDelete?.(threadId);
+    },
+  };
+}
+
+/**
+ * Generates a default thread ID
+ */
+export function generateDefaultThreadId(): string {
+  return `thread-${Date.now()}`;
+}

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;
+}