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

package/src/runtime/handlers.ts

@@ -0,0 +1,322 @@
+import { AppendMessage } from '@assistant-ui/react';
+import { StartRunConfig } from '@assistant-ui/react/dist/legacy-runtime/runtime-cores/core/ThreadRuntimeCore';
+import { PersonaProtocol, PersonaMessage, TransformMessages } from '../types';
+import type { PersonaLogger } from '../logging';
+import { parseMessages } from '../messages';
+import { fileToBase64 } from './utils';
+
+/**
+ * Creates the onNew handler for new messages
+ */
+export function createOnNewHandler(
+  protocols: PersonaProtocol[],
+  setMessages: React.Dispatch<React.SetStateAction<PersonaMessage[]>>,
+  setIsRunning: React.Dispatch<React.SetStateAction<boolean>>,
+  transformMessages?: TransformMessages,
+  logger?: PersonaLogger,
+) {
+  return async (message: AppendMessage) => {
+    const textPart = (message.content as Array<{ type: string; text?: string }>).find((c) => c.type === 'text');
+    const hasAttachments = message.attachments && message.attachments.length > 0;
+
+    if (!textPart && !hasAttachments) {
+      throw new Error('Message must contain text or attachments');
+    }
+
+    const ready = protocols.some((protocol) => protocol.getName() !== 'transaction' && protocol.status === 'connected');
+
+    if (!ready) {
+      setMessages((currentConversation) => {
+        const errorMessage: PersonaMessage = {
+          role: 'assistant',
+          type: 'text',
+          text: 'No protocol is connected.',
+          createdAt: new Date(),
+          finishReason: 'stop',
+        };
+        const newMessages = [...currentConversation, errorMessage];
+        return transformMessages ? transformMessages(newMessages) : newMessages;
+      });
+      return;
+    }
+
+    const input = textPart?.type === 'text' ? textPart.text ?? '' : '';
+    const userMessage: PersonaMessage = {
+      role: 'user',
+      type: 'text',
+      text: input,
+      createdAt: new Date(),
+    };
+
+    setMessages((currentConversation) => {
+      const newMessages = parseMessages([...currentConversation, userMessage]);
+      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',
+            createdAt: new Date(),
+          });
+        } else if (attachment.content) {
+          // Check for text content (from SimpleTextAttachmentAdapter)
+          const textPart = attachment.content.find((c) => c.type === 'text');
+          if (textPart && 'text' in textPart) {
+            content.push({
+              role: 'user',
+              file: {
+                name: attachment.name,
+                contentType: attachment.contentType,
+              },
+              text: textPart.text,
+              type: 'text',
+              createdAt: new Date(),
+            });
+          }
+          // Check for file content with base64 data (from SimpleFileAttachmentAdapter)
+          const filePart = attachment.content.find((c) => c.type === 'file');
+          if (filePart && 'data' in filePart) {
+            content.push({
+              role: 'user',
+              file: {
+                name: attachment.name,
+                base64: (filePart as { data: string }).data,
+                contentType: attachment.contentType,
+              },
+              text: '',
+              type: 'text',
+              createdAt: new Date(),
+            });
+          }
+        } else if (attachment.file) {
+          // Fallback: any file with no processed content — read as base64
+          content.push({
+            role: 'user',
+            file: {
+              name: attachment.name,
+              base64: await fileToBase64(attachment.file),
+              contentType: attachment.contentType || 'application/octet-stream',
+            },
+            text: '',
+            type: 'text',
+            createdAt: new Date(),
+          });
+        }
+      }
+    }
+
+    if (input) {
+      content.push({
+        role: 'user',
+        text: input,
+        type: 'text',
+        createdAt: new Date(),
+      });
+    }
+
+    logger?.debug('Sending message:', content);
+    await protocol?.sendPacket({ type: 'request', payload: content });
+  };
+}
+
+/**
+ * Creates the onEdit handler for editing messages
+ */
+export function createOnEditHandler(
+  protocols: PersonaProtocol[],
+  messages: PersonaMessage[],
+  setMessages: React.Dispatch<React.SetStateAction<PersonaMessage[]>>,
+  setIsRunning: React.Dispatch<React.SetStateAction<boolean>>,
+  transformMessages?: TransformMessages,
+  logger?: PersonaLogger,
+) {
+  return async (message: AppendMessage) => {
+    if (message.content[0]?.type !== 'text') {
+      throw new Error('Only text messages are supported');
+    }
+
+    const protocol = protocols.sort((a, b) => b.getPriority() - a.getPriority()).find((protocol) => protocol.status === 'connected');
+
+    if (!protocol) {
+      logger?.debug('No protocol available for edit');
+      return;
+    }
+
+    const parentId = message.parentId;
+    if (!parentId) {
+      logger?.debug('No parent ID provided for edit');
+      return;
+    }
+
+    const parentIndex = messages.findIndex((m) => m.id === parentId);
+    if (parentIndex === -1) {
+      logger?.debug('Parent message not found:', parentId);
+      return;
+    }
+
+    const messagesToKeep = messages.slice(0, parentIndex + 1);
+    const editedMessage: PersonaMessage = {
+      role: 'user',
+      text: message.content[0].text,
+      type: 'text',
+      createdAt: new Date(),
+    };
+
+    const newMessages = parseMessages([...messagesToKeep, editedMessage]);
+    setMessages(transformMessages ? transformMessages(newMessages) : newMessages);
+
+    setIsRunning(true);
+
+    const content: Array<PersonaMessage> = [
+      {
+        role: 'user',
+        text: message.content[0].text,
+        type: 'text',
+        createdAt: new Date(),
+      },
+    ];
+
+    logger?.debug('Sending edited message:', content);
+    await protocol.sendPacket({ type: 'request', payload: content });
+  };
+}
+
+/**
+ * Creates the onReload handler for regenerating messages
+ */
+export function createOnReloadHandler(
+  protocols: PersonaProtocol[],
+  messages: PersonaMessage[],
+  setMessages: React.Dispatch<React.SetStateAction<PersonaMessage[]>>,
+  setIsRunning: React.Dispatch<React.SetStateAction<boolean>>,
+  transformMessages?: TransformMessages,
+  logger?: PersonaLogger,
+) {
+  return async (parentId: string | null, config: StartRunConfig) => {
+    const protocol = protocols.sort((a, b) => b.getPriority() - a.getPriority()).find((protocol) => protocol.status === 'connected');
+
+    if (!protocol) {
+      logger?.debug('No protocol available for reload');
+      return;
+    }
+
+    const actualParentId = config.parentId ?? parentId;
+    if (!actualParentId) {
+      logger?.debug('No parent ID provided for reload');
+      return;
+    }
+
+    const parentIndex = messages.findIndex((msg) => msg.id === actualParentId);
+    if (parentIndex === -1) {
+      logger?.debug('Parent message not found:', actualParentId);
+      return;
+    }
+
+    const parentMessage = messages[parentIndex];
+
+    setMessages((currentMessages) => {
+      const messagesToKeep = currentMessages.slice(0, parentIndex + 1);
+      return transformMessages ? transformMessages(messagesToKeep) : messagesToKeep;
+    });
+
+    let userMessage: PersonaMessage | undefined;
+    if (parentMessage.role === 'assistant' || parentMessage.role === 'function') {
+      for (let i = parentIndex - 1; i >= 0; i--) {
+        if (messages[i].role === 'user') {
+          userMessage = messages[i];
+          break;
+        }
+      }
+    } else if (parentMessage.role === 'user') {
+      userMessage = parentMessage;
+    }
+
+    if (!userMessage) {
+      logger?.debug('No user message found to regenerate from');
+      return;
+    }
+
+    setIsRunning(true);
+
+    const content: Array<PersonaMessage> = [];
+
+    if (userMessage.image) {
+      content.push({
+        role: 'user',
+        image: userMessage.image,
+        text: '',
+        type: 'text',
+        createdAt: new Date(),
+      });
+    }
+
+    content.push({
+      role: 'user',
+      text: userMessage.text,
+      type: 'text',
+      createdAt: new Date(),
+    });
+
+    logger?.debug('Regenerating message with config:', {
+      actualParentId,
+      sourceId: config.sourceId,
+      custom: config.runConfig.custom,
+    });
+    await protocol.sendPacket({ type: 'request', payload: content });
+  };
+}
+
+/**
+ * Creates the onCancel handler for cancelling message generation
+ */
+export function createOnCancelHandler(
+  protocols: PersonaProtocol[],
+  setMessages: React.Dispatch<React.SetStateAction<PersonaMessage[]>>,
+  setIsRunning: React.Dispatch<React.SetStateAction<boolean>>,
+  transformMessages?: TransformMessages,
+) {
+  return () => {
+    setIsRunning(false);
+
+    setMessages((currentMessages) => {
+      const lastMessage = currentMessages[currentMessages.length - 1];
+      if (lastMessage?.role === 'assistant' && !lastMessage.finishReason) {
+        const updatedMessages = [...currentMessages];
+        updatedMessages[updatedMessages.length - 1] = {
+          ...lastMessage,
+          finishReason: 'stop',
+          status: { type: 'incomplete' },
+        };
+        return transformMessages ? transformMessages(updatedMessages) : updatedMessages;
+      }
+      return currentMessages;
+    });
+
+    protocols.forEach((protocol) => {
+      if (protocol.status === 'connected') {
+        protocol
+          .sendPacket({
+            type: 'command',
+            payload: { command: 'set_initial_context', arguments: { cancel: true } },
+          })
+          .catch(() => {});
+      }
+    });
+
+    return Promise.resolve();
+  };
+}

package/src/runtime/index.ts

@@ -0,0 +1,6 @@
+export * from './context';
+export * from './utils';
+export * from './protocols';
+export * from './handlers';
+export * from './listeners';
+export * from './threads';

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,105 @@
+import { ThreadData } from '../types';
+import type { SessionStorage } from '../storage';
+
+const DEFAULT_THREAD_ID = 'DEFAULT_THREAD_ID';
+/**
+ * Generates a new session ID
+ */
+export function generateSessionId(): string {
+  const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+  let sid = '';
+  for (let i = 0; i < 8; 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,
+) {
+  return {
+    threadId: currentThreadId,
+    threads: threadList
+      .filter((t) => t.status === 'regular')
+      .map((t) => ({
+        id: t.threadId,
+        threadId: t.threadId,
+        title: t.title || `Session ${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();
+      const newThread = {
+        threadId: newId,
+        status: 'regular' as const,
+        title: `Session ${newId}`,
+      };
+
+      setThreadList((prev) => [newThread, ...prev]);
+      setCurrentThreadId(newId);
+      onThreadCreate?.(newId);
+    },
+
+    onSwitchToThread: (threadId: string) => {
+      setCurrentThreadId(threadId);
+      onThreadSwitch?.(threadId);
+    },
+
+    onArchive: (threadId: string) => {
+      setThreadList((p) => p.map((t) => (t.threadId === threadId ? { ...t, status: 'archived' as const } : t)));
+      onThreadArchive?.(threadId);
+      if (threadId === DEFAULT_THREAD_ID) {
+        return;
+      }
+      storage.archive(threadId);
+    },
+
+    onUnarchive: (threadId: string) => {
+      setThreadList((prev) => prev.map((t) => (t.threadId === threadId ? { ...t, status: 'regular' as const } : t)));
+      onThreadUnarchive?.(threadId);
+    },
+
+    onDelete: async (threadId: string) => {
+      setThreadList((prev) => prev.filter((t) => t.threadId !== threadId));
+      if (currentThreadId === threadId) {
+        const remaining = threadList.filter((t) => t.threadId !== threadId && t.status === 'regular');
+        if (remaining.length > 0) {
+          setCurrentThreadId(remaining[0].threadId);
+        }
+      }
+      onThreadDelete?.(threadId);
+      if (threadId === DEFAULT_THREAD_ID) {
+        return;
+      }
+      await storage.delete(threadId);
+    },
+  };
+}
+
+/**
+ * Generates a default thread ID
+ */
+export function generateDefaultThreadId(): string {
+  return `thread-${Date.now()}`;
+}