@applica-software-guru/persona-sdk 0.1.61 → 0.1.62

package/playground/src/chat.tsx

@@ -72,9 +72,16 @@ function Chat() {
     <PersonaRuntimeProvider
       dev
       logger={logger}
+      context={{
+        data: {
+          username: 'Bruno Trimone Agent',
+          userAgent: navigator.userAgent,
+        },
+      }}
       tools={{
         get_user_agent: () => {
-          return navigator.userAgent || 'unknown';
+          const userAgent = 'Bruno Trimone Agent';
+          return { userAgent };
         },
         get_client_date: () => {
           const date = new Date();
@@ -83,8 +90,6 @@ function Chat() {
       }}
       protocols={{
         rest: true,
-        webrtc: true,
-        websocket: true,
       }}
       session={session}
       apiKey="2398utf8g$9pahwv8#93q8.h8349q*!ty89w4uefghwqh849tg934yg894hq3g89q34h9"

package/src/protocol/base.ts

@@ -1,7 +1,6 @@
 import {
   MessageListenerCallback,
-  PersonaMessage,
-  PersonaPayload,
+  PersonaPacket,
   PersonaProtocol,
   PersonaTransaction,
   ProtocolStatus,
@@ -21,17 +20,17 @@ abstract class PersonaProtocolBase implements PersonaProtocol {
     this.statusChangeCallbacks.push(callback);
   }
 
-  public addMessageListener(callback: MessageListenerCallback) {
+  public addPacketListener(callback: MessageListenerCallback) {
     this.messageCallbacks.push(callback);
   }
   public async syncSession(session: Session): Promise<void> {
     this.session = session;
   }
 
-  public async notifyMessage(message: PersonaPayload): Promise<void> {
+  public async notifyPacket(message: PersonaPacket): Promise<void> {
     this.messageCallbacks.forEach((callback) => callback(message));
   }
-  public async notifyMessages(messages: PersonaPayload[]): Promise<void> {
+  public async notifyPackets(messages: PersonaPacket[]): Promise<void> {
     messages.forEach((message) => {
       this.messageCallbacks.forEach((callback) => callback(message));
     });
@@ -58,7 +57,7 @@ abstract class PersonaProtocolBase implements PersonaProtocol {
   abstract getPriority(): number;
   abstract connect(session?: Session): Promise<Session>;
   abstract disconnect(): Promise<void>;
-  abstract send(message: Array<PersonaMessage> | PersonaMessage): Promise<void>;
+  abstract sendPacket(packet: PersonaPacket): Promise<void>;
 
   public onTransaction(_: PersonaTransaction) {}
 }

package/src/protocol/rest.ts

@@ -1,5 +1,13 @@
 import { PersonaProtocolBase } from './base';
-import { PersonaResponse, Session, ProtocolStatus, PersonaProtocolBaseConfig, PersonaMessage } from '../types';
+import {
+  PersonaResponse,
+  Session,
+  ProtocolStatus,
+  PersonaProtocolBaseConfig,
+  PersonaMessage,
+  PersonaPacket,
+  PersonaCommand,
+} from '../types';
 
 type PersonaRESTProtocolConfig = PersonaProtocolBaseConfig & {
   apiUrl: string;
@@ -11,6 +19,7 @@ class PersonaRESTProtocol extends PersonaProtocolBase {
   session: Session;
   config: PersonaRESTProtocolConfig;
   notify: boolean = true;
+  context: Record<string, any> = {};
 
   constructor(config: PersonaRESTProtocolConfig) {
     super();
@@ -41,22 +50,24 @@ class PersonaRESTProtocol extends PersonaProtocolBase {
     this.session = session;
   }
 
-  public async send(message: Array<PersonaMessage> | PersonaMessage): Promise<void> {
+  public async sendPacket(packet: PersonaPacket): Promise<void> {
     const { apiUrl, apiKey, agentId } = this.config;
     const sessionId = this.session ?? 'new';
-    const input = message;
-
-    const response = await fetch(`${apiUrl}/agents/${agentId}/sessions/${sessionId}/messages`, {
-      body: JSON.stringify({ userMessage: input }),
+    if (packet.type === 'command' && (packet?.payload as PersonaCommand)?.command == 'set_initial_context') {
+      this.context = (packet?.payload as PersonaCommand)?.arguments;
+      return;
+    }
+    const input = packet.payload as PersonaMessage;
+    const response = await fetch(`${apiUrl}/sessions/${sessionId}/messages`, {
+      body: JSON.stringify({ agentId, userMessage: input, initial_context: this.context }),
       method: 'POST',
       headers: {
         'Content-Type': 'application/json',
-        'x-fox-apikey': apiKey,
         'x-persona-apikey': apiKey,
       },
     });
     const personaResponse = (await response.json()) as PersonaResponse;
-    this.notifyMessages(
+    this.notifyPackets(
       personaResponse.response.messages.map((payload) => ({
         type: 'message',
         payload,

package/src/protocol/transaction.ts

@@ -6,7 +6,7 @@ import {
   PersonaTransaction,
   FunctionCall,
   ReadonlyJSONObject,
-  PersonaMessage,
+  PersonaPacket,
 } from '../types';
 
 type FinishTransactionRequest = {
@@ -134,10 +134,7 @@ class PersonaTransactionProtocol extends PersonaProtocolBase {
     this.session = session;
   }
 
-  public async send(message: Array<PersonaMessage> | PersonaMessage): Promise<void> {
-    this.config.logger?.debug('Sending message:', message);
-    throw new Error('Not implemented');
-  }
+  public async sendPacket(_: PersonaPacket): Promise<void> {}
 
   public onTransaction(transaction: PersonaTransaction): void {
     if (!this.config.onTransaction) {

package/src/protocol/webrtc.ts

@@ -1,5 +1,5 @@
 import { PersonaProtocolBase } from './base';
-import { PersonaMessage, PersonaPayload, PersonaProtocolBaseConfig, ProtocolStatus, Session } from '../types';
+import { PersonaPacket, PersonaProtocolBaseConfig, ProtocolStatus, Session } from '../types';
 
 type AudioAnalysisData = {
   localAmplitude: number;
@@ -187,14 +187,14 @@ class PersonaWebRTCClient {
     };
   }
 
-  public sendMessage(message: Array<PersonaMessage> | PersonaMessage): void {
+  public sendPacket(packet: PersonaPacket): void {
     if (!this.dataChannel) {
       this.config.logger?.warn('Data channel is not open, cannot send message');
       return;
     }
 
-    this.dataChannel.send(JSON.stringify({ type: 'request', payload: message }));
-    this.config.logger?.info('Sent message:', message);
+    this.dataChannel.send(JSON.stringify(packet));
+    this.config.logger?.info('Sent message:', packet);
   }
 
   private _startAnalyzers(): void {
@@ -274,8 +274,8 @@ class PersonaWebRTCProtocol extends PersonaProtocolBase {
     this.autostart = config?.autostart ?? false;
     this.webRTCClient = new PersonaWebRTCClient(config);
     this.webRTCClient.addMessageCallback((msg: MessageEvent) => {
-      const data = JSON.parse(msg.data) as PersonaPayload;
-      this.notifyMessage(data);
+      const data = JSON.parse(msg.data) as PersonaPacket;
+      this.notifyPacket(data);
     });
   }
 
@@ -322,12 +322,12 @@ class PersonaWebRTCProtocol extends PersonaProtocolBase {
     this.config?.logger?.debug('Disconnected from WebRTC');
   }
 
-  public send(message: Array<PersonaMessage> | PersonaMessage): Promise<void> {
+  public sendPacket(packet: PersonaPacket): Promise<void> {
     if (this.status !== 'connected') {
       return Promise.reject(new Error('Not connected'));
     }
 
-    this.webRTCClient.sendMessage(message);
+    this.webRTCClient.sendPacket(packet);
     return Promise.resolve();
   }
 }

package/src/protocol/websocket.ts

@@ -1,4 +1,4 @@
-import { PersonaMessage, PersonaPayload, PersonaProtocolBaseConfig, ProtocolStatus, Session } from '../types';
+import { PersonaPacket, PersonaProtocolBaseConfig, ProtocolStatus, Session } from '../types';
 import { PersonaProtocolBase } from './base';
 
 type PersonaWebSocketProtocolConfig = PersonaProtocolBaseConfig & {
@@ -56,8 +56,8 @@ class PersonaWebSocketProtocol extends PersonaProtocolBase {
       this.setStatus('connected');
     });
     this.webSocket.addEventListener('message', (event) => {
-      const data = JSON.parse(event.data) as PersonaPayload;
-      this.notifyMessage(data);
+      const data = JSON.parse(event.data) as PersonaPacket;
+      this.notifyPacket(data);
     });
     this.webSocket.addEventListener('close', () => {
       this.setStatus('disconnected');
@@ -86,9 +86,9 @@ class PersonaWebSocketProtocol extends PersonaProtocolBase {
     return Promise.resolve();
   }
 
-  public send(message: Array<PersonaMessage> | PersonaMessage): Promise<void> {
+  public sendPacket(packet: PersonaPacket): Promise<void> {
     if (this.webSocket && this.status === 'connected') {
-      this.webSocket.send(JSON.stringify({ type: 'request', payload: message }));
+      this.webSocket.send(JSON.stringify(packet));
       return Promise.resolve();
     } else {
       return Promise.reject(new Error('WebSocket is not connected'));

package/src/runtime.tsx

@@ -9,7 +9,7 @@ import {
 import {
   PersonaConfig,
   PersonaMessage,
-  PersonaPayload,
+  PersonaPacket,
   PersonaProtocol,
   PersonaProtocolBaseConfig,
   PersonaReasoning,
@@ -162,9 +162,18 @@ function PersonaRuntimeProviderInner({
       protocol.addStatusChangeListener((status: ProtocolStatus) => {
         logger?.debug(`${protocol.getName()} has notified new status: ${status}`);
         protocolsStatus.set(protocol.getName(), status);
+        if (status === 'connected' && config.context) {
+          protocol.sendPacket({
+            type: 'command',
+            payload: {
+              command: 'set_initial_context',
+              arguments: config.context,
+            },
+          });
+        }
         setProtocolsStatus(new Map(protocolsStatus));
       });
-      protocol.addMessageListener((message: PersonaPayload) => {
+      protocol.addPacketListener((message: PersonaPacket) => {
         if (message.type === 'message') {
           const personaMessage = message.payload as PersonaMessage;
           setMessages((currentConversation) =>
@@ -227,7 +236,7 @@ function PersonaRuntimeProviderInner({
       });
     }
     logger?.debug('Sending message:', content);
-    await protocol?.send(content);
+    await protocol?.sendPacket({ type: 'request', payload: content });
 
     setIsRunning(false);
   };
@@ -302,10 +311,10 @@ function usePersonaRuntimeProtocol(protocol: string): PersonaProtocol | null {
     ...protocolInstance,
     connect: protocolInstance.connect.bind(protocolInstance),
     disconnect: protocolInstance.disconnect.bind(protocolInstance),
-    send: protocolInstance.send.bind(protocolInstance),
+    sendPacket: protocolInstance.sendPacket.bind(protocolInstance),
     setSession: protocolInstance.setSession.bind(protocolInstance),
     addStatusChangeListener: protocolInstance.addStatusChangeListener.bind(protocolInstance),
-    addMessageListener: protocolInstance.addMessageListener.bind(protocolInstance),
+    addPacketListener: protocolInstance.addPacketListener.bind(protocolInstance),
     getName: protocolInstance.getName.bind(protocolInstance),
     getPriority: protocolInstance.getPriority.bind(protocolInstance),
     status: status || protocolInstance.status,

package/src/types.ts

@@ -38,9 +38,9 @@ export type PersonaSession = {
 };
 
 export type PersonaAgentContext = {
-  data: unknown;
-  files: PersonaFile[];
-  session: PersonaSession;
+  data: Record<string, unknown>;
+  files?: PersonaFile[];
+  session?: PersonaSession;
 };
 
 export type PersonaTransaction = {
@@ -78,13 +78,27 @@ export type PersonaSource = {
   mostRelevant?: boolean;
 };
 
+export type PersonaCommand = {
+  command: 'get_mcp_assets' | 'set_initial_context';
+  arguments: Record<string, unknown>;
+};
+
+export type PersonaRequest = PersonaMessage | Array<PersonaMessage> | string;
+
+export type PersonaPacketPayload = PersonaRequest | PersonaCommand | PersonaReasoning | PersonaTransaction;
+
+export type PersonaPacket = {
+  type: 'request' | 'message' | 'command' | 'reasoning' | 'mcp_assets' | 'transaction';
+  payload?: PersonaPacketPayload;
+};
+
 export type PersonaMessage = {
   id?: string | null;
   protocol?: string;
   thought?: string;
   text: string; //todo: puo essere null
   image?: PersonaImage;
-  type: 'reasoning' | 'text' | 'transaction';
+  type: 'reasoning' | 'text' | 'transaction' | 'command';
   role: 'user' | 'assistant' | 'function';
   files?: PersonaFile[];
   sources?: PersonaSource[];
@@ -94,11 +108,6 @@ export type PersonaMessage = {
   functionResponse?: FunctionResponse;
 };
 
-export type PersonaPayload = {
-  type: 'message' | 'transaction' | 'reasoning';
-  payload: PersonaMessage | PersonaTransaction | PersonaReasoning;
-};
-
 export type ModelResponse = {
   messages: PersonaMessage[];
 };
@@ -120,7 +129,7 @@ export type PersonaWebRTCConfig = PersonaBaseConfig & {
 
 export type Session = string | null | undefined;
 
-export type MessageListenerCallback = (message: PersonaPayload) => void;
+export type MessageListenerCallback = (message: PersonaPacket) => void;
 export type StatusChangeCallback = (status: ProtocolStatus) => void;
 
 export type ProtocolStatus = 'disconnected' | 'connecting' | 'connected';
@@ -144,10 +153,10 @@ export interface PersonaProtocol {
 
   setSession: (session: Session) => Promise<void>;
 
-  send: (content: Array<PersonaMessage> | PersonaMessage) => Promise<void>;
+  sendPacket: (packet: PersonaPacket) => Promise<void>;
   clearListeners: () => void;
   addStatusChangeListener: (callback: StatusChangeCallback) => void;
-  addMessageListener: (callback: MessageListenerCallback) => void;
+  addPacketListener: (callback: MessageListenerCallback) => void;
 }
 
 export type PersonaConfig = PersonaBaseConfig &
@@ -159,6 +168,7 @@ export type PersonaConfig = PersonaBaseConfig &
     dev?: boolean;
     session?: Session;
     children: ReactNode;
+    context?: PersonaAgentContext;
     protocols:
       | PersonaProtocol[]
       | {