@applica-software-guru/persona-sdk 0.1.46 → 0.1.48

package/src/protocol/transaction.ts

@@ -0,0 +1,154 @@
+import { PersonaProtocolBase } from './base';
+import {
+  Message,
+  Session,
+  ProtocolStatus,
+  PersonaProtocolBaseConfig,
+  PersonaTransaction,
+  FunctionCall,
+  ReadonlyJSONObject,
+} from '../types';
+
+type FinishTransactionRequest = {
+  success: boolean;
+  output: any;
+  error: string | null;
+};
+
+class PersonaTransactionsManager {
+  private config: PersonaTransactionProtocolConfig;
+
+  constructor(config: PersonaTransactionProtocolConfig) {
+    this.config = config;
+  }
+
+  async complete(transaction: PersonaTransaction, request: FinishTransactionRequest): Promise<void> {
+    await this.persist(transaction, { ...request, success: true });
+    this.config.logger?.debug('Transaction completed:', transaction);
+  }
+
+  async fail(transaction: PersonaTransaction, request: FinishTransactionRequest): Promise<void> {
+    await this.persist(transaction, { ...request, success: false });
+    this.config.logger?.debug('Transaction failed:', { ...transaction, ...request });
+  }
+
+  async persist(transaction: PersonaTransaction, request: FinishTransactionRequest): Promise<void> {
+    await fetch(`${this.config.apiUrl}/transactions/${transaction.id}`, {
+      body: JSON.stringify(request),
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        Accept: 'application/json',
+        'x-persona-apikey': this.config.apiKey,
+      },
+    });
+  }
+}
+
+export type PersonaToolCallback = (args: ReadonlyJSONObject | undefined) => void;
+export type PersonaTools = {
+  [key: string]: PersonaToolCallback;
+};
+
+class PersonaPersistableTransaction {
+  private transaction: PersonaTransaction;
+  private manager: PersonaTransactionsManager;
+
+  constructor(transaction: PersonaTransaction, manager: PersonaTransactionsManager) {
+    this.transaction = transaction;
+    this.manager = manager;
+  }
+
+  public getFunctionCall(): FunctionCall | null {
+    return this.transaction.functionCall;
+  }
+
+  async invoke(tools: PersonaTools): Promise<void> {
+    const functionCall = this.transaction.functionCall;
+    if (!functionCall) {
+      await this.fail('No function call found');
+      return;
+    }
+    const functionName = functionCall.name;
+    const functionArgs = functionCall.args;
+    const tool = tools[functionName];
+    if (!tool) {
+      await this.fail(`Tool ${functionName} not found`);
+      return;
+    }
+    try {
+      const result = await tool(functionArgs);
+      await this.complete({ date: new Date().toISOString(), result });
+    } catch (error) {
+      await this.fail(`Error executing tool ${functionName}: ${error}`);
+    }
+  }
+  async complete(output: any): Promise<void> {
+    await this.manager.complete(this.transaction, { success: true, output, error: null });
+  }
+  async fail(error: string): Promise<void> {
+    await this.manager.fail(this.transaction, { success: false, output: null, error });
+  }
+}
+
+type PersonaTransactionCallback = (transaction: PersonaPersistableTransaction) => void;
+
+type PersonaTransactionProtocolConfig = PersonaProtocolBaseConfig & {
+  apiUrl: string;
+  onTransaction: PersonaTransactionCallback;
+};
+
+class PersonaTransactionProtocol extends PersonaProtocolBase {
+  status: ProtocolStatus;
+  autostart: boolean;
+  session: Session;
+  config: PersonaTransactionProtocolConfig;
+  notify: boolean = true;
+
+  constructor(config: PersonaTransactionProtocolConfig) {
+    super();
+    this.config = config;
+    this.status = 'disconnected';
+    this.autostart = true;
+  }
+
+  public getName(): string {
+    return 'transaction';
+  }
+
+  public getPriority(): number {
+    return 0;
+  }
+
+  public async connect(session: Session): Promise<Session> {
+    this.setStatus('connected');
+    return session;
+  }
+
+  public async disconnect(): Promise<void> {
+    this.setStatus('disconnected');
+    this.session = null;
+  }
+
+  public async syncSession(session: Session): Promise<void> {
+    this.session = session;
+  }
+
+  public async send(message: Message): Promise<void> {
+    this.config.logger?.debug('Sending message:', message);
+    throw new Error('Not implemented');
+  }
+
+  public onTransaction(transaction: PersonaTransaction): void {
+    if (!this.config.onTransaction) {
+      this.config.logger?.error('Transaction protocol config is not set');
+      return;
+    }
+    const manager = new PersonaTransactionsManager(this.config);
+    const persistable = new PersonaPersistableTransaction(transaction, manager);
+    this.config.onTransaction(persistable);
+  }
+}
+
+export { PersonaTransactionProtocol };
+export type { PersonaTransactionProtocolConfig, FinishTransactionRequest, PersonaPersistableTransaction, PersonaTransactionCallback };

package/src/protocol/webrtc.ts

@@ -1,5 +1,5 @@
 import { PersonaProtocolBase } from './base';
-import { Message, PersonaMessage, PersonaProtocolBaseConfig, ProtocolStatus, Session } from '../types';
+import { Message, PersonaPayload, PersonaProtocolBaseConfig, ProtocolStatus, Session } from '../types';
 
 type AudioAnalysisData = {
   localAmplitude: number;
@@ -274,11 +274,8 @@ class PersonaWebRTCProtocol extends PersonaProtocolBase {
     this.autostart = config?.autostart ?? false;
     this.webRTCClient = new PersonaWebRTCClient(config);
     this.webRTCClient.addMessageCallback((msg: MessageEvent) => {
-      config.logger?.debug('Received data message:', msg.data);
-      const data = JSON.parse(msg.data) as { type: 'message' | unknown; payload: PersonaMessage | unknown };
-      if (data.type === 'message') {
-        this.notifyMessage(data.payload as PersonaMessage);
-      }
+      const data = JSON.parse(msg.data) as PersonaPayload;
+      this.notifyMessage(data);
     });
   }
 

package/src/protocol/websocket.ts

@@ -1,4 +1,4 @@
-import { Message, PersonaMessage, PersonaProtocolBaseConfig, ProtocolStatus, Session } from '../types';
+import { Message, PersonaPayload, PersonaProtocolBaseConfig, ProtocolStatus, Session } from '../types';
 import { PersonaProtocolBase } from './base';
 
 type PersonaWebSocketProtocolConfig = PersonaProtocolBaseConfig & {
@@ -56,14 +56,8 @@ class PersonaWebSocketProtocol extends PersonaProtocolBase {
       this.setStatus('connected');
     });
     this.webSocket.addEventListener('message', (event) => {
-      const data = JSON.parse(event.data) as { type: 'message' | unknown; payload: PersonaMessage | unknown };
-
-      if (data.type !== 'message') {
-        return;
-      }
-      const message = data.payload as PersonaMessage & { thought?: string };
-
-      this.notifyMessage(message?.thought ? { role: 'assistant', type: 'reasoning', text: message.thought } : message);
+      const data = JSON.parse(event.data) as PersonaPayload;
+      this.notifyMessage(data);
     });
     this.webSocket.addEventListener('close', () => {
       this.setStatus('disconnected');

package/src/runtime.tsx

@@ -3,16 +3,20 @@ import { useExternalStoreRuntime, AppendMessage, AssistantRuntimeProvider } from
 import {
   PersonaConfig,
   PersonaMessage,
+  PersonaPayload,
   PersonaProtocol,
   PersonaProtocolBaseConfig,
   PersonaResponse,
+  PersonaTransaction,
   ProtocolStatus,
   Session,
 } from './types';
 import { parseMessages, convertMessage } from './messages';
 import {
+  PersonaPersistableTransaction,
   PersonaRESTProtocol,
   PersonaRESTProtocolConfig,
+  PersonaTransactionProtocol,
   PersonaWebRTCProtocol,
   PersonaWebRTCProtocolConfig,
   PersonaWebSocketProtocol,
@@ -49,7 +53,7 @@ function PersonaRuntimeProviderInner({
       const baseEndpoint = dev ? 'localhost:8000' : 'persona.applica.guru/api';
       const baseEndpointProtocol = dev ? 'http' : 'https';
       const baseWebSocketProtocol = dev ? 'ws' : 'wss';
-      const availableProtocols = Object.keys(_protocols).map((key) => {
+      let availableProtocols = Object.keys(_protocols).map((key) => {
         switch (key) {
           case 'rest':
             const restConfig: PersonaProtocolBaseConfig | true | undefined = _protocols[key];
@@ -88,6 +92,20 @@ function PersonaRuntimeProviderInner({
             throw new Error(`Unknown protocol: ${key}`);
         }
       });
+
+      if (config.tools) {
+        availableProtocols.push(
+          new PersonaTransactionProtocol({
+            apiUrl: `${baseEndpointProtocol}://${baseEndpoint}`,
+            apiKey: config.apiKey,
+            agentId: config.agentId,
+            onTransaction: async (transaction: PersonaPersistableTransaction) => {
+              await transaction.invoke(config.tools!);
+            },
+            logger,
+          }),
+        );
+      }
       return availableProtocols;
     }
     throw new Error('Invalid protocols configuration');
@@ -109,8 +127,15 @@ function PersonaRuntimeProviderInner({
         protocolsStatus.set(protocol.getName(), status);
         setProtocolsStatus(new Map(protocolsStatus));
       });
-      protocol.addMessageListener((message: PersonaMessage) => {
-        setMessages((currentConversation) => parseMessages([...currentConversation, ...[{ ...message, protocol: protocol.getName() }]]));
+      protocol.addMessageListener((message: PersonaPayload) => {
+        if (message.type === 'message') {
+          const personaMessage = message.payload as PersonaMessage;
+          setMessages((currentConversation) =>
+            parseMessages([...currentConversation, ...[{ ...personaMessage, protocol: protocol.getName() }]]),
+          );
+        } else if (message.type === 'transaction') {
+          protocols.filter((p) => p !== protocol).forEach((p) => p.onTransaction(message.payload as PersonaTransaction));
+        }
       });
       if (protocol.autostart && protocol.status === 'disconnected') {
         logger?.debug(`Connecting to protocol: ${protocol.getName()}`);

package/src/types.ts

@@ -1,3 +1,4 @@
+import { PersonaTools } from 'src/protocol';
 import { PersonaLogger } from './logging';
 import { ReactNode } from 'react';
 
@@ -23,11 +24,41 @@ export type PersonaFile = {
   contentType: string;
 };
 
+export type PersonaSession = {
+  id: string;
+  code: string;
+  projectId: string;
+  agentId: string;
+  currentAgentId: string;
+  userId: string;
+  status: 'active' | 'finished';
+  type: 'realtime' | 'async';
+  createdAt: string;
+  finishedAt: string | null;
+};
+
+export type PersonaAgentContext = {
+  data: unknown;
+  files: PersonaFile[];
+  session: PersonaSession;
+};
+
+export type PersonaTransaction = {
+  id: string;
+  projectId: string;
+  sessionId: string;
+  status: 'pending' | 'completed' | 'failed';
+  error: string | null;
+  functionCall: FunctionCall | null;
+  context: PersonaAgentContext;
+};
+
 export type PersonaMessage = {
   id?: string | null;
   protocol?: string;
+  thought?: string;
   text: string;
-  type: 'reasoning' | 'text';
+  type: 'reasoning' | 'text' | 'transaction';
   role: 'user' | 'assistant' | 'function';
   files?: PersonaFile[];
   sessionId?: string;
@@ -36,6 +67,11 @@ export type PersonaMessage = {
   functionResponse?: FunctionResponse;
 };
 
+export type PersonaPayload = {
+  type: 'message' | 'transaction';
+  payload: PersonaMessage | PersonaTransaction;
+};
+
 export type ModelResponse = {
   messages: PersonaMessage[];
 };
@@ -58,7 +94,7 @@ export type PersonaWebRTCConfig = PersonaBaseConfig & {
 export type Session = string | null | undefined;
 export type Message = string;
 
-export type MessageListenerCallback = (message: PersonaMessage) => void;
+export type MessageListenerCallback = (message: PersonaPayload) => void;
 export type StatusChangeCallback = (status: ProtocolStatus) => void;
 
 export type ProtocolStatus = 'disconnected' | 'connecting' | 'connected';
@@ -78,6 +114,8 @@ export interface PersonaProtocol {
   connect: (session?: Session) => Promise<Session>;
   disconnect: () => Promise<void>;
 
+  onTransaction: (transaction: PersonaTransaction) => void;
+
   setSession: (session: Session) => Promise<void>;
 
   send: (message: Message) => Promise<void>;
@@ -102,4 +140,6 @@ export type PersonaConfig = PersonaBaseConfig &
           webrtc?: PersonaProtocolBaseConfig | true;
           websocket?: PersonaProtocolBaseConfig | true;
         };
+
+    tools?: PersonaTools;
   };