modality-kit 0.9.0 → 0.9.2

package/dist/index.js

@@ -5474,62 +5474,6 @@ class JSONRPCManager extends JSONRPCCall {
     };
     this.eventHandlers = eventHandlers;
   }
-  registerMethod(methodName, config) {
-    if (this.methods.has(methodName)) {
-      throw new Error(`Method '${methodName}' is already registered`);
-    }
-    this.methods.set(methodName, config);
-    console.log(`Registered JSON-RPC method: ${methodName}`);
-  }
-  unregisterMethod(methodName) {
-    const removed = this.methods.delete(methodName);
-    if (removed) {
-      console.log(`Unregistered JSON-RPC method: ${methodName}`);
-    }
-    return removed;
-  }
-  getRegisteredMethods() {
-    return Array.from(this.methods.keys());
-  }
-  handleRequest(method, params, options = {}) {
-    const { promise, request } = super.handleRequest(method, params, options);
-    this.sendMessage(request, options);
-    return { promise, request };
-  }
-  sendNotification(method, params, options) {
-    const notification = JSONRPCUtils.createNotification(method, params);
-    this.sendMessage(notification, options);
-  }
-  sendMessage(message, options) {
-    console.warn("JSONRPCManager.sendMessage not implemented - message not sent:", message, options);
-  }
-  async validateMessage(data, options = {}) {
-    try {
-      const messageStr = typeof data === "string" ? data : data.toString();
-      const message = JSONRPCUtils.deserialize(messageStr);
-      if (!message) {
-        console.error("Failed to parse JSON-RPC message:", messageStr);
-        const errorResponse = JSONRPCUtils.createErrorResponse(JSONRPCUtils.createError(-32700 /* PARSE_ERROR */, "Parse error"), null);
-        this.sendMessage(errorResponse, options);
-        return;
-      }
-      const validation = JSONRPCUtils.validateMessage(message);
-      if (!validation.valid) {
-        const errorResponse = JSONRPCUtils.createErrorResponse(validation.error, message.id || null);
-        this.sendMessage(errorResponse, options);
-        return;
-      }
-      const response = await this.processMessage(validation, options);
-      if (response && (!Array.isArray(response) || response.length > 0)) {
-        this.sendMessage(response, options);
-      }
-    } catch (err) {
-      const error = err;
-      console.error("Error handling WebSocket message:", error);
-      const errorResponse = JSONRPCUtils.createErrorResponse(JSONRPCUtils.createError(-32603 /* INTERNAL_ERROR */, "Internal error"), null);
-      this.sendMessage(errorResponse, options);
-    }
-  }
   async processMessage(validation, options = {}) {
     try {
       switch (validation.messageType) {
@@ -5633,6 +5577,62 @@ class JSONRPCManager extends JSONRPCCall {
     }
     return JSONRPCUtils.createError(-32603 /* INTERNAL_ERROR */, STANDARD_ERROR_MESSAGES[-32603 /* INTERNAL_ERROR */], { originalError: error.message });
   }
+  sendMessage(message, options) {
+    console.warn("JSONRPCManager.sendMessage not implemented - message not sent:", message, options);
+  }
+  sendNotification(method, params, options) {
+    const notification = JSONRPCUtils.createNotification(method, params);
+    this.sendMessage(notification, options);
+  }
+  registerMethod(methodName, config) {
+    if (this.methods.has(methodName)) {
+      throw new Error(`Method '${methodName}' is already registered`);
+    }
+    this.methods.set(methodName, config);
+    console.log(`Registered JSON-RPC method: ${methodName}`);
+  }
+  unregisterMethod(methodName) {
+    const removed = this.methods.delete(methodName);
+    if (removed) {
+      console.log(`Unregistered JSON-RPC method: ${methodName}`);
+    }
+    return removed;
+  }
+  getRegisteredMethods() {
+    return Array.from(this.methods.keys());
+  }
+  handleRequest(method, params, options = {}) {
+    const { promise, request } = super.handleRequest(method, params, options);
+    this.sendMessage(request, options);
+    return { promise, request };
+  }
+  async validateMessage(data, options = {}) {
+    try {
+      const messageStr = typeof data === "string" ? data : data.toString();
+      const message = JSONRPCUtils.deserialize(messageStr);
+      if (!message) {
+        console.error("Failed to parse JSON-RPC message:", messageStr);
+        const errorResponse = JSONRPCUtils.createErrorResponse(JSONRPCUtils.createError(-32700 /* PARSE_ERROR */, "Parse error"), null);
+        this.sendMessage(errorResponse, options);
+        return;
+      }
+      const validation = JSONRPCUtils.validateMessage(message);
+      if (!validation.valid) {
+        const errorResponse = JSONRPCUtils.createErrorResponse(validation.error, message.id || null);
+        this.sendMessage(errorResponse, options);
+        return;
+      }
+      const response = await this.processMessage(validation, options);
+      if (response && (!Array.isArray(response) || response.length > 0)) {
+        this.sendMessage(response, options);
+      }
+    } catch (err) {
+      const error = err;
+      console.error("Error handling WebSocket message:", error);
+      const errorResponse = JSONRPCUtils.createErrorResponse(JSONRPCUtils.createError(-32603 /* INTERNAL_ERROR */, "Internal error"), null);
+      this.sendMessage(errorResponse, options);
+    }
+  }
   getStats() {
     const parentStats = super.getStats();
     return {
@@ -5656,7 +5656,7 @@ class WebSocketClient {
     initialReconnectDelay: 1000,
     maxReconnectDelay: 30000,
     maxReconnectAttempts: 10,
-    callTimeout: 5000,
+    lastReconnectDelay: 300000,
     heartbeatInterval: 30000,
     enableKeepAlive: true,
     handleMessage: (_validMessage, _ws) => {}
@@ -5674,6 +5674,7 @@ class WebSocketClient {
     this.config = { ...this.config, ...config };
     this.url = url;
     this.reconnectDelay = this.config.initialReconnectDelay;
+    this.send = this.send.bind(this);
   }
   isValidWebSocketUrl(url) {
     try {
@@ -5720,7 +5721,7 @@ class WebSocketClient {
         this.reconnectAttempts = 0;
         this.reconnectDelay = this.config.initialReconnectDelay;
         this.attemptReconnect();
-      }, 300000);
+      }, this.config.lastReconnectDelay);
     }
   }
   onOpen(event) {
@@ -5811,6 +5812,9 @@ class WebSocketClient {
         }
       };
       this.ws.onmessage = (event) => {
+        if (this.config.onReceiveMessage) {
+          event = this.config.onReceiveMessage(event);
+        }
         logger3.info("WebSocket message received:", event.data);
         try {
           const message = JSONRPCUtils.deserialize(event.data);

package/dist/types/jsonrpc-manager.d.ts

@@ -58,56 +58,56 @@ export declare class JSONRPCManager<TContext> extends JSONRPCCall {
     private eventHandlers;
     constructor(config?: JSONRPCManagerConfig<TContext>, eventHandlers?: JSONRPCManagerEvents<TContext>);
     /**
-     * Register a JSON-RPC method
+     * Process incoming JSON-RPC message (supports batch requests)
      */
-    registerMethod<T = JSONRPCParams>(methodName: string, config: JSONRPCMethodConfig<TContext, T>): void;
+    private processMessage;
     /**
-     * Unregister a JSON-RPC method
+     * Process a JSON-RPC request
      */
-    unregisterMethod(methodName: string): boolean;
+    private processRequest;
     /**
-     * Get registered method names
+     * Process a JSON-RPC notification
      */
-    getRegisteredMethods(): string[];
+    private processNotification;
     /**
-     * Send a JSON-RPC request and return a promise for the response
+     * Process a JSON-RPC batch request
      */
-    handleRequest(method: string, params?: any, options?: any): {
-        promise: Promise<any>;
-        request: JSONRPCRequest;
-    };
+    private processBatchRequest;
     /**
-     * Send a JSON-RPC notification (no response expected)
+     * Default error handler
      */
-    sendNotification(method: string, params: any, options: TContext): void;
+    private defaultErrorHandler;
     /**
      * Send a message (to be overridden by WebSocket implementation)
      */
     protected sendMessage(message: JSONRPCMessage, options: TContext): void;
     /**
-     * Process incoming WebSocket message
+     * Send a JSON-RPC notification (no response expected)
      */
-    validateMessage(data: string | Buffer, options?: any): Promise<void>;
+    sendNotification(method: string, params: any, options: TContext): void;
     /**
-     * Process incoming JSON-RPC message (supports batch requests)
+     * Register a JSON-RPC method
      */
-    private processMessage;
+    registerMethod<T = JSONRPCParams>(methodName: string, config: JSONRPCMethodConfig<TContext, T>): void;
     /**
-     * Process a JSON-RPC request
+     * Unregister a JSON-RPC method
      */
-    private processRequest;
+    unregisterMethod(methodName: string): boolean;
     /**
-     * Process a JSON-RPC notification
+     * Get registered method names
      */
-    private processNotification;
+    getRegisteredMethods(): string[];
     /**
-     * Process a JSON-RPC batch request
+     * Send a JSON-RPC request and return a promise for the response
      */
-    private processBatchRequest;
+    handleRequest(method: string, params?: any, options?: any): {
+        promise: Promise<any>;
+        request: JSONRPCRequest;
+    };
     /**
-     * Default error handler
+     * Process incoming WebSocket message
      */
-    private defaultErrorHandler;
+    validateMessage(data: string | Buffer, options?: any): Promise<void>;
     /**
      * Get manager statistics
      */

package/dist/types/websocket-client.d.ts

@@ -3,10 +3,11 @@ interface WebSocketConfig {
     maxReconnectAttempts: number;
     initialReconnectDelay: number;
     maxReconnectDelay: number;
-    callTimeout: number;
+    lastReconnectDelay: number;
     heartbeatInterval: number;
     enableKeepAlive: boolean;
     handleMessage: (validMessage: JSONRPCValidationResult, ws: WebSocketClient) => void;
+    onReceiveMessage?: (event: any) => any;
 }
 interface WebSocketInfo {
     url: string;
@@ -25,7 +26,7 @@ export declare class WebSocketClient {
     private reconnectAttempts;
     private reconnectDelay;
     private heartbeatInterval;
-    constructor(url: string, config?: Record<keyof WebSocketConfig, any>);
+    constructor(url: string, config?: Partial<WebSocketConfig>);
     private isValidWebSocketUrl;
     private stopCleanupInterval;
     private stopHeartbeat;

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.9.0",
+  "version": "0.9.2",
   "name": "modality-kit",
   "repository": {
     "type": "git",