@applica-software-guru/persona-sdk 0.1.100 → 0.1.101

package/src/protocol/base.ts

@@ -1,73 +0,0 @@
-import {
-  MessageListenerCallback,
-  PersonaAgentContext,
-  PersonaPacket,
-  PersonaProtocol,
-  PersonaTransaction,
-  ProtocolStatus,
-  Session,
-  StatusChangeCallback,
-} from '../types';
-
-abstract class PersonaProtocolBase implements PersonaProtocol {
-  abstract status: ProtocolStatus;
-  abstract session: Session;
-  abstract autostart: boolean;
-
-  private statusChangeCallbacks: StatusChangeCallback[] = [];
-  private messageCallbacks: MessageListenerCallback[] = [];
-
-  public addStatusChangeListener(callback: StatusChangeCallback) {
-    this.statusChangeCallbacks.push(callback);
-  }
-
-  public addPacketListener(callback: MessageListenerCallback) {
-    this.messageCallbacks.push(callback);
-  }
-  public async syncSession(session: Session): Promise<void> {
-    this.session = session;
-  }
-
-  public async notifyPacket(message: PersonaPacket): Promise<void> {
-    this.messageCallbacks.forEach((callback) => callback(message));
-  }
-  public async notifyPackets(messages: PersonaPacket[]): Promise<void> {
-    messages.forEach((message) => {
-      this.messageCallbacks.forEach((callback) => callback(message));
-    });
-  }
-
-  public async setSession(session: Session): Promise<void> {
-    this.session = session;
-  }
-  public async setStatus(status: ProtocolStatus): Promise<void> {
-    const notify = this.status !== status;
-    this.status = status;
-    if (!notify) {
-      return;
-    }
-    this.statusChangeCallbacks.forEach((callback) => callback(status));
-  }
-
-  public clearListeners(): void {
-    this.statusChangeCallbacks = [];
-    this.messageCallbacks = [];
-  }
-
-  public setAgentContext(context: PersonaAgentContext): Promise<void> {
-    return this.sendPacket({
-      type: 'command',
-      payload: { command: 'set_initial_context', arguments: context },
-    });
-  }
-
-  abstract getName(): string;
-  abstract getPriority(): number;
-  abstract connect(session?: Session): Promise<Session>;
-  abstract disconnect(): Promise<void>;
-  abstract sendPacket(packet: PersonaPacket): Promise<void>;
-
-  public onTransaction(_: PersonaTransaction) {}
-}
-
-export { PersonaProtocolBase };

package/src/protocol/index.ts

@@ -1,5 +0,0 @@
-export * from './rest';
-export * from './base';
-export * from './websocket';
-export * from './webrtc';
-export * from './transaction';

package/src/protocol/rest.ts

@@ -1,107 +0,0 @@
-import { PersonaProtocolBase } from './base';
-import {
-  PersonaResponse,
-  Session,
-  ProtocolStatus,
-  PersonaProtocolBaseConfig,
-  PersonaMessage,
-  PersonaPacket,
-  PersonaCommand,
-} from '../types';
-import { ToolInstance } from '../tools';
-
-type PersonaRESTProtocolConfig = PersonaProtocolBaseConfig & {
-  apiUrl: string;
-};
-
-class PersonaRESTProtocol extends PersonaProtocolBase {
-  status: ProtocolStatus;
-  autostart: boolean;
-  session: Session;
-  config: PersonaRESTProtocolConfig;
-  notify: boolean = true;
-  context: Record<string, any> = {};
-  tools: ToolInstance[] = [];
-
-  constructor(config: PersonaRESTProtocolConfig) {
-    super();
-    this.config = config;
-    this.status = 'disconnected';
-    this.autostart = true;
-  }
-
-  public getName(): string {
-    return 'rest';
-  }
-
-  public getPriority(): number {
-    return 100;
-  }
-
-  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 sendPacket(packet: PersonaPacket): Promise<void> {
-    const { apiUrl, apiKey, agentId } = this.config;
-    const sessionId = this.session ?? 'new';
-    if (packet.type === 'command' && (packet?.payload as PersonaCommand)?.command == 'set_initial_context') {
-      this.context = (packet?.payload as PersonaCommand)?.arguments;
-      return;
-    } else if (packet.type === 'command' && (packet?.payload as PersonaCommand)?.command == 'set_local_tools') {
-      const tools = (packet?.payload as PersonaCommand)?.arguments.tools as ToolInstance[];
-      if (tools?.length > 0) {
-        this.notifyPacket({
-          type: 'message',
-          payload: {
-            type: 'text',
-            role: 'assistant',
-            text: 'Local tools with rest protocol are not supported.',
-          },
-        });
-      }
-      return;
-    }
-    const input = packet.payload as PersonaMessage;
-    try {
-      const response = await fetch(`${apiUrl}/sessions/${sessionId}/messages`, {
-        body: JSON.stringify({ agentId, userMessage: input, initialContext: this.context, tools: this.tools }),
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-          'x-persona-apikey': apiKey,
-        },
-      });
-      const personaResponse = (await response.json()) as PersonaResponse;
-      this.notifyPackets(
-        personaResponse.response.messages.map((payload) => ({
-          type: 'message',
-          payload,
-        })),
-      );
-    } catch (error) {
-      this.notifyPacket({
-        type: 'message',
-        payload: {
-          role: 'assistant',
-          type: 'text',
-          text: 'An error occurred while processing your request. Please try again later.',
-        },
-      });
-      this.config.logger?.error('Error sending packet:', error);
-    }
-  }
-}
-
-export { PersonaRESTProtocol };
-export type { PersonaRESTProtocolConfig };

package/src/protocol/transaction.ts

@@ -1,182 +0,0 @@
-import { PersonaProtocolBase } from './base';
-import { Session, ProtocolStatus, PersonaProtocolBaseConfig, PersonaTransaction, FunctionCall, PersonaPacket } from '../types';
-import { ToolInstance } from '../tools';
-import _ from 'lodash';
-
-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: any[]) => void | Record<string, any> | Promise<void | Record<string, any>>;
-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, toolInstance?: ToolInstance): 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 properties = _.get(toolInstance, 'schema.config.parameters.properties', {});
-      const paramNames =
-        properties && Object.keys(properties).length > 0
-          ? Object.keys(properties)
-          : tool
-              .toString()
-              .replace(/\n/g, ' ')
-              .match(/^[^(]*\(([^)]*)\)/)?.[1]
-              .split(',')
-              .map((p: string) => p.trim())
-              .filter(Boolean) || [];
-
-      // Map arguments in order
-      const orderedArgs = paramNames.map((name: string) => functionArgs[name]);
-      const result = await tool.apply(null, orderedArgs);
-      await this.complete(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;
-  tools: PersonaTools | ToolInstance[];
-  onTransaction?: PersonaTransactionCallback;
-};
-
-class PersonaTransactionProtocol extends PersonaProtocolBase {
-  status: ProtocolStatus;
-  autostart: boolean;
-  session: Session;
-  config: PersonaTransactionProtocolConfig;
-  notify: boolean = true;
-  private _tools: PersonaTools;
-  private _toolSchema: { [key: string]: ToolInstance } = {};
-
-  constructor(config: PersonaTransactionProtocolConfig) {
-    super();
-    this.config = config;
-    this.status = 'disconnected';
-    this.autostart = true;
-    if (Array.isArray(config.tools)) {
-      this._tools = {};
-      for (const tool of config.tools as ToolInstance[]) {
-        if (tool.schema && tool.implementation) {
-          this._tools[tool.schema.name] = tool.implementation;
-          this._toolSchema[tool.schema.name] = tool;
-        }
-      }
-    } else {
-      this._tools = config.tools as PersonaTools;
-    }
-  }
-
-  public getName(): string {
-    return 'transaction';
-  }
-
-  public getPriority(): number {
-    return 0;
-  }
-
-  public getToolInstance(name: string): ToolInstance | undefined {
-    return this._toolSchema[name];
-  }
-
-  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 sendPacket(_: PersonaPacket): Promise<void> {}
-
-  public onTransaction(transaction: PersonaTransaction): void {
-    const manager = new PersonaTransactionsManager(this.config);
-    const persistable = new PersonaPersistableTransaction(transaction, manager);
-    if (this.config.onTransaction) {
-      this.config.onTransaction(persistable);
-    } else {
-      const toolInstance = transaction.functionCall ? this.getToolInstance(transaction.functionCall.name) : undefined;
-      persistable.invoke(this._tools, toolInstance);
-    }
-  }
-
-  public getTools(): PersonaTools {
-    return this._tools;
-  }
-}
-
-export { PersonaTransactionProtocol };
-export type { PersonaTransactionProtocolConfig, FinishTransactionRequest, PersonaPersistableTransaction, PersonaTransactionCallback };