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

package/src/storage/persona.ts

@@ -0,0 +1,132 @@
+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 remove(sessionId: Session): Promise<void> {
+    if (!sessionId) return;
+    const url = `${this.endpoint}/sessions/${encodeURIComponent(String(sessionId))}`;
+    try {
+      const res = await fetch(url, { method: 'DELETE', headers: this.buildHeaders() });
+      if (!res.ok) {
+        const text = await res.text();
+        this.logger?.warn('PersonaSessionStorage: failed to delete session', res.status, text);
+        throw new Error(`Failed to delete session: ${res.status}`);
+      }
+      return;
+    } catch (err) {
+      this.logger?.warn('PersonaSessionStorage: error deleting session', err);
+      throw err;
+    }
+  }
+
+  async clearAll(): Promise<void> {
+    return Promise.reject(new Error('PersonaAPIMessageStorage: clearAll not supported'));
+  }
+
+  /**
+   * List all threads for a specific user from the Persona REST API
+   * GET /sessions?userId={userId}&page=1&size=100
+   */
+  async list(agentId: string, userId?: string): Promise<ThreadData[]> {
+    const params = new URLSearchParams({ page: '1', size: '100' });
+    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) {
+        this.logger?.warn('PersonaSessionStorage: failed to list sessions', res.status);
+        return [];
+      }
+
+      const data = await res.json();
+      if (!Array.isArray(data.items)) return [];
+      const threads: import('../types').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) {
+      this.logger?.warn('PersonaSessionStorage: error listing sessions', err);
+      return [];
+    }
+  }
+}

package/src/types.ts

@@ -1,7 +1,10 @@
 import { PersonaTools } from 'src/protocol';
-import { PersonaLogger } from './logging';
 import { ReactNode } from 'react';
 import type { ToolInstance } from './tools';
+import type { PersonaLogger } from './logging';
+import type { SessionStorage } from './storage';
+
+export type { PersonaLogger, SessionStorage };
 
 export type ReadonlyJSONObject = {
   readonly [key: string]: string | number | boolean | null | ReadonlyJSONObject | ReadonlyArray<ReadonlyJSONObject>;
@@ -97,7 +100,7 @@ export type PersonaMessage = {
   id?: string | null;
   protocol?: string;
   thought?: string;
-  text: string; //todo: puo essere null
+  text: string;
   image?: PersonaImage;
   type: 'reasoning' | 'text' | 'transaction' | 'command';
   role: 'user' | 'assistant' | 'function';
@@ -108,6 +111,12 @@ export type PersonaMessage = {
   functionCalls?: FunctionCall[];
   functionResponse?: FunctionResponse;
   status?: { type: 'running' | 'complete' | 'incomplete' };
+  // ThreadMessageLike compatible fields
+  createdAt?: Date;
+  metadata?: {
+    custom?: Record<string, unknown>;
+    [key: string]: unknown;
+  };
 };
 
 export type ModelResponse = {
@@ -133,6 +142,12 @@ export type Session = string | null | undefined;
 
 export type TransformMessages = (messages: PersonaMessage[]) => PersonaMessage[];
 
+export type ThreadData = {
+  threadId: string;
+  title?: string;
+  status: 'regular' | 'archived';
+};
+
 export type MessageListenerCallback = (message: PersonaPacket) => void;
 export type StatusChangeCallback = (status: ProtocolStatus) => void;
 
@@ -142,6 +157,7 @@ export type PersonaProtocolBaseConfig = {
   logger?: PersonaLogger;
   apiKey: string;
   agentId: string;
+  userId?: string;
 };
 
 export interface PersonaProtocol {
@@ -195,4 +211,50 @@ export type PersonaConfig = PersonaBaseConfig &
      * Optional message transform function that processes messages before they are displayed
      */
     transformMessages?: TransformMessages;
+
+    /**
+     * Enable thread management support
+     */
+    enableThreads?: boolean;
+
+    /**
+     * Session storage implementation
+     * If not provided, defaults to PersonaSessionStorage
+     */
+    sessionStorage?: SessionStorage;
+
+    /**
+     * Initial thread list (if thread management is enabled)
+     */
+    initialThreads?: ThreadData[];
+
+    /**
+     * Callback when a new thread is created
+     */
+    onThreadCreate?: (threadId: string) => void;
+
+    /**
+     * Callback when switching to a thread
+     */
+    onThreadSwitch?: (threadId: string) => void;
+
+    /**
+     * Callback when a thread is renamed
+     */
+    onThreadRename?: (threadId: string, newTitle: string) => void;
+
+    /**
+     * Callback when a thread is archived
+     */
+    onThreadArchive?: (threadId: string) => void;
+
+    /**
+     * Callback when a thread is unarchived
+     */
+    onThreadUnarchive?: (threadId: string) => void;
+
+    /**
+     * Callback when a thread is deleted
+     */
+    onThreadDelete?: (threadId: string) => void;
   };

package/vite.config.ts

@@ -18,7 +18,13 @@ export default defineConfig((configEnv: ConfigEnv) => {
         fileName: (format: string) => `bundle.${format}.js`,
       },
       rollupOptions: {
-        external: Object.keys(packageJson.peerDependencies),
+        external: [
+          ...Object.keys(packageJson.peerDependencies),
+          ...Object.keys(packageJson.dependencies || {}),
+          /^react\//,
+          /^react-dom\//,
+          /^@radix-ui\//,
+        ],
         input: resolve(__dirname, 'src', 'index.ts'),
         output: {
           globals: {
@@ -27,6 +33,10 @@ export default defineConfig((configEnv: ConfigEnv) => {
             'react/jsx-runtime': 'React',
             'react/jsx-dev-runtime': 'React',
             '@assistant-ui/react': 'AssistantUI',
+            '@radix-ui/react-dialog': 'RadixDialog',
+            '@radix-ui/react-slot': 'RadixSlot',
+            'rehype-raw': 'rehypeRaw',
+            zustand: 'zustand',
           },
         },
       },