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

package/src/projects.ts

@@ -0,0 +1,57 @@
+import type { PersonaProjectSubscription } from './types';
+
+type ProjectsApiConfig = {
+  baseUrl: string;
+  apiKey: string;
+};
+
+class ProjectsApi {
+  private readonly baseUrl: string;
+  private readonly apiKey: string;
+
+  constructor(config: ProjectsApiConfig) {
+    this.baseUrl = config.baseUrl.replace(/\/$/, '');
+    this.apiKey = config.apiKey;
+  }
+
+  private async request<T>(path: string, init?: RequestInit): Promise<T> {
+    const response = await fetch(`${this.baseUrl}${path}`, {
+      ...init,
+      headers: {
+        'Content-Type': 'application/json',
+        'x-persona-apikey': this.apiKey,
+        ...(init?.headers ?? {}),
+      },
+    });
+
+    if (!response.ok) {
+      throw new Error(await response.text());
+    }
+
+    return (await response.json()) as T;
+  }
+
+  async getSubscription(projectId: string): Promise<PersonaProjectSubscription> {
+    return this.request<PersonaProjectSubscription>(`/projects/${projectId}/subscription`);
+  }
+
+  async changeSubscriptionPlan(
+    projectId: string,
+    toPlanType: PersonaProjectSubscription['planType'],
+  ): Promise<PersonaProjectSubscription> {
+    return this.request<PersonaProjectSubscription>(`/projects/${projectId}/subscription/actions/change-plan`, {
+      method: 'POST',
+      body: JSON.stringify({ toPlanType }),
+    });
+  }
+
+  async addSubscriptionCredits(projectId: string, credits: number): Promise<PersonaProjectSubscription> {
+    return this.request<PersonaProjectSubscription>(`/projects/${projectId}/subscription/actions/add-credits`, {
+      method: 'POST',
+      body: JSON.stringify({ credits }),
+    });
+  }
+}
+
+export { ProjectsApi };
+export type { ProjectsApiConfig };

package/src/protocol/base.ts

@@ -0,0 +1,73 @@
+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

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

package/src/protocol/rest.ts

@@ -0,0 +1,107 @@
+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

@@ -0,0 +1,182 @@
+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 };