@gnsx/genesys.agent.client 0.3.3

package/src/GenesysAgentClient.ts

@@ -0,0 +1,318 @@
+import { AgentEventType, ClientMessageType, ServerErrorCode, ServerMessageType } from '@gnsx/genesys.agent.shared/browser';
+
+import { ClientEventType, ClientState } from './types.js';
+
+import type { ClientEventMap , ClientOptions, SessionConfig } from './types.js';
+import type { ClientMessage, ErrorMessage, ServerMessage} from '@gnsx/genesys.agent.shared/browser';
+
+const LOG_PREFIX = '[GenesysAgentClient]';
+
+export class GenesysAgentClient {
+  protected ws: WebSocket | null = null;
+  protected sessionId: string | null = null;
+  protected wsUrl: string | null = null;
+  protected state: ClientState = ClientState.DISCONNECTED;
+  protected reconnectAttempts = 0;
+  protected reconnectTimeout: ReturnType<typeof setTimeout> | null = null;
+  protected intentionalClose = false;
+
+  protected eventListeners: Map<ClientEventType, Set<Function>> = new Map();
+
+  protected serverAddress: string | null = null;
+
+  protected config: SessionConfig | null = null;
+
+  constructor(readonly options: ClientOptions = {}) {
+    this.options.autoReconnect = this.options.autoReconnect ?? true;
+    this.options.maxReconnectAttempts = this.options.maxReconnectAttempts ?? 5;
+    this.options.reconnectInterval = this.options.reconnectInterval ?? 1000;
+    this.options.debug = this.options.debug ?? false;
+  }
+
+  public async connect(config: SessionConfig): Promise<void> {
+    if (this.state === ClientState.CONNECTED || this.state === ClientState.CONNECTING) {
+      throw new Error('Already connected or connecting');
+    }
+
+    if (!config.serverAddress) {
+      throw new Error('Server address is required');
+    }
+
+    // save the config in case we need to connect again
+    this.config = config;
+
+    // Remove trailing slash from server address
+    this.serverAddress = config.serverAddress.replace(/\/+$/, '');
+
+    this.setState(ClientState.CONNECTING);
+    this.intentionalClose = false;
+
+    try {
+      // Create session via HTTP
+      const response = await fetch(`${this.serverAddress}/sessions`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ specPath: config.specPath })
+      });
+
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({ error: 'Failed to create session' }));
+        throw new Error(errorData.error ?? 'Failed to create session');
+      }
+
+      const sessionInfo: { sessionId: string; wsUrl: string } = await response.json();
+      this.sessionId = sessionInfo.sessionId;
+      this.wsUrl = sessionInfo.wsUrl;
+      if (!this.sessionId) {
+        throw new Error('Session ID is required');
+      }
+      if (!this.wsUrl) {
+        throw new Error('WebSocket URL is required');
+      }
+
+      // Connect WebSocket
+      await this.connectWebSocket(false);
+    } catch (error) {
+      this.setState(ClientState.DISCONNECTED);
+      throw error;
+    }
+  }
+
+  protected async connectWebSocket(isReconnecting: boolean): Promise<void> {
+    if (!this.wsUrl) {
+      throw new Error('No WebSocket URL available');
+    }
+
+    return new Promise((resolve, reject) => {
+      this.ws = new WebSocket(this.wsUrl!);
+
+      this.ws.onopen = () => {
+        this.setState(ClientState.CONNECTED);
+        this.reconnectAttempts = 0;
+        resolve();
+      };
+
+      this.ws.onmessage = (event) => {
+        try {
+          const message: ServerMessage = JSON.parse(event.data);
+          this.handleServerMessage(message);
+        } catch (error) {
+          this.debug('Failed to parse message:', error);
+        }
+      };
+
+      this.ws.onclose = () => {
+        this.setState(ClientState.DISCONNECTED);
+        if (!isReconnecting) {
+          this.emit(ClientEventType.DISCONNECTED, this.intentionalClose ? 'User disconnected' : 'Connection lost');
+
+          if (!this.intentionalClose && this.options.autoReconnect && this.sessionId) {
+            this.attemptReconnect();
+          }
+        }
+      };
+
+      this.ws.onerror = (error) => {
+        this.debug('WebSocket error:', error);
+        reject(error);
+      };
+    });
+  }
+
+  protected handleServerMessage(message: ServerMessage): void {
+    if (message.type === ServerMessageType.AGENT_EVENT) {
+      switch (message.event.type) {
+        case AgentEventType.USER_MESSAGE:
+          this.debug('USER_MESSAGE:\n', message.event.data.message);
+          break;
+        case AgentEventType.AGENT_MESSAGE:
+          this.debug('AGENT_MESSAGE:\n', message.event.data.message);
+          break;
+        case AgentEventType.STREAM_CHUNK:
+          this.debug('STREAM_CHUNK:\n', message.event.data.chunk);
+          break;
+        case AgentEventType.TOOL_CALL:
+          this.debug('TOOL_CALL:\n', message.event.data.toolName, message.event.data.input);
+          break;
+        case AgentEventType.TOOL_RESULT:
+          this.debug('TOOL_RESULT:\n', message.event.data.toolName, message.event.data.result);
+          break;
+        case AgentEventType.TOOL_ERROR:
+          console.error(LOG_PREFIX, 'TOOL_ERROR:\n', message.event.data.toolName, message.event.data.error);
+          break;
+        case AgentEventType.REASONING:
+          this.debug('REASONING:\n', message.event.data.text);
+          break;
+        case AgentEventType.TOKEN_USAGE:
+          this.debug('TOKEN_USAGE:\n', message.event.data);
+          break;
+        case AgentEventType.TODO_LIST:
+          this.debug('TODO_LIST:\n', message.event.data.todos);
+          break;
+        case AgentEventType.SEND_DATA:
+          this.debug('SEND_DATA:\n', message.event.data.data);
+          break;
+        case AgentEventType.ERROR:
+          console.error(LOG_PREFIX, 'AGENT_ERROR:\n', message.event.data.error);
+          break;
+        case AgentEventType.MESSAGES_CLEARED:
+          this.debug('MESSAGES_CLEARED:\n');
+          break;
+        default:
+          console.error(LOG_PREFIX, 'Unknown agent event:\n', message.event);
+          break;
+      }
+    } else {
+      this.debug('handleServerMessage:', message);
+    }
+
+    if (message.type === ServerMessageType.ERROR) {
+      this.handleServerError(message);
+    }
+    this.emit(ClientEventType.SERVER_MESSAGE, message);
+  }
+
+  public sendInput(text: string): void {
+    if (this.state !== ClientState.CONNECTED) {
+      throw new Error('Not connected');
+    }
+
+    this.send({
+      type: ClientMessageType.INPUT,
+      text
+    });
+  }
+
+  public abort(): void {
+    if (this.state !== ClientState.CONNECTED) {
+      throw new Error('Not connected');
+    }
+
+    throw new Error('Not implemented');
+  }
+
+  public disconnect(): void {
+    this.intentionalClose = true;
+
+    if (this.reconnectTimeout) {
+      clearTimeout(this.reconnectTimeout);
+      this.reconnectTimeout = null;
+    }
+
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+
+    this.sessionId = null;
+    this.wsUrl = null;
+    this.setState(ClientState.DISCONNECTED);
+  }
+
+  protected attemptReconnect(): void {
+    if (this.reconnectAttempts >= this.options.maxReconnectAttempts!) {
+      this.emit(ClientEventType.CONTROL_MESSAGE, { message: `Failed to reconnect after ${this.options.maxReconnectAttempts} attempts`, isError: true });
+      this.sessionId = null;
+      this.wsUrl = null;
+      return;
+    }
+
+    this.reconnectAttempts++;
+    const delay = Math.min(5000, this.options.reconnectInterval! * Math.pow(1.5, this.reconnectAttempts - 1));
+
+    this.setState(ClientState.RECONNECTING);
+    this.emit(ClientEventType.CONTROL_MESSAGE, { message: `Reconnect attempt ${this.reconnectAttempts}/${this.options.maxReconnectAttempts}...`, isError: false });
+
+    this.reconnectTimeout = setTimeout(async () => {
+      try {
+        await this.connectWebSocket(true);
+        this.emit(ClientEventType.CONTROL_MESSAGE, { message: 'Reconnected to server', isError: false });
+      } catch {
+        this.attemptReconnect();
+      }
+    }, delay);
+  }
+
+  protected send(message: ClientMessage): void {
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+      this.ws.send(JSON.stringify(message));
+    }
+  }
+
+  protected setState(state: ClientState): void {
+    if (this.state !== state) {
+      this.state = state;
+      this.emit(ClientEventType.STATE_CHANGE, state);
+    }
+  }
+
+  public getState(): ClientState {
+    return this.state;
+  }
+
+  public isConnected(): boolean {
+    return this.state === ClientState.CONNECTED;
+  }
+
+  public getSessionId(): string | null {
+    return this.sessionId;
+  }
+
+  // Event emitter methods
+  public on(event: ClientEventType, listener: ClientEventMap[ClientEventType]): ClientEventMap[ClientEventType] {
+    if (!this.eventListeners.has(event)) {
+      this.eventListeners.set(event, new Set());
+    }
+    this.eventListeners.get(event)!.add(listener);
+    return listener;
+  }
+
+  public off(event: ClientEventType, listener: ClientEventMap[ClientEventType]): void {
+    const listeners = this.eventListeners.get(event);
+    if (listeners) {
+      listeners.delete(listener);
+    }
+  }
+
+  public once(event: ClientEventType, listener: ClientEventMap[ClientEventType]): void {
+    const onceListener = ((...args: Parameters<ClientEventMap[ClientEventType]>) => {
+      this.off(event, onceListener);
+      (listener as Function)(...args);
+    }) as ClientEventMap[ClientEventType];
+
+    this.on(event, onceListener);
+  }
+
+  protected emit(event: ClientEventType, ...args: Parameters<ClientEventMap[ClientEventType]>): void {
+    const listeners = this.eventListeners.get(event);
+    if (listeners) {
+      listeners.forEach(listener => {
+        try {
+          (listener as Function)(...args);
+        } catch (error) {
+          this.debug(`Error in ${event} listener:`, error);
+        }
+      });
+    }
+  }
+
+  protected debug(...args: unknown[]): void {
+    if (this.options.debug) {
+      console.log(LOG_PREFIX, ...args);
+    }
+  }
+
+
+  protected async handleServerError(message: ErrorMessage): Promise<void> {
+    if (message.code === ServerErrorCode.SESSION_NOT_FOUND) {
+      // reconnect to get a new session
+      try {
+        console.warn('SESSION_NOT_FOUND, reconnecting to get a new session');
+        this.disconnect();
+        await this.connect(this.config!);
+      } catch (error) {
+        console.error(error);
+      }
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,56 @@
+export * from './GenesysAgentClient.js';
+export * from './types.js';
+
+// Re-export shared types explicitly for proper bundling with dts-bundle-generator
+// (inlinedLibraries doesn't properly handle subpath exports like /browser)
+export {
+  AgentEventType,
+  ServerMessageType,
+  ClientMessageType,
+  ServerErrorCode,
+  TodoStatus,
+  TodoPriority,
+} from '@gnsx/genesys.agent.shared/browser';
+
+export type {
+  AgentEvent,
+  ServerMessage,
+  ClientMessage,
+  SessionInfo,
+  AgentEventMessage,
+  ConnectionEstablishedMessage,
+  RequestInputMessage,
+  ErrorMessage,
+  PingMessage,
+  SessionInfoMessage,
+  SessionRestoredMessage,
+  InputMessage,
+  // Event types
+  UserMessageEvent,
+  AgentMessageEvent,
+  StreamChunkEvent,
+  ToolCallEvent,
+  ToolResultEvent,
+  ToolErrorEvent,
+  ReasoningEvent,
+  TokenUsageEvent,
+  TodoItem,
+  TodoListEvent,
+  SendDataEvent,
+  ErrorEvent,
+  MessagesClearedEvent,
+  ModelUpdatedEvent,
+  RoundFinishedEvent,
+} from '@gnsx/genesys.agent.shared/browser';
+
+// Re-export constants
+export {
+  DEFAULT_PORT,
+  DEFAULT_SESSION_DIR,
+  DEFAULT_SESSION_TIMEOUT,
+  DEFAULT_MAX_SESSIONS,
+  MAX_FILE_SIZE,
+  WS_HEARTBEAT_INTERVAL,
+  SYSTEM_CONTEXT_PLACEHOLDER,
+  PROJECT_LAYOUT_PLACEHOLDER,
+} from '@gnsx/genesys.agent.shared/browser';

package/src/types.ts

@@ -0,0 +1,39 @@
+import type { ServerMessage } from '@gnsx/genesys.agent.shared/browser';
+
+export interface ClientOptions {
+  autoReconnect?: boolean;
+  maxReconnectAttempts?: number;
+  reconnectInterval?: number;
+  debug?: boolean;
+}
+
+export interface SessionConfig {
+  serverAddress: string;
+  specPath: string;
+}
+
+export interface ControlMessage {
+  message: string;
+  isError: boolean;
+}
+
+export enum ClientState {
+  DISCONNECTED = 'disconnected',
+  CONNECTING = 'connecting',
+  CONNECTED = 'connected',
+  RECONNECTING = 'reconnecting'
+}
+
+export enum ClientEventType {
+  SERVER_MESSAGE = 'serverMessage',
+  DISCONNECTED = 'disconnected',
+  STATE_CHANGE = 'stateChange',
+  CONTROL_MESSAGE = 'controlMessage',
+}
+
+export interface ClientEventMap {
+  [ClientEventType.SERVER_MESSAGE]: (message: ServerMessage) => void;
+  [ClientEventType.DISCONNECTED]: (reason?: string) => void;
+  [ClientEventType.STATE_CHANGE]: (state: ClientState) => void;
+  [ClientEventType.CONTROL_MESSAGE]: (message: ControlMessage) => void;
+}